MyBatis（下）-摩杜云开发者社区

8.自定义映射resultMap

8.1 resultMap处理字段和属性的映射关系

字段名和属性名不一致的情况，如何处理映射关系

1、为查询的字段设置别名，和属性名保持一致 2、当字段符合MySQL的要求使用_，而属性符合Java的要求使用驼峰此时可以在MyBatis的核心配置文件中设置一个全局配置，可以自动将下划线映射为驼峰，自动将_类型的字段名转换为驼峰

例如：字段名user_name，设置了mapUnderscoreToCamelCase，此时字段名就会转换为userName

3、使用resultMap自定义映射处理

resultMap：设置自定义的映射关系
id：唯一标识
type：处理映射关系的实体类的类型
常用的标签：
id：处理主键和实体类中属性的映射关系
result：处理普通字段和实体类中属性的映射关系
associate：处理多对一的映射关系（处理实体类类型的属性）
column：设置映射关系中的字段名，必须是sql查询出的某个字段
property：设置映射关系中的属性的属性名，必须是处理的实体类类型中的属性名

增加实体类Emp和Demp

在配置文件中添加如下：

<settings>
    <!--将下划线映射为驼峰-->
    <setting name="mapUnderscoreToCamelCase" value="true"/>
    <!--开启延迟加载-->
    <setting name="lazyLoadingEnabled" value="true"/>
    <!--按需加载-->
    <setting name="aggressiveLazyLoading" value="true"/>
</settings>
<typeAliases>
    <package name="com.lowell.mybatis.pojo"/>
</typeAliases>

在EmpMapper中新增：

/**
 * 根据id查询员工信息
 * @param empId
 * @return
 */
Emp getEmpByEmpId(@Param("empId") Integer empId);

<resultMap id="empResultMap" type="Emp">
    <id column="emp_id" property="empId"/>
    <result column="emp_name" property="empName"/>
    <result column="age" property="age"/>
    <result column="gender" property="gender"/>
</resultMap>
    
<!--Emp getEmpByEmpId(@Param("empId") Integer empId);-->
<select id="getEmpByEmpId" resultMap="empResultMap">
    select * from t_emp where emp_id = #{empId}
</select>

@Test
public void testGetEmpByEmpId(){
    SqlSession sqlSession = SqlSessionUtil.getsqlSession();
    EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
    Emp emp = mapper.getEmpByEmpId(1);
    System.out.println(emp);
}

测试结果如下：

DEBUG 10-23 11:54:11,855 ==>  Preparing: select * from t_emp where emp_id = ? (BaseJdbcLogger.java:137) 
DEBUG 10-23 11:54:11,928 ==> Parameters: 1(Integer) (BaseJdbcLogger.java:137) 
DEBUG 10-23 11:54:11,971 <==      Total: 1 (BaseJdbcLogger.java:137) 
Emp{empId=1, empName='Lee', age=20, gender='male', dept=null}

8.2 多对一映射处理

查询员工信息以及员工所对应的部门信息

1. 级联方式处理映射关系

/**
 * 查询员工以及对应的部门信息
 * @param empId
 * @return
 */
Emp getEmpAndDepByEmpId(@Param("empId") Integer empId);

<resultMap id="empAndDeptResultMap" type="Emp">
    <id column="emp_id" property="empId"/>
    <result column="emp_name" property="empName"/>
    <result column="age" property="age"/>
    <result column="gender" property="gender"/>
    <result column="dept_id" property="dept.deptId"/>
    <result column="dept_name" property="dept.deptName"/>
</resultMap>
    
<!--Emp getEmpAndDepByEmpId(@Param("empId") Integer empId)-->
<select id="getEmpAndDepByEmpId" resultMap="empAndDeptResultMap">
    select
    t_emp.*, t_dept.*
    from t_emp
    left join t_dept
    on t_emp.dept_id = t_dept.dept_id
    where t_emp.emp_id = #{empId}
</select>

@Test
public void testGetEmpAndDeptByEmpId(){
    SqlSession sqlSession = SqlSessionUtil.getsqlSession();
    EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
    Emp emp = mapper.getEmpAndDepByEmpId(1);
    System.out.println(emp);
}

测试结果如下：

DEBUG 10-23 14:19:55,833 ==>  Preparing: select t_emp.*, t_dept.* from t_emp left join t_dept on t_emp.dept_id = t_dept.dept_id where t_emp.emp_id = ? (BaseJdbcLogger.java:137) 
DEBUG 10-23 14:19:55,866 ==> Parameters: 1(Integer) (BaseJdbcLogger.java:137) 
DEBUG 10-23 14:19:55,894 <==      Total: 1 (BaseJdbcLogger.java:137) 
Emp{empId=1, empName='Lee', age=20, gender='male', dept=null}

2. 使用association处理映射关系

