03-MyBatis连接池与事物及动态SQL和多表查询

Mybatis 连接池与事务深入

1.1 回顾连接池

连接池：我们在实际开发中都会使用连接池。因为它可以减少我们获取连接所消耗的时间。

1.2 Mybatis 的连接池技术

我们在前面的 WEB 课程中也学习过类似的连接池技术，而在 Mybatis 中也有连接池技术，但是它采用的是自己的连接池技术。在 Mybatis 的 SqlMapConfig.xml 配置文件中，通过来实现 Mybatis 中连接池的配置。

1.2.1 Mybatis 连接池的分类

在 Mybatis 中我们将它的数据源 dataSource 分为以下几类：

可以看出 Mybatis 将它自己的数据源分为三类： POOLED 采用传统的javax.sql.DataSource规范中的连接池，mybatis中有针对规范的实现 UNPOOLED 采用传统的获取连接的方式，虽然也实现Javax.sql.DataSource接口，但是并没有使用池的思想。 JNDI 采用服务器提供的JNDI技术实现，来获取DataSource对象，不同的服务器所能拿到DataSource是不一样。注意：如果不是web或者maven的war工程，是不能使用的。我们课程中使用的是tomcat服务器，采用连接池就是dbcp连接池。

具体结构如下：

相应地，MyBatis 内部分别定义了实现了 java.sql.DataSource 接口的 UnpooledDataSource， PooledDataSource 类来表示 UNPOOLED、POOLED 类型的数据源。

在这三种数据源中，我们一般采用的是 POOLED 数据源（很多时候我们所说的数据源就是为了更好的管理数据库连接，也就是我们所说的连接池技术）。

1.2.2 创建一个新的工程

复制之前的那个修改一下就可以了。

1.2.3 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 在初始化时，根据<dataSource>的 type 属性来创建相应类型的的数据源 DataSource，即：
type=”POOLED”：MyBatis 会创建 PooledDataSource 实例
type=”UNPOOLED” ： MyBatis 会创建 UnpooledDataSource 实例
type=”JNDI”：MyBatis 会从 JNDI 服务上查找 DataSource 实例，然后返回使用

1.2.4 分析UnpooledDataSource和PooledDataSource

1、找到UnpooledDataSource和PooledDataSource

进去大家就可以看到他们两个都实现了DataSource接口，这个DataSource就是javax.sql的DataSource也就是JDBC连接规范中的定义，那这个里面一定就会有一个方法getConnection(),那我们从UnpooledDataSource怎么去找呢，也很容易。

2、回到UnpooledDataSource

看这个类里面是不是有连接数据库的信息，然后你就可以到这个类里面去找getConnection()方法，然后它执行了一个doGetConnection()方法。

3、点击doGetConnection跟进去源码

首先它在这个地方就创建了一个Properties对象，然后把用户名和密码都设置进去了，接着又再次调用了doGetConnection()方法

4、继续点击doGetConnection()方法跟进去

也就是这个方法在起作用，而这个方法的第二行话，认识嘛，这句话不就是经常写的DriverManager.getConnection嘛。

5、点击一句话initializeDriver

这个里面就不用想了，也就是Class.forName()，这个不就是我们说的注册驱动嘛。

6、回到doGetConnection()方法

不就是给我们注册驱动，获取连接，并且再返回回去

7、分析完回到PooledDataSource

它也实现了DataSource那么我们也去找getConnection()方法，它调用了一个popConnection方法

8、右击跟进去popConnection方法

在这个里面首先conn == null，下面就有一个同步代码块，刚刚我们说过它必须是一个线程安全的，接着继续它说!state.idleConnections.isEmpty()这句话的意思就是空闲的连接还有，然后remove(0);，现在我们需要知道idleConnections是谁，我们就点进去看一下

9、进入到idleConnections

进入到里面我们发现他就是一个ArrayList，那么就和刚刚我们讲的连接池契合上了，他是一个集合。

它在集合里面做了什么事情呢，如果他的空闲有的话，他就拿一个出来用，那么如果他的空闲没有了，他就会进入else，else又干了一件事state.activeConnections.size() < poolMaximumActiveConnections，说白了就是活动的连接池数量小于设定的最大值，他就可以conn = new PooledConnection(dataSource.getConnection(), this);

在这个里面这句话大家应该都知道是什么意思dataSource.getConnection()拿一个连接出来，也就是说他就可以给你创建一个新的，换句话说，如果我们的空闲还有位置，那你拿一个用，如果空闲里面没了，它就会判断你这个活动连接里面还有没有地，有地我就给你创建一个新的，然后我们给你割进去，当前它也有可能活动里面也没地了，也就是走到了下面那一块的else，它就会获取活动中最老的一个连接出来，然后进行一些相关的设置和清理操作，来给我们用

