MyBatis详细教程，一文带你学习MyBatis，MyBatis超详细教程

一、MyBatis概述

1.1框架

在文献中看到的framework被翻译为框架
Java常用框架：
SSM三大框架： Spring+SpringMVC+MyBatis
SpringBoot
SpringCloud等等。
框架其实就是对通用代码的封装，提前写好一些接口和类，我们可以在写项目的时候直接写入这些
接口和类（引入框架）,基于这些写好的接口和类进行开发，可以大大提高开发效率。
框架一般以jar包的形式存在。（Jar包中有class文件以及各种配置文件等）
SSM三大框架的学习顺序：
方式一：MyBatis、Spring、SpringMVC（建议）
方式二：Spring、MyBatis、SpringMVC

1.2三层架构

表现层（UI）：直接跟前端打交互（一是接收前端ajax请求，二是返回json数据给前端）
业务逻辑层（BLL）：一是处理表现层转发过来的前端请求（也就是具体业务），二是将从持久层
获
取的数据返回到表现层。
数据访问层（DAL）：直接操作数据库完成CRUD，并将获得的数据返回到上一层（也就是业务逻
辑
层）。
Java持久层框架：
MyBatis
Hibernate(实现了JPA规范)
JOOQ
Guzz
Spring Data(实现了JPA规则)
ActiveJDBC
…

1.3 JDBC不足

示列代码1：
示列代码2：
// …
// sql语句写死在java程序中
String sql = “insert into
t_user(id,idCard,username,password,birth,gender,email,city,street,zipcode,ph
one,grade) values(?,?,?,?,?,?,?,?,?,?,?,?)”;
PreparedStatement ps = conn.prepareStatement(sql);
// 繁琐的赋值：思考一下，这种有规律的代码能不能通过反射机制来做自动化。
ps.setString(1, “1”);
ps.setString(2, “123456789”);
ps.setString(3, “zhangsan”);
ps.setString(4, “123456”);
ps.setString(5, “1980-10-11”);
ps.setString(6, “男”);
ps.setString(7, “zhangsan@126.com”);
ps.setString(8, “郑州”);
ps.setString(9, “郑州管城回族区二河大街”);
ps.setString(10, “1000000”);
ps.setString(11, “16398574152”);
ps.setString(12, “A”);
// 执行SQL
int count = ps.executeUpdate();
// …
/ …
// sql语句写死在java程序中
String sql = “select
id,idCard,username,password,birth,gender,email,city,street,zipcode,phone,grade
from t_user”;
PreparedStatement ps = conn.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
List userList = new ArrayList<>();
// 思考以下循环中的所有代码是否可以使用反射进自动化封装。
while(rs.next()){
// 获取数据
String id = rs.getString(“id”);
String idCard = rs.getString(“idCard”);
String username = rs.getString(“username”);
String password = rs.getString(“password”);
String birth = rs.getString(“birth”);
String gender = rs.getString(“gender”);
String email = rs.getString(“email”);
String city = rs.getString(“city”);
String street = rs.getString(“street”);
String zipcode = rs.getString(“zipcode”);
JDBC不足：
SQL语句写死在Java程序中，不灵活。改SQL的话就要改Java代码。违背开闭原则OCP。
给?传值是繁琐的。能不能自动化？？？
将结果集封装成Java对象是繁琐的。能不能自动化？？？
1.4了解MyBatis
MyBatis本质上就是对JDBC的封装，通过MyBatist完成CRUD
MyBatis在三层架构中负责持久化层，属于持久化层框架
MyBatis的发展历程
MyBatis本是apache的一个开源项目iBatis，2010年这个项目由apache software foundation迁
移到了google code，并且改名为MyBatis。2013年11月迁移到Github。
iBATIS一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBATIS提供的持久
层框架包括SQL Maps（SQL映射）和Data Access Objects（DAOs）。
打开mybatis代码可以看到它的包结构中包含：ibatis
ORM：对象关系映射
O（Object）：Java虚拟机中的Java对象
R（Relational）：关系型数据库
M（Mapping）：将Java虚拟机中的Java对象映射到数据库表中一行记录，或是将数据库表中一行
记录映射成Java虚拟机中的一个Java对象。
Mybatis是一个半自动化的ORM，因为SQL语句是自己编写的。
也有全自动的，比如Hibernate就是全自动的，它调用方法，会自动生成SQL语句。
String phone = rs.getString(“phone”);
String grade = rs.getString(“grade”);
// 创建对象
User user = new User();
// 给对象属性赋值
user.setId(id);
user.setIdCard(idCard);
user.setUsername(username);
user.setPassword(password);
user.setBirth(birth);
user.setGender(gender);
user.setEmail(email);
user.setCity(city);
user.setStreet(street);
user.setZipcode(zipcode);
user.setPhone(phone);
user.setGrade(grade);
// 添加到集合
userList.add(user);
}
// …
ORM图示
MyBatis属于半自动化ORM框架。
Hibernate属于全自动化的ORM框架。
MyBatis框架特点：
支持定制化 SQL、存储过程、基本映射以及高级映射
避免了几乎所有的 JDBC 代码中手动设置参数以及获取结果集
支持XML开发，也支持注解式开发。（mybatis大部分是采用XML方式开发）
将接口和 Java的对象映射成数据库中的记录
体积小好学：两个jar包，两个XML配置文件。
完全做到sql解耦合。
提供了基本映射标签。
提供了映射标签。
提供了XML标签，支持动态SQL的编写。
…

