1.概念

 

 

2.开发环境搭建

2.1 开发环境

 2.2 创建Maven工程

<!--junit测试-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
</dependency>
<!--Mybatis核心-->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.7</version>
</dependency>
<!--Mysql驱动-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.21</version>
</dependency>

 2.3 创建Mybatis的核心配置文件

习惯上命名为mybatis-configxml，这个文件名仅仅只是建议，并非强制要求。将来整合Spring之后，这个配置文件可以省略，所以大家操作时可以直接复制、粘贴。

核心配置文件主要用于配置连接数据库的环境以及MyBatis的全局配置信息

核心配置文件存放的位置是src/main/resources目录下

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--配置连接数据库的环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <!--数据源-->
            <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="mysql123."/>
            </dataSource>
        </environment>
    </environments>
    <!--引入mybatis的映射文件-->
    <mappers>
        <mapper resource=""/>
    </mappers>
</configuration>

2.4 创建mapper接口

 2.5 创建Mybatis的映射文件

 

 mapper接口和映射文件要保证两个一致:

1、mapper接口的全类名和映射文件的namespace一致

2、mapper接口中的方法的方法名要和映射文件中的sql的id保持一致

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.fd.mybatis.mapper.UserMapper">

    <!--
    mapper接口和映射文件要保证两个一致:
        1，mapper接口的全类名和映射文件的namespace一致
        2、mapper接口中的方法的方法名要和映射文件中的sqL的id保持一致
    -->
    <insert id="insertUser">
        insert into t_user values('4','admin','123456',23,'男','123456@qq.com')
    </insert>
</mapper>

2.6 创建测试方法