<resultMap id="empAndDeptResultMap" type="Emp">
    <id column="emp_id" property="empId"/>
    <result column="emp_name" property="empName"/>
    <result column="age" property="age"/>
    <result column="gender" property="gender"/>
    <!--
        association：处理多对一的映射关系（处理实体类类型的属性）
        如该例中的Emp中的属性dept是一个实体类
        property：设置需要处理映射关系的属性的属性名
        javaType：设置要处理的属性的类型
    -->
    <association property="dept" javaType="Dept">
        <id column="dept_id" property="deptName"/>
        <result column="dept_name" property="deptName"/>
    </association>
</resultMap>

<!--Emp getEmpAndDepByEmpId(@Param("empId") Integer empId)-->
<select id="getEmpAndDepByEmpId" resultMap="empAndDeptResultMap">
    select
    t_emp.*, t_dept.*
    from t_emp
    left join t_dept
    on t_emp.dept_id = t_dept.dept_id
    where t_emp.emp_id = #{empId}
</select>

3.分步查询

①查询员工信息

在EmpMapper.java中新增第一步接口：

/**
 * 通过分布查询，查询员工以及对应的部门信息的第一步
 * @param empId
 * @return
 */
Emp getEmpAndDepByStepOne(@Param("empId") Integer empId);

在EmpMapper.xml中新增：

<resultMap id="empAndDeptByStepResultMap" type="Emp">
    <id column="emp_id" property="empId"/>
    <result column="emp_name" property="empName"/>
    <result column="age" property="age"/>
    <result column="gender" property="gender"/>
    <!--
        property：设置需要处理映射关系的属性的属性名
        select：设置分步查询的sql的唯一标识
        column：将查询的某个字段作为分步查询的sql的条件
        fetchType：在开启了延迟加载的环境中，通过该属性设置当前的分步查询是否使用延迟加载
        fetchType="eager(立即加载)|lazy(延迟加载)"
    -->
    <association property="dept" fetchType="eager"
                 select="com.lowell.mybatis.mapper.DeptMapper.getEmpAndDeptByStepTwo"
                 column="dept_id">
    </association>
</resultMap>
<!--Emp getEmpAndDepByStepOne(@Param("empId") Integer empId);-->
<select id="getEmpAndDepByStepOne" resultMap="empAndDeptByStepResultMap">
    select * from t_emp where emp_id = #{empId};
</select>

②根据员工所对应的部门id查询部门信息

在DeptMapper.java中新增第二步接口：

/**
 * 通过分布查询，查询员工以及对应的部门信息的第二步
 * @param deptId
 * @return
 */
Dept getEmpAndDeptByStepTwo(@Param("deptId") Integer deptId);

在DeptMapper.xml中新增：

<!--Dept getEmpAndDeptByStepTwo(@Param("deptId") Integer deptId);-->
<select id="getEmpAndDeptByStepTwo" resultType="Dept">
    select * from t_dept where dept_id = #{deptId}
</select>

@Test
public void testGetEmpAndDeptByStep(){
    SqlSession sqlSession = SqlSessionUtil.getsqlSession();
    EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
    Emp emp = mapper.getEmpAndDepByStepOne(2);
    System.out.println(emp);
}

测试结果如下：

我们可以看到，执行了两个SQL语句

select * from t_emp where emp_id = ? select * from t_dept where dept_id = ?

DEBUG 10-23 14:40:00,346 ==>  Preparing: select * from t_emp where emp_id = ?; (BaseJdbcLogger.java:137) 
DEBUG 10-23 14:40:00,371 ==> Parameters: 2(Integer) (BaseJdbcLogger.java:137) 
DEBUG 10-23 14:40:00,389 ====>  Preparing: select * from t_dept where dept_id = ? (BaseJdbcLogger.java:137) 
DEBUG 10-23 14:40:00,390 ====> Parameters: 2(Integer) (BaseJdbcLogger.java:137) 
DEBUG 10-23 14:40:00,394 <====      Total: 1 (BaseJdbcLogger.java:137) 
DEBUG 10-23 14:40:00,394 <==      Total: 1 (BaseJdbcLogger.java:137) 
Emp{empId=2, empName='李四', age=23, gender='男', dept=Dept{deptId=2, deptName='B', emps=null}}

8.3 一对多映射处理

1. collection

/**
 * 查询部门以及部门中的员工信息
 * @param deptId
 * @return
 */
Dept getDeptAndEmpByDeptId(@Param("deptId") Integer deptId);

<!--Dept getDeptAndEmpByDeptId(@Param("deptId") Integer deptId);-->
<select id="getDeptAndEmpByDeptId" resultMap="deptAndEmpResultMap">
    select *
    from t_dept
    left join t_emp
    on t_dept.dept_id=t_emp.dept_id
    where t_dept.dept_id = #{deptId}