1.3 Mybatis 的事务控制

1.3.1 JDBC 中事务的回顾

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

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

1.3.2 Mybatis 中事务提交方式

Mybatis 中事务的提交方式，本质上就是调用 JDBC 的 setAutoCommit()来实现事务控制。我们运行之前所写的代码：

@Test
public void testSaveUser() throws Exception {
    User user = new User();
    user.setUsername("mybatis user09");
    //6.执行操作
    int res = userDao.saveUser(user);
    System.out.println(res);
    System.out.println(user.getId());
}

@Before//在测试方法执行之前执行
public void init()throws Exception {
    //1.读取配置文件
    in = Resources.getResourceAsStream("SqlMapConfig.xml");
    //2.创建构建者对象
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    //3.创建 SqlSession 工厂对象
    factory = builder.build(in);
    //4.创建 SqlSession 对象
    session = factory.openSession();
    //5.创建 Dao 的代理对象
    userDao = session.getMapper(IUserDao.class);
}

@After//在测试方法执行完成之后执行
public void destroy() throws Exception{
    //7.提交事务
    session.commit();
    //8.释放资源
    session.close();
    in.close();
}

观察在它在控制台输出的结果：

这是我们的 Connection 的整个变化过程，通过分析我们能够发现之前的 CUD 操作过程中，我们都要手动进行事务的提交，原因是setAutoCommit()方法，在执行时它的值被设置为 false 了，所以我们在 CUD 操作中，必须通过 sqlSession.commit()方法来执行提交操作。

1.3.3 Mybatis 自动提交事务的设置

通过上面的研究和分析，现在我们一起思考，为什么 CUD 过程中必须使用 sqlSession.commit()提交事务？主要原因就是在连接池中取出的连接，都会将调用 connection.setAutoCommit(false)方法，这样我们就必须使用 sqlSession.commit()方法，相当于使用了 JDBC 中的 connection.commit()方法实现事务提交。明白这一点后，我们现在一起尝试不进行手动提交，一样实现 CUD 操作。

    @Before//用于在测试方法执行之前执行
    public void init()throws Exception{
        //1.读取配置文件，生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.获取SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.获取SqlSession对象
        sqlSession = factory.openSession(true);
        //4.获取dao的代理对象
        userDao = sqlSession.getMapper(IUserDao.class);
    }

    @After//用于在测试方法执行之后执行
    public void destroy()throws Exception{
        //提交事务
        //sqlSession.commit();
        //6.释放资源
        sqlSession.close();
        in.close();
    }

我们发现，此时事务就设置为自动提交了，同样可以实现CUD操作时记录的保存。虽然这也是一种方式，但就编程而言，设置为自动提交方式为 false再根据情况决定是否进行提交，这种方式更常用。因为我们可以根据业务情况来决定提交是否进行提交。

Mybatis 的态动态 SQL 语句

Mybatis 的映射文件中，前面我们的 SQL 都是比较简单的，有些时候业务逻辑复杂时，我们的 SQL 是动态变化的，此时在前面的学习中我们的 SQL 就不能满足要求了。参考的官方文档，描述如下：

创建一个新工程

1、里面的步骤还是一样的复制上一个的改动就好了。

2、把里面的增删改方法都删了，保留查询就可以了，因为我们用不到。

2.1 动态SQL之if 标签

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

2.1.1 持久层 Dao 接口

package com.sixstar.mybatis.dao;

import com.sixstar.mybatis.domain.QueryVo;
import com.sixstar.mybatis.domain.User;

import java.util.List;

//用户的持久层接口
public interface IUserDao {

    /**
     * 根据传入参数条件
     * @param user 查询的条件：有可能有用户名，有可能有性别，也有可能有地址，还有可能是都有
     * @return
     */
    List<User> findUserByCondition(User user);
}

2.1.2 持久层 Dao 映射配置

<?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">
<!--
    namespace属性是名称空间的意思。
    功能相当于 给配置文件定义一个包名。
    一般情况下。可以写两种值，一种是对应类的全类名
    一种情况是。对应类的处理接口全类名（后面讲）。
 -->

<mapper namespace="com.sixstar.mybatis.dao.IUserDao">

    <!-- 根据条件查询-->
    <select id="findUserByCondition" resultMap="userMap" parameterType="user">
        select * from user where 1=1
        <if test="userName != null">
          and username = #{userName}
        </if>
        <if test="userSex != null">
            and sex = #{userSex}
        </if>
    </select>
</mapper>

注意：标签的 test 属性中写的是对象的属性名，如果是包装类的对象要使用 OGNL 表达式的写法。另外要注意 where 1=1 的作用~！

