Mybatis框架第二篇

目录

  • 第一章：Mybatis 连接池与事务

    • 1.1-Mybatis连接池
    • 1.2-Mybatis 的事务控制
  • 第二章：Mybatis 的动态 SQL 语句
    • 2.1-<if>标签
    • 2.2-<where>标签
    • 2.3-<foreach>标签
    • 2.4-Mybatis 编写的 SQL 片段
  • 第三章：Mybatis 多表查询之多对一
    • 3.1-需求
    • 3.2-数据库脚本
    • 3.3-方式1
    • 3.2-方式2
  • 第四章：Mybatis 多表查询之一对多
    • 4.1-需求
    • 4.2-编写Sql语句
    • 4.3-User实体类
    • 4.4-IUserDao 接口中加入查询方法
    • 4.5-IUserDao 映射文件配置
    • 4.6-测试类
  • 第五章： Mybatis 多表查询之多对多
    • 5.1-数据表模型
    • 5.2-数据库脚本
    • 5.3-实现 Role 到 User 多对多

第一章：Mybatis 连接池与事务

1.1-Mybatis连接池

Mybatis 连接池的分类

  • UNPOOLED 不使用连接池的数据源
  • POOLED 使用连接池的数据源
  • JNDI 使用 JNDI 实现的数据源

三种数据源中，我们一般采用的是 POOLED 数据源

Mybatis 中数据源的配置

我们的数据源配置就是在 SqlMapConfig.xml 文件中，具体配置如下：

<!-- 配置数据源（连接池）信息 -->
<dataSource type="POOLED">
    <property name="driver" value="${jdbc.driver}"/>
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
</dataSource>

MyBatis 在初始化时，根据的 type 属性来创建相应类型的的数据源 DataSource，即：

type=”POOLED”：MyBatis 会创建 PooledDataSource 实例

type=”UNPOOLED” ： MyBatis 会创建 UnpooledDataSource 实例

type=”JNDI”：MyBatis 会从 JNDI 服务上查找 DataSource 实例，然后返回使用

1.2-Mybatis 的事务控制

JDBC事务回顾

在 JDBC 中我们可以通过手动方式将事务的提交改为手动方式，通过 setAutoCommit()方法就可以调整。 通过 JDK 文档，我们找到该方法如下：

Mybatis 框架因为是对 JDBC 的封装，所以 Mybatis 框架的事务控制方式，本身也是用 JDBC 的 setAutoCommit()方法来设置事务提交方式的。

Mybatis事务控制

通过SqlSessionFactory工厂对象创建SqlSession对象时可以设置是否自动提交，设置如下：

  SqlSession openSession();      // 不自动提交

  SqlSession openSession(boolean var1);  // 布尔值为true时，事务自动提交

SqlSession对象中提供方法实现提交事务

void commit();    // 提交事务
void rollback();  // 事务回滚

第二章：Mybatis 的动态 SQL 语句

Mybatis 的映射文件中，前面我们的 SQL 都是比较简单的。但有些时候业务逻辑复杂时，我们的 SQL 是动态变化的。此时Mybatis，也提供了相应的解决方案。需要我们在dao.xml配置文件中，通过指定的标签来实现sql语句的动态变化。

2.1-<if>标签

需求

我们根据实体类的不同取值，使用不同的 SQL 语句来进行查询。比如在 id 如果不为空时可以根据 id 查询， 如果 username 不同空时还要加入用户名作为条件。这种情况在我们的多条件组合查询中经常会碰到。

持久层 Dao 接口

/**
* 根据用户信息，查询用户列表
* @param user
* @return
*/
List<User> findByUser(User user);

持久层 Dao 映射配置

<select id="findByUser" resultType="user" parameterType="user">
    select * from user where 1=1
    <if test="username!=null and username != '' ">
        and username like #{username}
    </if>
    <if test="address != null">
     and address like #{address}
    </if>