</select>

@Test
public void testGetDeptAndEmpByDeptId(){
    SqlSession sqlSession = SqlSessionUtil.getsqlSession();
    DeptMapper mapper = sqlSession.getMapper(DeptMapper.class);
    Dept dept = mapper.getDeptAndEmpByDeptId(1);
    System.out.println(dept);
}

测试结果如下：

DEBUG 10-23 14:55:33,465 ==>  Preparing: select * from t_dept left join t_emp on t_dept.dept_id=t_emp.dept_id where t_dept.dept_id = ? (BaseJdbcLogger.java:137) 
DEBUG 10-23 14:55:33,493 ==> Parameters: 1(Integer) (BaseJdbcLogger.java:137) 
DEBUG 10-23 14:55:33,516 <==      Total: 1 (BaseJdbcLogger.java:137) 
Dept{deptId=1, deptName='A', emps=[Emp{empId=4, empName='赵六', age=25, gender='女', dept=null}]}

2. 分步查询

①查询部门信息

在DeptMapper.java中新增

/**
 * 通过分布查询部门以及部门中的员工信息的第一步
 * @param deptId
 * @return
 */
Dept getDeptAndEmpByStepOne(@Param("deptId") Integer deptId);

在DeptMapper.xml中新增：

<resultMap id="deptAndEmpResultMapByStep" type="Dept">
    <id column="dept_id" property="deptId"/>
    <result column="dept_name" property="deptName"/>
    <collection property="emps"
                select="com.lowell.mybatis.mapper.EmpMapper.getDeptAndEmpByStepTwo"
                column="dept_id">
    </collection>
</resultMap>

<!--Dept getDeptAndEmpByStepOne(@Param("deptId") Integer deptId);-->
<select id="getDeptAndEmpByStepOne" resultMap="deptAndEmpResultMapByStep">
    select * from t_dept where dept_id = #{deptId}
</select>

②根据部门id查询部门中的所有员工

在EmpMapper.java中新增

/**
 * 通过分布查询，查询部门以及部门员工信息的第二步
 * @param deptId
 * @return
 */
List<Emp> getDeptAndEmpByStepTwo(@Param("deptId") Integer deptId);

在EmpMapper.xml中新增：

<!--List<Emp> getDeptAndEmpByStepTwo(@Param("deptId") Integer deptId);-->
<select id="getDeptAndEmpByStepTwo" resultType="Emp">
    select * from t_emp where dept_id = #{deptId}
</select>

@Test
public void testGetDeptAndEmpByStep(){
    SqlSession sqlSession = SqlSessionUtil.getsqlSession();
    DeptMapper mapper = sqlSession.getMapper(DeptMapper.class);
    Dept dept = mapper.getDeptAndEmpByStepOne(1);
    System.out.println(dept);
}

测试结果如下：

DEBUG 10-23 14:58:48,497 ==>  Preparing: select * from t_dept where dept_id = ? (BaseJdbcLogger.java:137) 
DEBUG 10-23 14:58:48,526 ==> Parameters: 1(Integer) (BaseJdbcLogger.java:137) 
DEBUG 10-23 14:58:48,584 <==      Total: 1 (BaseJdbcLogger.java:137) 
DEBUG 10-23 14:58:48,586 ==>  Preparing: select * from t_emp where dept_id = ? (BaseJdbcLogger.java:137) 
DEBUG 10-23 14:58:48,586 ==> Parameters: 1(Integer) (BaseJdbcLogger.java:137) 
DEBUG 10-23 14:58:48,590 <==      Total: 1 (BaseJdbcLogger.java:137) 
Dept{deptId=1, deptName='A', emps=[Emp{empId=4, empName='赵六', age=25, gender='女', dept=null}]}

分步查询的优点

可以实现延迟加载，但是必须在核心配置文件中设置全局配置信息：

lazyLoadingEnabled：延迟加载的全局开关，当开启时，所有关联对象都会延迟加载

aggressiveLazyLoading：当开启时，任何方法的调用都会加载该对象的所有属性否则，每个属性会按需加载

此时就可以实现按需加载，获取的数据是什么，就只会执行相应的sql。此时可通过association和 collection中的fetchType属性设置当前的分步查询是否使用延迟加载， fetchType="lazy(延迟加载)|eager(立即加载)"

9. 动态SQL

Mybatis框架的动态SQL技术是一种根据特定条件动态拼装SQL语句的功能，它存在的意义是为了解决拼接SQL语句字符串时的痛点问题。

9.1 `if`

if标签可通过test属性的表达式进行判断，若表达式的结果为true，则标签中的内容会执行；反之标签中的内容不会执行

/**
 * 根据条件查询员工信息
 * @param emp
 * @return
 */
List<Emp> getEmpByCondition(Emp emp);