二、MyBatis入门程序

只要你会JDBC，MyBatis就可以学。

2.1版本

软件版本：
IntelliJ IDEA：2022.1.4
Navicat for MySQL：16.0.14
MySQL数据库：8.0.30
组件版本：
MySQL驱动：8.0.30
MyBatis：3.5.10
JDK：Java17
JUnit：4.13.2
Logback：1.2.11

2.2Mybatis下载

从github下载，地址：https://github.com/mybatis/mybatis-3
将框架以及框架的源码都下载下来，下载框架后解压，打开mybatis目录
通过以上解压可以看到，框架一般都是以jar包的形式存在。我们的mybatis课程使用maven，所
以这个jar我们不需要。
官方手册需要。

2.3 MyBatis入门程序开发步骤

写代码前准备：
准备数据库表：汽车表t_car,字段包括：
创建表的SQL脚本：
数据展示如下:
2.2 加载mybatis的五个步骤

1. 配置Maven环境，打包方式设置为jar，加载MyBatis，MySQL
   CREATE TABLE t_car (
   id BIGINT(20) NOT NULL AUTO_INCREMENT,
   car_num VARCHAR(255) DEFAULT NULL,
   brand VARCHAR(255) DEFAULT NULL,
   guide_price DECIMAL(10,0) DEFAULT NULL,
   produce_time CHAR(10) DEFAULT NULL,
   car_type VARCHAR(255) DEFAULT NULL,
   PRIMARY KEY (id)
   ) ENGINE=INNODB DEFAULT CHARSET=utf8;
   INSERT INTO t_car (id, car_num, brand, guide_price, produce_time,
   car_type) VALUES (165, ‘6666’, ‘丰田霸道’, 32.00, ‘2020-11-11’, ‘燃油车’);
   INSERT INTO t_car (id, car_num, brand, guide_price, produce_time,
   car_type) VALUES (166, ‘1202’, ‘大众速腾’, 30.00, ‘2020-11-11’, ‘燃油车’);
   INSERT INTO t_car (id, car_num, brand, guide_price, produce_time,
   car_type) VALUES (167, ‘1203’, ‘奔驰GLC’, 5.00, ‘2010-12-03’, ‘燃油车’);
   INSERT INTO t_car (id, car_num, brand, guide_price, produce_time,
   car_type) VALUES (168, ‘1204’, ‘奥迪Q7’, 3.00, ‘2009-10-11’, ‘燃油车’);
   INSERT INTO t_car (id, car_num, brand, guide_price, produce_time,
   car_type) VALUES (169, ‘1205’, ‘朗逸’, 4.00, ‘2001-10-11’, ‘新能源’);
   INSERT INTO t_car (id, car_num, brand, guide_price, produce_time,
   car_type) VALUES (171, ‘1207’, ‘奥迪A6’, 30.00, ‘2000-01-02’, ‘燃油车’);
   INSERT INTO t_car (id, car_num, brand, guide_price, produce_time,
   car_type) VALUES (172, ‘6666’, ‘丰田霸道’, 32.00, ‘2020-11-11’, ‘燃油车’);
   jar
2. 新建，编辑mybatis-config.xml文件（放入resources文件夹）
   注意1：mybatis核心配置文件的文件名不一定是mybatis-config.xml，可以是其它名字。
   注意2：mybatis核心配置文件存放的位置也可以随意。这里选择放在resources根下，相当于放到了类
   的
   根路径下。
3. 新建，配置xxxMapper.xml文件
   