@Test
public void mybatisTest() {
    try {
        // 获取核心配置文件的输入流
        InputStream stream = Resources.getResourceAsStream("mybatis_config.xml");
        // 获取SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        // 获取SqlSessionFactory对象
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(stream);
        // 获取sql的会话对象SqlSession（不会自动提交事务）,是Mybatis提供的操作数据的对象
        // SqlSession sqlSession = sqlSessionFactory.openSession();
        // 获取sql的会话对象SqlSession（会自动提交事务）
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        // 获取UserMapper的代理实现类,
        // 通过getMapper方法，重写接口方法：通过UserMapper的全类名来找到当前对象的映射文件，再通过要调用的方法找到要调用的sql语句

        /**
         * mapper接口和映射文件要保证两个一致:
         *         1，mapper接口的全类名和映射文件的namespace一致
         *         2、mapper接口中的方法的方法名要和映射文件中的sqL的id保持一致
         * */

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        // 执行sql方法
        int result = mapper.insertUser();

        // 接口重写的底层实现： 通过唯一标识找到sql并执行，唯一标识是namespace.sqlId
        // int result = sqlSession.insert("com.fd.mybatis.mapper.UserMapper.insertUser");

        System.out.println("结果：" + result);
        // 需要手动提交事务
        // sqlSession.commit();
        // 关闭会话
        sqlSession.close();
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

2.7 加入log4j日志功能

1.添加依赖

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

 2. 加入log4j的配置文件

log4j的配置文件名为log4j.xml，存放的位置是src/main/resources目录下

<?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="%-5p %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>
    <root>
        <level value="debug"/>
        <appender-ref ref="STDOUT"/>
    </root>
</log4j:configuration>

日志的级别：从左到右打印的内容越来越详细

FATAL(致命)>ERROR(错误)>WARN(警告)>INFO(信息)>DEBUG(调试)

实现效果：

2.8 总结：

1. 创建Mybatis的核心配置文件
2. 创建mapper接口对象
3. 创建mapper接口映射文件（mapper接口的全类名和映射文件的namespace一致、mapper接口中的方法的方法名要和映射文件中的sql的id保持一致）
4. 创建测试方法

3.Mybatis核心配置文件讲解

3.1 引入properties文件

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mydb?serverTimezone=UTC
jdbc.username=root
jdbc.password=mysql123.

3.2 核心配置文件

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

    <!--
        Mybatis核心配置文件中的标签必须按照指定的顺序配置
        (properties?,settings?,typeAliases?,typeHandlers?,objectFactory?,objectWrapperFactory?,reflectorFactory?,plugins?,environments?,databaseIdProvider?,mappers?)
    -->

    <!--引入properties文件，此后就可以在当前文件中使用${key}的方式访问value-->
    <properties resource="jdbc.properties"/>

    <!--
        typeAliases：设置类型别名，即为某个具体的类型设置一个别名
        在Mybatis的范围中，就可以使用别名标识一个具体的类型
    -->
    <typeAliases>
        <!--
            type: 设置需要起别名的类型
            alias: 设置某个类型的别名
        -->
        <typeAlias type="com.fd.mybatis.pojo.User" alias="abc"></typeAlias>
        <!--若不设置alias，当前的类型拥有默认的别名，即类名且不区分大小写-->
        <typeAlias type="com.fd.mybatis.pojo.User"></typeAlias>
        <!--通过包设置类型别名，指定包下所有的类型将全部拥有默认的别名，即类名且不区分大小写-->
        <package name="com.fd.mybatis.pojo"/>
    </typeAliases>
    <!--
        environments: 配置连接数据库的环境
            属性：
            default: 设置默认使用的环境的id
    -->
    <environments default="development">
        <!--
            environment: 设置一个具体的连接数据库的环境
            属性：
                id: 设置环境的唯一标识，不能重复
        -->
        <environment id="development">
            <!--
                transactionManager：设置事务管理器
                属性：
                    type: 设置事务管理的方式
                    type="JDBC | MANAGED" 两种方式
                    JDBC:表示使用JDBC中原生的事务管理方式
                    MANAGED:被管理，例如Spring
            -->
            <transactionManager type="JDBC"/>
            <!--
                dataSource：设置数据源
                属性：
                    type:设置数据源的类型
                    type="POOLED | UNPOOLED | JNDI"
                    POOLED:表示使用数据库连接池，创建好连接后交给连接池管理
                    UNPOOLED:表示不使用数据库连接池,连接数据库时每次新创建连接
                    JNDI:表示使用上下文中的数据源
            -->
            <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的映射文件-->
    <mappers>
        <!--一个mapper接口就要创建一个映射文件，实际开发中接口很多一般不推荐使用这种方式，推荐使用包引入的方式-->
        <!--<mapper resource="mappers/UserMapper.xml"/>-->
        <!--
            以包的方式引入映射文件，但是必须满足两个条件:
            1、mapper接口和映射文件所在的包必须一致
            2、mapper接口的名宇和映射文件的名字必须一致
        -->
        <package name="com.fd.mybatis.mapper"/>
    </mappers>
</configuration>

3.3  代码框架结构

4.User对象数据库：增删改查

4.1 mapper接口对象

package com.fd.mybatis.mapper;

import com.fd.mybatis.pojo.User;

import java.util.List;

/**
 * @author 付东
 */
public interface UserMapper {

    /**
     * 新增用户
     *
     * @author lucky_fd
     * @return int
     **/
    int insertUser();

    /**
     * 修改用户
     *
     * @author lucky_fd
     * @return int
     **/
    int updateUser();

    /**
     * 删除用户
     *
     * @author lucky_fd
     * @return int
     **/
    int deleteUser();

    /**
     * 查询用户
     *
     * @author lucky_fd
     * @return com.fd.mybatis.pojo.User
     **/
    User getUserById();

    /**
     * 查询用户
     *
     * @author lucky_fd
     * @return java.util.List<com.fd.mybatis.pojo.User>
     **/
    List<User> selectUser();
}

4.2 mapper映射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.fd.mybatis.mapper.UserMapper">

    <!--
    mapper接口和映射文件要保证两个一致:
        1，mapper接口的全类名和映射文件的namespace一致
        2、mapper接口中的方法的方法名要和映射文件中的sqL的d保持一致
    -->
    <insert id="insertUser">
        insert into t_user values('2','root','123456',23,'男','123456@qq.com')
    </insert>

    <update id="updateUser">
        update t_user set password = 'qwer' where id = '1';
    </update>

    <delete id="deleteUser">
        delete from t_user where id = '1'
    </delete>

    <!--
        resultType: 设置结果类型，及查询的数据要转换的java类型
        resultMap: 自定义映射，处理多对一或一对多的映射关系
    -->
    <select id="getUserById" resultType="com.fd.mybatis.pojo.User">
        select * from t_user where id = '1'
    </select>

    <select id="selectUser" resultType="User">
        select * from t_user
    </select>
</mapper>

4.3 测试类

package com.fd.mybatis;

import static org.junit.Assert.assertTrue;

import com.fd.mybatis.mapper.UserMapper;
import com.fd.mybatis.pojo.User;
import com.fd.mybatis.utils.SqlSessionUtil;
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 java.io.IOException;
import java.io.InputStream;
import java.util.List;

/**
 * Unit test for simple App.
 */
public class AppTest
{
    /**
     * Rigorous Test :-)
     */
    @Test
    public void shouldAnswerWithTrue()
    {
        assertTrue( true );
    }

    @Test
    public void mybatisAddTest() {
        try {
            // 获取核心配置文件的输入流
            InputStream stream = Resources.getResourceAsStream("mybatis_config.xml");
            // 获取SqlSessionFactoryBuilder对象
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
            // 获取SqlSessionFactory对象
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(stream);
            // 获取sql的会话对象SqlSession（不会自动提交事务）,是Mybatis提供的操作数据的对象
            // SqlSession sqlSession = sqlSessionFactory.openSession();
            // 获取sql的会话对象SqlSession（会自动提交事务）
            SqlSession sqlSession = sqlSessionFactory.openSession(true);
            // 获取UserMapper的代理实现类,
            // 通过getMapper方法，重写接口方法：通过UserMapper的全类名来找到当前对象的映射文件，再通过要调用的方法找到要调用的sql语句

            /**
             * mapper接口和映射文件要保证两个一致:
             *         1，mapper接口的全类名和映射文件的namespace一致
             *         2、mapper接口中的方法的方法名要和映射文件中的sqL的d保持一致
             * */

            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            // 执行sql方法
            int result = mapper.insertUser();

            // 接口重写的底层实现： 通过唯一标识找到sql并执行，唯一标识是namespace.sqlId
            // int result = sqlSession.insert("com.fd.mybatis.mapper.UserMapper.insertUser");

            System.out.println("结果：" + result);
            // 需要手动提交事务
            // sqlSession.commit();
            // 关闭会话
            sqlSession.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Test
    public void updateTest() {
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int result = mapper.updateUser();
        System.out.println("结果：" + result);
    }

    @Test
    public void deleteTest() {
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int result = mapper.deleteUser();
        System.out.println("结果：" + result);
    }

    @Test
    public void selectTest() {
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.getUserById();
        System.out.println(user.toString());
    }

    @Test
    public void SelectAllUserTest() {
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = mapper.selectUser();
        userList.forEach(user -> System.out.println(user.toString()));
    }
}

4.4 代码结构：

5.Mybatis获取参数值的方式

5.1 若mapper接口方法的参数为单个的字面量类型（推荐）

此时可以通过#{}和${}以任意的内容获取参数值，一定要注意${}的单引号问题

5.2 若mapper接口方法的参数为多个的字面量类型

此时MyBatis会将参数放在map集合中，以两种方式存储数据

a>以arg0,arg1...为键，以参数为值

b>以param1,param2..·为键，以参数为值

因此，只需要通过#{}和${}访map集合的键，就可以获取相对应的值，一定要注意${}的单引号问题

 5.3 若mapper接口方法的参数为map集合类型的参数

只需要通过#{}和${}访问map集合的键，就可以获取相对应的值，一定要注意${}的单引号问题

5.4 若mapper接口方法的参数为实体类类型的参数（推荐）

只需要通过#{}和${}访问实体类中的属性 就可以获取相对应的属性值，一定要注意${}的单引号问题

5.5 可以在mapper接口方法的参数上设置@Param注解（推荐）

此时MyBatis会将这些参数放在map中，以两种方式进行存储

a>以@Param注解的value属性值为键，以参数为值

b>以param1,param2...为键，以参数为值

只需要通过#{}和${}访问map集合的键，就可以获取相对应的值，一定要注意${}的单引号问题

6.Mybatis的查询功能

6.1 mapper接口对象

package com.fd.mybatis.mapper;

import com.fd.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 {

    /*
    * 若sql语句查询的结果为多条时，一定不能以实体类类型作为方法的返回值,
    *       否则会抛出异常TooManyResultsException
    * 若sql语句查询的结果为1条时，此时可以使用实体类类型List集合类型作为方法的返回值
    *
    * */

    User getUserById(@Param("id") String id);

    List<User> getAllUser();

    Integer getCount();

    Map<String, Object> getUserByIdToMap(String id);

    /**
     * 查询所有的用户为map集合
     *
     * 若查询的数据有多条时，并且要将每条数据转换为map集台
     * 此时有两种解决方案:
     *  1、将mapper接口方法的返回值设置为泛型是map的List集合
     *     List<Map<String, Object>> getAllUserToMap();
     *  2、可以将每条数据转换的map集合放在一个大的map中，但是必须要通过@MapKey注解
     *      将查询的某个字段的值作为大的map的键
     *      @MapKey("id")
     *     Map<String, Object> getAllUserToMap();
     *
     * @author lucky_fd
     * @return java.util.Map<java.lang.String,java.lang.Object>
     **/
    @MapKey("id")
    Map<String, Object> getAllUserToMap(); // List<Map<String, Object>> getAllUserToMap();

    /**
     * 通过用户名模糊查询
     *
     * @author lucky_fd
     * @param name 用户名
     * @return java.util.List<com.fd.mybatis.pojo.User>
     **/
    List<User> selectUserByLike(String name);
}

6.2 mapper映射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.fd.mybatis.mapper.SelectMapper">

    <select id="getUserById" resultType="User">
        select * from t_user where id = #{id}
    </select>

    <select id="getAllUser" resultType="User">
        select * from t_user
    </select>

    <!--
        MyBatis中为Java中常用的类型设置了类型别名
        Integer: Integer，int
        int: _int,_integer
        Map: map
        String: string
    -->
    <select id="getCount" resultType="int">
        select count(*) from t_user
    </select>

    <select id="getUserByIdToMap" resultType="map">
        select * from t_user where id = #{id}
    </select>

    <select id="getAllUserToMap" resultType="map">
        select * from t_user
    </select>

    <!--
        模糊查询方法：（三种方式）
    -->
    <select id="selectUserByLike" resultType="User">
        <!--select * from t_user where name like '%${name}%'-->
        <!--select * from t_user where name like concat('%',#{name}, '%')-->
        select * from t_user where name like "%"#{name}"%"
    </select>
</mapper>

7.Mybatis 获取自增主键

7.1 接口对象方法

/**
 * 新增用户
 *
 * */
int insertUser(User user);

7.2 mapper映射文件

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

7.3 测试方法

/**
 * 新增用户
 * 并返回自增主键
 * */
@Test
public void insertUserTest() {
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
    User user = new User(null, "张三", "qesdf", 25, "男", "123@qq.com");
    mapper.insertUser(user);
    // 返回自增ID
    System.out.println(user);
}

 测试结果：

​​​​​​​

8.resultMap自定义映射功能

8.1 实体类：

package com.fd.mybatis.pojo;

/**
 * SSM
 *
 * @author lucky_fd
 * @since 2023-05-22
 */

public class Dept {
    private String deptId;

    private String deptName;

    public Dept(String deptId, String deptName) {
        this.deptId = deptId;
        this.deptName = deptName;
    }

    public Dept() {
    }

    public String getDeptId() {
        return deptId;
    }

    public void setDeptId(String deptId) {
        this.deptId = deptId;
    }

    public String getDeptName() {
        return deptName;
    }

    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }

    @Override
    public String toString() {
        return "Dept{" +
                "deptId='" + deptId + '\'' +
                ", deptName='" + deptName + '\'' +
                '}';
    }
}


package com.fd.mybatis.pojo;

/**
 * SSM
 *
 * @author lucky_fd
 * @since 2023-05-22
 */

public class Emp {
    private String empId;

    private String name;

    private Integer age;

    private String gender;

    private Integer deptId;

    private Dept dept;

    public Emp() {
    }

    public Emp(String empId, String name, Integer age, String gender, Integer deptId) {
        this.empId = empId;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.deptId = deptId;
    }

    public String getEmpId() {
        return empId;
    }

    public void setEmpId(String empId) {
        this.empId = empId;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public Integer getDeptId() {
        return deptId;
    }

    public void setDeptId(Integer deptId) {
        this.deptId = deptId;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "empId='" + empId + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                ", deptId=" + deptId +
                ", dept=" + dept +
                '}';
    }

    public Dept getDept() {
        return dept;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }
}

8.2 mapper接口对象

package com.fd.mybatis.mapper;

import com.fd.mybatis.pojo.Emp;

public interface EmpMapper {

    Emp getEmpById(String id);

    Emp getEmpAndDeptById(String id);
}



package com.fd.mybatis.mapper;

import com.fd.mybatis.pojo.Dept;

public interface DeptMapper {

    Dept getDeptById(String id);
}

 8.3 mapper配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--
        Mybatis核心配置文件中的标签必须按照指定的顺序配置
        (properties?,settings?,typeAliases?,typeHandlers?,objectFactory?,objectWrapperFactory?,reflectorFactory?,plugins?,environments?,databaseIdProvider?,mappers?)
    -->

    <properties resource="jdbc.properties"/>

    <settings>
        <!--将下划线映射为驼峰-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!--开启延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!--
            按需加载 默认值为false
            aggressiveLazyLoading: 当开启时，任何方法的调用都会加载该对象的所有属性。否则，每个属性会按需加载
            此时就可以实现按需加载，获取的数据是什么，就只会执行相应的sl。
        -->
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>

    <typeAliases>
        <package name="com.fd.mybatis.pojo"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <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>

    <mappers>
        <package name="com.fd.mybatis.mapper"/>
    </mappers>
</configuration>

 8.4 mapper映射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.fd.mybatis.mapper.EmpMapper">

    <!--
        字段名和属性名不一致的情况，如何处理映射关系：
        1、为查询的字段设置别名，和属性名保持一致
        2、当字段符合MySOL的要求使用，而属性符合java的要求使用驼峰
            此时可以在MyBatis的核心配置文件中设置一个全局配置，可以自动将下划线映射为驼峰
            emp_id:empId, emp_name : empName
            <setting name="mapUnderscoreToCamelCase" value="true"/>
        3、使用resultMap设置自定义映射关系
            处理多对一得映射关系：
            1、级联方式处理
            2、association
            3、分步查询
    -->

    <!--
        resultMap:设置自定义的映射关系
            id:唯一标识
            type:处理映射关系的实体类的类型
        常用的标签:
            id:处理主键和实体类中属性的映射关系
            result: 处理普通字段和实体类中属性的映射关系
            column: 设置映射关系中的字段名，必须是sqL查询出的某个字段
            property: 设通映射关系中的属性的属性名，必须是处理的实体类类型中的属性名
            association:
    -->
    <resultMap id="empResultMap" type="com.fd.mybatis.pojo.Emp">
        <id property="empId" column="emp_id"/>
        <result property="age" column="age"/>
        <result property="name" column="name"/>
        <result property="gender" column="gender"/>
        <result property="deptId" column="dept_id"/>
    </resultMap>

    <!--resultType="com.fd.mybatis.pojo.Emp"-->
    <select id="getEmpById"  resultMap="empResultMap">
        select * from t_emp where emp_id = #{id}
    </select>

    <!--
        级联处理多对一映射关系
    -->
    <resultMap id="empAndDeptResultMapOne" type="Emp">
        <id property="empId" column="emp_id"/>
        <result property="age" column="age"/>
        <result property="name" column="name"/>
        <result property="gender" column="gender"/>
        <result property="dept.deptId" column="dept_id"/>
        <result property="dept.deptName" column="dept_name"/>
    </resultMap>

    <!--
        association: 处理多对一得映射关系
        property:设置需要处理映射关系的属性的属性名
        javaType: 设置要处理的属性的类型I
    -->
    <resultMap id="empAndDeptResultMapTwo" type="Emp">
        <id property="empId" column="emp_id"/>
        <result property="age" column="age"/>
        <result property="name" column="name"/>
        <result property="gender" column="gender"/>
        <association property="dept" javaType="Dept">
            <id property="deptId" column="dept_id"/>
            <result property="deptName" column="dept_name"/>
        </association>
    </resultMap>

    <!--
        分步查询：
        property:设置需要处理映射关系的属性的属性名
        select:设置分步查询的sql的唯一标识
        column:将查询出的某个宇段作为分步查询的sqL的条你
    -->
    <resultMap id="empAndDeptResultMapThree" type="Emp">
        <id property="empId" column="emp_id"/>
        <result property="age" column="age"/>
        <result property="name" column="name"/>
        <result property="gender" column="gender"/>
        <association property="dept" column="dept_id" select="com.fd.mybatis.mapper.DeptMapper.getDeptById"/>
    </resultMap>

    <!--
        resultMap:设置自定义的映射关系
    -->
    <select id="getEmpAndDeptById" resultMap="empAndDeptResultMapThree">
        select emp.*, d.* from t_emp emp left join t_dept d on emp.dept_id = d.dept_id where emp.emp_id = #{id}
    </select>

</mapper>

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.fd.mybatis.mapper.DeptMapper">

    <!--
         ofType: 设置集合类型的属性中存储的数据的类型
    -->
    <resultMap id="resultMap" type="com.fd.mybatis.pojo.Dept">
        <result property="deptId" column="dept_id"/>
        <result property="deptName" column="dept_name"/>
        <collection property="empList" ofType="Emp">
            <id property="empId" column="emp_id"/>
            <result property="age" column="age"/>
            <result property="name" column="name"/>
            <result property="gender" column="gender"/>
        </collection>
    </resultMap>

    <resultMap id="resultMapTwo" type="com.fd.mybatis.pojo.Dept">
        <result property="deptId" column="dept_id"/>
        <result property="deptName" column="dept_name"/>
        <collection property="empList" column="dept_id" select="selectEmpByDeptId" fetchType="lazy"/>
    </resultMap>

    <select id="getDeptById" resultType="com.fd.mybatis.pojo.Dept">
        select * from t_dept where dept_id = #{id}
    </select>

    <select id="getDeptAndEmpById" resultMap="resultMap">
        select emp.*, d.* from t_emp emp right join t_dept d on emp.dept_id = d.dept_id where d.dept_id = #{id}
    </select>
</mapper>

8.5 resultMap标签自定义映射

一个resultMap标签，就是对应着一个实体类。id就是他的名字，type就是他们的身体。实体类和对应表是一一对应的，实体类中每一个属性都对应着一个表中的字段。其中有个别属性上标明注解@TableField(exist = false)，其含义就是该属性在表中不存在，大多为引用的属性，引用的集合，或者是为了满足某种业务需求而声明的某种标志（比如sql多表查询时把某个表中的某个字段数据给另一个实体中某个属性赋值而起的别名）等等。

<resultMap id="唯一标识" type="映射的entity对象的绝对路径">
    <id column="表主键字段" jdbcType="字段类型" property="映射entity对象的主键属性" />
 
    <result column="表某个字段" jdbcType="字段类型" property="映射entity对象的某个属性"/>
 
    <!-- 指的是entity对象中的对象属性 -->
    <association property="entity中某个对象属性" javaType="这个对象的绝对路径">
        <id column="这个对象属性对应的表的主键字段" jdbcType="字段类型" property="这个对象属性内的主键属性"/>
        <result column="表某个字段" jdbcType="字段类型" property="这个对象属性内的某个属性"/>
    </association>
 
    <!-- 指的是entity对象中的集合属性 -->
    <collection property="entity中的某个集合属性" ofType="这个集合泛型所存实体类的绝对路径">
        <id column="这个集合属性中泛型所存实体类对象对应表的主键字段" jdbcType="字段类型"
            property="这个集合属性中泛型所存实体类对象的主键属性"
        />
        <result column="表某个字段" jdbcType="字段类型" 
                property="这个集合属性泛型所存实体类对象的属性"
        />  
    </collection>
 
    <!-- 引用另一个resultMap (套娃) -->
    <collection property="entity中的某个集合属性" 
                resultMap="这个引用的resultMap的type,就是这个集合属性泛型所存实体类的绝对路径"
    />
</resultMap>

8.6 多对一映射处理方式

1.级联方式处理映射

<!--
    级联处理多对一映射关系
-->
<resultMap id="empAndDeptResultMapOne" type="Emp">
    <id property="empId" column="emp_id"/>
    <result property="age" column="age"/>
    <result property="name" column="name"/>
    <result property="gender" column="gender"/>
    <result property="dept.deptId" column="dept_id"/>
    <result property="dept.deptName" column="dept_name"/>
</resultMap>

2.association: 处理多对一得映射关系

<!--
    association: 处理多对一得映射关系
    property:设置需要处理映射关系的属性的属性名
    javaType: 设置要处理的属性的类型I
-->
<resultMap id="empAndDeptResultMapTwo" type="Emp">
    <id property="empId" column="emp_id"/>
    <result property="age" column="age"/>
    <result property="name" column="name"/>
    <result property="gender" column="gender"/>
    <association property="dept" javaType="Dept">
        <id property="deptId" column="dept_id"/>
        <result property="deptName" column="dept_name"/>
    </association>
</resultMap>

3.分步查询

<!--
    分步查询：
    property:设置需要处理映射关系的属性的属性名
    select:设置分步查询的sql的唯一标识
    column:将查询出的某个宇段作为分步查询的sqL的条件
    fetchType:在开启了延迟加载的环境中，通过该属性设置当前的分步查询是否使用延迟加载
    fetchType="eager(立即加载) || lazy(延迟加载)”
-->
<resultMap id="empAndDeptResultMapThree" type="Emp">
    <id property="empId" column="emp_id"/>
    <result property="age" column="age"/>
    <result property="name" column="name"/>
    <result property="gender" column="gender"/>
    <association property="dept" column="dept_id" select="com.fd.mybatis.mapper.DeptMapper.getDeptById"/>
</resultMap>

分步查询的优点:可以实现延迟加载

但是必须在核心配置文件中设置全局配置信息:

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

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

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

8.7 一对多映射处理方式

1.通过collection处理一对多映射

<!--
     ofType: 设置集合类型的属性中存储的数据的类型
-->
<resultMap id="resultMap" type="com.fd.mybatis.pojo.Dept">
    <result property="deptId" column="dept_id"/>
    <result property="deptName" column="dept_name"/>
    <collection property="empList" ofType="Emp">
        <id property="empId" column="emp_id"/>
        <result property="age" column="age"/>
        <result property="name" column="name"/>
        <result property="gender" column="gender"/>
    </collection>
</resultMap>

<select id="getDeptAndEmpById" resultMap="resultMap">
    select emp.*, d.* from t_emp emp right join t_dept d on emp.dept_id = d.dept_id where d.dept_id = #{id}
</select>

2.通过分步查询处理一对多映射

<resultMap id="resultMapTwo" type="com.fd.mybatis.pojo.Dept">
    <result property="deptId" column="dept_id"/>
    <result property="deptName" column="dept_name"/>
    <collection property="empList" column="dept_id" select="selectEmpByDeptId" fetchType="lazy"/>
</resultMap>

9.Mybatis动态SQL功能

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

9.1 if标签

通过test属性中的表达式判断标签中的内容是否有效(是否会拼接到sql中)

<if test="empName != null and empName != ''">
    and name = #{empName}
</if>

9.2 where标签

a.where标签中有条件成立，会自动生成where关健字

b.会自动将where标签中内容前多余的and去掉，但是其中内容后多余的and无法去掉

c.where标签中没有任何一个条件成立，则where没有任何功能

select * from t_emp
<where>
    <if test="empName != null and empName != ''">
        and name = #{empName}
    </if>
    <if test="age != null">
        and age = #{age}
    </if>
    <if test="gender != null and gender != ''">
        and gender = #{gender}
    </if>
</where>

9.3 trim标签

prefix、suffix:在标签中内容前面或后面添加指定内容

prefixOverrides、suffixOverrides:在标签中内容前面或后面去掉指定内容

select * from t_emp
<trim prefix="where" suffixOverrides="and">
    <if test="empName != null and empName != ''">
        name = #{empName} and
    </if>
    <if test="age != null">
        age = #{age} and
    </if>
    <if test="gender != null and gender != ''">
        gender = #{gender} and
    </if>
</trim>

9.4 choose when otherwise 标签

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

select * from t_emp
<where>
    <choose>
        <when test="empName != null and empName != ''">
            name = #{empName}
        </when>
        <when test="age != null">
            age = #{age}
        </when>
    </choose>
</where>

9.5 foreach标签

Mybatis中把list也是存在Map中，默认"list"是键名，list数据是值；Mybatis中数组也是存在Map中，默认"array"是键名，array数组数据是值。

collection:设置要循环的数组或集合

item:用一个字符串表示数组或集合中的每一个数据

separator:设置每次循环的数据之间的分隔符

open: 循环的所有内容以什么开始

close: 循环的所有内容以什么结束

<insert id="insertMoreEmp">
    insert into t_emp values
    <foreach collection="emps” item="emp” separator=",">
        (null, #{emp.empName}, #{emp.age}, #(emp.gender}, null)
    </foreach>
</insert>

<delete id="delete">
    delete from t emp where
    <foreach collection="empids" item="empid" separator="or">
        emp_id = #{empId]
    </foreach>
</delete>

9.6 sql片段标签

可以记录一段sql，在需要用的地方使用include标签进行引用

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

select <include refid=empColumns"></include> from t_emp

10.Mybatis缓存

10.1 MyBatis的一级缓存

一级缓存是SqlSession级别的，通过同一个SqlSession查询的数据会被缓存，下次查询相同的数据，就会从缓存中直接获取，不会从数据库重新访问。一级缓存默认是开启的

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

1)不同的SqlSession对应不同的一级缓存

2)同一个SqlSession但是查询条件不同

3)同一个SqlSession两次查询期间执行了任何一次增删改操作

4)同一个SqlSession两次查询期间手动清空了缓存 sqlSession.clearCache();

案列演示：

@Test
public void getEmpByIdTest() {
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    CacheMapper mapper = sqlSession.getMapper(CacheMapper.class);
    Emp emp = mapper.getEmpById("1");
    System.out.println(emp);
    Emp emp2 = mapper.getEmpById("1");
    System.out.println(emp2);
}

案列结果：

10.2  MyBatis的二级缓存

二级缓存是SqlSessionFactory级别，通过同一个SqlSessionFactory创建的SqlSession查询的结果会被缓存；此后若再次执行相同的查询语句，结果就会从缓存中获取

二级缓存开启的条件:

a> 在核心配置文件中，设置全局配置属性cacheEnabled="true”，默认为true，不需要设置

b> 在映射文件中设置标签

c> 二级缓存必须在SqlSession关闭或提交之后有效

d> 查询的数据所转换的实体类类型必须实现序列化的接口

使二级缓存失效的情况:

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

案列演示：

@Test
public void cacheTest() throws IOException {
    InputStream io = Resources.getResourceAsStream("mybatis-config.xml");
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    SqlSessionFactory sqlSessionFactory = builder.build(io);
    SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
    CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class);
    Emp emp = mapper1.getEmpById("1");
    System.out.println(emp);
    sqlSession1.close();
    SqlSession sqlSession2 = sqlSessionFactory.openSession(true);
    CacheMapper mapper2 = sqlSession2.getMapper(CacheMapper.class);
    Emp emp1 = mapper2.getEmpById("1");
    System.out.println(emp1);
    sqlSession2.close();
}

案列结果：

10.3 二级缓存的相关配置

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

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

• LRU(Least Recently Used) - 最近最少使用的: 移除最长时间不被使用的对象
• FIFO (First in First out) - 先进先出: 按对象进入缓存的顺序来移除它们。
• SOFT - 软引用: 移除基于垃圾回收器状态和软引用规则的对象
• WEAK - 弱引用: 更积极地移除基于垃圾收集器状态和弱引用规则的对象。

2.flushInterval属性: 刷新间隔，单位毫秒

默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句时刷新

3.size属性:引用数目，正整数

代表缓存最多可以存储多少个对象，太大容易导致内存溢出

4.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.0.3</version>
</dependency>
<!--slf4j日志门面的一个具体实现-->
<dependency>
  <groupId>ch.qos.logback</groupId>
  <artifactId>logback-classic</artifactId>
  <version>1.2.11</version>
</dependency>

 2.各个jar包功能

 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="F:\java\ehcache" />

    <defaultCache
            maxElementsInMemory="10000"
            maxElementsOnDisk="10000000"
            eternal="false"
            overflowToDisk="true"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
    </defaultCache>
</ehcache>

        <!--
        <?xml version="1.0" encoding="UTF-8"?>
        <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                 xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
                 updateCheck="false">
            &lt;!&ndash;
               diskStore：为缓存路径，ehcache分为内存和磁盘两级，此属性定义磁盘的缓存位置。参数解释如下：
               user.home – 用户主目录
               user.dir  – 用户当前工作目录
               java.io.tmpdir – 默认临时文件路径
             &ndash;&gt;
            <diskStore path="E:\java\ehcache"/>
            &lt;!&ndash;
               defaultCache：默认缓存策略，当ehcache找不到定义的缓存时，则使用这个缓存策略。只能定义一个。
             &ndash;&gt;
            &lt;!&ndash;
              name:缓存名称。
              maxElementsInMemory:缓存最大数目
              maxElementsOnDisk：硬盘最大缓存个数。
              eternal:对象是否永久有效，一但设置了，timeout将不起作用。
              overflowToDisk:是否保存到磁盘，当系统当机时
              timeToIdleSeconds:设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
              timeToLiveSeconds:设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
              diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
              diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
              diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
              memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
              clearOnFlush：内存数量最大时是否清除。
              memoryStoreEvictionPolicy:可选策略有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）。
              FIFO，first in first out，这个是大家最熟的，先进先出。
              LFU， Less Frequently Used，就是上面例子中使用的策略，直白一点就是讲一直以来最少被使用的。如上面所讲，缓存的元素有一个hit属性，hit值最小的将会被清出缓存。
              LRU，Least Recently Used，最近最少使用的，缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。
           &ndash;&gt;
            <defaultCache
                    eternal="false"
                    maxElementsInMemory="10000"
                    overflowToDisk="false"
                    diskPersistent="false"
                    timeToIdleSeconds="1800"
                    timeToLiveSeconds="259200"
                    memoryStoreEvictionPolicy="LRU"/>

            <cache
                    name="cloud_user"
                    eternal="false"
                    maxElementsInMemory="5000"
                    overflowToDisk="false"
                    diskPersistent="false"
                    timeToIdleSeconds="1800"
                    timeToLiveSeconds="1800"
                    memoryStoreEvictionPolicy="LRU"/>

        </ehcache>
        -->

4.Mapper配置文件设置二级缓存类型

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

5.加入logback日志

存在SLF4j时，作为简易日志的log4j将失效，此时我们需要借助SLF4j的具体实现logback来打印日志。创建logback的配置文件logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- scan：当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true。 scanPeriod：设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒当scan为true时，此属性生效。默认的时间间隔为1分钟。
   debug：当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 -->
<configuration scan="false" scanPeriod="60 seconds" debug="false">
    <!-- 定义日志的根目录 value表示的是打印到哪里的-->
    <property name="LOG_HOME" value="${catalina.base}/logs/" />
    <!-- 定义日志文件名称  value表示的是log的名称-->
    <property name="appName" value="u-plan"></property>
    <!-- ch.qos.logback.core.ConsoleAppender 表示控制台输出 -->
    <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        <Encoding>UTF-8</Encoding>
        <!-- 日志输出格式：%d表示日期时间，%thread表示线程名，%-5level：级别从左显示5个字符宽度 %logger{50} 表示logger名字最长50个字符，否则按照句点分割。
            %msg：日志消息，%n是换行符 -->
        <layout class="ch.qos.logback.classic.PatternLayout">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </layout>
    </appender>

    <!-- 滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件 -->
    <appender name="appLogAppender"
              class="ch.qos.logback.core.rolling.RollingFileAppender">
        <Encoding>UTF-8</Encoding>
        <!-- 指定日志文件的名称 -->
        <file>${LOG_HOME}/${appName}.log</file>
        <!-- 当发生滚动时，决定 RollingFileAppender 的行为，涉及文件移动和重命名 TimeBasedRollingPolicy：
            最常用的滚动策略，它根据时间来制定滚动策略，既负责滚动也负责出发滚动。 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 滚动时产生的文件的存放位置及文件名称 %d{yyyy-MM-dd}：按天进行日志滚动 %i：当文件大小超过maxFileSize时，按照i进行文件滚动 -->
            <fileNamePattern>${LOG_HOME}/${appName}-%d{yyyy-MM-dd}-%i.log
            </fileNamePattern>
            <!-- 可选节点，控制保留的归档文件的最大数量，超出数量就删除旧文件。假设设置每天滚动， 且maxHistory是365，则只保存最近365天的文件，删除之前的旧文件。注意，删除旧文件是，
                那些为了归档而创建的目录也会被删除。 -->
            <MaxHistory>30</MaxHistory>
            <!-- 当日志文件超过maxFileSize指定的大小是，根据上面提到的%i进行日志文件滚动 注意此处配置SizeBasedTriggeringPolicy是无法实现按文件大小进行滚动的，必须配置timeBasedFileNamingAndTriggeringPolicy -->
            <timeBasedFileNamingAndTriggeringPolicy
                    class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>512MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
        </rollingPolicy>
        <!-- 日志输出格式：%d表示日期时间，%thread表示线程名，%-5level：级别从左显示5个字符宽度 %logger{50} 表示logger名字最长50个字符，否则按照句点分割。
            %msg：日志消息，%n是换行符 -->
        <layout class="ch.qos.logback.classic.PatternLayout">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [ %thread ] - [ %-5level ] [%logger{50} : %line ] - %msg%n</pattern>
        </layout>
    </appender>

    <!-- logger主要用于存放日志对象，也可以定义日志类型、级别 name：表示匹配的logger类型前缀，也就是包的前半部分 level：要记录的日志级别，包括
        TRACE < DEBUG < INFO < WARN < ERROR additivity：作用在于children-logger是否使用 rootLogger配置的appender进行输出，false：表示只用当前logger的appender-ref，true：表示当前logger的appender-ref和rootLogger的appender-ref都有效 -->
    <!-- hibernate logger -->
    <logger name="com.fd.mybatis.mapper" level="debug" />
    <!-- Spring framework logger -->
<!--    <logger name="org.springframework" level="error" additivity="false"></logger>
    <logger name="com.fairyland" level="info" additivity="true">
        <appender-ref ref="appLogAppender" />
    </logger>-->

    <!-- root与logger是父子关系，没有特别定义则默认为root，任何一个类只会和一个logger对应， 要么是定义的logger，要么是root，判断的关键在于找到这个logger，然后判断这个logger的appender和level。 -->
    <root level="info">
        <appender-ref ref="stdout" />
        <appender-ref ref="appLogAppender" />
    </root>
</configuration>

 6.测试方法

@Test
public void cacheTest() throws IOException {
    InputStream io = Resources.getResourceAsStream("mybatis-config.xml");
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    SqlSessionFactory sqlSessionFactory = builder.build(io);
    SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
    CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class);
    Emp emp = mapper1.getEmpById("1");
    System.out.println(emp);
    sqlSession1.close();
    SqlSession sqlSession2 = sqlSessionFactory.openSession(true);
    CacheMapper mapper2 = sqlSession2.getMapper(CacheMapper.class);
    Emp emp1 = mapper2.getEmpById("1");
    System.out.println(emp1);
    sqlSession2.close();
}

