MyBatis从原理到实战

持久层技术解决方案

• JDBC技术：Connection PreparedStatement ResultSet
• Spring的JdbcTemplate：Spring中对jdbc的简单封装
• Apache的DBUtils

MyBatis入门

Mybatis是一个优秀的基于Java的持久层框架，它内部封装了jdbc，使开发者只需要关注sql语句本身，而不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。

Mybatis通过xml或注解的方式将要执行的各种statement配置起来，并通过Java对象和statement中sql的动态参数进行映射生成最终执行的sql语句，最后由Mybatis框架执行sql并将结果映射为Java对象并返回。

ORM思想：Object Relational Mapping 对象关系映射
就是把数据库表和实体类及实体类的属性对应起来。

环境搭建

创建maven工程并导入坐标

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.4.5</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.8</version>
    </dependency>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
  </dependencies>

创建实体类和dao接口

public class User implements Serializable {

    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
	
	get()...
	set()...
}

接口：

public interface IUserDao {
    List<User> findAll();
}

创建Mybatis的主配置文件SqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<!-- mybatis的主配置文件 -->
<configuration>
    <!-- 配置环境 -->
    <environments default="mysql">
        <!-- 配置mysql的环境-->
        <environment id="mysql">
            <!-- 配置事务的类型-->
            <transactionManager type="JDBC"></transactionManager>
            <!-- 配置数据源（连接池） -->
            <dataSource type="POOLED">
                <!-- 配置连接数据库的4个基本信息 -->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="916521"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件 -->
    <mappers>
        <mapper resource="top/tjtulong/dao/IUserDao.xml"/>
    </mappers>
</configuration>

创建映射配置文件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">
<mapper namespace="top.tjtulong.dao.IUserDao">
    <!--配置查询所有-->
    <select id="findAll" resultType="top.tjtulong.domain.User">
        select * from user
    </select>
</mapper>

环境搭建的注意事项：

• IUserDao和IUserMapper是一样的
• 在Idea中创建目录的时候，它和包是不一样的。
  包在创建时：top.tjtulong.dao它是三级结构
  目录在创建时：top.tjtulong.dao是一级目录
• mybatis的映射配置文件位置必须和dao接口的包结构相同
• 映射配置文件的mapper标签namespace属性的取值必须是dao接口的全限定类名
• 映射配置文件的操作配置，id属性的取值必须是dao接口的方法名

当我们遵从了第三，四，五点之后，我们在开发中就无须再写dao的实现类。

SqlMapConfig.xml配置文件

配置properties：可以在标签内部配置连接数据库的信息。也可以通过属性引用外部配置文件信息

• resource属性：用于指定配置文件的位置，是按照类路径的写法来写，并且必须存在于类路径下。
• url属性：是要求按照URL的写法来写地址

URL：Uniform Resource Locator 统一资源定位符。它是可以唯一标识一个资源的位置。
它的写法：
http://localhost:8080/mybatisserver/demo1Servlet
协议 主机 端口 URI

URI：Uniform Resource Identifier 统一资源标识符。它是在应用中可以唯一定位一个资源的。

typeAlias用于配置别名。type属性指定的是实体类全限定类名，alias属性指定别名，当指定了别名就不再区分大小写 ，用于指定要配置别名的包，当指定之后，该包下的实体类都会注册别名，并且类名就是别名，不再区分大小写。

package用于指定要配置别名的包，当指定之后，该包下的实体类都会注册别名，并且类名就是别名，不再区分大小写。

<!-- mybatis的主配置文件 -->
<configuration>
    <properties resource="jdbcConfig.properties"></properties>

    <typeAliases>
        <package name="top.tjtulong.domain"></package>
    </typeAliases>
    <!-- 配置环境 -->
    <environments default="mysql">
        <!-- 配置mysql的环境-->
        <environment id="mysql">
            <!-- 配置事务的类型-->
            <transactionManager type="JDBC"></transactionManager>
            <!-- 配置数据源（连接池） -->
            <dataSource type="POOLED">
                <!-- 配置连接数据库的4个基本信息 -->
                <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>
        </environment>
    </environments>

    <!-- 指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件 -->
    <mappers>
        <package name="top.tjtulong.dao"></package>
    </mappers>