org.mybatis mybatis 3.5.11 mysql mysql-connector-java 8.0.30 <?xml version="1.0" encoding="UTF-8" ?> 注意1：sql语句最后结尾可以不写“;” 注意2：CarMapper.xml文件的名字不是固定的。可以使用其它名字。 注意3：CarMapper.xml文件的位置也是随意的。这里选择放在resources根下，相当于放到了类的根 路 径下。 注意4：将CarMapper.xml文件路径配置到 4. 在xxxMapper中编写SQL代码(在3中已经实现) 5. 把xxxMapper.xml文件路径放入mybatis-config.xml中（在2中已完成） 2.3 MyBatis中的事务 在mybatis-config.xml中有一行为 type类型可以写成两种，一种是JDBC另一种是MANAGED（不区分大小写） JDBC：交给JDBC处理事务（默认false，表示开启事务，需要手动提交） MANAGED：有用到spring框架时设置为此，表交给框架处理事务，如果没有用到框架设置为此类型， 则没有人处理事务，会自动提交 注意事项： SqlSessionFactory.openSession()默认开启事务 ## 2.4 编写MyBatis代码 <?xml version="1.0" encoding="UTF-8" ?> insert into t_car(id,car_num,brand,guide_price,produce_time,car_type) values (null,1003,"面包车",13.00,"2020-10-13","飞行汽车") SqlSession sqlSession = null; try { SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder(); SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(Resources.getResourceAsReader("mybatisconfig.xml")); sqlSession = sqlSessionFactory.openSession(); 核心配置文件的名字是随意的，因为以下代码： 核心配置文件必须放到resources目录下吗？放到D盘根目录下，可以吗？测试一下。 将mybatis-config.xml文件拷一份放到D盘根下，然后编写以下程序： 以上程序运行后，看到数据库表t_car中新增一条数据，成功了 经过测试说明mybatis核心配置文件的名字是随意的，存放路径也是随意的。 虽然mybatis核心配置文件的名字不是固定的，但通常该文件的名字叫做：mybatis-config.xml 虽然mybatis核心配置文件的路径不是固定的，但通常该文件会存放到类路径当中，这样让项目的移植 更 int count = sqlSession.insert("insertCar"); System.out.println("新增了记录"+count); //提交事务 sqlSession.commit(); } catch (Exception e) { if (sqlSession != null) { sqlSession.rollback(); } e.printStackTrace(); }finally { if (sqlSession != null) { sqlSession.close(); } } InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("mybatisconfig.xml"); 加健壮。 在mybatis中提供了一个类：Resources【org.apache.ibatis.io.Resources】，该类可以从类路径当 中获取资源，我们通常使用它来获取输入流InputStream，代码如下 ## 2.5 在MyBatis中引入JUnit 在maven中添加junit依赖 新建test包，以及创建CarMapperTest类 在新建的类中编写MyBatis代码 // 这种方式只能从类路径当中获取资源，也就是说mybatis-config.xml文件需要在类路径下。 InputStream is = Resources.getResourceAsStream("mybatis-config.xml"); junit junit 4.13.2 test public class CarMapperTest { @Test public void insertCar(){ SqlSession sqlSession = null; try { SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder(); SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(Resources.getResourceAsReader("mybatisconfig.xml")); sqlSession = sqlSessionFactory.openSession(); int count = sqlSession.insert("insertCar"); // 这个"insertCar"必须是 sql的id System.out.println("新增了记录"+count); //提交事务 sqlSession.commit(); } catch (Exception e) { if (sqlSession != null) { sqlSession.rollback(); 运行，测试一下，绿色就是没问题 junit小知识点： 断言测试方法：Assert.assertEquals(期望值，实际值) ## 2.6 MyBatis集成日志组件 SLF4J（沙拉疯）：logback就是继承沙拉疯实现的 LOG4J： LOG4J2： STDOUT_LOGGING：MyBatis内部实现的日志组件， logback、log4j、log4j2是同一个作者编写的 若使用STDOUT_LOGGING，需要在mybatis-config.xml里添加配置文件 注意：settings标签必须添加在configuration下面 STDOUT_LOGGING 是mybatis默认配置的日志组件，只需要下面配置开启即可！ 这边不使用STDOUT_LOGGING日志组件，我们使用最常用的logback组件 配置步骤： 1. 在maven中添加logback的依赖 } e.printStackTrace(); }finally { if (sqlSession != null) { sqlSession.close(); } } } } 2. 在mybatis-config.xml中删除日志设置（除了STDOUT_LOGGING自带日志组件外，其他组件不需 要写日志设置） 3. 写配置文件（名字必须为logback.xml或logback-test.xml）必须放在resources目录下 4. 运行测试 ch.qos.logback logback-classic 1.2.11 test <?xml version="1.0" encoding="UTF-8"?> [%thread] %-5level %logger{50} - %msg%n 日志输出级别,LOGBACK日志级别包括五个：TRACE < DEBUG < INFO < WARN < ERROR-- > ## 2.7 MyBatis工具类的编写 在编写代码中，每次都通过SqlSessionFactoryBuilder三步骤获取session太麻烦，我们编写一个工具类 get会比较方便点 1. 新建类utils.SqlSessionUtil 2. 编写代码 public class SqlSessionUtil { private static SqlSessionFactory sqlSessionFactory; /** * 类加载时初始化sqlSessionFactory对象 */ static { try { SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSes sionFactoryBuilder(); sqlSessionFactory = sqlSessionFactoryBuilder. build(Resources.getResourceAsStream("mybatis-config.xml")); } catch (Exception e) { e.printStackTrace(); } } /** * 每调用一次openSession()可获取一个新的会话，该会话支持自动提交。 * * @return 新的会话对象 */ public static SqlSession openSession() { return sqlSessionFactory.openSession(true); } } public class SqlSessionUtilTest { /** * 测试工具类 */ @Test public void openSessionTest(){ SqlSession session = SqlSessionUtil.openSession(); int count = session.insert("insertCar"); System.out.println(count); session.commit(); //提交事物 3. 运行测试（数据库正常添加，完成） # 三、使用MyBatis完成CRUD 准备工作 创建module（Maven的普通Java模块）：mybatis-002-crud pom.xml 打包jar包 依赖： mybatis依赖 mysql驱动 Junit依赖 logback依赖 mybatis-config.xml放在类的根路径下 CarMapper.xml放在类的根路径下 logback.xml放在类的根路径下 提供com.zy.mybatis.utils.SqlSessionUtil.java工具类 创建测试用例：com.zy.mybatis.CarMapperTest.java 3.1 实现Insert新增 1.1 MyBatis中完成Map集合传参 第一个入门程序已完成，现在我们来做MyBatis的CRUD操作 入门程序有个问题：实战的时候新增数据表行数据不可能是固定值 回顾： 存在问题：SQL语句中的值不应该写死，值应该是用户提供的。之前的JDBC代码是这样写的 session.close(); } } insert into t_car(id,car_num,brand,guide_price,produce_time,car_type) values (null,1003,"面包车",13.00,"2020-10-13","飞行汽车") 在Mybatis中可以这样做： 在Java程序中，将数据放到Map集合中 在SQL语句中使用#{map集合的key}来完成传值，#{}等同于JDBC中的?，#{}就是占位符。 1. 继续完善这个程序，新建一个模块叫CRUD，如图，把模块1的一些文件拷贝过来，maven依赖引 用 2. 修改CarMapper.xml文件，加上占位符在MyBatis中占位符为#{}，对应JDBC的? 3. 编写测试代码 // JDBC中使用? 作为占位符。那么MyBatis中会使用什么作为占位符呢？ String sql = "insert into t_car(car_num,brand,guide_price,produce_time,car_ type) values(?,?,?,?,?)"; // ...... // 给 ? 传值。那么MyBatis中应该怎么传值呢？ ps.setString(1,"103"); ps.setString(2,"奔驰E300L"); ps.setDouble(3,50.3); ps.setString(4,"2022-01-01"); ps.setString(5,"燃油车"); insert into t_car(id,car_num,brand,guide_price,produce_time,car_type) values (null,#{},#{},#{},#{},#{}) public class CarMapperTest { @Test public void insertCar(){ SqlSession session = SqlSessionUtil.openSession(); Map