11.Mybatis分页功能实现

11.1 实现分页的方法

(1) MyBatis 使用 RowBounds 对象进行分页，它是针对 ResultSet 结果集执行的内存分页，而非物理分页；

(2) 可以在 sql 内直接书写带有物理分页的参数来完成物理分页功能，

(3) 也可以使用分页插件来完成物理分页。

11.2 RowBounds分页

@Test
public void pageByRowsBoundsTest() {
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();

    RowBounds rowBounds = new RowBounds(1, 2);
    List<EMP> emps = sqlSession.selectList("com.fd.mybatis.mapper.EMPMapper.selectByExample", null, rowBounds);
    emps.forEach(System.out::println);
    sqlSession.close();

}

11.3 使用Limit分页

语法： select * from user limit startIndex,pageSize
select * from user limit 0,2;

 具体实现：

<select id="getUserByLimit" parameterType="map" resultMap="UserMap">
    select * from t_user limit #{startIndex},#{pageSize};
</select>

11.4 分页插件实现分页

1. 添加依赖

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

 2. 配置分页插件

mybatis-config.xml配置文件添加分页插件

<!--类型别名-->
<typeAliases>
    <package name="com.fd.mybatis.pojo"/>
</typeAliases>

<plugins>
    <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>

3. 分页插件的使用

