MyBatis学习笔记

一、MyBatis常用

1、[MyBatis官方文档]:mybatis – MyBatis 3 | 简介

2、[maven包]:Maven Repository: org.mybatis » mybatis (mvnrepository.com)

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.3</version>
</dependency>
<!--mysql-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.24</version>
</dependency>
<!--junit-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>

3、mybatis核心配置文件

<?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>
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
        <property name="driver" value="driver"/>
        <property name="url" value="url"/>
        <property name="username" value="username"/>
        <property name="password" value="password"/>
      </dataSource>
    </environment>
  </environments>
  <mappers>
    <mapper resource="com..."/>
  </mappers>
</configuration>

4、编写sql语句映射的配置文件 Mapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.mybatis.example.BlogMapper">
    <resultMap id="adminResultMap" type="adminUser">
        <result column="admin_user_id" property="adminUserId"/>
    </resultMap>
    <sql id="admin_filed">
        admin_user_id, login_user_name, login_password, nick_name
    </sql>
    <sql id="updateSql">
        <if test="adminUserName!=null">
            login_user_name=#{adminUserName},
        </if>
        <if test="adminUserPwd!=null">
            login_password=#{adminUserPwd}
        </if>
    </sql>
    <select id="selectBlog" resultType="Blog">
        select * from Blog where id = #{id}
    </select>
</mapper>

二、创建第一个MyBatis项目

1、创建一个maven项目

2、导入maven依赖

常用的为mybatis、junit、mysql

3、连接数据库

连接成功后的画面：

4、创建核心配置文件

在resource下创建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>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/databaseName?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF8"/>
                <property name="username" value="username"/>
                <property name="password" value="password"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/qing/dao/UserMapper.xml"></mapper>
    </mappers>
</configuration>

• 11行修改databaseName为自己的数据库名

• useSSL=true 设置存储安全模式

• & ；是“&&”的转义

• useUnicode=true&characterEncoding=UTF-8 设置编码模式 ，必须添加

• 12行的username为数据库名

• 13行的password为密码

• 18-20行为mapper映射，每个mapper配置文件都需要在核心配置文件中添加映射路径

5、编写Mybais工具类 创建数据库连接