用or来删除
CarMapper.xml
2. 批量插入
/**

• 通过foreach完成批量删除
• @param ids
• @return
  /
  int deleteBatchByForeach2(@Param(“ids”) Long[] ids);
  delete from t_car where
  
  id = #{id}
  
  
  @Test
  public void testDeleteBatchByForeach2(){
  CarMapper mapper = SqlSessionUtil.openSession().getMapper(CarMapper.cla
  ss);
  int count = mapper.deleteBatchByForeach2(new Long[]{40L, 41L, 42L});
  System.out.println(“删除了几条记录：” + count);
  SqlSessionUtil.openSession().commit();
  }
  
  insert into t_car values
  
  (null,#{car.carNum},#{car.brand},#{car.guidePrice},#
  {car.produceTime},#{car.carType})
  
  
  int insertMatch(@Param(“cars”) List cars);
  @Test
  public void testInsertBatchByForeach(){
  CarMapper mapper = SqlSessionUtil.openSession().getMapper(CarMapper.class);
  Car car1 = new Car(null, “2001”, “兰博基尼”, 100.0, “1998-10-11”, “燃油车”);
  Car car2 = new Car(null, “2001”, “兰博基尼”, 100.0, “1998-10-11”, “燃油车”);
  Car car3 = new Car(null, “2001”, “兰博基尼”, 100.0, “1998-10-11”, “燃油车”);
  List cars = Arrays.asList(car1, car2, car3);
  int count = mapper.insertBatchByForeach(cars);
  System.out.println(“插入了几条记录” + count);
  SqlSessionUtil.openSession().commit();
  }
  9.7 sql标签与include标签
  sql标签用来声明sql片段
  include标签用来将声明的sql片段包含到某个sql语句当中
  十、MyBatis的高级映射及延迟加载
  10.1 数据库表的准备
  准备数据库表：一个班级对应多个学生。班级表：t_clazz。学生表：t_stu
  Student
  Claszz
  
  id,
  car_num as carNum,
  brand,
  guide_price as guidePrice,
  produce_time as produceTime,
  car_type as carType
  
  
  select from t_car
  
  /*
• 学生类
• @author
• @version 1.0
• @since 1.0
  */
  public class Student {
  private Integer sid;
  private String sname;
  //…
  }
  创建mapper接口：StudentMapper、ClazzMapper
  创建mapper映射文件：StudentMapper.xml、ClazzMapper.xml
  10.2 多对一映射
  判断哪个是主表的方法：哪个在前
  比如多对一就是多在前，多个学生对应一个班级，此时学生就是主表
  多对一如何在jvm里解释
  将学生类中添加班级类即可
  left join左连接，把左边的全部查出来，右边有的则匹配，没有则为null
  记得要在表后面跟上代称，如t_stu s
  查询结果：
  问题：根据ID查询学生信息，并返回班级信息