<select id="getEmpByConditionOne" resultType="Emp">
    select * from t_emp where
    <if test="empName != null and empName != ''">
        emp_name = #{empName}
    </if>
    <if test="age != null and age != ''">
        and age = #{age}
    </if>
    <if test="gender != null and gender != ''">
        and gender = #{gender}
    </if>
</select>

9.2 `where`

where和if一般结合使用：

1、若where标签中的if条件都不满足，则where标签没有任何功能，即不会添加where关键字

2、若where标签中的if条件满足，则where标签会自动添加where关键字，并将条件最前方多余的 and去掉

注意：where标签不能去掉条件最后多余的and

<select id="getEmpByCondition" resultType="Emp">
    select * from t_emp
    <where>
        <if test="empName != null and empName != ''">
            emp_name = #{empName}
        </if>
        <if test="age != null and age != ''">
            and age = #{age}
        </if>
        <if test="gender != null and gender != ''">
            and gender = #{gender}
        </if>
    </where>
</select>

@Test
public void testGetEmpByCondition() {
    SqlSession sqlSession = SqlSessionUtil.getsqlSession();
    DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
    Emp emp = new Emp(null, "", 20, "");
    List<Emp> empList = mapper.getEmpByCondition(emp);
    empList.forEach(System.out::println);
}

测试结果如下：

DEBUG 10-23 15:31:58,242 ==>  Preparing: select * from t_emp WHERE age = ? (BaseJdbcLogger.java:137) 
DEBUG 10-23 15:31:58,268 ==> Parameters: 20(Integer) (BaseJdbcLogger.java:137) 
DEBUG 10-23 15:31:58,285 <==      Total: 1 (BaseJdbcLogger.java:137) 
Emp{empId=1, empName='Lee', age=20, gender='male'}

9.3 `trim`

trim用于去掉或添加标签中的内容

常用属性：

prefix、suffix：在标签中内容前面或者后面添加指定内容 prefixOverrides、suffixOverrides：在标签中内容前面或者后面去掉指定内容

<sql id="empColumns">
    emp_id, emp_name, age, gender, dept_id
</sql>
<!--List<Emp> getEmpByCondition(Emp emp);-->
<select id="getEmpByCondition" resultType="Emp">
    select <include refid="empColumns"></include> from t_emp
    <trim prefix="where" suffixOverrides="and">
    <if test="empName != null and empName != ''">
        emp_name = #{empName} and
    </if>
    <if test="age != null and age != ''">
        age = #{age} and
    </if>
    <if test="gender != null and gender != ''">
        gender = #{gender}
    </if>
    </trim>
</select>

9.4 `choose、when、otherwise`

相当于Java中的if...else if...else when至少设置一个 otherwise最多设置一个

/**
 * 使用choose查询员工信息
 * @param emp
 * @return
 */
List<Emp> getEmpByChoose(Emp emp);

<!--List<Emp> getEmpByChoose(Emp emp);-->
<select id="getEmpByChoose" resultType="Emp">
    select * from t_emp
    <where>
        <choose>
            <when test="empName != null and empName != ''">
                emp_name = #{empName}
            </when>
            <when test="age != null and age != ''">
                age = #{age}
            </when>
            <when test="gender != null and gender != ''">
                gender = #{gender}
            </when>
        </choose>
    </where>
</select>

@Test
public void testGetEmpByChoose() {
    SqlSession sqlSession = SqlSessionUtil.getsqlSession();
    DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
    Emp emp = new Emp(null, "", 20, "");
    List<Emp> empList = mapper.getEmpByChoose(emp);
    empList.forEach(System.out::println);
}

9.5 `foreach`

/**
 * 批量添加员工信息
 * @param emps
 */
void insertMoreEmp(@Param("emps") List<Emp> emps);