a.在查询功能之前使用PageHelper.startPage(int pageNum,int pageSize)开启分页功能

pageNum:当前页的页码

pageSize:每页显示的条数

b.在查询获取list集合之后，使用Pagelnfo pagelnfo = new Pagelnfo<>(List list, int navigatePages)获取分页相关数据。

list:分页之后的数据

navigatePages: 导航分页的页码数

c.分页相关数据

Pagelnfo{

pageNum=8,pageSize=4, size=2, startRow=29, endRow=30, total=30, pages=8,

list=Page{count=true, pageNum=8, pageSize=4, startRow=28, endRow=32, total=30,

pages=8,reasonable=false, pageSizeZero=false},

prePage=7, nextPage=0, isFirstPage=false, isLastPage=true, hasPreviousPage=true, hasNextPage=false, navigatePages=5, navigateFirstPage4, navigateLastPage8.navigatepageNums=[4, 5, 6, 7 8]

}

pageNum:当前页的页码

pageSize: 每页显示的条数

size:当前页显示的真实条数

total: 总记录数

pages:总页数

prePage:上一页的页码

nextPage:下一页的页码

isFirstPage/isLastPage: 是否为第一页/最后一页

hasPreviousPage/hasNextPage: 是否存在上一页/下一页

navigatePages:导航分页的页码数

