Mybatis知识点记录

---

Mybatis

1. 简介

1.1 历史

1.2 特性

• 定制化SQL：即可以自己手写SQL语句。
• 支持存储过程
• 支持高级映射：即POJO和数据库字段的映射方式可以自定义。
• 封装了JDBC代码，和结果集的处理过程：不用手写JDBC代码和结果集处理的过程。

---

2. 官方下载

---

3. 与其他持久层框架对比

---

4. 快速开始

4.1 开发环境

• IDE：IDEA: 2022.2.4。
• 构建工具：maven 3.8.5
• MySQL版本：MySQL8
• MyBatis 版本：MyBatis 3.5.7

4.2 Maven

pom.xml

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

        <!-- junit 测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!-- MySQL驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>
    </dependencies>

4.3 核心配置文件

建议命名：mybatis-config.xml
放置路径：src/main/resources

核心配置文件作用：

• 配置链接数据库的环境
• 配置MyBatis

mybatis-config.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">

<configuration>
    <!--
        配置链接数据库的环境
        default : 选择那个环境有效
     -->
    <environments default="development">
        <environment id="development">

            <!-- 事务管理器 -->
            <transactionManager type="JDBC"></transactionManager>

            <!-- 数据源 即连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 引入 MyBatis 的映射文件 : 存放SQL语句 和 POJO的映射方式 -->
    <mappers>
        <mapper resource="mappers/UserMapper.xml"></mapper>
    </mappers>
</configuration>

4.4 Mapper接口

相当于DAO，但是不用创建实现类，MyBatis会创建代理类，并执行映射文件当中的SQL。

起名规则：POJO的名+Mapper
放置路径：src/main/java/com/atguigu/mybatis/mapper/UserMapper.java

package com.atguigu.mybatis.mapper;

public interface UserMapper {
    /**
     * 添加用户信息
     */
    int insertUser();
}

4.5 映射文件

Mapper 接口当中的一个抽象方法 对应 映射文件当中的一个SQL语句。

起名规则：POJO的名+Mapper.xml
放置路径：src/main/resources/com/atguigu/mybatis/mapper/UserMapper.xml

这里我们写一条固定的插入SQL，参数如何传递请请看后方比较详细的笔记。

UserMapper.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接口 -->
<mapper namespace="com.atguigu.mybatis.mapper.UserMapper">
    <!--
        id : 对应接口的方法名称.
    -->
    <select id="insertUser">
        INSERT INTO t_user VALUES (NULL, 'admin', '123456', 23, '男', '12345@qq.com');
    </select>
</mapper>

4.6 测试功能

下方代码：从开始到创建 SqlSessionFactory 只用创建一次即可，因此可以单独封装即可。
openSession() 获得 SqlSession 默认是不自动提交事务，因此需要自己手动提交。

放置路径：src/test/java/com/atguigu/mybatis/test/MybatisTest.java

MybatisTest.java

package com.atguigu.mybatis;

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.Test;
import com.atguigu.mybatis.mapper.UserMapper;

import java.io.IOException;
import java.io.InputStream;

public class MyBatisTest {
    @Test
    public void testInsert() throws IOException {
        // 获取核心配置文件的输入流
        InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");

        // 获取SqlSessionFactoryBuilder 对象 -> 工厂构建器
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();

        // 创建 SqlSession 工厂 -> 创建会话
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(resourceAsStream);

        // 获取 会话 对象 -> MyBatis 提供的操作数据库的对象
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 获得Mapper接口的代理类 -> 操纵Mapper类执行数据库操作
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        // 执行SQL操作
        Integer rows = userMapper.insertUser();
        System.out.println("rows = " + rows);

        // 提交事务 -> 事务是默认开启的
        sqlSession.commit();

        // 关闭资源
        sqlSession.close();
    }
}

4.7 log4j

日志级别：FATAL（致命）> ERROR（错误）>WARN（警告）INFO（信息）> DEBUG（调试）
从左到右打印的内容越来越详细.

pom.xml

<!-- log4j -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

放置路径：src/main/resources/log4j.xml

网址爆红不用管他
log4j.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
        <param name="Encoding" value="UTF-8"/>
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5d %d{MM-dd HH:mm:ss,SSS} %m (%F:%L) \n"/>
        </layout>
    </appender>

    <logger name="java.sql">
        <level value="debug"/>
    </logger>
    <logger name="org.apache.ibatis" >
        <level value="info"/>
    </logger>

    <!-- 默认配置，级别为debug 且根据name为log.console和 log.file两个appender输出-->
    <root>
        <level value="debug"/>
        <appender-ref ref="STDOUT"/>
    </root>
</log4j:configuration>