public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;
    //静态代码块
    static {
        try {
            //获取sqlSessionFactory对象
            //获取资源文件mybatis-config.xml
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //SqlSession包含了面向数据库执行Sql命令的所有方法
    public static SqlSession sqlSession(){
        SqlSession sqlSession = sqlSessionFactory.openSession();
        return sqlSession;
    }
}

6、创建Mapper接口，创建对应的sql映射配置文件

xml文件内容：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.qing.dao.UserMapper">
    <select id="getUserList" resultType="com.qing.pojo.User">
        select *from mybatis.user
    </select>
</mapper>

• namespace绑定接口
• id ”getUserList”中对应接口中需实现的方法名
• resultType定义返回类型为User
• 一个select标签里面就包含了一个方法，可以在mapper中编写多个select标签

7、使用junit 测试（发现一个问题）

public class UserDaoTest {
    @Test
    public void test() {
        //获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.sqlSession();
        //执行sql
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> list = mapper.getUserList();
        for (User user : list) {
            System.out.println(user.toString());
        }
    }
}

出现问题：配置文件找不到

这是因为 UserMapper配置文件在java代码下，Maven 通常会忽略掉标记为 Sources 的文件夹中的配置文件

解决方法：

1、 第一种：将配置文件放入 resources 文件夹中

2、第二种：在总项目下的pom.xml文件中的build下配置resource，防止资源导出失败（推荐使用）

    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

运行成功：

三、mybatis项目注意事项

1、配置文件中，namespace绑定接口时，是使用的 “ . ”

<mapper namespace="com.qing.dao.UserMapper">

2、核心配置文件中，mapper注册配置文件的映射时，是使用的 “ / ”

 <mappers>
        <mapper resource="com/qing/dao/UserMapper.xml"></mapper>
 </mappers>

3、在配置文件中编写sql语句时，必须对应语句的标签，select语句对应select标签，insert语句对应insert标签，update语句对应update标签

<mapper namespace="com.qing.dao.UserMapper">
    <select id="getUserList" resultType="com.qing.pojo.User">
        select *from mybatis.user
    </select>
    <select id="getUserById" resultType="com.qing.pojo.User" parameterType="int">
        select * from mybatis.user where id=#{id}
    </select>
    <insert id="addUser" parameterType="com.qing.pojo.User">
        insert into mybatis.user(id, name, pwd) values(#{id},#{name},#{pwd});
    </insert>
    <update id="updateUser" parameterType="com.qing.pojo.User">
        update mybatis.user set  name=#{name},pwd=#{pwd} where id=#{id};
    </update>
    <delete id="deleteUser" parameterType="int">
        delete from mybatis.user where id=#{id};
    </delete>
</mapper>

因为数据库的增删改返回的都是int类型，而select返回的可以为null或者一个对象，如果insert语句使用select标签包含

    <select id="addUser" parameterType="com.qing.pojo.User">
        insert into mybatis.user(id, name, pwd) values(#{id},#{name},#{pwd});
    </select>

那么会出现以下错误：

Mapper method 'com.qing.dao.UserMapper.addUser attempted to return null from a method with a primitive return type (int).
// 映射器方法'com.qing.dao.UserMapper.addUser尝试从具有原始返回类型（int）的方法返回null。

4、数据库的增删改都需要提交事务，如果不设置提交事务，即便是执行了方法且成功了，数据库的数据都不会得到更新

sqlSession.commit(); //提交事务

5、核心配置文件的标签顺序

mybatis中核心配置文件的标签顺序是有严格要求的

四、模糊查询

1、在java代码中传递通配符 “%”

 List<User> userList = mapper.getUserLike("%宝%");

2、在sql拼接中使用通配符

select * from mybatis.user where name like "%"#{value}"%";

五、优化

1、核心配置文件优化

在resource资源目录下创建一个db.properties文件，存储数据库的链接驱动、账号、密码

db.properties文件内如如下：

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/databaseName?useSSL=true&useUnicode=true&characterEncoding=UTF-8
username=userName
password=userPwd

核心配置文件内如如下：

<?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>
    <!--    引入外部配置文件-->
    <properties resource="db.properties"></properties>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

这样使用的好处就是不用在mybatis核心配置文件中将数据库账号密码写死，单独使用一个文件保存，更加灵活。

2、别名优化

优化接口映射文件中的类型，如：”com.qing.pojo.User”

<select id="getUserList" resultType="com.qing.pojo.User">
        select *from mybatis.user
</select>

（1）方法一：可以在核心配置文件中配置别名

<typeAliases>
        <typeAlias type="com.qing.pojo.User" alias="User"></typeAlias>
</typeAliases>

给com.qing.pojo.User 取了一个别名User

（2）方法二：使用注解，在实体类前添加 “@Alias()”

@Alias("User")
public class User {
}

最后使用时，就直接使用“User”这个别名，而不用使用”com.qing.pojo.User”

 <select id="getUserList" resultType="User">
        select *from mybatis.user
</select>

3、开启驼峰命名规则映射

    <!--开启数据库字段映射为驼峰命名-->
    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>

六、映射器（mappers）

每编写一个dao层接口，都需要在核心配置文件中注册

方法一：绑定对应接口的映射配置文件，如UserMapper.xml

    <mappers>
        <mapper resource="com/qing/dao/UserMapper.xml"></mapper>
    </mappers>

方法二：使用class绑定注册

    <mappers>    
        <mapper class="com.qing.dao.UserMapper"></mapper>
    </mappers>

使用class注意点：

• 接口和它的Mapper配置文件必须同名
• 接口和它的配置文件必须在同一个包下
• 如下图

方法三：使用扫描包注册绑定

    <mappers>
        <package name="com.qing.dao"/>
    </mappers>

此方法注意事项与第二种方法一样

七、解决数据库的字段与实体类的属性名不一致

实体类：

    private int id;
    private String name;
    private String password;

数据库字段：

在查询时，就会出现数据库找不到对应的pwd字段值，最后显示为“null”

User{id=1, name='qingfan', pwd='null'}

解决方法

方法一：在数据库查询语句中去别名(不推荐使用)

    <select id="getUserById" resultType="User" parameterType="int">
        select id,name,pwd as password from mybatis.user where id=#{id}
    </select>

方法二： 使用resultMap结果集映射（推荐使用）

    <resultMap id="UserMap" type="User">
        <result property="password" column="pwd"></result>
    </resultMap>
    <select id="getUserById" resultMap="UserMap">
         select id,name,password from mybatis.user where id=#{id}
    </select>

第5行使用resultMap代替之前的resultType，第1行给resultMap定义返回类型为User，第2行中的 property 为实体类的属性名，column 为数据库的字段名，相当于给数据库中的字段名pwd起了一个别名password。

八、日志

1、日志工厂

日志工厂有：

• SLF4J
• LOG4J（重要）
• STDOUT_LOGGING（重要）
• LOG4J2
• JDK_LOGGING
• COMMONS_LOGGING
• NO_LOGGING

    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

在核心配置文件的settings标签中设置

2、log4j

• 使用log4j可以控制每一条日志的输出格式
• 通过定义每一条日志的信息级别，我们能够更加细致地控制日志的生成过程
• 通过一个配置文件灵活的配置，不需要修改应用的代码
• 可以控制日志输出的目的地：控制台，文件，gui等

(1) 导入log4j包

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

(2) log4j.properties

#将等级为DEBUG的日志信息输出到console和file这两个目的地，console 和file的定义在下面的代码
log4j.rootLogger=DEBUG,console,file
#控制台输出的相关设置
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern= [%c] - %m%n
#文件输出的相关设置 文件名 qing.log 
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/qing.log        
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c ]%m%n
#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

(3) 配置log4j日志的实现

<settings>
    <setting name="logImpl" value="LOG4J"/>
</settings>

(4) 输出

import org.apache.log4j.Logger;
import org.junit.Test;
public class TestLog4j {
    static Logger logger= Logger.getLogger(TestLog4j.class);
    @Test
    public void testLog4j(){
        logger.info("进入testLog4j");
        logger.error("testLog4j错误");
        logger.debug("debug!!");
    }
}

• 导包不能导错，需要导入“org.apache.log4j.Logger”
• 设置日志对象Logger，参数为当前类的class

qing.log文件内容

九、注解开发

• mybatis注解开发就简化了xml映射配置文件，不用在为每一个接口编写一个xml文件了
• 使用注解开发，就直接在接口的方法上面，使用@select注解
• 注解开发虽然使用很简单方便，但对稍微复杂的sql语句就不行了，并且无法解决字段与属性名不一致的问题

public interface UserMapper {
    @Select("select *from user")
    List<User> getUserList();
}

本质：反射实现

底层：动态代理

使用注解开发时，接口中若有多个参数时：

• 一个基本的参数类型就对应一个@Param()注解
• 引用类型不用加@Param
• 如果只有一个基本类型时，也可以不用使用

@Select("select *from user where id=#{uid}")
User getUserById(@Param("uid") int id);

@Param中的参数名才是传递到sql语句中的属性名，例如使用了“uid”代替“id”

十、LomBok

1、安装lombok插件

安装完成后需重启idea

2、导入lombok依赖

<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
</dependency>

lombok的注解：

@Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors
@Wither
@With
@SneakyThrows
@val
@var

@Data   //无参构造、get、set、tostring
@NoArgsConstructor  //无参构造
@AllArgsConstructor //全参构造
public class User {
    private int id;
    private String name;
    private String password;
}

十一、多对一处理

按语句嵌套查询 子查询

1、数据库

创建teacher表和student表，student表中的tid字段为外键，关联teacher表的id

2、Student类

@Data
public class Student {
    private int id;
    private String name;
    //外键关联 多个学生关联一个老师 多对一
    private Teacher teacher;
}

3、修改mapper配置文件位置

不再将映射配置文件放在dao层下，而是放在resources资源文件下，但必须保持接口与配置文件路径一致，如图中：com.qing.dao

4、编写核心配置文件的映射

    <mappers>
        <mapper class="com.qing.dao.TeacherMapper"></mapper>
        <mapper class="com.qing.dao.StudentMapper"/>
    </mappers>

5、StudentMapper.xml文件

查询所有的学生信息

根据查询出来的学生的tid，寻找对应的老师

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.qing.dao.StudentMapper">
    <select id="getStudentList" resultMap="StudentMap">
        select *from student
    </select>
    <resultMap id="StudentMap" type="Student">
        <result property="id" column="id"/>
        <result property="name" column="name"/>
        <!-- 复杂属性，需要单独处理 对象association 集合collection-->
        <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
    </resultMap>
    <select id="getTeacher" resultType="Teacher">
        select *from teacher where id=#{tid}
    </select>
</mapper>

第14行就根据查询到的tid，映射成一个Teacher对象，这里的property对应student类中的属性teacher对象，tid为数据库中的字段，javaType为指定属性的类型

按查询结果嵌套查询（重要）

    <!--    方式二-->
    <select id="getStudentList2" resultMap="StudentMap2">
        select s.id,s.name sname,t.name tname from student s,teacher t where s.tid=t.id
    </select>
    <resultMap id="StudentMap2" type="Student">
        <result property="id" column="id"></result>
        <result property="name" column="sname"></result>
        <association property="teacher" javaType="Teacher">
            <result property="name" column="tname"></result>
        </association>
    </resultMap>

十二、一对多（按结果嵌套）

1、实体类

public class Student {
    private int id;
    private String name;
    private int tid;
}

public class Teacher {
    private int id;
    private String name;
    //一个老师多个学生 一对多
    private List<Student> students;
}

2、TeacherMapper.xml文件

<mapper namespace="com.qing.dao.TeacherMapper">
    <select id="getTeacher" resultMap="TeacherMap">
        select s.id sid,s.name sname,t.name tname,t.id tid from student s,teacher t
        where s.tid=t.id and t.id=#{tid}
    </select>
    <resultMap id="TeacherMap" type="Teacher">
        <result property="id" column="tid"></result>
        <result property="name" column="tname"/>
        <!--students是一个集合，使用ofType获取-->
        <collection property="students" ofType="Student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>
</mapper>

十三、动态SQL

1、动态获取ID

public class IDUtils {
    public static String getId(){
        return UUID.randomUUID().toString().replaceAll("-","");
    }
}

2、if、where

<select id="queryBlogIf" parameterType="map" resultType="Blog">
    select *from blog
    <where>
        <if test="title!=null">
            title=#{title}
        </if>
        <if test="author!=null">
            and author=#{author}
        </if>
    </where>
</select>

将要添加的条件放到一个map集合中，使用if标签进行条件判断对sql语句进行追加

where标签可以自动的判断当前的判断条件，如果为第一个判断条件，则会自动去除语句前的and，如上述代码，如果只对author进行限制，那么会自动去掉“ and author=#{author}”的and；反之如果不是第一个判断条件且语句没有and，则会自动添加and

3、choose、when

    <select id="queryBlogChoose" parameterType="map" resultType="Blog">
        select *from blog
        <where>
            <choose>
                <when test="title!=null">
                    title=#{title}
                </when>
                <when test="author!=null">
                     author=#{author}
                </when>
                <otherwise>
                     views=#{views}
                </otherwise>
            </choose>
        </where>
    </select>

choose标签会选择一条判断执行，当满足第一条后，就会跳出；如果都没有满足的条件，则会执行otherwise

4、set

<update id="updateBlog" parameterType="map">
    update blog
    <set>
        <if test="title!=null">
            title=#{title},
        </if>
        <if test="author!=null">
            author=#{author},
        </if>
    </set>
    where id=#{id}
</update>

使用set标签会自动拼接set，并智能的去除多余的“，”。例如只需要判断title，那么拼接sql语句时，就会自动把后面的“，”去掉

5、sql片段

<sql id="if-title-author">
    <if test="title!=null">
        and title=#{title}
    </if>
    <if test="author!=null">
        and author=#{author}
    </if>
</sql>
<select id="queryBlogIf" parameterType="map" resultType="Blog">
    select *from blog
        <where>
            -- 原代码
            <!--            <if test="title!=null">-->
            <!--                and title=#{title}-->
            <!--            </if>-->
            <!--            <if test="author!=null">-->
            <!--                and author=#{author}-->
            <!--            </if>-->
            -- 简化后
            <include refid="if-title-author"></include>
        </where>
</select>

使用sql片段可以简化冗余的代码，例如上述的两个if判断，就可以使用sql标签将他们提取出来。其中的id作为这一部分代码的标识符，与include标签中的refid对应

6、foreEach

<select id="searchBlogById" parameterType="map" resultType="Blog">
    select *from blog
    <where>
        <foreach collection="ids" item="id" open="and ("  close=")" separator="or">
            id=#{id}
        </foreach>
    </where>
</select>

collection为指定的集合，item是集合中的集合项（index为索引），open为指定的开头字符串，close为结尾字符串，separator为分隔符。

当collection为map时，index是键、item是值

上述代码拼接成sql：select *from blog WHERE ( id=? or id=? )

public void test5() {
    SqlSession sqlSession = MybatisUtils.sqlSession();
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    Map map = new HashMap();
    ArrayList<Integer> ids = new ArrayList<>();
    ids.add(1);
    ids.add(5);
    map.put("ids", ids);
    List<Blog> blogs = mapper.searchBlogById(map);
    for (Blog blog : blogs) {
        System.out.println(blog);
    }
    sqlSession.commit();
}

十四、缓存

1、一级缓存

• 一级缓存默认开启，只在一次SqlSession中有效
• 一级缓存也叫本地缓存，默认开启，无法关闭，可以手动清理

sqlSession.clearCache();

可以从上图看到，查询相同的东西时，只需执行一次sql语句，第一次执行的结果就会保存到一级缓存中

而当手动清理缓存后，就会执行两次sql

缓存失效的情况：

• 查询不同的东西
• 增删改操作会修改原来的数据，必定会刷新缓存
• 查询不同的mapper.xml
• 手动清理缓存

2、二级缓存

• 二级缓存叫做全局缓存，是基于namespace级别的缓存
• 一级缓存只作用于一次会话，当会话关闭后，缓存就关闭了，二级缓存就能达到即使会话关闭了，也能将一级缓存的数据保存到二级缓存中
• 不同的mapper查出的数据会放在自己对应的缓存（map）中

二级缓存的开启：

在核心配置文件的setting中设置

<!--        显示开启全局缓存-->
<setting name="cacheEnabled" value="true"/>

在对应接口的Mapper.xml的mapper标签中设置

<mapper namespace="com.qing.dao.UserMapper">
    <!--    开启二级缓存-->
    <cache/>
</mapper>

也可以自定义参数

    <!--    开启二级缓存-->
    <cache eviction="FIFO"
           flushInterval="6000"
           size="512"
           readOnly="true">
    </cache>

• flushInterval：刷新间隔 毫秒
• size：存储的最大引用
• readOnly：返回的对象只读

3、自定义缓存

1）导包

<!-- https://mvnrepository.com/artifact/org.mybatis.caches/mybatis-ehcache -->
<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.2.1</version>
</dependency>

2）在Mapper.xml配置文件中添加cache标签

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

3）添加ehcache.xml文件

<?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">
    <!--
       diskStore：为缓存路径，ehcache分为内存和磁盘两级，此属性定义磁盘的缓存位置。参数解释如下：
       user.home – 用户主目录
       user.dir  – 用户当前工作目录
       java.io.tmpdir – 默认临时文件路径
     -->
    <diskStore path="./tmpdir/Tmp_EhCache"/>
    <!--defaultCache：默认缓存策略，当ehcache找不到定义的缓存时，则使用这个缓存策略。只能定义一个 -->
    <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"/>
    <!--
      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，最近最少使用的，缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。
   -->
</ehcache>

注：若复制xml文件时，“http://ehcache.org/ehcache.xsd”报错，显示为红色，需要进行以下步骤：