navigatepageNums:导航分页的页码，[1,2,3,4,5]

4. 测试方法

@Test
public void pageTest() {
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    EMPMapper mapper = sqlSession.getMapper(EMPMapper.class);
    // 开启分页
    Page<Object> objectPage = PageHelper.startPage(1, 4);
    System.out.println(objectPage);

    // 查询所有数据
    List<EMP> emps = mapper.selectByExample(null);
    emps.forEach(System.out::println);
    System.out.println("--------------------------------");

   // 查询功能之后获取分页相关的所有数据
    PageInfo<EMP> pageInfo = new PageInfo<>(emps, 5);
    System.out.println(pageInfo);
    /*
    * PageInfo{
    * pageNum=1, pageSize=4, size=4, 
    * startRow=1, endRow=4, total=7, 
    * pages=2, 
    * list=Page{count=true, pageNum=1, pageSize=4, startRow=0, endRow=4, total=7, pages=2, reasonable=false, pageSizeZero=false}
    * [EMP [Hash = -1617114975, empId=1, name=张三弟弟, age=null, gender=男, deptId=1, serialVersionUID=1], EMP [Hash = -1616153014, empId=2, name=张三弟弟, age=40, gender=男, deptId=1, serialVersionUID=1], EMP [Hash = -2116313700, empId=3, name=王五, age=25, gender=男, deptId=1, serialVersionUID=1], EMP [Hash = 1482850467, empId=4, name=123, age=2, gender=1, deptId=1, serialVersionUID=1]], prePage=0, nextPage=2, isFirstPage=true, isLastPage=false, hasPreviousPage=false, hasNextPage=true, navigatePages=5, navigateFirstPage=1, navigateLastPage=2, navigatepageNums=[1, 2]}
     * 
    * */
}