</configuration>

查询操作

    /**
     * 入门案例
     * @param args
     */
    public static void main(String[] args)throws Exception {
        //1.读取配置文件
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        //3.使用工厂生产SqlSession对象
        SqlSession session = factory.openSession();
        //4.使用SqlSession创建Dao接口的代理对象
        IUserDao userDao = session.getMapper(IUserDao.class);
        //5.使用动态代理对象执行方法
        List<User> users = userDao.findAll();
        for(User user : users){
            System.out.println(user);
        }
        //6.释放资源
        session.close();
        in.close();
    }

基于注解开发

不再需要写创建映射配置文件IUserDao.xml，直接在接口方法上加入注解，效果相同：

public interface IUserDao {

    @Select("select * from user")
    List<User> findAll();

}

自定义查询方法

public class UserDaoImpl implements IUserDao {

    private SqlSessionFactory factory;

    public UserDaoImpl(SqlSessionFactory  factory){
        this.factory = factory;
    }


    public List<User> findAll(){
        //1.使用工厂创建SqlSession对象
        SqlSession session = factory.openSession();
        //2.使用session执行查询所有方法
        List<User> users = session.selectList("top.tjtulong.dao.IUserDao.findAll");
        session.close();
        //3.返回查询结果
        return users;
    }
}

应用的设计模式

建造者模式、工厂模式、代理模式。

自定义MyBatis

Resourse

public class Resources {

    /**
     * 根据传入的参数，获取一个字节输入流
     * @param filePath
     * @return
     */
    public static InputStream getResourceAsStream(String filePath){
        return Resources.class.getClassLoader().getResourceAsStream(filePath);
    }
}

配置类

* 自定义mybatis的配置类
 */
public class Configuration {

    private String driver;
    private String url;
    private String username;
    private String password;

    private Map<String,Mapper> mappers = new HashMap<String,Mapper>();

    public Map<String, Mapper> getMappers() {
        return mappers;
    }

    public void setMappers(Map<String, Mapper> mappers) {
        this.mappers.putAll(mappers);//此处需要使用追加的方式
    }

    public String getDriver() {
        return driver;
    }