2.1.3 测试

    /**
     * 测试查询所有
     */
    @Test
    public void testFindByCondition(){
        User u = new User();
        u.setUserName("老王");
//        u.setUserSex("女");

        //5.执行查询所有方法
        List<User> users = userDao.findUserByCondition(u);
        for(User user : users){
            System.out.println(user);
        }

    }

2.2 动态SQL之where标签

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

2.2.1 持久层 Dao 映射配置

<?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">
<!--
    namespace属性是名称空间的意思。
    功能相当于 给配置文件定义一个包名。
    一般情况下。可以写两种值，一种是对应类的全类名
    一种情况是。对应类的处理接口全类名（后面讲）。
 -->

<mapper namespace="com.sixstar.mybatis.dao.IUserDao">

    <select id="findUserByCondition" resultMap="userMap" parameterType="user">
        select * from user
        <where>
            <if test="userName != null">
                and username = #{userName}
            </if>
            <if test="userSex != null">
                and sex = #{userSex}
            </if>
        </where>
    </select>
</mapper>

2.3 动态标签之foreach标签

2.3.1 需求

传入多个 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)
这样我们在进行范围查询时，就要将一个集合中的值，作为参数动态添加进来。
这样我们将如何进行参数的传递？

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

package com.sixstar.mybatis.domain;


import java.util.List;

public class QueryVo {

    private User user;

    private List<Integer> ids;

    public List<Integer> getIds() {
        return ids;
    }

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

    public User getUser() {
        return user;
    }

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

2.3.2 持久层 Dao 接口

package com.sixstar.mybatis.dao;

import com.sixstar.mybatis.domain.QueryVo;
import com.sixstar.mybatis.domain.User;

import java.util.List;

//用户的持久层接口
public interface IUserDao {

    /**
     * 根据queryvo中提供的id集合，查询用户信息
     * @param vo
     * @return
     */
    List<User> findUserInIds(QueryVo vo);
}

2.3.3 持久层 Dao 映射

<?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">
<!--
    namespace属性是名称空间的意思。
    功能相当于 给配置文件定义一个包名。
    一般情况下。可以写两种值，一种是对应类的全类名
    一种情况是。对应类的处理接口全类名（后面讲）。
 -->

<mapper namespace="com.sixstar.mybatis.dao.IUserDao">

    <!-- 根据queryvo中的Id集合实现查询用户列表 -->
    <select id="findUserInIds" resultMap="userMap" parameterType="queryvo">
        select * from user
        <where>
            <if test="ids != null and ids.size()>0">
                <foreach collection="ids" open="and id in (" close=")" item="uid" separator=",">
                    #{uid}
                </foreach>
            </if>
        </where>
    </select>
</mapper>

SQL 语句：
    select 字段 from user where id in (?)
<foreach>标签用于遍历集合，它的属性：
    collection:代表要遍历的集合元素，注意编写时不要写#{}
    open:代表语句的开始部分
    close:代表结束部分
•   item:代表遍历集合的每个元素，生成的变量名
•   sperator:代表分隔符

2.3.3.1 编写测试方法

    /**
     * 测试foreach标签的使用
     */
    @Test
    public void testFindInIds(){
        QueryVo vo = new QueryVo();
        List<Integer> list = new ArrayList<>();
        list.add(41);
        list.add(42);
        list.add(46);
        vo.setIds(list);


        //5.执行查询所有方法
        List<User> users = userDao.findUserInIds(vo);
        for(User user : users){
            System.out.println(user);
        }

    }

2.4 Mybatis中简化编写的 SQL片段

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

2.4.1 定义代码片段

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

2.4.2 引用代码片段

<!-- 配置查询所有操作 -->
<select id="findAll" resultType="user">
    <include refid="defaultSql"></include>
</select>

Mybatis 多表查询之一对多

分析

mybatis中的多表查询
    表之间的关系有几种：
        一对多
        多对一
        一对一
        多对多
    举例：
        用户和订单就是一对多
        订单和用户就是多对一
            一个用户可以下多个订单
            多个订单属于同一个用户

        人和身份证号就是一对一
            一个人只能有一个身份证号
            一个身份证号只能属于一个人

        老师和学生之间就是多对多
            一个学生可以被多个老师教过
            一个老师可以交多个学生
        
    mybatis中的多表查询：
        示例：用户和账户
            一个用户可以有多个账户
            一个账户只能属于一个用户（多个账户也可以属于同一个用户）
        步骤：
            1、建立两张表：用户表，账户表
                让用户表和账户表之间具备一对多的关系：需要使用外键在账户表中添加
            2、建立两个实体类：用户实体类和账户实体类
                让用户和账户的实体类能体现出来一对多的关系
            3、建立两个配置文件
                用户的配置文件
                账户的配置文件
            4、实现配置：
                当我们查询用户时，可以同时得到用户下所包含的账户信息
                当我们查询账户时，可以同时得到账户的所属用户信息

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

步骤

1.1 创建表

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;

insert  into `account`(`ID`,`UID`,`MONEY`) values (1,46,1000),(2,45,1000),(3,46,2000);

1.2 创建一个新的工程

里面的内容还是一样的复制，然后改动。

1、IUserDao里面的方法只保留查询所有和根据id查询

package com.sixstar.mybatis.dao;

import com.sixstar.mybatis.domain.User;

import java.util.List;

//用户的持久层接口
public interface IUserDao {