12. Mybatis经典面试题

1.Dao(Mapper)接口的工作原理是什么？Dao(Mapper)接口里的方法，参数不同时，方法能重载吗？

错误回答：Dao 接口里的方法，是不能重载的，因为是全限名+方法名的保存和寻找策略。

正确回答：

通常一个 xml 映射文件，都会写一个 Dao 接口与之对应。Dao 接口就是人们常说的 Mapper 接口，接口的全限名，就是映射文件中的 namespace 的值，接口的方法名，就是映射文件中 MappedStatement 的 id 值，接口方法内的参数，就是传递给 sql 的参数。 Mapper 接口是没有实现类的，当调用接口方法时，接口全限名+方法名拼接字符串作为 key 值，可唯一定位一个 MappedStatement。

Mybatis 的 Dao 接口可以有多个重载方法，但是多个接口对应的映射必须只有一个，否则启动会报错。

Dao 接口的工作原理是 JDK 动态代理，MyBatis 运行时会使用 JDK 动态代理为 Dao 接口生成代理 proxy 对象，代理对象 proxy 会拦截接口方法，转而执行 MappedStatement 所代表的 sql，然后将 sql 执行结果返回。

补充：

Dao 接口方法可以重载，但是需要满足以下条件：

1. 仅有一个无参方法和一个有参方法
2. 多个有参方法时，参数数量必须一致。且使用相同的 @Param ，或者使用 param1 这种

 2.MyBatis 是否支持延迟加载？如果支持，它的实现原理是什么？