</select>
<!--注意：<if>标签的 test 属性中写的是对象的属性名，如果是包装类的对象要使用 OGNL 表达式的写法。
另外要注意 where 1=1 的作用~！-->

测试

public void testFindByUser() {
    User u = new User();
    u.setUsername("%王%");
    u.setAddress("%北京%");
    List<User> users = userDao.findByUser(u);
    for(User user : users) {
       System.out.println(user);
    }
}

2.2-<where>标签

为了简化上面 where 1=1 的条件拼装，我们可以采用标签来简化开发。

<!-- 根据用户信息查询 -->
<select id="findByUser" resultType="user" parameterType="user">
        select * from user
        <where>
            <if test="username!=null and username != '' ">
                and username like #{username}
            </if>
            <if test="address != null">
             and address like #{address}
            </if>
        </where>
</select>

2.3-<foreach>标签

需求

传入多个 id 查询用户信息，用下边两个 sql 实现： SELECT * FROM USERS WHERE username LIKE ‘%张%‘ AND (id =10 OR id =89 OR id=16) 或 SELECT * FROM USERS WHERE username LIKE ‘%张%‘ AND id IN (10,89,16) 这样我们在进行范围查询时，就要将一个集合中的值，作为参数动态添加进来。 这样我们将如何进行参数的传递？

在 QueryVo 中加入一个 List 集合用于封装参数

public class QueryVo {
  private User user;
  private List ids;

  public User getUser() {
    return user;
  }

  public void setUser(User user) {
    this.user = user;
  }

  public List getIds() {
    return ids;
  }

  public void setIds(List ids) {
    this.ids = ids;
  }
}

持久层 Dao 接口

/**
* 根据 id 集合查询用户
* @param vo
* @return
*/
List<User> findInIds(QueryVo vo);

持久层 Dao 映射配置

<!-- 查询所有用户在 id 的集合之中 -->
<select id="findInIds" resultType="user" parameterType="queryvo">
    <!-- select * from user where id in (1,2,3,4,5); -->
    select * from user
    <where>
        <if test="ids != null and ids.size() > 0">
            <foreach collection="ids" open="id in ( " close=")" item="uid" separator=",">
                #{uid}
            </foreach>
        </if>
    </where>
</select>
<!--
    SQL 语句：
        select 字段 from user where id in (?)
        <foreach>标签用于遍历集合，它的属性：
        collection:代表要遍历的集合元素，注意编写时不要写#{}
        open:代表语句的开始部分
        close:代表结束部分
        item:代表遍历集合的每个元素，生成的变量名
        sperator:代表分隔符
-->

测试

@Test
public void testFindInIds() {
        QueryVo vo = new QueryVo();
        List<Integer> ids = new ArrayList<Integer>();
        ids.add(41);
        ids.add(42);
        ids.add(43);
        ids.add(46);
        ids.add(57);
        vo.setIds(ids);
        //6.执行操作
        List<User> users = userDao.findInIds(vo);
        for(User user : users) {
         System.out.println(user);
        }
}

2.4-Mybatis 编写的 SQL 片段

Sql 中可将重复的 sql 提取出来，使用时用 include 引用即可，最终达到 sql 重用的目的

定义代码片段

<!-- 抽取重复的语句代码片段 -->
    <sql id="defaultSql">
        select * from user
    </sql>

调用代码片段

<!-- 配置查询所有操作 -->
<select id="findAll" resultType="user">
    <include refid="defaultSql"></include>
</select>
<!-- 根据 id 查询 -->
<select id="findById" resultType="UsEr" parameterType="int">
    <include refid="defaultSql"></include>
    where id = #{uid}
</select>

第三章：Mybatis 多表查询之多对一

3.1-需求

本次案例主要以最为简单的用户和账户的模型来分析 Mybatis 多表关系。用户为 User 表，账户为Account 表。一个用户（User）可以有多个账户（Account）。具体关系如下：