    /**
     * 查询所有用户
     * @return
     */
    List<User> findAll();

    /**
     * 根据 id 查询
     * @param userId
     * @return
     */
    User findById(Integer userId);

}

2、映射文件也是一样的只保留查询所有和根据id查询

<?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">
<!--
    namespace属性是名称空间的意思。
    功能相当于 给配置文件定义一个包名。
    一般情况下。可以写两种值，一种是对应类的全类名
    一种情况是。对应类的处理接口全类名（后面讲）。
 -->

<mapper namespace="com.sixstar.mybatis.dao.IUserDao">

    <!--查询所有-->
    <select id="findAll" resultType="user">
        select * from user
    </select>

    <!-- 根据id查询用户 -->
    <select id="findById" parameterType="int" resultType="user">
        select * from user where id = #{uid}
    </select>

</mapper>

3、删除QueryVo类

4、修改实体类

package com.sixstar.mybatis.domain;

import java.io.Serializable;
import java.util.Date;

public class User implements Serializable {

    private Integer id;
    private String username;
    private String address;
    private String sex;
    private Date birthday;

    public Integer getId() {
        return id;
    }

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

    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;
    }

    public String getSex() {
        return sex;
    }

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

    public Date getBirthday() {
        return birthday;
    }

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

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

3.1 一对一查询( 多对一)

需求
    查询所有账户信息，关联查询下单用户信息。
注意：
    因为一个账户信息只能供某个用户使用，所以从查询账户信息出发关联查询用户信息为一对一查询。如
    果从用户信息出发查询用户下的账户信息则为一对多查询，因为一个用户可以有多个账户。

3.1.1 定义账户信息的实体类

package com.sixstar.mybatis.domain;

import java.io.Serializable;

/**
 * <p>Title: Account</p>
 * <p>Description: 账户的实体类</p>
 */
public class Account implements Serializable {

    private Integer id;
    private Integer uid;
    private Double money;

    public Integer getId() {
        return id;
    }

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

    public Integer getUid() {
        return uid;
    }

    public void setUid(Integer 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 +
                '}';
    }
}

3.1.2 定义层账户的持久层 Dao 接口

package com.sixstar.mybatis.dao;

import com.sixstar.mybatis.domain.Account;

import java.util.List;


public interface IAccountDao {

    /**
     * 查询所有账户
     * @return
     */
    List<Account> findAll();
    
}

3.1.3 定义 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="com.sixstar.mybatis.dao.IAccountDao">

    <!-- 查询所有 -->
    <select id="findAll" resultType="account">
        select * from account;
    </select>

</mapper>

3.1.4 创建 AccountTest 测试类

package com.sixstar.test;

import com.sixstar.mybatis.dao.IAccountDao;
import com.sixstar.mybatis.domain.Account;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.InputStream;
import java.util.List;

public class AccountTest {

    private InputStream in;
    private SqlSession sqlSession;
    private IAccountDao accountDao;

    @Before//用于在测试方法执行之前执行
    public void init()throws Exception{
        //1.读取配置文件，生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.获取SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.获取SqlSession对象
        sqlSession = factory.openSession(true);
        //4.获取dao的代理对象
        accountDao = sqlSession.getMapper(IAccountDao.class);
    }

    @After//用于在测试方法执行之后执行
    public void destroy()throws Exception{
        //提交事务
        // sqlSession.commit();
        //6.释放资源
        sqlSession.close();
        in.close();
    }