    public void setDriver(String driver) {
        this.driver = driver;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getUsername() {
        return username;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

SqlSessionFactoryBuilder

dom4j + xpath解析xml

public class SqlSessionFactoryBuilder {

    /**
     * 根据参数的字节输入流来构建一个SqlSessionFactory工厂
     * @param config
     * @return
     */
    public SqlSessionFactory build(InputStream config){
        Configuration cfg = XMLConfigBuilder.loadConfiguration(config);
        return new DefaultSqlSessionFactory(cfg);
    }
}

SqlSessionFactory

public class DefaultSqlSessionFactory implements SqlSessionFactory{

    private Configuration cfg;

    public DefaultSqlSessionFactory(Configuration cfg){
        this.cfg = cfg;
    }

    /**
     * 用于创建一个新的操作数据库对象
     * @return
     */
    @Override
    public SqlSession openSession() {
        return new DefaultSqlSession(cfg);
    }
}

SqlSession

public class DefaultSqlSession implements SqlSession {

    private Configuration cfg;
    private Connection connection;

    public DefaultSqlSession(Configuration cfg){
        this.cfg = cfg;
        connection = DataSourceUtil.getConnection(cfg);
    }

    /**
     * 用于创建代理对象
     * @param daoInterfaceClass dao的接口字节码
     * @param <T>
     * @return
     */
    @Override
    public <T> T getMapper(Class<T> daoInterfaceClass) {
        return (T) Proxy.newProxyInstance(daoInterfaceClass.getClassLoader(),
                new Class[]{daoInterfaceClass},new MapperProxy(cfg.getMappers(),connection));
    }

    /**
     * 用于释放资源
     */
    @Override
    public void close() {
        if(connection != null) {
            try {
                connection.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

Handler类

public class MapperProxy implements InvocationHandler {

    //map的key是全限定类名+方法名
    private Map<String, Mapper> mappers;
    private Connection conn;

    public MapperProxy(Map<String,Mapper> mappers,Connection conn){
        this.mappers = mappers;
        this.conn = conn;
    }

    /**
     * 用于对方法进行增强的，我们的增强其实就是调用selectList方法
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //1.获取方法名
        String methodName = method.getName();
        //2.获取方法所在类的名称
        String className = method.getDeclaringClass().getName();
        //3.组合key
        String key = className+"."+methodName;
        //4.获取mappers中的Mapper对象
        Mapper mapper = mappers.get(key);
        //5.判断是否有mapper
        if(mapper == null){
            throw new IllegalArgumentException("传入的参数有误");
        }
        //6.调用工具类执行查询所有
        return new Executor().selectList(mapper,conn);
    }
}

MyBatis的crud操作

保存操作

映射配置文件中：

    <!--保存所有-->
    <insert id="saveUser" parameterType="top.tjtulong.domain.User">
        insert into user(username,address,sex,birthday) values (#{username},#{address},#{sex},#{birthday})
    </insert>

save

    @Test
    public void testSave() throws IOException {
        User user = new User();
        user.setUsername("mybatis save user");
        user.setAddress("上海市同济大学");
        user.setSex("男");
        user.setBirthday(new Date());

        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        SqlSession session = factory.openSession();
        IUserDao userDao = session.getMapper(IUserDao.class);

        userDao.saveUser(user);
        session.commit();

        session.close();
        in.close();
    }

新增用户后，同时还要返回当前新增用户的id值，因为id是由数据库的自动增长来实现的，所以就相当于我们要在新增后将自动增长auto_increment的值返回。

    <!--保存所有-->
    <insert id="saveUser" parameterType="top.tjtulong.domain.User">
        <!--获取插入操作后返回的id-->
        <selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">
            select last_insert_id()
        </selectKey>
        insert into user(username,address,sex,birthday) values (#{username},#{address},#{sex},#{birthday})
    </insert>

更新操作

    <!-- 更新用户 -->
    <update id="updateUser" parameterType="top.tjtulong.domain.User">
        update user set username=#{username},address=#{address},sex=#{userex},birthday=#{birthday} where id=#{id}
    </update>

update

    @Test
    public void testUpdate() throws IOException {
        User user = new User();
        user.setId(49);
        user.setUsername("mybatis update user");
        user.setAddress("上海市同济大学");
        user.setSex("女");
        user.setBirthday(new Date());

        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        SqlSession session = factory.openSession();
        IUserDao userDao = session.getMapper(IUserDao.class);

        userDao.updateUser(user);
        session.commit();

        session.close();
        in.close();
    }

删除操作

    /**
     * 删除用户
     */
    void deleteUser(Integer userId);

映射配置文件：

    <!-- 删除用户-->
    <delete id="deleteUser" parameterType="java.lang.Integer">
        delete from user where id = #{uid}
    </delete>

注：这里的占位符uid是任意的

模糊查询

<!-- 根据名称模糊查询 -->
    <select id="findByName" parameterType="string" resultMap="top.tjtulong.domain.User">
          select * from user where username like #{name}
        <!-- select * from user where username like '%${value}%'-->
   </select>

聚合函数

    /**
     * 查询记录数
     */
    int findTotal();

映射配置文件：

    <!--获取总记录数-->
    <select id="findTotal" resultType="int">
        select count(*) from user
    </select>

OGNL表达式

Object Graphic Navigation Language:对象图导航语言
它是通过对象的取值方法来获取对象，在写法上把get给省略了，例如：user.username代替user.getUsername()。

由多个对象组成查询条件

    <!-- 根据queryVo的条件查询用户 -->
    <select id="findUserByVo" parameterType="top.tjtulong.domain.QueryVo" resultMap="userMap">
        select * from user where username like #{user.username}
    </select>

测试类：

    /**
     * 测试使用QueryVo作为查询条件
     */
    @Test
    public void testFindByVo(){
        QueryVo vo = new QueryVo();
        User user = new User();
        user.setUserName("%王%");
        vo.setUser(user);
        //5.执行查询一个方法
        List<User> users = userDao.findUserByVo(vo);
        for(User u : users){
            System.out.println(u);
        }
    }

返回值对象封装

注：MySQL在windows下不区分大小写，username与userName完全相同。

当pojo类中的属性名和数据库中的字段不一致时，可以采用配置别名的方式（ResultMap）。

    <!-- 配置 查询结果的列名和实体类的属性名的对应关系 -->
    <resultMap id="userMap" type="top.tjtulong.domain.User">
        <!-- 主键字段的对应 -->
        <id property="userId" column="id"></id>
        <!--非主键字段的对应-->
        <result property="userName" column="username"></result>
        <result property="userAddress" column="address"></result>
        <result property="userSex" column="sex"></result>
        <result property="userBirthday" column="birthday"></result>
    </resultMap>
	
	<!-- 查询所有 -->
    <select id="findAll" resultMap="userMap">
        <!--select id as userId,username as userName,address as userAddress,sex as userSex,birthday as userBirthday from user;-->
        select * from user;
    </select>

这种方式执行效率较慢。

Dao方式的Mybatis

public class UserDaoImpl implements IUserDao {

    private SqlSessionFactory factory;

    public UserDaoImpl(SqlSessionFactory factory){
        this.factory = factory;
    }

    @Override
    public User findById(Integer userId) {
        //1.根据factory获取SqlSession对象
        SqlSession session = factory.openSession();
        //2.调用SqlSession中的方法，实现查询一个
        User user = session.selectOne("top.tjtulong.dao.IUserDao.findById",userId);
        //3.释放资源
        session.close();
        return user;
    }
}

**User user = session.selectOne(“top.tjtulong.dao.IUserDao.findById”,userId);**不通过动态代理实现dao接口，而是直接进行查询。

使用代理Dao方法执行的底层也是执行了session.selectxxx方法。

连接池

MyBatis中提供了3种方式的配置

Mybatis的SqlMapConfig.xml配置文件中，通过<dataSource type=”pooled”>来实现Mybatis中连接池的配置。

type类型的取值：

• POOLED采用传统的javax.sql.DataSourse规范中的连接池，MyBatis中有针对于它的实现
• UNPOOLED采用传统的获取连接的方式，虽然也实现了javax.sql.DataSourse接口，但没有针对于池的思想
• JNDI采用了服务器提供的JNDI技术实现，如果不是web工程，不能使用。

UNPOOLED

POOLED

MyBatis实现的数据库连接池中有两个列表：

// 空闲池
protected final List<PooledConnection> idleConnections = new ArrayList();
// 活动池
protected final List<PooledConnection> activeConnections = new ArrayList();

从连接池中获取连接的方法主要是在popConnection方法中实现的，它的流程图如下：

  // 获取连接
  @Override
  public Connection getConnection(String username, String password) throws SQLException {
    return popConnection(username, password).getProxyConnection();
  }
  
  // 从连接池中获取连接
  private PooledConnection popConnection(String username, String password) throws SQLException {
    // 等待的个数
    boolean countedWait = false;
    // PooledConnection 对象
    PooledConnection conn = null;
    long t = System.currentTimeMillis();
    // 无效的连接个数
    int localBadConnectionCount = 0;

    while (conn == null) {
      synchronized (state) {
        // 检测是否还有空闲的连接
        if (!state.idleConnections.isEmpty()) {
          // 连接池中还有空闲的连接，则直接获取连接返回
          conn = state.idleConnections.remove(0);
        } else {
          // 连接池中已经没有空闲连接了
          if (state.activeConnections.size() < poolMaximumActiveConnections) {
            // 活跃的连接数没有达到最大值，则创建一个新的数据库连接
            conn = new PooledConnection(dataSource.getConnection(), this);
          } else {
            // 如果活跃的连接数已经达到允许的最大值了，则不能创建新的数据库连接
            // 获取最先创建的那个活跃的连接
            PooledConnection oldestActiveConnection = state.activeConnections.get(0);
            long longestCheckoutTime = oldestActiveConnection.getCheckoutTime();
            // 检测该连接是否超时
            if (longestCheckoutTime > poolMaximumCheckoutTime) {
              // 如果该连接超时，则进行相应的统计
              state.claimedOverdueConnectionCount++;
              state.accumulatedCheckoutTimeOfOverdueConnections += longestCheckoutTime;
              state.accumulatedCheckoutTime += longestCheckoutTime;
              // 将超时连接移出 activeConnections 集合
              state.activeConnections.remove(oldestActiveConnection);
              if (!oldestActiveConnection.getRealConnection().getAutoCommit()) {
                  // 如果超时未提交，则自动回滚
                  oldestActiveConnection.getRealConnection().rollback();
              }
              // 创建新的 PooledConnection 对象，但是真正的数据库连接并没有创建
              conn = new PooledConnection(oldestActiveConnection.getRealConnection(), this);
              conn.setCreatedTimestamp(oldestActiveConnection.getCreatedTimestamp());
              conn.setLastUsedTimestamp(oldestActiveConnection.getLastUsedTimestamp());
              // 设置该超时的连接为无效
              oldestActiveConnection.invalidate();
            } else {
               // 如果无空闲连接，无法创建新的连接且无超时连接，则只能阻塞等待
              // Must wait
              try {
                if (!countedWait) {
                  state.hadToWaitCount++; // 等待次数
                  countedWait = true;
                }
                long wt = System.currentTimeMillis();
                // 阻塞等待
                state.wait(poolTimeToWait);
                state.accumulatedWaitTime += System.currentTimeMillis() - wt;
              } catch (InterruptedException e) {
                break;
              }
            }
          }
        }
        // 已经获取到连接
        if (conn != null) {
          if (conn.isValid()) {
            // 如果连连接有效，事务未提交则回滚
            if (!conn.getRealConnection().getAutoCommit()) {
              conn.getRealConnection().rollback();
            }
            // 设置 PooledConnection 相关属性
            conn.setConnectionTypeCode(assembleConnectionTypeCode(dataSource.getUrl(), username, password));
            conn.setCheckoutTimestamp(System.currentTimeMillis());
            conn.setLastUsedTimestamp(System.currentTimeMillis());
            // 把连接加入到活跃集合中去
            state.activeConnections.add(conn);
            state.requestCount++;
            state.accumulatedRequestTime += System.currentTimeMillis() - t;
          } else {
            // 无效连接
            state.badConnectionCount++;
            localBadConnectionCount++;
            conn = null;
          }
        }
      }
    }
    return conn;
  }

更多细节见：POOLED线程池

真正连接打开的时间点，只是在我们执行SQL语句时，才会进行。其实这样做我们也可以进一步发现，数据库连接是我们最为宝贵的资源，只有在要用到的时候，才去获取并打开连接，当我们用完了就再立即将数据库连接归还到连接池中。

事务

在连接池中取出的连接，都会将调用connection.setAutoCommit(false)方法，这样我们就必须使用sqlSession.commit()方法，相当于使用了JDBC中的connection.commit()方法实现事务提交。

自动提交方法只需：

session = factory.openSession(true);

动态SQL

if标签

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

在映射配置文件中：

    <!--根据条件查询-->
    <select id="findUserByCondition" resultType="User" parameterType="User">
        select * from user where 1=1
        <if test="username != null">
            and username = #{username}
        </if>
    </select>

where标签

当条件较多时，可以使用where标签：

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

foreach标签

子查询情况：select * from user where id in (1,2,3,4);

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

<foreach>标签用于遍历集合，它的属性：

• collection:代表要遍历的集合元素，注意编写时不要写#{}
• open:代表语句的开始部分
• close:代表结束部分
• item:代表遍历集合的每个元素，生成的变量名
• sperator:代表分隔符

    <!-- 根据queryvo中的Id集合实现查询用户列表 -->
    <select id="findUserInIds" resultMap="userMap" parameterType="queryvo">
        <include refid="defaultUser"></include>
        <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>

多表查询

表之间的关系：

• 一对多
• 多对一
• 一对一
• 多对多

其中MyBatis把多对一看做一对一

示例：用户和账户（一个用户多个账户，一个账户对应一个用户）

一对一

首先创建账户类，账户类中有用户类：

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

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

映射配置文件：

<mapper namespace="top.tjtulong.dao.IAccountDao">

    <!-- 定义封装account和user的resultMap -->
    <resultMap id="accountUserMap" type="account">
        <id property="id" column="aid"></id>
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
        <!-- 一对一的关系映射：配置封装user的内容-->
        <association property="user" 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 * from account
    </select>

    <select id="findAllAccount" resultMap="accountUserMap">
        select a.*,u.username,u.address from account a , user u where u.id = a.uid;
    </select>
</mapper>

接口方法：

public interface IAccountDao {

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

    /**
     * 查询账户及其用户
     * @return
     */
    List<AccountUser> findAllAccount();
}

实现方法：

@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());
        }
    }

一对多

<mapper namespace="top.tjtulong.dao.IUserDao">

    <!-- 定义User的resultMap-->
    <resultMap id="userAccountMap" 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>
        <!-- 配置user对象中accounts集合的映射 -->
        <collection property="accList" 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>

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

</mapper>

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

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

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

多对多

示例：用户与角色，一个用户可以有多个角色，一个用户可以赋予多个用户。

Role中有User

public class Role implements Serializable {

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

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

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

User中有Role

public class User implements Serializable {

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

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

映射文件(resultMap与一对多相同，仅sql语句不同)：

<mapper namespace="top.tjtulong.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>

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

延迟加载

延迟加载： 就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称懒加载. 好处：先从单表查询，需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。

立即加载： 一调用方法立即查询

一对多、多对多：延迟加载
多对一、一对一：立即加载

使用assocation实现延迟加载

开启Mybatis的延迟加载策略：

    <settings>
        <!--开启Mybatis支持延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="aggressiveLazyLoading" value="false"></setting>
    </settings>

账户的持久层映射文件：

<?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="top.tjtulong.dao.IAccountDao">

    <!-- 定义封装account和user的resultMap -->
    <resultMap id="accountUserMap" type="account">
        <id property="id" column="id"></id>
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
        <!-- 一对一的关系映射：配置封装user的内容
        select属性指定的内容：查询用户的唯一标识：
        column属性指定的内容：用户根据id查询时，所需要的参数的值
        -->
        <association property="user" column="uid" javaType="user" select="top.tjtulong.dao.IUserDao.findById"></association>
    </resultMap>

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

上面的assocation中使用了账户中的查询方法。
账户的持久层映射文件：

<mapper namespace="top.tjtulong.dao.IUserDao">

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

</mapper>

select：填写我们要调用的select映射的 id
column：填写我们要传递给select映射的参数

    @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());
        }
    }

实现了延迟加载：

使用Collection实现延迟加载

<mapper namespace="top.tjtulong.dao.IUserDao">

    <!-- 定义User的resultMap-->
    <resultMap id="userAccountMap" 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>
        <!-- 配置user对象中accounts集合的映射 -->
        <collection property="accounts" ofType="account" select="top.tjtulong.dao.IAccountDao.findAccountByUid" column="id"></collection>
    </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>

• select属性： 用于指定查询account列表的sql语句，所以填写的是该sql映射的id ；
• column属性： 用于指定select属性的sql语句的参数来源，上面的参数来自于user的id列，所以就写成id这一个字段名了。

缓存

存在于内存中的临时数据，可以减少与数据库的交互次数，提高执行效率，经常查询、不经常修改和数据的正确与否对最终结果影响不大的数据适合于存在缓存。

一级缓存

它指的是MyBatis中SqlSession对象的缓存，当我们执行查询后，查询的结果会同时存入到SqlSession为我们提供的一块区域中，该区域的结果是一个Map，当我们再次查询同样的数据，MyBatis会先去SqlSession中查询是否有数据，有的话直接取出即可。当SqlSession消失时，一级缓存即消失。

    /**
     * 测试一级缓存
     */
    @Test
    public void testFirstLevelCache(){
        SqlSession sqlSession1 = factory.openSession();
        IUserDao dao1 = sqlSession1.getMapper(IUserDao.class);
        User user1 = dao1.findById(41);
        System.out.println(user1);
        
        IUserDao dao2 = sqlSession1.getMapper(IUserDao.class);
        User user2 = dao2.findById(41);
        System.out.println(user2);
        sqlSession2.close();

        System.out.println(user1 == user2);//true
    }

如果sqlSession去执行commit操作（执行插入、更新、删除），清空SqlSession中的一级缓存，这样做的目的为了让缓存中存储的是最新的信息，避免脏读。

二级缓存

它是指MyBatis中SqlSessionFactory对象的缓存，由同一个SqlSessionFactory对象创建的SqlSession共享其缓存。

二级缓存是mapper映射级别的缓存，多个SqlSession去操作同一个Mapper映射的sql语句，多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。

第一步：在SqlMapConfig.xml文件开启二级缓存

<settings>
    <!-- 开启二级缓存的支持 -->
    <setting name="cacheEnabled" value="true"/> 
</settings>

第二步：配置相关的Mapper映射文件

<mapper namespace="top.tjtulong.dao.IUserDao"> 
    <!-- 开启二级缓存的支持 --> 
    <cache></cache>
</mapper>

第三步：配置statement上面的useCache属性

<select id="findById" resultType="user" parameterType="int" useCache="true"> 
    select * from user where id = #{uid}
</select>

测试：

    /**
     * 测试一级缓存
     */
    @Test
    public void testFirstLevelCache(){
        SqlSession sqlSession1 = factory.openSession();
        IUserDao dao1 = sqlSession1.getMapper(IUserDao.class);
        User user1 = dao1.findById(41);
        System.out.println(user1);
        sqlSession1.close();//一级缓存消失

        SqlSession sqlSession2 = factory.openSession();
        IUserDao dao2 = sqlSession2.getMapper(IUserDao.class);
        User user2 = dao2.findById(41);
        System.out.println(user2);
        sqlSession2.close();

        System.out.println(user1 == user2);//false不存对象存数值
    }

当我们在使用二级缓存时，所缓存的类一定要实现java.io.Serializable接口，这种就可以使用序列化方式来保存对象。

注解开发

@Insert：实现新增
@Update：实现更新
@Delete：实现删除
@Select：实现查询
@Result：实现结果集封装
@Results：可以与@Result一起使用，封装多个结果集
@ResultMap：实现引用@Results定义的封装
@One：实现一对一结果集封装
@Many：实现一对多结果集封装
@SelectProvider：实现动态SQL映射
@CacheNamespace：实现注解二级缓存的使用

注：注解配置不能与xml配置同时存在，否则会报错

注解配置

SqlMapConfig配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<!-- mybatis的主配置文件 -->
<configuration>
    <properties resource="jdbcConfig.properties"></properties>

    <typeAliases>
        <package name="top.tjtulong.domain"></package>
    </typeAliases>
    <!-- 配置环境 -->
    <environments default="mysql">
        <!-- 配置mysql的环境-->
        <environment id="mysql">
            <!-- 配置事务的类型-->
            <transactionManager type="JDBC"></transactionManager>
            <!-- 配置数据源（连接池） -->
            <dataSource type="UNPOOLED">
                <!-- 配置连接数据库的4个基本信息 -->
                <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>
        </environment>
    </environments>
    
    <!--指定带有注解的dao接口所在位置-->
    <mappers>
        <package name="top.tjtulong.dao"></package>
    </mappers>
</configuration>

在接口上加上注解：

    /**
     * 查询所有用户信息及其账户信息
     *
     * @return
     */
    @Select("select * from user")
    List<User> findAll();

CRUD操作

    /**
     * 保存用户
     * @param user
     */
    @Insert("insert into user(username,address,sex,birthday)values(#{username},#{address},#{sex},#{birthday})")
    void saveUser(User user);

    /**
     * 更新用户
     * @param user
     */
    @Update("update user set username=#{username},sex=#{sex},birthday=#{birthday},address=#{address} where id=#{id}")
    void updateUser(User user);

    /**
     * 删除用户
     * @param userId
     */
    @Delete("delete from user where id=#{id} ")
    void deleteUser(Integer userId);

    /**
     * 根据id查询用户
     * @param userId
     * @return
     */
    @Select("select * from user where id=#{id} ")
    User findById(Integer userId);

    /**
     * 根据用户名称模糊查询
     * @param username
     * @return
     */
//    @Select("select * from user where username like #{username} ")
    @Select("select * from user where username like '%${value}%' ")
    List<User> findUserByName(String username);

    /**
     * 查询总用户数量
     * @return
     */
    @Select("select count(*) from user ")
    int findTotalUser();

属性与表列对应

     /**
     * 查询所有账户，并且获取每个账户所属的用户信息
     * @return
     */
    @Select("select * from account")
    @Results(id="accountMap",value = {
            @Result(id=true,column = "id",property = "id"),
            @Result(column = "uid",property = "uid"),
            @Result(column = "money",property = "money"),
            @Result(property = "user",column = "uid",one=@One(select="top.tjtulong.dao.IUserDao.findById",fetchType= FetchType.EAGER))
    })
    List<Account> findAll();

一对一查询

@one注解

    /**
     * 查询所有账户，并且获取每个账户所属的用户信息
     * @return
     */
    @Select("select * from account")
    @Results(id="accountMap",value = {
            @Result(id=true,column = "id",property = "id"),
            @Result(column = "uid",property = "uid"),
            @Result(column = "money",property = "money"),
            @Result(property = "user",column = "uid",one=@One(select="top.tjtulong.dao.IUserDao.findById",fetchType= FetchType.EAGER))
    })
    List<Account> findAll();

一对多查询

@many注解
fetchType = FetchType.LAZY表示延迟加载

    /**
     * 查询所有用户
     * @return
     */
    @Select("select * from user")
    @Results(id="userMap",value={
            @Result(id=true,column = "id",property = "userId"),
            @Result(column = "username",property = "userName"),
            @Result(column = "address",property = "userAddress"),
            @Result(column = "sex",property = "userSex"),
            @Result(column = "birthday",property = "userBirthday"),
            @Result(property = "accounts",column = "id",
                    many = @Many(select = "top.tjtulong.dao.IAccountDao.findAccountByUid",
                                fetchType = FetchType.LAZY))
    })
    List<User> findAll();

Mybatis与Spring组合原理

可参考：https://blog.csdn.net/qq_31142553/article/details/86655951

MapperScannerConfigurer的postProcessBeanDefinationRegistry()创建ClassPathMapperScanner(继承了ClassPathBeanDefinationScanner)。@ComponentScan的底层就是ClassPathBeanDefinationScanner，负责把Bean定义加载到BeanDefinitionMap。

doScan()扫描返回了多个Dao实例，其中doScan()下的processBeanDefinitions()方法把保存在ioc中的要加强的Dao接口进行了替换，替换为了MapperFactoryBean。

// 配置有参构造器，传入接口名称作为参数
definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName);
// 把BeanDefination中的Class属性改变为mapperFactoryBeanClass
definition.setBeanClass(this.mapperFactoryBeanClass);
// 修改注入模型
definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);

FactoryBean最终获取的对象时getObject()的返回值。

这个方法首先又会调用成员变量MapperRegistry实例的getMapper方法，根据接口拿到了MapperProxyFactory对象。然后Mapper ProxyFactory创建一个动态代理对象返回，然后存入一个Map中供下一次使用。