MyBatis 仅支持 association 关联对象和 collection 关联集合对象的延迟加载，association 指的就是一对一，collection 指的就是一对多查询。在 MyBatis 配置文件中，可以配置是否启用延迟加载 lazyLoadingEnabled=true|false。

它的原理是，使用 CGLIB 创建目标对象的代理对象，当调用目标方法时，进入拦截器方法，比如调用 a.getB().getName() ，拦截器 invoke() 方法发现 a.getB() 是 null 值，那么就会单独发送事先保存好的查询关联 B 对象的 sql，把 B 查询上来，然后调用 a.setB(b)，于是 a 的对象 b 属性就有值了，接着完成 a.getB().getName() 方法的调用。这就是延迟加载的基本原理。

当然了，不光是 MyBatis，几乎所有的包括 Hibernate，支持延迟加载的原理都是一样的。

3.MyBatis 能执行一对一、一对多的关联查询吗？都有哪些实现方式，以及它们之间的区别？

能，MyBatis 不仅可以执行一对一、一对多的关联查询，还可以执行多对一，多对多的关联查询，多对一查询，其实就是一对一查询，只需要把 selectOne() 修改为 selectList() 即可；多对多查询，其实就是一对多查询，只需要把 selectOne() 修改为 selectList() 即可。

关联对象查询，有两种实现方式，一种是单独发送一个 sql 去查询关联对象，赋给主对象，然后返回主对象。另一种是使用嵌套查询，嵌套查询的含义为使用 join 查询，一部分列是 A 对象的属性值，另外一部分列是关联对象 B 的属性值，好处是只发一个 sql 查询，就可以把主对象和其关联对象查出来。

