Mybatis框架第二篇

时间：2020-02-05 16:12:58 阅读：81 评论：0 收藏：0 [点我收藏+]

标签：字段 class 业务逻辑模型 except 返回 system hda 创建

第一章：Mybatis 连接池与事务
- 1.1-Mybatis连接池
- 1.2-Mybatis 的事务控制
第二章：Mybatis 的动态 SQL 语句
第三章：Mybatis 多表查询之多对一
第四章：Mybatis 多表查询之一对多
第五章： Mybatis 多表查询之多对多

第一章：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 SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40111 SET SQL_NOTES=@OLD_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("-------------");
    }
  }
}

Mybatis框架第二篇

标签：字段 class 业务逻辑模型 except 返回 system hda 创建

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

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行

Mybatis框架第二篇

第一章：Mybatis 连接池与事务

1.1-Mybatis连接池

Mybatis 连接池的分类

Mybatis 中数据源的配置

1.2-Mybatis 的事务控制

JDBC事务回顾

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 多对多

业务需求及实现sql

角色实体类

Role 持久层接口

映射配置文件

测试类

2.1-`<if>`标签

2.2-`<where>`标签

2.3-`<foreach>`标签