    /**
     * 测试查询所有
     */
    @Test
    public void testFindAll(){
        List<Account> accounts = accountDao.findAll();
        for(Account account : accounts){
            System.out.println("--------每个account的信息------------");
            System.out.println(account);
        }
    }
}

需求

查询所有账户，同时还要获取到当前账户的所属用户信息

步骤

1、首先你需要把SQL语句写出来才行，因为你只有把SQL语句写出来了才能去写代码

2、现在我们想要两个表又关联，那么我们就需要把两张表的SQL语句写在一起

3、给这两个表的数据起别名

select u.*,a.id as aid,a.uid,a.money from account a,user u where u.id = a.uid;

4、SQL语句有了之后我们需要保留那些信息，首先这个id我们有两个所以保留一个就可以了，现在我们就要名称、地址，别的就不想要了，这点出发我们就可以有两种解决办法，先看简单的。

3.1.1 方式一

3.1.1.1 定义 AccountUser 类

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

package com.sixstar.mybatis.domain;


public class AccountUser extends Account {

    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 + ''' +
                '}';
    }
}

3.1.1.2 定义层账户的持久层 Dao接口

package com.sixstar.mybatis.dao;

import com.sixstar.mybatis.domain.Account;
import com.sixstar.mybatis.domain.AccountUser;

import java.util.List;


public interface IAccountDao {

    /**
     * 查询所有账户，并且带有用户名称和地址信息
     * @return
     */
    List<AccountUser> findAllAccount();
}

3.1.1.3 定义 AccountDao.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="com.sixstar.mybatis.dao.IAccountDao">

    <!--查询所有账户同时包含用户名和地址信息-->
    <select id="findAllAccount" resultType="accountuser">
        select a.*,u.username,u.address from account a , user u where u.id = a.uid;
    </select>

</mapper>

注意：因为上面查询的结果中包含了账户信息同时还包含了用户信息，所以我们的返回值类型 returnType 的值设置为 AccountUser 类型，这样就可以接收账户信息和用户信息了。

3.1.1.4 在测试类中测试findAllAccount方法

    /**
     * 测试查询所有账户，同时包含用户名称和地址
     */
    @Test
    public void testFindAllAccountUser(){
        List<AccountUser> aus = accountDao.findAllAccount();
        for(AccountUser au : aus){
            System.out.println(au);
        }
    }

注意：这种方式在企业中是不常用的。

3.1.2 方式二

使用 resultMap，定义专门的 resultMap 用于映射一对一查询结果。

通过面向对象的(hasa)关系可以得知，我们可以在 Account 类中加入一个 User 类的对象来代表这个账户
是哪个用户的。

3.1.2.1 修改 Account 类

package com.sixstar.mybatis.domain;

import java.io.Serializable;

/**
 * <p>Title: Account</p>
 * <p>Description: 账户的实体类</p>
 */
public class Account implements Serializable {

    private Integer id;
    private Integer uid;
    private Double money;

    //从表实体应该包含一个主表实体的对象引用
    private User user;

    public User getUser() {
        return user;
    }

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

}

3.1.2.2 重新定义 AccountDao.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="com.sixstar.mybatis.dao.IAccountDao">

    <!-- 定义封装account和user的resultMap -->
    <resultMap id="accountUserMap" type="account">
        <id property="id" column="aid"/>
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
        <!-- 一对一的关系映射：配置封装user的内容
        property-表名
        查询条件-表名
        javaType-封装对象
        -->
        <association property="user" column="uid" javaType="user">
            <id property="id" column="id"></id>
            <result column="username" property="username"></result>
            <result column="address" property="address"></result>
            <result column="sex" property="sex"></result>
            <result column="birthday" property="birthday"></result>
        </association>
    </resultMap>

    <!-- 查询所有 -->
    <select id="findAll" resultMap="accountUserMap">
        select u.*,a.id as aid,a.uid,a.money from account a,user u where u.id = a.uid;
    </select>

</mapper>

企业中使用普遍。

3.1.2.3 在AccountTest 类中修改测试方法

    /**
     * 测试查询所有
     */
    @Test
    public void testFindAll(){
        List<Account> accounts = accountDao.findAll();
        for(Account account : accounts){

            System.out.println("--------每个account的信息------------");
            System.out.println(account);
            System.out.println(account.getUser());
        }
    }

3.2 一对多查询

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

3.2.1 编写 SQL 语句

SELECT u.*, acc.id id,acc.uid,acc.money FROM user u LEFT JOIN account acc ON u.id = acc.uid

3.2.2 User 类加入 List

package com.sixstar.mybatis.domain;

import java.io.Serializable;
import java.util.Date;
import java.util.List;

public class User implements Serializable {

    private Integer id;
    private String username;
    private String address;
    private String sex;
    private Date birthday;

    private List<Account> accounts;
    
    public List<Account> getAccounts() {
        return accounts;
    }
    public void setAccounts(List<Account> accounts) {
        this.accounts = accounts;
    }

    public Integer getId() {
        return id;
    }

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

    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;
    }

    public String getSex() {
        return sex;
    }

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

    public Date getBirthday() {
        return birthday;
    }

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

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

3.2.3 用户持久层 Dao 接口中加入查询方法

package com.sixstar.mybatis.dao;

import com.sixstar.mybatis.domain.User;

import java.util.List;

//用户的持久层接口
public interface IUserDao {

    /**
     * 查询所有用户
     * @return
     */
    List<User> findAll();

}

3.2.4 用户持久层 Dao映射文件配置

<?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">
<!--
    namespace属性是名称空间的意思。
    功能相当于 给配置文件定义一个包名。
    一般情况下。可以写两种值，一种是对应类的全类名
    一种情况是。对应类的处理接口全类名（后面讲）。
 -->

<mapper namespace="com.sixstar.mybatis.dao.IUserDao">

    <!-- 定义User的resultMap-->
    <resultMap id="userAccountMap" type="user">
        <id property="id" column="id"></id>
        <result property="username" column="username"/>
        <result property="address" column="address"></result>
        <result property="sex" column="sex"></result>
        <result property="birthday" column="birthday"></result>
        <!-- 配置user对象中accounts集合的映射 -->
        <collection property="accounts" ofType="account">
            <id column="aid" property="id"></id>
            <result column="uid" property="uid"></result>
            <result column="money" property="money"></result>
        </collection>
    </resultMap>

    <!-- 查询所有 -->
    <select id="findAll" resultMap="userAccountMap">
        select * from user u left outer join account a on u.id = a.uid
    </select>

</mapper>

3.2.5 测试方法

package com.sixstar.test;

import com.sixstar.mybatis.dao.IUserDao;
import com.sixstar.mybatis.domain.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.InputStream;
import java.util.List;

public class UserTest {

    private InputStream in;
    private SqlSession sqlSession;
    private IUserDao userDao;

    @Before//用于在测试方法执行之前执行
    public void init()throws Exception{
        //1.读取配置文件，生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.获取SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.获取SqlSession对象
        sqlSession = factory.openSession(true);
        //4.获取dao的代理对象
        userDao = sqlSession.getMapper(IUserDao.class);
    }

    @After//用于在测试方法执行之后执行
    public void destroy()throws Exception{
        //提交事务
        // sqlSession.commit();
        //6.释放资源
        sqlSession.close();
        in.close();
    }

    /**
     * 测试查询所有
     */
    @Test
    public void testFindAll(){
        List<User> users = userDao.findAll();
        for(User user : users){
            System.out.println("-----每个用户的信息------");
            System.out.println(user);
            System.out.println(user.getAccounts());
        }
    }



}

Mybatis 多表查询之多对多

示例

用户和角色
            一个用户可以有多个角色
            一个角色也能属于多个用户

步骤

1、创建一个新的工程复制上一个改动

1.1 删除IAccountDao接口、删除Account实现类、删除IAccountDao.xml配置文件、删除AccountTest测试类

1.2 删除AccountUser实现类

1.3 修改User类，删除里面的

   private List<Account> accounts;

    public List<Account> getAccounts() {
        return accounts;
    }
    public void setAccounts(List<Account> accounts) {
        this.accounts = accounts;
    }

1.4 修改IUserDao.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">
<!--
    namespace属性是名称空间的意思。
    功能相当于 给配置文件定义一个包名。
    一般情况下。可以写两种值，一种是对应类的全类名
    一种情况是。对应类的处理接口全类名（后面讲）。
 -->

<mapper namespace="com.sixstar.mybatis.dao.IUserDao">

    <!-- 定义User的resultMap-->
    <resultMap id="userAccountMap" type="user">
        <id property="id" column="id"></id>
        <result property="username" column="username"/>
        <result property="address" column="address"></result>
        <result property="sex" column="sex"></result>
        <result property="birthday" column="birthday"></result>
    </resultMap>

    <!-- 查询所有 -->
    <select id="findAll" resultMap="userAccountMap">
        select * from user
    </select>

    <!-- 根据id查询用户 -->
    <select id="findById" parameterType="int" resultType="user">
        select * from user where id = #{uid}
    </select>

</mapper>

1.5 修改UserTest测试类，删除

System.out.println(user.getAccounts());

2、建立两张表：用户表，角色表让用户表和角色表之间具备一对多的关系：需要使用外键在账户表中添加

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;

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


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;

insert  into `user_role`(`UID`,`RID`) values (41,1),(45,1),(41,2);

4.1 实现 Role 到 User 多对多

通过前面的学习，我们使用 Mybatis 实现一对多关系的维护。多对多关系其实我们看成是双向的一对多关系。

4.1.1 用户与角色的关系模型

用户与角色的多对多关系模型如下：

4.1.2 编写角色实体类

package com.sixstar.mybatis.domain;

import java.io.Serializable;
import java.util.List;


public class Role implements Serializable {

    private Integer roleId;
    private String roleName;
    private String roleDesc;

    //多对多的关系映射：一个角色可以赋予多个用户
    private List<User> users;

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

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

    public Integer getRoleId() {
        return roleId;
    }

    public void setRoleId(Integer roleId) {
        this.roleId = roleId;
    }

    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;
    }

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

4.1.3 编写 Role 持久层接口

package com.sixstar.mybatis.dao;

import com.sixstar.mybatis.domain.Role;

import java.util.List;


public interface IRoleDao {

    /**
     * 查询所有角色
     * @return
     */
    List<Role> findAll();
}

4.1.4 编写映射文件

<?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="com.sixstar.mybatis.dao.IRoleDao">

    <!--定义role表的ResultMap-->
    <resultMap id="roleMap" type="role">
        <id property="roleId" column="rid"></id>
        <result property="roleName" column="role_name"></result>
        <result property="roleDesc" column="role_desc"></result>
    </resultMap>

    <!--查询所有-->
    <select id="findAll" resultMap="roleMap">
       select *from role
    </select>
</mapper>

4.1.6 编写测试类

package com.sixstar.test;

import com.sixstar.mybatis.dao.IRoleDao;
import com.sixstar.mybatis.domain.Role;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.InputStream;
import java.util.List;


public class RoleTest {

    private InputStream in;
    private SqlSession sqlSession;
    private IRoleDao roleDao;

    @Before//用于在测试方法执行之前执行
    public void init()throws Exception{
        //1.读取配置文件，生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.获取SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.获取SqlSession对象
        sqlSession = factory.openSession(true);
        //4.获取dao的代理对象
        roleDao = sqlSession.getMapper(IRoleDao.class);
    }

    @After//用于在测试方法执行之后执行
    public void destroy()throws Exception{
        //提交事务
        // sqlSession.commit();
        //6.释放资源
        sqlSession.close();
        in.close();
    }

    /**
     * 测试查询所有
     */
    @Test
    public void testFindAll(){
        List<Role> roles = roleDao.findAll();
        for(Role role : roles){
            System.out.println("---每个角色的信息----");
            System.out.println(role);
            System.out.println(role.getUsers());
        }
    }


}

4.1.7 业务要求及实现 SQL

需求：
实现查询所有对象并且加载它所分配的用户信息。
分析：
查询角色我们需要用到Role表，但角色分配的用户的信息我们并不能直接找到用户信息，而是要通过中
间表(USER_ROLE 表)才能关联到用户信息。

select u.*,r.id as rid,r.role_name,r.role_desc from role r
  left outer join user_role ur  on r.id = ur.rid
  left outer join user u on u.id = ur.uid

4.1.8 修改映射文件

<?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="com.sixstar.mybatis.dao.IRoleDao">

    <!--定义role表的ResultMap-->
    <resultMap id="roleMap" type="role">
        <id property="roleId" column="rid"></id>
        <result property="roleName" column="role_name"></result>
        <result property="roleDesc" column="role_desc"></result>
        <collection property="users" ofType="user">
            <id column="id" property="id"></id>
            <result column="username" property="username"></result>
            <result column="address" property="address"></result>
            <result column="sex" property="sex"></result>
            <result column="birthday" property="birthday"></result>
        </collection>
    </resultMap>

    <!--查询所有-->
    <select id="findAll" resultMap="roleMap">
       select u.*,r.id as rid,r.role_name,r.role_desc from role r
        left outer join user_role ur  on r.id = ur.rid
        left outer join user u on u.id = ur.uid
    </select>
</mapper>

4.2 实现 User 到 Role 的多对多

4.2.1 User 到 Role 的对多

从 User 出发，我们也可以发现一个用户可以具有多个角色，这样用户到角色的关系也还是一对多关系。这样
我们就可以认为 User 与 Role 的多对多关系，可以被拆解成两个一对多关系来实现。

4.2.2 编写角色实体类

package com.sixstar.mybatis.domain;

import java.io.Serializable;
import java.util.Date;
import java.util.List;

public class User implements Serializable {

    private Integer id;
    private String username;
    private String address;
    private String sex;
    private Date birthday;

    //多对多的关系映射：一个用户可以具备多个角色
    private List<Role> roles;

    public List<Role> getRoles() {
        return roles;
    }

    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }

    public Integer getId() {
        return id;
    }

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

    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;
    }

    public String getSex() {
        return sex;
    }

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

    public Date getBirthday() {
        return birthday;
    }

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

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

4.2.3 编写映射文件

<?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">
<!--
    namespace属性是名称空间的意思。
    功能相当于 给配置文件定义一个包名。
    一般情况下。可以写两种值，一种是对应类的全类名
    一种情况是。对应类的处理接口全类名（后面讲）。
 -->

<mapper namespace="com.sixstar.mybatis.dao.IUserDao">

    <!-- 定义User的resultMap-->
    <resultMap id="userMap" type="user">
        <id property="id" column="id"></id>
        <result property="username" column="username"></result>
        <result property="address" column="address"></result>
        <result property="sex" column="sex"></result>
        <result property="birthday" column="birthday"></result>
        <!-- 配置角色集合的映射 -->
        <collection property="roles" ofType="role">
            <id property="roleId" column="rid"></id>
            <result property="roleName" column="role_name"></result>
            <result property="roleDesc" column="role_desc"></result>
        </collection>
    </resultMap>

    <!-- 查询所有 -->
    <select id="findAll" resultMap="userMap">
        select u.*,r.id as rid,r.role_name,r.role_desc from user u
         left outer join user_role ur  on u.id = ur.uid
         left outer join role r on r.id = ur.rid
    </select>

</mapper>

4.2.4 编写测试类

package com.sixstar.test;

import com.sixstar.mybatis.dao.IUserDao;
import com.sixstar.mybatis.domain.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.InputStream;
import java.util.List;

public class UserTest {

    private InputStream in;
    private SqlSession sqlSession;
    private IUserDao userDao;

    @Before//用于在测试方法执行之前执行
    public void init()throws Exception{
        //1.读取配置文件，生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.获取SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.获取SqlSession对象
        sqlSession = factory.openSession(true);
        //4.获取dao的代理对象
        userDao = sqlSession.getMapper(IUserDao.class);
    }

    @After//用于在测试方法执行之后执行
    public void destroy()throws Exception{
        //提交事务
        // sqlSession.commit();
        //6.释放资源
        sqlSession.close();
        in.close();
    }

    /**
     * 测试查询所有
     */
    @Test
    public void testFindAll(){
        List<User> users = userDao.findAll();
        for(User user : users){
            System.out.println("-----每个用户的信息------");
            System.out.println(user);
            System.out.println(user.getRoles());
        }
    }

}

JNDI数据源

JNDI：Java Naming and Directory Interface。是SUN公司推出的一套规范，属于JavaEE技术之一。目的是模仿windows系统中的注册表。

在服务器中注册数据源：

03-MyBatis连接池与事物及动态SQL和多表查询

03-MyBatis连接池与事物及动态SQL和多表查询

Mybatis 连接池与事务深入

1.1 回顾连接池

1.2 Mybatis 的连接池技术

1.2.1 Mybatis 连接池的分类

1.2.2 创建一个新的工程

1.2.3 Mybatis 中数据源的配置

1.2.4 分析UnpooledDataSource和PooledDataSource

1.3 Mybatis 的事务控制

1.3.1 JDBC 中事务的回顾

1.3.2 Mybatis 中事务提交方式

1.3.3 Mybatis 自动提交事务的设置

Mybatis 的态动态 SQL 语句

创建一个新工程

2.1 动态SQL之if 标签

2.1.1 持久层 Dao 接口

2.1.2 持久层 Dao 映射配置

2.1.3 测试

2.2 动态SQL之where标签

2.2.1 持久层 Dao 映射配置

2.3 动态标签之foreach标签

2.3.1 需求

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

2.3.2 持久层 Dao 接口

2.3.3 持久层 Dao 映射

2.3.3.1 编写测试方法

2.4 Mybatis中简化编写的 SQL片段

2.4.1 定义代码片段

2.4.2 引用代码片段

Mybatis 多表查询之一对多

分析

步骤

1.1 创建表

1.2 创建一个新的工程

3.1 一对一查询( 多对一)

3.1.1 定义账户信息的 实体类

3.1.2 定义层 账户的持久层 Dao 接口

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

3.1.4 创建 AccountTest 测试类

需求

步骤

3.1.1 方式一

3.1.1.1 定义 AccountUser 类

3.1.1.2 定义层账户的持久层 Dao接口

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

3.1.1.4 在测试类中测试findAllAccount方法

3.1.2 方式二

3.1.2.1 修改 Account 类

3.1.2.2 重新定义 AccountDao.xml 文件

3.1.2.3 在AccountTest 类中修改测试方法

3.2 一对多查询

3.2.1 编写 SQL 语句

3.2.2 User 类加入 List

3.2.3 用户持久层 Dao 接口中加入查询方法

3.2.4 用户持久层 Dao映射文件配置

3.2.5 测试方法

Mybatis 多表查询之多对多

示例

步骤

4.1 实现 Role 到 User 多对多

4.1.1 用户与角色的关系模型

4.1.2 编写角色实体类

4.1.3 编写 Role 持久层接口

4.1.4 编写映射文件

4.1.6 编写测试类

4.1.7 业务要求及实现 SQL

4.1.8 修改映射文件

4.2 实现 User 到 Role 的多对多

4.2.1 User 到 Role 的 对多

4.2.2 编写角色实体类

4.2.3 编写映射文件

4.2.4 编写测试类

JNDI数据源

3.1.1 定义账户信息的实体类

3.1.2 定义层账户的持久层 Dao 接口

4.2.1 User 到 Role 的对多