那么问题来了，join 查询出来 100 条记录，如何确定主对象是 5 个，而不是 100 个？其去重复的原理是 <resultMap> 标签内的 <id> 子标签，指定了唯一确定一条记录的 id 列，MyBatis 根据 <id> 列值来完成 100 条记录的去重复功能， <id> 可以有多个，代表了联合主键的语意。

同样主对象的关联对象，也是根据这个原理去重复的，尽管一般情况下，只有主对象会有重复记录，关联对象一般不会重复。

举例：下面 join 查询出来 6 条记录，一、二列是 Teacher 对象列，第三列为 Student 对象列，MyBatis 去重复处理后，结果为 1 个老师 6 个学生，而不是 6 个老师 6 个学生。

4.MyBatis 是否可以映射 Enum 枚举类？

MyBatis 可以映射枚举类，不单可以映射枚举类，MyBatis 可以映射任何对象到表的一列上。映射方式为自定义一个 TypeHandler ，实现 TypeHandler 的 setParameter() 和 getResult() 接口方法。 TypeHandler 有两个作用：

• 一是完成从 javaType 至 jdbcType 的转换；
• 二是完成 jdbcType 至 javaType 的转换，体现为 setParameter() 和 getResult() 两个方法，分别代表设置 sql 问号占位符参数和获取列查询结果。