1. 第一种方式（级连属性映射）
   /**

• 班级类
  */
  public class Clazz {
  private Integer cid;
  private String cname;
  //…
  }
  select s.sid,s.sname,c.cid,c.cname
  from t_stu s left join t_clazz c on s.cid=c.cid
  where s.sid = 1
  2.第二种方式（Association）
  将resultMap中的类设置为Association（即另一个类）

3. 第三种方式（分步查询）
   两条SQL语句，分步查询。（这种方式常用：优点一是可复用。优点二是支持懒加载）
   第一处：association中select位置填写sqlId。sqlId=namespace+id。其中column属性作为这条子sql
   语
   句的条件。
   
   
   
   
   
   
   
   
   select s.sid,s.sname,s.cid,c.cname from t_stu s left join t_clazz c on
   s.cid=c.cid where s.sid = #{sid}
   
   
   public class StudentMapperTest {
   @Test
   public void testSelectBySid(){
   StudentMapper mapper =
   SqlSessionUtil.openSession().getMapper(StudentMapper.class);
   Student student = mapper.selectBySid(1);
   System.out.println(student);
   }
   }
   
   
   
   
   
   
   
   

第二处： 在Clazzmapper接口中添加方法 第三处：在ClazzMapper.xml文件中进行配置 ClazzMapper.xml 执行结果，可以很明显看到先后有两条sql语句执行： 分步优点： 第一个优点：代码复用性增强。 第二个优点：支持延迟加载。【暂时访问不到的数据可以先不查询。提程序的执效率。】 4.延迟加载（懒加载） 用到的时候加载，不用到的时候不加载 select sid,sname,cid from t_stu where sid=#{sid} <?xml version="1.0" encoding="UTF-8" ?> select * from t_clazz where cid = #{cid} .... public class StudentMapperTest { @Test public void testSelectBySid(){ StudentMapper mapper = SqlSessionUtil.openSession().getMapper(StudentMapper.class); Student student = mapper.selectBySid(1); //System.out.println(student); // 只获取学姓名 String sname = student.getSname(); System.out.println("学生姓名：" + sname); } } public class StudentMapperTest { @Test public void testSelectBySid(){ StudentMapper mapper = SqlSessionUtil.openSession().getMapper(StudentMapper.class); Student student = mapper.selectBySid(1); //System.out.println(student); // 只获取学生姓 通过以上的测试可以看出，我们已经开启了全局延迟加载策略。 开启全局延迟加载之后，所有的sql都会持延迟加载，如果某个sql你不希望它持延迟加载怎么办呢？ 将fetchType设置为eager： 10.3 一对多映射原理 一对多：一个班级对应多个学生（班级是主表，学生是副表） 实现方法：在Clazz班级类中设置一个数组，这样可以容纳多个学生 String sname = student.getSname(); System.out.println("学生姓名：" + sname); // 到这之后，想获取班级名字了 String cname = student.getClazz().getCname(); System.out.println("学的班级名称：" + cname);