<!--void insertMoreEmp(@Param("emps")List<Emp> emps);-->
<insert id="insertMoreEmp">
    insert into t_emp values
    <!--
		collection：设置要循环的数组或者集合
		item：用一个字符串表示数组或者集合中的每一个数据
		separator：设置每次循环的数据之间的分割符
		open：循环的所有内容以什么开始
		close：循环的所有内容以什么结束
	-->
    <foreach collection="emps" item="emp" separator=",">
        (null, #{emp.empName}, #{emp.age}, #{emp.gender}, null)
    </foreach>
</insert>

@Test
public void testInsertMoreEmp() {
    SqlSession sqlSession = SqlSessionUtil.getsqlSession();
    DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
    Emp emp1 = new Emp(null, "Lee1", 20, "男");
    Emp emp2 = new Emp(null, "Lee2", 20, "男");
    Emp emp3 = new Emp(null, "Lee3", 20, "男");
    List<Emp> list = Arrays.asList(emp1, emp2, emp3);
    mapper.insertMoreEmp(list);
}

将上述插入的记录删除：

/**
 * 批量删除
 * @param empIds
 */
void deleteMoreEmp(@Param("empIds") Integer[] empIds);

<!--void deleteMoreEmp(@Param("empIds") Integer[] empIds);-->
<delete id="deleteMoreEmp">
    <!--delete from t_emp where emp_id in
        <foreach collection="empIds" item="empId" separator="," open="(" close=")">
            #{empId}
        </foreach>-->
    delete from t_emp where
    <foreach collection="empIds" item="empId" separator="or">
        emp_id = #{empId}
    </foreach>
</delete>

@Test
public void testDeleteMoreEmp() {
    SqlSession sqlSession = SqlSessionUtil.getsqlSession();
    DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
    Integer[] empIds = new Integer[]{34, 35, 36};
    mapper.deleteMoreEmp(empIds);
}

9.6 SQL片段

sql片段，可以记录一段公共sql片段，在使用的地方通过include标签进行引入

<sql id="empColumns">
    emp_id, emp_name, age, gender, dept_id
</sql>

10. MyBatis的缓存

Mybatis的缓存分为一级缓存和二级缓存。

10.1 一级缓存

也叫本地缓存，是SqlSession级别的缓存。当执行查询时，会先从一级缓存中查找是否有对应的数据，如果有则直接返回，如果没有则从数据库中查询并将结果存入一级缓存中。通过同一个SqlSession查询的数据会被缓存，下次查询相同的数据，就会从缓存中直接获取，不会从数据库重新访问。一级缓存的作用范围是SqlSession，当SqlSession关闭或者清空缓存时，一级缓存中的数据也会被清空。

使一级缓存失效的四种情况：

不同的SqlSession对应不同的一级缓存
同一个SqlSession但是查询条件不同
同一个SqlSession两次查询期间执行了任何一次增删改操作
同一个SqlSession两次查询期间手动清空了缓存

10.2 二级缓存

也叫全局缓存，是Mapper级别的缓存。当多个SqlSession执行相同的查询时，会先从二级缓存中查找是否有对应的数据，如果有则直接返回，如果没有则从数据库中查询并将结果存入二级缓存中。二级缓存的作用范围是同一个Mapper的所有SqlSession，当SqlSession关闭或者清空缓存时，二级缓存中的数据不会被清空。

二级缓存开启的条件

在核心配置文件中，设置全局配置属性cacheEnabled="true"，默认为true，不需要设置
在映射文件中设置标签
二级缓存必须在SqlSession关闭或提交之后有效
查询的数据所转换的实体类类型必须实现序列化的接口

使二级缓存失效的情况：两次查询之间执行了任意的增删改，会使一级和二级缓存同时失效

10.3 二级缓存的相关配置

在mapper配置文件中添加的cache标签可以设置一些属性：

eviction属性：缓存回收策略，默认的是 LRU。

LRU（Least Recently Used） – 最近最少使用的：移除最长时间不被使用的对象。

FIFO（First in First out） – 先进先出：按对象进入缓存的顺序来移除它们。

SOFT– 软引用：移除基于垃圾回收器状态和软引用规则的对象。

WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。

flushInterval属性：刷新间隔，单位毫秒默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句时刷新
size属性：引用数目，正整数

代表缓存最多可以存储多少个对象，太大容易导致内存溢出
readOnly属性：只读，true/false

true：只读缓存；会给所有调用者返回缓存对象的相同实例，因此这些对象不能被修改，这提供了很重要的性能优势

false：读写缓存；会返回缓存对象的拷贝（通过序列化）,这会慢一些，但是安全，因此默认是false

10.4 MyBatis缓存查询的顺序

先查询二级缓存，因为二级缓存中可能会有其他程序已经查出来的数据，可以拿来直接使用。

如果二级缓存没有命中，再查询一级缓存

如果一级缓存也没有命中，则查询数据库

SqlSession关闭之后，一级缓存中的数据会写入二级缓存

10.5 整合第三方缓存EHCache

1.添加依赖

<!-- Mybatis EHCache整合包 -->
<dependency>
<groupId>org.mybatis.caches</groupId>
<artifactId>mybatis-ehcache</artifactId>
<version>1.2.1</version>
</dependency>
<!-- slf4j日志门面的一个具体实现 -->
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.2.3</version>
</dependency>

2.各jar包功能

jar包名称	作用
`mybatis-ehcache`	`Mybatis`和`EHCache`的整合包
ehcache	EHCache核心包
slf4j-api	SLF4J日志门面包
logback-classic	支持SLF4J门面接口的一个具体实现

3. 创建EHCache的配置文件ehcache.xml

<?xml version="1.0" encoding="utf-8" ?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
    <!-- 磁盘保存路径 -->
    <diskStore path="D:\lowell\ehcache"/>
    <defaultCache
            maxElementsInMemory="1000"
            maxElementsOnDisk="10000000"
            eternal="false"
            overflowToDisk="true"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
    </defaultCache>
</ehcache>

4.设置二级缓存的类型

<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

5.加入logback日志

存在SLF4J时，作为简易日志的log4j将失效，此时我们需要借助SLF4J的具体实现logback来打印日志

创建logback的配置文件logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="true">
    <!-- 指定日志输出的位置 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <!-- 日志输出的格式 -->
            <!-- 按照顺序分别是： 时间、日志级别、线程名称、打印日志的类、日志主体内容、换行
            -->
            <pattern>[%d{HH:mm:ss.SSS}] [%-5level] [%thread] [%logger]
                [%msg]%n</pattern>
        </encoder>
    </appender>
    <!-- 设置全局日志级别。日志级别按顺序分别是： DEBUG、INFO、WARN、ERROR -->
    <!-- 指定任何一个日志级别都只打印当前级别和后面级别的日志。 -->
    <root level="DEBUG">
        <!-- 指定打印日志的appender，这里通过“STDOUT”引用了前面配置的appender -->
        <appender-ref ref="STDOUT" />
    </root>
    <!-- 根据特殊需求指定局部日志级别 -->
    <logger name="com.lowell.mybatis.mapper" level="DEBUG"/>
</configuration>

11. MyBatis的逆向工程

正向工程：先创建Java实体类，由框架负责根据实体类生成数据库表。 Hibernate是支持正向工程的。

逆向工程：先创建数据库表，由框架负责根据数据库表，反向生成如下资源：

Java实体类
Mapper接口
Mapper映射文件

MyBatis的逆向工程（MyBatis Generator）是一个为MyBatis框架提供自动代码生成的工具。它可以从数据库表结构中自动生成Java实体类、Mapper接口和映射文件，大大减少了手动编写这些代码的工作量。

11.1 创建逆向工程的步骤

1.添加依赖和插件

<!-- 依赖MyBatis核心包 -->
    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>

        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.2.0</version>
        </dependency>

        <!-- junit测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- log4j日志 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
        </dependency>
    </dependencies>
    <!-- 控制Maven在构建过程中相关配置 -->
    <build>

    <!-- 构建过程中用到的插件 -->
    <plugins>
        <!-- 具体插件，逆向工程的操作是以构建过程中插件形式出现的 -->
        <plugin>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-maven-plugin</artifactId>
            <version>1.3.0</version>

            <!-- 插件的依赖 -->
            <dependencies>
                <!-- 逆向工程的核心依赖 -->
                <dependency>
                    <groupId>org.mybatis.generator</groupId>
                    <artifactId>mybatis-generator-core</artifactId>
                    <version>1.3.2</version>
                </dependency>

                <!-- MySQL驱动 -->
                <dependency>
                    <groupId>mysql</groupId>
                    <artifactId>mysql-connector-java</artifactId>
                    <version>5.1.49</version>
                </dependency>
            </dependencies>
        </plugin>
    </plugins>
    </build>

2. 创建MyBatis的核心配置文件`mybatis-config.xml`

3.创建逆向工程的配置文件

文件名必须是：generatorConfig.xml

在配置文件中，选择要生成代码的数据库表。可以指定生成全部表的代码，也可以选择特定的表进行生成。

配置生成代码的规则：在配置文件中，可以设置生成代码的一些规则，例如生成的包名、类名的前缀和后缀等。可以根据项目的需求进行相应的配置。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>

    <!--
    targetRuntime: 执行生成的逆向工程的版本
    MyBatis3Simple: 生成基本的CRUD（清新简洁版）
    MyBatis3: 生成带条件的CRUD（奢华尊享版）
    -->

    <context id="DB2Tables" targetRuntime="MyBatis3">
        <!-- 数据库的连接信息 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/ssm?
characterencoding=utf-8"
                        userId="root"
                        password="817484">
        </jdbcConnection>
        <!-- javaBean的生成策略-->
        <javaModelGenerator targetPackage="com.lowell.mybatis.pojo"
                            targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true" />
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
        <!-- SQL映射文件的生成策略 -->
        <sqlMapGenerator targetPackage="com.lowell.mybatis.mapper"
                         targetProject=".\src\main\resources">
            <property name="enableSubPackages" value="true" />
        </sqlMapGenerator>
        <!-- Mapper接口的生成策略 -->
        <javaClientGenerator type="XMLMAPPER"
                             targetPackage="com.lowell.mybatis.mapper" targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true" />
        </javaClientGenerator>

        <!-- 逆向分析的表 -->
        <!-- tableName设置为*号，可以对应所有表，此时不写domainObjectName -->
        <!-- domainObjectName属性指定生成出来的实体类的类名 -->
        <table tableName="t_emp" domainObjectName="Emp"/>
        <table tableName="t_dept" domainObjectName="Dept"/>
    </context>
</generatorConfiguration>

4.执行MBG插件的generate目标

通过运行MyBatis Generator，它会读取配置文件中的设置，连接到数据库，并根据指定的规则生成相应的Java代码。

5.效果如下

11.2 测试

@Test
public void testMBG(){
    SqlSession sqlSession = SqlSessionUtil.getsqlSession();
    EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);

    // 根据id查询数据
    /*Emp emp = mapper.selectByPrimaryKey(1);
    System.out.println(emp);*/

    // 查询所有数据
    /*List<Emp> list = mapper.selectByExample(null);
    list.forEach(System.out::println);*/

    //根据条件查询数据
    /*EmpExample example = new EmpExample();
    example.createCriteria().andAgeGreaterThanOrEqualTo(22).andGenderEqualTo("男");
    List<Emp> list = mapper.selectByExample(example);
    list.forEach(System.out::println);*/

    Emp emp = new Emp(1, "Lee", 25, "male");
    // 测试普通修改功能
    mapper.updateByPrimaryKey(emp);

    // 测试选择性修改
    mapper.updateByPrimaryKeySelective(emp);

}