需求 查询所有账户信息，关联查询下单用户信息。

注意： 因为一个账户信息只能供某个用户使用，所以从查询账户信息出发关联查询用户信息为一对一查询。

如 果从用户信息出发查询用户下的账户信息则为一对多查询，因为一个用户可以有多个账户。

3.2-数据库脚本

/*
SQLyog Ultimate v12.09 (64 bit)
MySQL - 5.5.40 : Database - db7
*********************************************************************
*/

CREATE DATABASE /*!32312 IF NOT EXISTS*/`db7` /*!40100 DEFAULT CHARACTER SET utf8 */;

USE `db7`;

/*Table structure for table `account` */

DROP TABLE IF EXISTS `account`;

CREATE TABLE `account` (
  `ID` int(11) NOT NULL COMMENT '编号',
  `UID` int(11) DEFAULT NULL COMMENT '用户编号',
  `MONEY` double DEFAULT NULL COMMENT '金额',
  PRIMARY KEY (`ID`),
  KEY `FK_Reference_8` (`UID`),
  CONSTRAINT `FK_Reference_8` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

/*Data for the table `account` */

insert  into `account`(`ID`,`UID`,`MONEY`) values (1,1,111),(2,1,2222),(3,2,6666),(4,1,2321),(5,2,65656),(6,4,8888);

/*Table structure for table `user` */

DROP TABLE IF EXISTS `user`;

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(32) DEFAULT NULL,
  `birthday` date DEFAULT NULL,
  `sex` varchar(22) DEFAULT NULL,
  `address` varchar(32) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=19 DEFAULT CHARSET=utf8;

/*Data for the table `user` */

insert  into `user`(`id`,`username`,`birthday`,`sex`,`address`) values (1,'张三丰','2018-12-12','male','海南'),(2,'李四','2019-09-04','female','南京'),(3,'王五','2020-02-12','male','北京'),(4,'赵六','2020-01-01','female','上海'),(18,NULL,NULL,NULL,NULL);

3.3-方式1

定义账户信息的实体类

public class Account implements Serializable {
  private int id;
  private int uid;
  private double money;

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public int getUid() {
    return uid;
  }

  public void setUid(int uid) {
    this.uid = uid;
  }

  public double getMoney() {
    return money;
  }

  public void setMoney(double money) {
    this.money = money;
  }

  @Override
  public String toString() {
    return "Account{" +
            "id=" + id +
            ", uid=" + uid +
            ", money=" + money +
            '}';
  }
}

编写 Sql 语句

# 实现查询账户信息时，也要查询账户所对应的用户信息。
SELECT
 account.*,
 user.username,
 user.address
FROM
 account,
 USER
WHERE account.uid = user.id

在 MySQL 中测试的查询结果如下：

定义 AccountUser 类

为了能够封装上面 SQL 语句的查询结果，定义 AccountCustomer 类中要包含账户信息同时还要包含用户信 息，所以我们要在定义 AccountUser 类时可以继承 Account 类。

public class AccountUser extends Account implements Serializable {
  private String username;
  private String address;

  public String getUsername() {
    return username;
  }

  public void setUsername(String username) {
    this.username = username;
  }

  public String getAddress() {
    return address;
  }

  public void setAddress(String address) {
    this.address = address;
  }

  @Override
  public String toString() {
    return super.toString()+"AccountUser{" +
            "username='" + username + '\'' +
            ", address='" + address + '\'' +
            '}';
  }
}

定义账户的持久层 Dao 接口

public interface IAccountDao {
  /**
   * 查询所有账户，同时获取账户的所属用户名称以及它的地址信息
   * @return
   */
  List<AccountUser> findAll();
}

定义 IAccountDao.xml 文件中的查询配置信息

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.lpl666.dao.IAccountDao">
    <select id="findAll" resultType="AccountUser">
      SELECT account.*, user.username, user.address FROM account, USER WHERE account.uid = user.id
    </select>
</mapper>

创建 AccountTest 测试类

public class AccountTest {
  private static InputStream is;
  private static SqlSession sqlSession;
  private static IAccountDao dao;
  @Before
  public void init(){
    // 读取配置文件
    try {
      is = Resources.getResourceAsStream("SqlMapConfig.xml");
      // 创建工厂构建者对象
      SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
      // 创建SqlSessionFactory工厂对象
      SqlSessionFactory sqlSessionFactory = builder.build(is);
      // 创建SqlSession对象
      sqlSession = sqlSessionFactory.openSession();
      // 创建dao代理对象
      dao = sqlSession.getMapper(IAccountDao.class);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
  @After
  public  void destroy() throws IOException {
    sqlSession.commit();
    is.close();
    sqlSession.close();
  }

  /**
   * 查询
   */
  @Test
  public void getAll() throws IOException {
    List<AccountUser> all = dao.findAll();
    for (AccountUser accountUser : all) {
      System.out.println(accountUser);
    }
  }
}

定义专门的 po 类作为输出类型，其中定义了 sql 查询结果集所有的字段。此方法较为简单，企业中使用普 遍。

3.2-方式2

使用 resultMap，定义专门的 resultMap 用于映射一对一查询结果。 通过面向对象的(has a)关系可以得知，我们可以在 Account 类中加入一个 User 类的对象来代表这个账户 是哪个用户的。

修改 Account 类

在 Account 类中加入 User 类的对象作为 Account 类的一个属性

public class Account implements Serializable {
  private int id;
  private int uid;
  private double money;
  private User user;

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public int getUid() {
    return uid;
  }

  public void setUid(int uid) {
    this.uid = uid;
  }

  public double getMoney() {
    return money;
  }

  public void setMoney(double money) {
    this.money = money;
  }

  public User getUser() {
    return user;
  }

  public void setUser(User user) {
    this.user = user;
  }

  @Override
  public String toString() {
    return "Account{" +
            "id=" + id +
            ", uid=" + uid +
            ", money=" + money +
            ", user=" + user.toString() +
            '}';
  }
}

修改 AccountDao 接口中的方法

public interface IAccountDao {
  /**
   * 查询所有账户，同时获取账户的所属用户名称以及它的地址信息
   * @return
   */
  List<Account> findAll();
}
// 注意：第二种方式，将返回值改 为了 Account 类型。
// 因为 Account 类中包含了一个 User 类的对象，它可以封装账户所对应的用户信息

重新定义 IAccountDao.xml 文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.lpl666.dao.IAccountDao">
    <!-- 建立对应关系 -->
    <resultMap id="AccountMap" type="Account">
        <id property="id" column="aid"></id>
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
        <!-- 它是用于指定从表方的引用实体属性的 -->
        <association property="user" javaType="User">
            <id property="id" column="id"></id>
            <result property="username" column="username"></result>
            <result property="birthday" column="birthday"></result>
            <result property="sex" column="sex"></result>
            <result property="address" column="address"></result>
        </association>
    </resultMap>

    <select id="findAll" resultMap="AccountMap">
      SELECT a.`id` AS aid,a.`uid`,a.`money`,u.* FROM account AS a, USER AS u WHERE a.uid = u.id
    </select>
</mapper>

在 AccountTest 类中加入测试方法

public class Account implements Serializable {
  private int id;
  private int uid;
  private double money;
  private User user;

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public int getUid() {
    return uid;
  }

  public void setUid(int uid) {
    this.uid = uid;
  }

  public double getMoney() {
    return money;
  }

  public void setMoney(double money) {
    this.money = money;
  }

  public User getUser() {
    return user;
  }

  public void setUser(User user) {
    this.user = user;
  }

  @Override
  public String toString() {
    return "Account{" +
            "id=" + id +
            ", uid=" + uid +
            ", money=" + money +
            ", user=" + user.toString() +
            '}';
  }
}

第四章：Mybatis 多表查询之一对多

4.1-需求

需求： 查询所有用户信息及用户关联的账户信息。 分析： 用户信息和他的账户信息为一对多关系，并且查询过程中如果用户没有账户信息，此时也要将用户信息 查询出来，我们想到了左外连接查询比较合适。

数据库脚本同上

4.2-编写Sql语句

SELECT * FROM
    USER
    LEFT JOIN
    account
    ON user.`id`=account.`uid`

4.3-User实体类

public class User implements Serializable {
  private int id;
  private String username;
  private String birthday;
  private String sex;
  private String address;
  private List<Account> accountList;

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getUsername() {
    return username;
  }

  public void setUsername(String username) {
    this.username = username;
  }

  public String getBirthday() {
    return birthday;
  }

  public void setBirthday(String birthday) {
    this.birthday = birthday;
  }

  public String getSex() {
    return sex;
  }

  public void setSex(String sex) {
    this.sex = sex;
  }

  public String getAddress() {
    return address;
  }

  public void setAddress(String address) {
    this.address = address;
  }

  @Override
  public String toString() {
    return "User{" +
            "id=" + id +
            ", username='" + username + '\'' +
            ", birthday=" + birthday +
            ", sex='" + sex + '\'' +
            ", address='" + address + '\'' +
            '}';
  }

  public List<Account> getAccountList() {
    return accountList;
  }

  public void setAccountList(List<Account> accountList) {
    this.accountList = accountList;
  }
}

4.4-IUserDao 接口中加入查询方法

public interface IUserDao {
  /**
   * 查询所有用户信息（包含用户所拥有的账户列表）
   * @return
   */
  List<User> findAll();
}

4.5-IUserDao 映射文件配置

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.lpl666.dao.IUserDao">
    <resultMap id="UserMap" type="User">
        <id property="id" column="id"></id>
        <result property="sex" column="sex"></result>
        <result property="username" column="username"></result>
        <result property="address" column="address"></result>
        <result property="birthday" column="birthday"></result>
        <result property="address" column="address"></result>
        <!--
            collection 是用于建立一对多中集合属性的对应关系
            ofType 用于指定集合元素的数据类型
            -->
        <collection property="accountList" ofType="Account">
            <id column="aid" property="id"></id>
            <result column="money" property="money"></result>
            <result column="uid" property="uid"></result>
        </collection>
    </resultMap>
    <!--查询所有用户-->
    <select id="findAll" resultMap="UserMap">
        SELECT User.*,a.`id` AS aid,a.`money`,a.`uid` FROM USER LEFT OUTER JOIN account AS a  ON user.`id`=a.`uid`
    </select>
</mapper>

collection 部分定义了用户关联的账户信息。表示关联查询结果集

property="accountList"： 关联查询的结果集存储在 User 对象的上哪个属性。

ofType="Account"： 指定关联查询的结果集中的对象类型即List中的对象类型。此处可以使用别名，也可以使用全限定名。

4.6-测试类

public class UserTest {
  private static InputStream is;
  private static SqlSession sqlSession;
  private static IUserDao dao;
  @Before
  public void init(){
    // 读取配置文件
    try {
      is = Resources.getResourceAsStream("SqlMapConfig.xml");
      // 创建工厂构建者对象
      SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
      // 创建SqlSessionFactory工厂对象
      SqlSessionFactory sqlSessionFactory = builder.build(is);
      // 创建SqlSession对象
      sqlSession = sqlSessionFactory.openSession();
      // 创建dao代理对象
      dao = sqlSession.getMapper(IUserDao.class);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
  @After
  public  void destroy() throws IOException {
    sqlSession.commit();
    is.close();
    sqlSession.close();
  }

  /**
   * 查询
   */
  @Test
  public void getAll() throws IOException {
    List<User> all = dao.findAll();
    for (User user : all) {
      System.out.println(user);
      List<Account> list = user.getAccountList();
      for (Account account : list) {
        System.out.println(account);
      }
      System.out.println("-----------");
    }

  }
}

第五章： Mybatis 多表查询之多对多

5.1-数据表模型

多对多关系其实我们看成是双向的一对多 。

我们使用用户与角色的关系模型来演示

在 MySQL 数据库中添加角色表，用户角色的中间表。 角色表

5.2-数据库脚本

/*
SQLyog Ultimate v12.09 (64 bit)
MySQL - 5.5.40 : Database - db7
*********************************************************************
*/
CREATE DATABASE /*!32312 IF NOT EXISTS*/`db7` /*!40100 DEFAULT CHARACTER SET utf8 */;

USE `db7`;
/*Table structure for table `role` */

DROP TABLE IF EXISTS `role`;

CREATE TABLE `role` (
  `id` int(11) NOT NULL COMMENT '编号',
  `role_name` varchar(30) DEFAULT NULL COMMENT '角色名称',
  `role_desc` varchar(60) DEFAULT NULL COMMENT '角色描述',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

/*Data for the table `role` */

insert  into `role`(`id`,`role_name`,`role_desc`) values (1,'院长','管理整个学院'),(2,'总裁','管理整个公司'),(3,'校长','管理整个学校');

/*Table structure for table `user` */

DROP TABLE IF EXISTS `user`;

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(32) DEFAULT NULL,
  `birthday` date DEFAULT NULL,
  `sex` varchar(22) DEFAULT NULL,
  `address` varchar(32) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=19 DEFAULT CHARSET=utf8;

/*Data for the table `user` */

insert  into `user`(`id`,`username`,`birthday`,`sex`,`address`) values (1,'张三丰','2018-12-12','male','海南'),(2,'李四','2019-09-04','female','南京'),(3,'王五','2020-02-12','male','北京'),(4,'赵六','2020-01-01','female','上海'),(18,'陈七','2020-02-03','male','杭州');

/*Table structure for table `user_role` */

DROP TABLE IF EXISTS `user_role`;

CREATE TABLE `user_role` (
  `UID` int(11) NOT NULL COMMENT '用户编号',
  `RID` int(11) NOT NULL COMMENT '角色编号',
  PRIMARY KEY (`UID`,`RID`),
  KEY `FK_Reference_10` (`RID`),
  CONSTRAINT `FK_Reference_10` FOREIGN KEY (`RID`) REFERENCES `role` (`ID`),
  CONSTRAINT `FK_Reference_9` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

/*Data for the table `user_role` */

insert  into `user_role`(`UID`,`RID`) values (3,1),(4,1),(1,2),(2,3),(3,3);

/*!40101 SET [email protected]_SQL_MODE */;
/*!40014 SET [email protected]_FOREIGN_KEY_CHECKS */;
/*!40014 SET [email protected]_UNIQUE_CHECKS */;
/*!40111 SET [email protected]_SQL_NOTES */;

5.3-实现 Role 到 User 多对多

业务需求及实现sql

需求： 实现查询所有对象并且加载它所分配的用户信息。

分析： 查询角色我们需要用到Role表，但角色分配的用户的信息我们并不能直接找到用户信息，而是要通过中 间表(USER_ROLE 表)才能关联到用户信息。

SELECT
  r.*,
  u.id AS uid,
  u.`address`,
  u.`birthday`,
  u.`sex`,
  u.`username`
FROM
    role AS r
LEFT JOIN
    user_role AS ur
ON
    r.`id`=ur.`RID`
LEFT JOIN
    USER AS u
ON
    ur.`UID`=u.`id`

角色实体类

public class Role {
  private int id;
  private String roleName;
  private String roleDesc;
  private List<User> users;

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getRoleName() {
    return roleName;
  }

  public void setRoleName(String roleName) {
    this.roleName = roleName;
  }

  public String getRoleDesc() {
    return roleDesc;
  }

  public void setRoleDesc(String roleDesc) {
    this.roleDesc = roleDesc;
  }

  public List<User> getUsers() {
    return users;
  }

  public void setUsers(List<User> users) {
    this.users = users;
  }

  @Override
  public String toString() {
    return "Role{" +
            "id=" + id +
            ", roleName='" + roleName + '\'' +
            ", roleDesc='" + roleDesc + '\'' +
            '}';
  }
}

Role 持久层接口

public interface IRoleDao {
  /**
   * 获取所有角色（包含所有属于该角色的用户列表）
   * @return
   */
  List<Role> findAll();
}

映射配置文件

IRoleDao.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.lpl666.dao.IRoleDao">
    <resultMap id="roleMap" type="Role">
        <id property="id" column="rid"></id>
        <result property="roleName" column="role_name"></result>
        <result property="roleDesc" column="role_desc"></result>
        <collection property="users" ofType="User">
            <id property="id" column="id"></id>
            <result property="username" column="username"></result>
            <result property="address" column="address"></result>
            <result property="birthday" column="birthday"></result>
            <result property="sex" column="sex"></result>
        </collection>
    </resultMap>
    <!--查询所有角色信息（包含属于某一个角色的所有用户信息）-->
    <select id="findAll" resultMap="roleMap">
        SELECT u.*,r.id AS rid,r.role_desc,r.role_name FROM role AS r LEFT JOIN user_role AS ur ON r.id=ur.RID LEFT JOIN USER AS u ON ur.UID=u.id
    </select>
</mapper>

测试类

public class RoleTest {
  private static InputStream is;
  private static SqlSession sqlSession;
  private static IRoleDao dao;
  @Before
  public void init(){
    // 读取配置文件
    try {
      is = Resources.getResourceAsStream("SqlMapConfig.xml");
      // 创建工厂构建者对象
      SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
      // 创建SqlSessionFactory工厂对象
      SqlSessionFactory sqlSessionFactory = builder.build(is);
      // 创建SqlSession对象
      sqlSession = sqlSessionFactory.openSession();
      // 创建dao代理对象
      dao = sqlSession.getMapper(IRoleDao.class);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
  @After
  public  void destroy() throws IOException {
    sqlSession.commit();
    is.close();
    sqlSession.close();
  }

  /**
   * 查询
   */
  @Test
  public void getAll() throws IOException {
    List<Role> all = dao.findAll();
    for (Role role : all) {
      System.out.println(role);
      List<User> list = role.getUsers();
      for (User user : list) {
        System.out.println(user);
      }
      System.out.println("-------------");
    }
  }
}

原文地址：https://www.cnblogs.com/lpl666/p/12264174.html

时间： 2024-10-05 10:51:12

Mybatis框架第二篇的相关文章

轻量级ORM框架——第二篇：Dapper中的一些复杂操作和inner join应该注意的坑

上一篇博文中我们快速的介绍了dapper的一些基本CURD操作,也是我们manipulate db不可或缺的最小单元,这一篇我们介绍下相对复杂 一点的操作,源码分析暂时就不在这里介绍了. 一:table sql 为了方便,这里我们生成两个表,一个Users,一个Product,sql如下: <1> Users table CREATE TABLE [dbo].[Users]( [UserID] [int] IDENTITY(1,1) NOT NULL, [UserName] [varchar]

一步一步教你搭建自动化测试框架——python篇

这两天用python写了一个自动化测试框架,取名为Auty.准备用来做Web方面的接口测试,以下为Auty框架一步一步的搭建过程—— Auty自动化测试框架第一篇——生成执行列表 Auty自动化测试框架第二篇——读取与执行脚本列表 Auty自动化测试框架第三篇——添加异常处理与日志收集 Auty自动化测试框架第四篇——生成测试结果报告 Auty自动化测试框架第五篇——自动化安装库与配置说明

MyBatis框架中Mapper映射配置的使用及原理解析(三) 配置篇 Configuration

从上文<MyBatis框架中Mapper映射配置的使用及原理解析(二) 配置篇 SqlSessionFactoryBuilder,XMLConfigBuilder> 我们知道XMLConfigBuilder调用parse()方法解析Mybatis配置文件,生成Configuration对象. Configuration类主要是用来存储对Mybatis的配置文件及mapper文件解析后的数据,Configuration对象会贯穿整个Mybatis的执行流程,为Mybatis的执行过程提供必要的配

Django框架之第二篇

Django框架之第二篇 一.知识点回顾 1.MTV模型 model:模型,和数据库相关的 template:模板,存放html文件,模板语法(目的是将变量如何巧妙的嵌入到HTML页面中). views:视图函数 另加urls:url路径与视图函数的映射关系,,可以不是一一对应的. 2.相关的一些命令 创建一个Django项目:django-admin  startproject  projectname 创建一个项目下的应用:python3  manage.py  startapp  appn

MyBatis框架之第一篇

MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code,并且改名为MyBatis.2013年11月迁移到Github. ●[GitHub] GitHub就是一个互联网上的超大SVN库,里面维护着许多开源项目的代码.任何人都可以把自己好多项目代码放上去共享,同时接受其他人的共同开发. 2.2.什么是MyBatis MyBatis是使用java语言编写的一个优秀的持久层框架,是对JDBC操

Java并发包下锁学习第二篇Java并发基础框架-队列同步器介绍

Java并发包下锁学习第二篇队列同步器 还记得在第一篇文章中,讲到的locks包下的类结果图吗?如下图: ? 从图中,我们可以看到AbstractQueuedSynchronizer这个类很重要(在本文中,凯哥就用AQS来代替这个类).我们先来了解这个类.对这个类了解之后,学习后面的会更容易了. 本篇是<凯哥(凯哥Java:kagejava)并发编程学习>系列之<Lock系列>教程的第一篇:<Java并发包下锁学习第二篇:队列同步器>. 本文主要内容:同步器介绍:同步器

MyBatis框架中Mapper映射配置的使用及原理解析(二) 配置篇 SqlSessionFactoryBuilder，XMLConfigBuilder

在 <MyBatis框架中Mapper映射配置的使用及原理解析(一) 配置与使用> 的demo中看到了SessionFactory的创建过程: SqlSessionFactory sessionFactory = null; String resource = "mybatisConfig.xml"; try { sessionFactory = new SqlSessionFactoryBuilder().build(Resources .getResourceAsRea

SSM:spring+springmvc+mybatis框架中的XML配置文件功能详细解释

SSM:spring+springmvc+mybatis框架中的XML配置文件功能详细解释 2016-04-14 23:40 13030人阅读 评论(2) 收藏 举报 分类: SSM(7) 这几天一直在整合SSM框架,虽然网上有很多已经整合好的,但是对于里面的配置文件并没有进行过多的说明,很多人知其然不知其所以然,经过几天的搜索和整理,今天总算对其中的XML配置文件有了一定的了解,所以拿出来一起分享一下,希望有不足的地方大家批评指正~~~ 首先   这篇文章暂时只对框架中所要用到的配置文件进行解

Mybatis框架(9)---Mybatis自定义插件生成雪花ID做为表主键项目

Mybatis自定义插件生成雪花ID做为主键项目 先附上项目项目GitHub地址 spring-boot-mybatis-interceptor 有关Mybatis雪花ID主键插件前面写了两篇博客作为该项目落地的铺垫. 1.Mybatis框架---Mybatis插件原理 2.java算法---静态内部类实现雪花算法 该插件项目可以直接运用于实际开发中,作为分布式数据库表主键ID使用. 一.项目概述 1.项目背景 在生成表主键ID时,我们可以考虑主键自增 或者 UUID,但它们都有很明显的缺点 主