1.第一种方式（collection方式）
在select中增加collection标签，表示集合
2. 第二种方式（分步式加载）

select c.cid,c.cname,s.sid,s.sname from t_clazz c left join t_stu s on c.cid=s.cid where c.cid=#{cid} 修改以下三个位置即可： ClazzMapper.xml StudentMapper接 StudentMapper.xml 3. 一对多延迟加载 一对多延迟加载机制和多对 一是 一样的。同样是通过两种方式： 第一种：fetchType="lazy" 第二种： 修改全局的配置setting，lazyLoadingEnaled=true,如果开启全局延迟加载，向让某个 SQL不使用延迟加载：fetchType="eager" 十一、MyBatis缓存cache机制 11.1 了解缓存机制 MyBatis的缓存机制： 在执行DQL（select语句）的时候，MyBatis把语句加载到jvm虚拟机中，若是下次又执行完全一样的语 句，则直接从缓存中读取，若是期间执行了增删改（改动数据库）的操作则自动清空缓存，必须重新从 硬盘中读取 select cid,cname from t_clazz where cid=#{cid} /** * 根据班级编号获取所有的学。 * @param cid * @return */ List selectByCid(Integer cid); select * from t_student where cid = #{cid} public void selectById2() throws Exception{ SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader("mybatisconfig.xml")); SqlSession session1 = sessionFactory.openSession(); CarMapper mapper1 = session1.getMapper(CarMapper.class); Car car1 = mapper1.selectById2(19L); System.out.println(car1); //只有当SqlSession关闭的时候，一级缓存才会到二级缓存里 session1.close(); SqlSession session2 = sessionFactory.openSession(); CarMapper mapper2 = session2.getMapper(CarMapper.class); Car car2 = mapper2.selectById2(19L); System.out.println(car2); session2.close();

二级缓存的失效：只要两次查询之间出现了增删改操作。二级缓存就会失效。【一级缓存也会失效】

1. eviction：指定从缓存中移除某个对象的淘汰算法。默认采用LRU策略。
   LRU：Least Recently Used。最近最少使用。优先淘汰在间隔时间内使频率最低的对
   象。(其
   实还有这种淘汰算法LFU，最不常用。)
   FIFO：First In First Out。一种先进先出的数据缓存器。先进入二级缓存的对象最先被淘汰。
   SOFT：软引用。淘汰软引用指向的对象。具体算法和JVM的垃圾回收算法有关。
   WEAK：弱引用。淘汰弱引用指向的对象。具体算法和JVM的垃圾回收算法有关。
2. flushInterval：
   二级缓存的刷新时间间隔。单位毫秒。如果没有设置。就代表不刷新缓存，只要内存足够大，一直
   会向二级缓存中缓存数据。除非执行了增删改。
3. readOnly：
   true：多条相同的sql语句执行之后返回的对象是共享的同一个。性能好。但是多线程并发可能
   会存在安全问题。
   false：多条相同的sql语句执行之后返回的对象是副本，调用了clone方法。性能一般。但安全。
4. size：
   设置二级缓存中最多可存储的java对象数量。默认值1024。
   11.6 集成Ehcache
   集成EhCache是为了代替mybatis自带的二级缓存。一级缓存是无法替代的。
   mybatis对外提供了接，也可以集成第三方的缓存组件。例如EhCache、Memcache等。都可以。
   EhCache是Java写的。Memcache是C语言写的。所以mybatis集成EhCache较为常见，按照以下步骤操
   作，就可以完成集成：
   第一步：引入mybatis整合ehcache的依赖。

org.mybatis.caches mybatis-ehcache 1.2.2 ch.qos.logback logback-classic 1.2.11test <?xml version="1.0" encoding="UTF-8"?>