根据id查询数据

DEBUG 10-24 16:02:38,111 ==>  Preparing: select emp_id, emp_name, age, gender, dept_id from t_emp where emp_id = ? (BaseJdbcLogger.java:137) 
DEBUG 10-24 16:02:38,147 ==> Parameters: 1(Integer) (BaseJdbcLogger.java:137) 
DEBUG 10-24 16:02:38,165 <==      Total: 1 (BaseJdbcLogger.java:137) 
Emp{empId=1, empName='Lee', age=20, gender='male', deptId=null}

查询所有数据

DEBUG 10-24 16:03:30,507 ==>  Preparing: select emp_id, emp_name, age, gender, dept_id from t_emp (BaseJdbcLogger.java:137) 
DEBUG 10-24 16:03:30,531 ==> Parameters:  (BaseJdbcLogger.java:137) 
DEBUG 10-24 16:03:30,552 <==      Total: 30 (BaseJdbcLogger.java:137) 
Emp{empId=1, empName='Lee', age=20, gender='male', deptId=null}
Emp{empId=2, empName='李四', age=23, gender='男', deptId=2}
Emp{empId=3, empName='王五', age=24, gender='男', deptId=3}
Emp{empId=4, empName='赵六', age=25, gender='女', deptId=1}
Emp{empId=5, empName='??a', age=25, gender='?', deptId=null}
Emp{empId=6, empName='a', age=null, gender='null', deptId=null}
Emp{empId=7, empName='a', age=null, gender='null', deptId=null}
Emp{empId=8, empName='a', age=null, gender='null', deptId=null}
Emp{empId=9, empName='a', age=null, gender='null', deptId=null}
Emp{empId=10, empName='a', age=null, gender='null', deptId=null}
Emp{empId=11, empName='a', age=null, gender='null', deptId=null}
Emp{empId=12, empName='a', age=null, gender='null', deptId=null}
Emp{empId=13, empName='a', age=null, gender='null', deptId=null}
Emp{empId=14, empName='a', age=null, gender='null', deptId=null}
Emp{empId=15, empName='a', age=null, gender='null', deptId=null}
Emp{empId=16, empName='a', age=null, gender='null', deptId=null}
Emp{empId=17, empName='a', age=null, gender='null', deptId=null}
Emp{empId=18, empName='a', age=null, gender='null', deptId=null}
Emp{empId=19, empName='a', age=null, gender='null', deptId=null}
Emp{empId=20, empName='a', age=null, gender='null', deptId=null}
Emp{empId=21, empName='a', age=null, gender='null', deptId=null}
Emp{empId=22, empName='a', age=null, gender='null', deptId=null}
Emp{empId=23, empName='a', age=null, gender='null', deptId=null}
Emp{empId=24, empName='a', age=null, gender='null', deptId=null}
Emp{empId=25, empName='a', age=null, gender='null', deptId=null}
Emp{empId=26, empName='a', age=null, gender='null', deptId=null}
Emp{empId=27, empName='a', age=null, gender='null', deptId=null}
Emp{empId=28, empName='a', age=null, gender='null', deptId=null}
Emp{empId=29, empName='a', age=null, gender='null', deptId=null}
Emp{empId=30, empName='a', age=null, gender='null', deptId=null}