---

5. 核心配置文件

---

6. IDEA核心配置文件模板

（1）核心配置文件mybatis-config.xml

文件位置：src/main/resources/mybatis-config.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">

<configuration>
    <!--Mybatis核心配置文件中的标签必须按照指定的顺序配置-->
    <!--引入properties文件，此后就可以在当前文件中使用${key}的方式来访问到value-->
    <properties resource="jdbc.properties"></properties>
    
    <settings>
        <!--自动将下划线映射为驼峰-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!--开启延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!--按需加载-->
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>
    
    <!--typeAliases:类型别名,为某个具体的类型设置一个别名，然后再mybatis的范围中，可以使用别名来表示一个具体的类型-->
    <typeAliases>
        <!--以包的方式设置别名,该包下的所有实体类均为默认别名-->
        <package name=""/>
    </typeAliases>

    <!--
        配置链接数据库的环境:
            可以配置多个环境，比如测试环境和开发环境 ;
            使用id区分，不能重复。
            default : 默认选择哪个环境有效。
     -->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"></transactionManager>
            <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>
        </environment>
    </environments>

    <!-- 引入 MyBatis 的映射文件 : 存放SQL语句 和 POJO的映射方式 -->
    <mappers>
        <!--
            以包的方式来引入映射文件，但是必须满足两个条件：
                1、mapper接口和映射文件所在的包必须一致；
                2、mapper接口名字和映射文件的名字必须一致；
        -->
        <package name=""/>
    </mappers>
</configuration>

（2）配置数据库的jdbc.properties

文件位置：src/main/resources/jdbc.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/ssm?serverTimezone=UTC
jdbc.username=root
jdbc.password=root

---

7. 获取参数

Mybatis映射文件 Sql语句获取参数到SQL语句的情况：

• 1.单个字面量类型（基本数据类型）
• 2.多个字面量类型（基本数据类型）
• 3.Map
• 4.单个POJO（最常用）
• 5.@Param （最常用的方式）
• 6.List<泛型>

（1）UserMapper接口类

文件位置：src/main/java/com/atguigu/mybatis/mapper/UserMapper.java

package com.atguigu.mybatis.mapper;

import com.atguigu.mybatis.pojo.User;
import org.apache.ibatis.annotations.Param;

import java.util.Map;

/**
 * Mybatis获取参数值的两种方式：#{}和${}
 * #{}的本质是占位符赋值；（较为多的使用）
 * ${}的本质是字符串拼接；
 * 1、若mapper接口方法的参数为单个的字面量类型，此时可以通过#{}或${}以任意内容获取参数值，但是一定要注意${}的单引号问题。
 * 2、若mapper接口方法的参数是多个的字面临类型，此时Mybatis会将参数放入map集合中，以两种方式存储数据：
 *  （1）以arg0、arg1....为键，以参数为值；
 *  （2）以param1、param2....为键，以参数为值；
 *  因此，我们只需要通过#{}和${}访问map集合的键，就可以拿到参数值。
 * 3、若mapper接口方法的参数为一个map集合类型的参数，此时我们只需要通过#{}和${}访问map集合的键，就可以拿到相对应参数值。
 * 4、若mapper接口方法的参数为实体类类型的参数，此时我们只需要通过#{}和${}访问实体类中属性名，就可以拿到相对应的参数值。
 * 5、可以在mapper接口方法的参数上设置@Param注解，此时mybatis会将这些参数放在map中，以两种方式来进行存储：
 *  （1）以@Param注解的value属性值为键，以参数为值；
 *  （2）以param1、param2....为键，以参数为值；
 */
public interface UserMapper {
    /**
     * 根据用户名查询用户信息
     * @param username
     * @return
     */
    User getUserByUsername(String username);

    /**
     * 验证登录
     * @param username
     * @param password
     * @return
     */
    User checkLogin(String username,String password);

    /**
     * {username: "xxxx"}
     * {password: "xxxx"}
     * @param map
     * @return
     */
    User cheLoginByMap(Map<String,Object> map);

    /**
     * 添加用户信息的功能
     * @param user
     */
    void insertUser(User user);

    /**
     * 验证登录功能（使用@Param注解方式）
     * @param username
     * @param password
     * @return
     */
    User checkLoginByParam(@Param("username") String username, @Param("password") String password);
}

（2）UserMapper.xml