根据条件查询数据

DEBUG 10-24 16:03:56,803 ==>  Preparing: select emp_id, emp_name, age, gender, dept_id from t_emp WHERE ( age >= ? and gender = ? ) (BaseJdbcLogger.java:137) 
DEBUG 10-24 16:03:56,828 ==> Parameters: 22(Integer), 男(String) (BaseJdbcLogger.java:137) 
DEBUG 10-24 16:03:56,843 <==      Total: 1 (BaseJdbcLogger.java:137) 
Emp{empId=5, empName='??a', age=25, gender='?', deptId=null}

测试修改功能

12. 分页插件

12.1 分页插件的使用步骤

1.添加依赖

<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>5.2.0</version>
</dependency>

2.配置分页插件

在MyBatis的核心配置文件中配置插件

<plugins>
    <!--设置分页插件-->
    <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>

3.分页插件的使用

@Test
    public void testPage() {
        SqlSession sqlSession = SqlSessionUtil.getsqlSession();
        EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
        //查询功能之前开启分页功能
        Page<Object> page = PageHelper.startPage(5, 4);
        List<Emp> list = mapper.selectByExample(null);
        // 查询功能之后可以获取分页相关的所有数据
        PageInfo<Emp> pageInfo = new PageInfo<>(list, 5);
        list.forEach(System.out::println);
        System.out.println(pageInfo);
    }

测试结果：

DEBUG 10-24 16:13:50,756 Cache Hit Ratio [SQL_CACHE]: 0.0 (LoggingCache.java:60) 
DEBUG 10-24 16:13:50,801 ==>  Preparing: SELECT count(0) FROM t_emp (BaseJdbcLogger.java:137) 
DEBUG 10-24 16:13:50,824 ==> Parameters:  (BaseJdbcLogger.java:137) 
DEBUG 10-24 16:13:50,841 <==      Total: 1 (BaseJdbcLogger.java:137) 
DEBUG 10-24 16:13:50,843 ==>  Preparing: select emp_id, emp_name, age, gender, dept_id from t_emp LIMIT ?, ? (BaseJdbcLogger.java:137) 
DEBUG 10-24 16:13:50,844 ==> Parameters: 16(Long), 4(Integer) (BaseJdbcLogger.java:137) 
DEBUG 10-24 16:13:50,845 <==      Total: 4 (BaseJdbcLogger.java:137) 
Emp{empId=17, empName='a', age=null, gender='null', deptId=null}
Emp{empId=18, empName='a', age=null, gender='null', deptId=null}
Emp{empId=19, empName='a', age=null, gender='null', deptId=null}
Emp{empId=20, empName='a', age=null, gender='null', deptId=null}
// PageInfo
PageInfo{pageNum=5, pageSize=4, size=4, 
startRow=17, endRow=20, total=30, 
pages=8, 
list=Page{count=true, pageNum=5, pageSize=4, startRow=16, endRow=20, total=30, pages=8, reasonable=false, pageSizeZero=false}
[Emp{empId=17, empName='a', age=null, gender='null', deptId=null}, 
Emp{empId=18, empName='a', age=null, gender='null', deptId=null}, 
Emp{empId=19, empName='a', age=null, gender='null', deptId=null}, 
Emp{empId=20, empName='a', age=null, gender='null', deptId=null}], 
prePage=4, nextPage=6, isFirstPage=false, isLastPage=false, 
hasPreviousPage=true, hasNextPage=true, 
navigatePages=5, navigateFirstPage=3, navigateLastPage=7, navigatepageNums=[3, 4, 5, 6, 7]}

8.自定义映射resultMap

8.1 resultMap处理字段和属性的映射关系

8.2 多对一映射处理

1. 级联方式处理映射关系

2. 使用association处理映射关系

3.分步查询

①查询员工信息

②根据员工所对应的部门id查询部门信息

8.3 一对多映射处理

1. collection

2. 分步查询

①查询部门信息

②根据部门id查询部门中的所有员工

分步查询的优点

9. 动态SQL

9.1 if

9.2 where

9.3 trim

9.4 choose、when、otherwise

9.5 foreach

9.6 SQL片段

10. MyBatis的缓存

10.1 一级缓存

10.2 二级缓存

10.3 二级缓存的相关配置

10.4 MyBatis缓存查询的顺序

10.5 整合第三方缓存EHCache

1.添加依赖

2.各jar包功能

3. 创建EHCache的配置文件ehcache.xml

4.设置二级缓存的类型

5.加入logback日志

11. MyBatis的逆向工程

11.1 创建逆向工程的步骤

1.添加依赖和插件

2. 创建MyBatis的核心配置文件mybatis-config.xml

3.创建逆向工程的配置文件

4.执行MBG插件的generate目标

5.效果如下

11.2 测试

12. 分页插件

12.1 分页插件的使用步骤

1.添加依赖

2.配置分页插件

3.分页插件的使用

9.1 `if`

9.2 `where`

9.3 `trim`

9.4 `choose、when、otherwise`

9.5 `foreach`

2. 创建MyBatis的核心配置文件`mybatis-config.xml`