文件位置：src/main/resources/com/atguigu/mybatis/mapper/UserMapper.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接口 -->
<mapper namespace="com.atguigu.mybatis.mapper.UserMapper">
    <!--单个字面量类型（基本数据类型）-->
    <!--User getUserByUsername(String username);-->
    <!--1、占位符方式-->
    <select id="getUserByUsername" resultType="User">
        select * from  t_user where username=#{username}
    </select>
    <!--2、字符串拼接方式-->
    <select id="getUserByUsername" resultType="User">
        select * from t_user where username = '${username}'
    </select>

    <!--多个字面量类型（基本数据类型）-->
    <!--User checkLogin(String username,String password);-->
    <select id="checkLogin" resultType="User">
        select * from t_user where username=#{param1} and password=#{param2}
    </select>

    <!--Map集合类型-->
    <!--User cheLoginByMap(Map<String,Object> map);-->
    <select id="cheLoginByMap" resultType="User">
        select * from t_user where username=#{username} and password=#{password}
    </select>
    
    <!--实体类型-->
    <!--void insertUser(User user);-->
    <insert id="insertUser">
        insert into t_user values(null,#{username},#{password},#{age},#{gender},#{email})
    </insert>
    
    <!--@Param注释方式-->
    <!--User checkLoginByParam(@Param("username") String username, @Param("password") String password);-->
    <select id="checkLoginByParam" resultType="User">
        select * from t_user where username=#{username} and password=#{password}
    </select>
</mapper>

---

8. 查询功能详解

查询功能：

• 1. 返回结果是一个实体类
• 2. 返回结果是一个List集合
• 3. 返回结果是一个单行单列的数据
• 4. 返回结果是一个Map集合
• 5. 返回结果是一个map的list集合

（1）SelectMapper.java接口类

文件位置：src/main/java/com/atguigu/mybatis/mapper/SelectMapper.java

package com.atguigu.mybatis.mapper;

import com.atguigu.mybatis.pojo.User;
import org.apache.ibatis.annotations.MapKey;
import org.apache.ibatis.annotations.Param;

import java.util.List;
import java.util.Map;

public interface SelectMapper {
    /**
     * 1、若SQL语句查询的结果为多条时，一定不能以实体类类型为返回值，否则会抛出异常（TooManyResultException）；
     * 2、若SQL语句查询的结果为一条时，此时可以使用实体类类型或List集合类型来作为方法的返回值；
     */

    /**
     * 根据id来查询用户信息
     * @param id
     * @return
     */
    User getUserById(@Param("id") Integer id);

    /**
     * 获取所有的用户信息
     * @return
     */
    List<User> getAllUser();

    /**
     * 查询用户的总数量
     * @return
     */
    Integer getCount();

    /**
     * 根据用户id查询用户信息为一个map集合
     * @param id
     * @return
     */
    Map<String,Object> getUserByIdToMap(@Param("id") Integer id);

    /**
     * 获取所有用户信息到一个map集合
     * 若查询的数据有多条时，并且要将每条数据转换为map集合，此时有两种解决方案：
     *  1、将mapper接口方法的返回值设置为泛型是map的List集合；
     * 		List<Map<String,Object>> getAllUserToMap();
     *  2、将每条数据转换的map集合放到一个大的map集合中，但是必须通过@MapKey注解，将查询的某个字段的值作为这个大的map的键
     *  	(id作为键，小map作为值）
     *  	{
     *      	2={password=123456, gender=男, id=2, age=23, email=12345@qq.com, username=admin},
     *      	3={password=123, gender=男, id=3, age=23, email=12345@qq.com, username=root},
     *      	5={password=123456, gender=男, id=5, age=23, email=12345@qq.com, username=admin}
     *  	}
     * @return
     */
    //List<Map<String,Object>> getAllUserToMap();
    @MapKey("id")
    Map<String,Object> getAllUserToMap();
}

（2）SelectMapper.xml

文件位置：src/main/resources/com/atguigu/mybatis/mapper/SelectMapper.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接口 -->
<mapper namespace="com.atguigu.mybatis.mapper.SelectMapper">
    <!--User getUserById(@Param("id") Integer id);-->
    <select id="getUserById" resultType="User">
        select * from t_user where id=#{id}
    </select>

    <!--List<User> getAllUser();-->
    <select id="getAllUser" resultType="User">
        select * from t_user
    </select>

    <!--Integer getCount();-->
    <!--
        mybatis底层起好了类型别名，可以直接使用Integer、interger、Map、map、String、string等作为结果的类型
    -->
    <select id="getCount" resultType="Integer">
        select count(*) from t_user
    </select>

    <!--Map<String,Object> getUserByIdToMap(@Param("id") Integer id);-->
    <select id="getUserByIdToMap" resultType="map">
        select * from t_user where id=#{id}
    </select>
    
    <!--Map<String,Object> getAllUserToMap();-->
    <select id="getAllUserToMap" resultType="map">
        select * from t_user
    </select>
</mapper>

---

9. 特殊SQL

特殊的SQL语句：

• 1. 模糊查询
• 2. 批量删除
• 3. 动态设置表名
• 4. 添加信息并获取自增的主键

(1)SpecialSQLMapper.java接口类

文件位置：src/main/java/com/atguigu/mybatis/mapper/SpecialSQLMapper.java

package com.atguigu.mybatis.mapper;

import com.atguigu.mybatis.pojo.User;
import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface SpecialSQLMapper {
    /**
     * 通过用户名模糊查询用户信息
     * @param mohu
     * @return
     */
    List<User> getUserByLike(@Param("mohu") String mohu);

    /**
     * 批量删除
     * @param ids
     */
    void deleteMoreUser(@Param("ids") String ids);

    /**
     * 动态设置表名
     * @param tableName
     * @return
     */
    List<User> getUserList(@Param("tableName") String tableName);

    /**
     * 添加用户信息并获取自增的主键
     * @param user
     * @return
     */
    Integer insertUser(User user);
}

（2）SpecialSQLMapper.xml

文件位置：src/main/resources/com/atguigu/mybatis/mapper/SpecialSQLMapper.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接口 -->
<mapper namespace="com.atguigu.mybatis.mapper.SpecialSQLMapper">
    <!--List<User> getUserByLike(@Param("mohu") String mohu);-->
    <!--第一种方式：使用${}方式-->
    <select id="getUserByLike" resultType="User">
        select * from t_user where username like '%${mohu}%'
    </select>
    <!--第二种方式:使用concat将字符串拼接-->
    <select id="getUserByLike" resultType="user">
        SELECT * FROM t_user WHERE username like CONCAT('%', #{mohu}, '%');
    </select>
    <!-- 第三种方式：用的最多的方式的 -->
    <select id="getUserByLike" resultType="user">
        SELECT * FROM t_user WHERE username like "%"#{mohu}"%"
    </select>

    <!--void deleteMoreUser(@Param("ids") String ids);-->
    <delete id="deleteMoreUser">
        delete from t_user where id in (${ids})
    </delete>

    <!--List<User> getUserList(@Param("tableName") String tableName);-->
    <select id="getUserList" resultType="User">
        select * from ${tableName}
    </select>

    <!--Integer insertUser(User user);-->
    <!--
        useGeneratedKeys:表示当前添加功能使用自增的主键；
        keyProperty:将添加的数据自增的主键赋值给实体类型的参数的属性赋值；
    -->
    <insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
        insert into t_user values (null,#{username},#{password},#{age},#{gender},#{email})
    </insert>
</mapper>

---

10. ResultMap

10.1 字段名和属性名不一致的情况

属性名和数据库字段名不一致的查询的三种方式：

• 为查询的字段设置别名，和属性名保持一致；
• 当字段符合MySQL的要求使用_，而属性符合java的要求使用驼峰。此时可以在mybatis的核心配置文件中设置一个全局配置，可以自动的将下划线映射为驼峰；
• 使用resultMap自定义映射处理；

10.1.1 方式一： 使用别名

通过SQL语句起别名的方式解决数据库的字段和实体类的属性名称不一致的问题。

EmpMapper.xml

文件位置：src/main/resources/com/atguigu/mybatis/mapper/EmpMapper.xml

    <!--方式一：使用别名-->
    <select id="getEmpByEmpId" resultType="Emp">
        select emp_id empId,emp_name empName,age,gender from t_emp where emp_id=#{empId}
    </select>

10.1.2 方式二： 在核心配置文件中添加settings配置将下滑线映射为驼峰

在核心配置文件配置typeAliases标签以后，就可以直接在映射文件中自动映射。

（1）Mybatis核心配置文件mybatis-config.xml

文件位置：src/main/resources/mybatis-config.xml

    <!--typeAliases:类型别名,为某个具体的类型设置一个别名，然后再mybatis的范围中，可以使用别名来表示一个具体的类型-->
    <typeAliases>
        <!--以包的方式设置别名,该包下的所有实体类均为默认别名-->
        <package name="com.atguigu.mybatis.pojo"/>
    </typeAliases>

（2）EmpMapper.xml

文件位置：src/main/resources/com/atguigu/mybatis/mapper/EmpMapper.xml

    <!--方式二：在核心配置文件中添加settings配置将下滑线映射为驼峰-->
    <select id="getEmpByEmpId" resultType="Emp">
        select * from t_emp where emp_id = #{empId}
    </select>

10.1.3 方式三： 自定义映射

使用 ResltMap , 注意 resultMap 和 resultType 是二选一的。

    <!--方式三：自定义映射-->
    <!--
        resultMap:设置自定义的映射关系；
        id：唯一标识；
        type：处理映射关系的实体类的类型；
    -->
    <resultMap id="empResultMap" type="Emp">
        <!--
            常用标签：
                id：处理主键和实体类中属性的映射关系；
                result：处理普通字段和实体类中属性的映射关系；
                column：设置映射关系中的字段名，必须是sql查询出的某个字段；
                property：设置映射关系中的属性的属性名，必须是当前处理的实体类类型中的属性名；
        -->
        <id column="emp_id" property="empId"></id>
        <result column="emp_name" property="empName"></result>
        <result column="age" property="age"></result>
        <result column="gender" property="gender"></result>
    </resultMap>
    <select id="getEmpByEmpId" resultMap="empResultMap">
        select * from t_emp where emp_id = #{empId}
    </select>

10.2 多对一关系

POJO：多个emp对应一个Dept，多个成员对应一个部门。

Emp实体类

public class Emp {
    private Integer empId;
    private String empName;
    private Integer age;
    private String gender;
    //多对一关系，对应的是一个对象
    private Dept dept;
}

处理多对一的映射关系：

• 级联方式
• association标签：专门用来处理多对一的映射关系（处理实体类类型的属性）
• 分步骤查询方式

10.2.1 级联方式

EmpMapper.xml

文件位置：src/main/resources/com/atguigu/mybatis/mapper/EmpMapper.xml

    <!--第一种方式：级联方式-->
    <resultMap id="empAndDeptResultMapOne" type="Emp">
        <id column="emp_id" property="empId"></id>
        <result column="emp_name" property="empName"></result>
        <result column="age" property="age"></result>
        <result column="gender" property="gender"></result>
        <result column="dept_id" property="dept.deptId"></result>
        <result column="dept_name" property="dept.deptName"></result>
    </resultMap>
  	<!--Emp getEmpAndDeptByEmpId(@Param("empId") Integer empId);-->
    <select id="getEmpAndDeptByEmpId" resultMap="empAndDeptResultMapOne">
        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>

10.2.2 association标签

EmpMapper.xml

文件位置：src/main/resources/com/atguigu/mybatis/mapper/EmpMapper.xml

<!--第二种方式：association标签-->
    <resultMap id="empAndDeptResultMapTwo" type="Emp">
        <id column="emp_id" property="empId"></id>
        <result column="emp_name" property="empName"></result>
        <result column="age" property="age"></result>
        <result column="gender" property="gender"></result>
        <!--
            association:处理多对一的映射关系（处理实体类类型的属性）；
            property：设置需要处理映射关系的属性的属性名；
            javaType：设置要处理的属性的类型；
        -->
        <association property="dept" javaType="Dept">
            <id column="dept_id" property="deptId"></id>
            <result column="dept_name" property="deptName"></result>
        </association>
    </resultMap>
    
    <!--Emp getEmpAndDeptByEmpId(@Param("empId") Integer empId);-->
    <select id="getEmpAndDeptByEmpId" resultMap="empAndDeptResultMapTwo">
        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>

10.2.3 分步骤查询方式

分布查询需要两个接口方法，然后再各自的映射文件中填写SQL语句，两条语句使用association标签中的select和column连接在一起。

（1）EmpMapper.java接口类

文件位置：src/main/java/com/atguigu/mybatis/mapper/EmpMapper.java

    /**
     * 通过分步骤查询获取员工及员工部门信息的第一步
     * @param empId
     * @return
     */
    Emp getEmpAndDeptByStep(@Param("empId") Integer empId);

（2）DeptMapper.java接口类

文件位置：src/main/java/com/atguigu/mybatis/mapper/DeptMapper.java

    /**
     * 通过分步骤查询获取员工及员工部门信息的第二步
     * @return
     */
    Dept getEmpAndDeptByStepTwo(@Param("deptId") Integer deptId);

（3）EmpMapper.xml

文件位置：src/main/resources/com/atguigu/mybatis/mapper/EmpMapper.xml

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

（3）DeptMapper.xml

文件位置：src/main/resources/com/atguigu/mybatis/mapper/DeptMapper.xml

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

10.3 一对多关系

POJO：一个 Dept 对应多个 Emp。一个部门对应多个成员。

Dept 实体类

public class Dept {
    private Integer deptId;
    private String deptName;
    //一对多，对应的是一个集合
    private List<Emp> emps;
}

处理一对多的映射关系：

• collection
• 分步骤查询

10.3.1 collection

（1）DeptMapper.java接口类

文件位置：src/main/java/com/atguigu/mybatis/mapper/DeptMapper.java

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

（2）DeptMapper.xml

文件位置：src/main/resources/com/atguigu/mybatis/mapper/DeptMapper.xml

<!--第一种方式：collection-->
    <resultMap id="deptAndEmpResultMap" type="Dept">
        <id column="dept_id" property="deptId"></id>
        <result column="dept_name" property="deptName"></result>
        <!--
            collection:处理一对多的映射关系（处理集合类型的属性的）
            ofType:设置集合类型的属性中存储的数据的类型；
        -->
        <collection property="emps" ofType="Emp">
            <id column="emp_id" property="empId"></id>
            <result column="emp_name" property="empName"></result>
            <result column="age" property="age"></result>
            <result column="gender" property="gender"></result>
        </collection>
    </resultMap>
    
    <!--Dept getDeptAndEmpByDeptId(@Param("deptId") Integer deptId);-->
    <select id="getDeptAndEmpByDeptId" resultMap="deptAndEmpResultMap">
        select t_dept.*,t_emp.* from t_dept left join t_emp on t_dept.dept_id = t_emp.dept_id where t_dept.dept_id = #{deptId}
    </select>

10.3.2 分步骤查询

（1）DeptMapper.java接口类

文件位置：src/main/java/com/atguigu/mybatis/mapper/DeptMapper.java

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

（2）EmpMapper.java接口类

文件位置：src/main/java/com/atguigu/mybatis/mapper/EmpMapper.java

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

（3）DeptMapper.xml

文件位置：src/main/resources/com/atguigu/mybatis/mapper/DeptMapper.xml

    <!--第二种方式：分步骤查询-->
    <resultMap id="deptAndEmpByStepResultMapOne" type="Dept">
        <id column="dept_id" property="deptId"></id>
        <result column="dept_name" property="deptName"></result>
        <collection property="emps" fetchType="eager" select="com.atguigu.mybatis.mapper.EmpMapper.getDeptAndEmpByStepTwo" column="dept_id"></collection>
    </resultMap>
    <!--Dept getDeptAndEmpByStepOne(@Param("deptId") Integer deptId);-->
    <select id="getDeptAndEmpByStepOne" resultMap="deptAndEmpByStepResultMapOne">
        select * from t_dept where dept_id = #{deptId}
    </select>

（4）EmpMapper.xml

文件位置：src/main/resources/com/atguigu/mybatis/mapper/EmpMapper.xml

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

---

11. 动态SQL

11.1 if标签

（1）DynamicSQLMapper.java接口类

文件位置：src/main/java/com/atguigu/mybatis/mapper/DynamicSQLMapper.java

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

（2）DynamicSQLMapper.xml

文件位置：src/main/resources/com/atguigu/mybatis/mapper/DynamicSQLMapper.xml

    <!--
        动态SQL：
        1、if标签：通过test属性中的表达式判断标签中的内容是否有效，来判断是否拼接到SQL语句中；
            where 1=1 是为了避免出现第一个为null，第二个sql拼接时候带着and导致sql语句错误
    -->
    <!--List<Emp> getEmpByCondition(Emp emp);-->
    <select id="getEmpByCondition" resultType="Emp">
        select * from t_emp where 1=1
            <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>

11.2 where标签

使用where标签与if标签结合的方式

DynamicSQLMapper.xml

文件位置：src/main/resources/com/atguigu/mybatis/mapper/DynamicSQLMapper.xml

    <!--
        where标签：
            1、若where标签中有if标签，if成立的话，会自动生成where关键字；
            2、会自动将where标签中前面的多余的and去掉，内容后面多余的and去不掉；
            3、若where标签中没有任何一个标签成立，则where标签中没有任何功能；
    -->
    <select id="getEmpByConditionTwo" 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>

11.3 trim标签

当and写到后面的时候，where标签将不能够自动去掉and关键字；
这时候，我们可以使用trim标签实现去掉多的，加上少的。

DynamicSQLMapper.xml

文件位置：src/main/resources/com/atguigu/mybatis/mapper/DynamicSQLMapper.xml

    <!--
        trim标签：
            1、prefix：在标签中内容的前面添加指定内容；
            2、suffix：在标签中内容的后面添加指定内容；
            3、prefixOverrides：在标签中内容的前面去掉指定内容；
            4、suffixOverrides：在标签中内容的后面去掉指定内容；
            
    -->
    <select id="getEmpByCondition" resultType="Emp">
        select * 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>

11.4 choose、when、otherwise标签

判断单一条件，只选择一个进行判断，如果有一个when满足了条件，则不进行后面的判断了。

DynamicSQLMapper.xml

文件位置：src/main/resources/com/atguigu/mybatis/mapper/DynamicSQLMapper.xml

    <!--
        choose、when、otherwise标签:相当于if-else if-else语句
        when至少要设置一个；otherwise最多设置一个；
    -->
    <!--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>

11.5 foreach标签

    <!--
        foreach标签
            collection:遍历的集合或数组；
            item：遍历项；
            separator：分隔符（自动在分隔符的前后含有空格）；
            open：循环的所有内容以什么为开始；
            close：循环的所有内容以什么为结束；
    -->

11.5.1 批量添加

DynamicSQLMapper.java

文件位置：src/main/java/com/atguigu/mybatis/mapper/DynamicSQLMapper.java

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

DynamicSQLMapper.xml

文件位置：src/main/resources/com/atguigu/mybatis/mapper/DynamicSQLMapper.xml

    <!--foreach标签-->
    <!--批量添加-->
    <!--void insertMoreEmp(@Param("emps") List<Emp> emps);-->
    <insert id="insertMoreEmp">
        insert into t_emp values
            <foreach collection="emps" item="emp" separator=",">
                (null,#{emp.empName},#{emp.age},#{emp.gender},null)
            </foreach>
    </insert>

11.5.2 批量删除

DynamicSQLMapper.java

文件位置：src/main/java/com/atguigu/mybatis/mapper/DynamicSQLMapper.java

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

DynamicSQLMapper.xml

文件位置：src/main/resources/com/atguigu/mybatis/mapper/DynamicSQLMapper.xml

    <!--批量删除-->
    <!--void deleteMoreEmp(@Param("empIds") Integer[] empIds);-->
    <!--”where id in (xx,xx,xx,xx)“方式-->
    <delete id="deleteMoreEmpOne">
        delete from t_emp where emp_id in (
            <foreach collection="empIds" item="empId" separator=",">
                #{empId}
            </foreach>
        )
    </delete>
    <!--open和close方式来书写左右开始结束括号-->
    <delete id="deleteMoreEmpTwo">
        delete from t_emp where emp_id in
            <foreach collection="empIds" item="empId" separator="," open="(" close=")">
                #{empId}
            </foreach>
    </delete>
    <!--"where id=? or id=?"方式-->
    <delete id="deleteMoreEmp">
        delete from t_emp where
            <foreach collection="empIds" item="empId" separator="or">
                emp_id = #{empId}
            </foreach>
    </delete>

11.6 SQL片段

声明一段sql语句片段，然后在其他地方的sql语句中引用使用。

DynamicSQLMapper.xml

文件位置：src/main/resources/com/atguigu/mybatis/mapper/DynamicSQLMapper.xml

    <!--
        SQL片段：可以记录一段sql，在需要使用的地方使用include标签来进行引用。
    -->
    <sql id="empColumns">
        emp_id,emp_name,age,gender,dept_id
    </sql>

    <select id="getEmpByCondition" resultType="Emp">
        select <include refid="empColumns"></include> 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>

---

12. Mybatis的缓存

12.1 Mybatis的一级缓存

    /**
     * mybatis的一级缓存：
     * mybatis的一级缓存是SqlSession级别的，即通过同一个SqlSession来查询同一条数据会被缓存
     * 再次使用同一条SqlSession查询同一条数据，会从缓存获取。
     * mybatis的一级缓存是默认自动开启的。
     */

• 以下四种情况会导致一级缓存失效：
  1. 不同SqlSession对应不同的一级缓存。（即不同SqlSession，即使是相同查询条件也无用）。
  2. 同一个SqlSession但是查询条件不同。
  3. 同一个SqlSession 两次查询期间执行了任何一次针对此表增删改操作。
  4. 同一个SqlSession两次查询期间手动清空了缓存。

12.2 Mybatis的二级缓存

    /**
     * mybatis的二级缓存：
     * mybatis的二级缓存是SqlSessionFactory级别的，即通过同一个SqlSessionFactory所获取的SqlSessionFactory对象，
     * 查询的数据会被缓存，在通过同一个SqlSessionFactory所获取的SqlSession查询相同一个数据会从缓存中获取。
     * @throws IOException
     */

12.2.1 Mybatis的二级缓存开启的四个条件

1.核心配置文件中设置

核心配置文件中默认cacheEnabled的属性值是true，所以即使不设置也是可以的。

<settings>
  <setting cacheEnabled="true"></setting>
</settings>

2.映射文件中设置<cache/>标签

<mapper namespace="com.atguigu.mybatis.mapper.CacheMapper">
    <cache></cache>
</mapper>

3.二级缓存必须是在 SQLSession 关闭或提交之后有效。（即SQLSession关闭或提交后，一级缓存当中的数据才会保存到一级缓存中）

    @Test
    public void testCache() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        CacheMapper mapper = sqlSession.getMapper(CacheMapper.class);
        Emp empById = mapper.getEmpById(1);
        System.out.println(empById);
        //关闭sqlSession
        sqlSession.close();

        SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
        CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class);
        Emp empById1 = mapper1.getEmpById(1);
        System.out.println(empById1);
        //关闭sqlSession1
        sqlSession1.close();
    }

4. 实体类必须实现 Serializable 接口。

public class Emp implements Serializable {
    private Integer empId;
    private String empName;
    private Integer age;
    private String gender;

12.2.2 mybatis的二级缓存失效

任意一次增删该就会清空mybatis的二级缓存（唯一 一种情况）

12.2.3 Mybatis的二级缓存的相关配置

12.3 Mybatis缓存查询的顺序

1. 先查询二级缓存，因为二级缓存当中可能会有其他线程已经查询出来的数据。
2. 二级缓存没有命中，则再查询一级缓存。
3. 一级缓存也没有命中，则执行查询数据库。
4. SQLSession关闭之后，一级缓存当中的数据会写入到二级缓存。

12.4 整合第三方缓存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包功能

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

文件命名：ehcache.xml 强制要求
文件路径：src/main/resources/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:\atguigu\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"></cache>

5.加入logback日志

文件命名：logback.xml 强制要求
文件路径：src/main/resources/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.atguigu.mybatis.mapper" level="DEBUG"/>
</configuration>

6.EHCache配置文件说明

---

13. Mybatis的逆向工程

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

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

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

1.添加插件和依赖

在pom.xml中添加插件和依赖

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.atguigu.mybatis</groupId>
    <artifactId>mybatis_mbg</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <!-- 依赖MyBatis核心包 -->
    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</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>8.0.16</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>8.0.16</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>
    <properties>
        <maven.compiler.source>19</maven.compiler.source>
        <maven.compiler.target>19</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
</project>

2.创建MyBatis的核心配置文件
mybatis-config.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">

<configuration>
    <!--Mybatis核心配置文件中的标签必须按照指定的顺序配置-->
    <!--引入properties文件，此后就可以在当前文件中使用的方式来访问到value-->
    <properties resource="jdbc.properties"></properties>

    <settings>
        <!--自动将下划线映射为驼峰-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!--开启延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!--按需加载-->
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>

    <!--typeAliases:类型别名,为某个具体的类型设置一个别名，然后再mybatis的范围中，可以使用别名来表示一个具体的类型-->
    <typeAliases>
        <!--以包的方式设置别名,该包下的所有实体类均为默认别名-->
        <package name="com.atguigu.mybatis.pojo"/>
    </typeAliases>

    <!--
        配置链接数据库的环境:
            可以配置多个环境，比如测试环境和开发环境 ;
            使用id区分，不能重复。
            default : 默认选择哪个环境有效。
     -->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"></transactionManager>
            <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>
        </environment>
    </environments>

    <!-- 引入 MyBatis 的映射文件 : 存放SQL语句 和 POJO的映射方式 -->
    <mappers>
        <!--
            以包的方式来引入映射文件，但是必须满足两个条件：
                1、mapper接口和映射文件所在的包必须一致；
                2、mapper接口名字和映射文件的名字必须一致；
        -->
        <package name="com.atguigu.mybatis.mapper"/>
    </mappers>
</configuration>

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

文件命名：generatorConfig.xml 强制性命名
文件路径：src/main/resources/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: 执行生成的逆向工程的版本
        	1、MyBatis3Simple: 生成基本的CRUD（清新简洁版）
        	2、MyBatis3: 生成带条件的CRUD（奢华尊享版）
    -->
    <context id="DB2Tables" targetRuntime="MyBatis3">
        <!-- 数据库的连接信息 -->
        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC"
                        userId="root"
                        password="root">
        </jdbcConnection>
        <!-- javaBean的生成策略-->
        <javaModelGenerator targetPackage="com.atguigu.mybatis.pojo"
                            targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true" />
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
        <!-- SQL映射文件的生成策略 -->
        <sqlMapGenerator targetPackage="com.atguigu.mybatis.mapper"
                         targetProject=".\src\main\resources">
            <property name="enableSubPackages" value="true" />
        </sqlMapGenerator>
        <!-- Mapper接口的生成策略 -->
        <javaClientGenerator type="XMLMAPPER"
                             targetPackage="com.atguigu.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目标

---

14. 分页插件

14.1 分页插件的使用步骤

1.添加依赖
pom.xml

        <!--分页插件依赖-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.2.0</version>
        </dependency>

2.核心配置文件（mybatis-config.xml）中配置分页插件

文件位置：src/main/resources/mybatis-config.xml

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

3.效果