Mybatis
Mybatis入门简介
MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。
maven仓库
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.11</version>
</dependency>
第一个mybatis程序
1. 搭建数据库
2. 新建项目
- 新建一个普通的maven项目，删除普通的maven项目的src目录
- 在pom.xml里面导入jar 包
<!-- mysql驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.31</version>
</dependency>
<!--mybatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.11</version>
</dependency>
<!-- junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
</dependency>
3. 创建一个普通的maven子模块
4. 进行mybatis核心配置文件的配置
- 在该子模块中的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>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/> <!--事务管理 类型为jdbc-->
<dataSource type="POOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver"/> <!--添加驱动-->
<property name="url" value="jdbc:mysql://localhost:3306/study?useSSL=true&useUnicode=true&characterEncoding=GBK"/> <!--数据库url,以及后面的参数-->
<property name="username" value="root"/> <!--数据库用户名-->
<property name="password" value="zypszabl20755045"/> <!--数据库登陆密码-->
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="com/zyp/xxx/xxxxx.xml"/>
</mappers>
</configuration>
其中，一些相应的配置根据情况灵活改变，url配置？后面是添加的其他配置，多个配置之间用 & 隔开。<mappers> </mappers>用于注册mapper。
5.编写mybatis工具类
- 在如图所示位置创建一个工具类
- 编写工具类的内容
public class MybatisUtils { //sqlSessionFactory--->sqlsession
//使用mybatis第一步，获取sqlsessionfactory对象
private static SqlSessionFactory sqlSessionFactory;
static{
try {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
} catch (IOException e) {
e.printStackTrace();
}
}
//有了sqlsessionfactory就可以获取sqlsession实例了
//sqlsession包含了所有对数据库执行sql语句的所有方法
public static SqlSession getSqlSession(){
SqlSession sqlSession=sqlSessionFactory.openSession();
return sqlSession;
}
}
String resource = "mybatis-config.xml"对应的就是前面的配置文件，由于在maven项目中，resources里的文件编译后都是在根目录下，所以可以这样写。
6.编写程序代码
- pojo实体类
- Dao层接口与配置文件
- 先在接口中定义一个函数-》获取用户列表
public interface UserDao {
List<User> getUserList();
}
- 编写配置文件
<?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">
<!--namespace 命名空间 使用其绑定一个Dao（Mapper）的接口-->
<mapper namespace="com.zyp.dao.UserDao">
<!--一条查询语句-->
<!--id对应 namespace绑定的接口中的函数。 resultType对应pojo的实体类-->
<select id="getUserList" resultType="com.zyp.pojo.User">
select * from study.user
</select>
</mapper>
select * from study.user ：表示查的是study数据库中的user表
namespace对应Mapper接口，id对应接口里的函数名，resultType对应pojo的实体类
7.注册Mappers
在resources/mybatis-config.xml中的<mappers></mappers>中注册，如
<mappers>
<mapper resource="com/zyp/dao/UserMapper.xml"/>
</mappers>
使用resources注册时，根据target目录生成出来的.xml文件来写。若是遇到target中没有mybatis的核心配置文件，在pom.xml中添加下面这段代码：
<build>
<resources>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
</resources>
</build>
8.测试
在test目录下进行测试，使用junit:
public class UserDaoTest {
@Test
public void test(){
//获取SqlSession对象
SqlSession sqlSession= MybatisUtils.getSqlSession();
//通过sqlSession.getMapper()将UserDao接口的.class获取得到UserDao对象
UserDao userDao=sqlSession.getMapper(UserDao.class);
//调用userDao实例的函数
List<User> userlist=userDao.getUserList();
for(User user:userlist){
System.out.println(user);
}
//关闭，释放资源
sqlSession.close();
}
}
CRUD
- Usermapper接口（增删改查）
public interface UserMapper {
List<User> getUserList(); //获取用户列表
User getUserById(int id); //根据id找用户
int addUser(User user); //增添用户
int updateUser(User user); //修改
int deleteUser(int id); //删除
}
- 对应用xml配置文件实现
<?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">
<!--namespace 命名空间 使用其绑定一个Dao（Mapper）的接口-->
<mapper namespace="com.zyp.dao.UserMapper">
<!--一条查询语句-->
<!--id对应 namespace绑定的接口中的函数。 resultType返回值类型对应pojo的实体类-->
<select id="getUserList" resultType="com.zyp.pojo.User">
select * from study.user
</select>
<!-- parameterType是传参数的类型，resultType是返回值类型 -->
<!-- 使用#{}来获取参数 -->
<select id="getUserById" parameterType="int" resultType="com.zyp.pojo.User">
select * from study.user where id=#{id}
</select>
<!-- parameterType参数类型要定位到 pojo层的实体类-->
<!-- 当传的参数是类时，#{}里面可以直接写类中的变量名，如这里的id,name,age-->
<insert id="addUser" parameterType="com.zyp.pojo.User">
insert into study.user (id, name, age) values (#{id}, #{name}, #{age})
</insert>
<!-- 改-->
<update id="updateUser" parameterType="com.zyp.pojo.User">
update study.user set name=#{name},age=#{age} where id=#{id}
</update>
<!--删 -->
<delete id="deleteUser" parameterType="int">
delete from study.user where id=#{id}
</delete>
</mapper>
parameterType传参类型，使用#{}对变量取值，study是数据库名，user是表名
- 使用
public class UserDaoTest {
@Test
public void getUserList(){
//获取SqlSession对象
SqlSession sqlSession= MybatisUtils.getSqlSession();
//通过sqlSession.getMapper()将UserDao接口的.class获取得到UserDao对象
UserMapper userDao=sqlSession.getMapper(UserMapper.class);
//调用userDao实例的函数
List<User> userlist=userDao.getUserList();
for(User user:userlist){
System.out.println(user);
}
//关闭，释放资源
sqlSession.close();
}
@Test
public void getUserByIdTest(){
SqlSession sqlSession=MybatisUtils.getSqlSession();
UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
User user=userMapper.getUserById(2);
System.out.println(user);
sqlSession.close();
}
//增删改查必须需要提交事务
@Test
public void addUserTest(){
SqlSession sqlSession=MybatisUtils.getSqlSession();
UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
int n=userMapper.addUser(new User(3, "李四",100));
if(n>0){
System.out.println("有"+n+"行受到影响");
}
sqlSession.commit(); //提交事务
sqlSession.close(); //释放资源
}
@Test
public void updateUser(){
SqlSession sqlSession=MybatisUtils.getSqlSession();
UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
int n=userMapper.updateUser(new User(3,"打包",1));
if(n>0){
System.out.println("一共有"+n+"行受到影响");
}
sqlSession.commit(); //提交事务
sqlSession.close(); //释放资源
}
@Test
public void deleteUser(){
SqlSession sqlSession=MybatisUtils.getSqlSession();
UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
int n= userMapper.deleteUser(3);
if(n>0){
System.out.println("一共有"+n+"行受到影响");
}
sqlSession.commit(); //提交事务
sqlSession.close(); //释放资源
}
}
需要注意的是：“增删改”需要提交事务sqlSession.commit();才会生效
万能Map
很多时候，我们parameterType传递参数不是只有一个值，或者当pojo中的实体类属性很多很多的时候，我们可以使用map来进行参数传递。
1. Dao/Mapper接口
int addUser2(Map<String, Object> map);
2. xml实现类
<insert id="addUser2" parameterType="map">
insert into study.user (id, name, age) values (#{userId}, #{userName}, #{userAge})
</insert>
此时parameterType="map"
3. 使用
@Test
public void addUserTest2(){
SqlSession sqlSession=MybatisUtils.getSqlSession();
UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
Map<String, Object> map=new HashMap<String, Object>();
map.put("userId", 3);
map.put("userName", "nihao");
map.put("userAge", 90);
int n=userMapper.addUser2(map);
if(n>0){
System.out.println("有"+n+"行受到影响");
}
sqlSession.commit(); //提交事务
sqlSession.close(); //释放资源
}
模糊查询
List<User> getUserLike(String value);
<!--模糊查询-->
<select id="getUserLike" parameterType="String" resultType="com.zyp.pojo.User">
select * from user where name like #{value}
</select>
@Test
public void getUserLike(){
SqlSession sqlSession=MybatisUtils.getSqlSession();
UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
List<User> users=userMapper.getUserLike("%曾%");
for(User user:users){
System.out.println(user);
}
sqlSession.close();
}
环境配置（environments）
可以使用配置多套环境，通过default选择默认的环境。
mybatis默认的事务管理器就是JDBC,数据源就是POOLED。
属性（properties）
可以使用通过properties的属性来实现引用配置文件，这些属性都是可以外部配置的
编写一个配置文件，**resources/db.properties**
driver = com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/study?useSSL=true&useUnicode=true&characterEncoding=GBK
username=root
password=z***********5
引入配置文件
在Mybatis核心配置文件mybatis-config.xml中
类型别名（typeAliases）
- 类型别名可为 Java 类型设置一个缩写名字
- 意在降低冗余的全限定类名书写
<!--可以给实体类起别名-->
<typeAliases>
<typeAlias type="com.zyp.pojo.User" alias="user"/>
</typeAliases>
上面是给某一个具体的实体类起了别名
<!--可以给实体类起别名-->
<typeAliases>
<package name="com.zyp.pojo"/>
</typeAliases>
也可以像这样指定一个包名，MyBatis 会在包名下面搜索需要的Java Bean实体类。默认取得别名就是这个类的类名，首字母小写！！！
@Alias("user")
public class User {
...
}
也可以向上面一样对Java bean实体类 使用注解取别名@Alias("")
设置(Settings)
了解几个常见的：
- cacheEnabled，是否开启全局缓存
- lazyLoadingEnabled，是否开启延迟加载（懒加载）
- mapUnderscoreToCamelCase，是否开启数据库的下划线命名转化成实体类的驼峰命名
- logImpl，指定 MyBatis 所用日志的具体实现，未指定时将自动查找。
映射器（mappers）
- 方式一：使用相对于类路径的资源引用
**（最推荐使用）**
<mappers>
<mapper resource="com/zyp/dao/UserMapper.xml"/>
</mappers>
- 方式二：映射器接口实现类的完全限定类名
<mappers>
<mapper class="com.zyp.dao.UserMapper"/>
</mappers>
注意点：1.接口和它的mapper配置文件必须同名。 2.接口和它的mapper配置文件必在同一个包下
- 方式三：将包内的映射器接口全部注册为映射器
<mappers>
<package name="com.zyp.dao"/>
</mappers>
注意点：1.接口和它的mapper配置文件必须同名。 2.接口和它的mapper配置文件必在同一个包下
ResultMap结果集映射
假设数据库字段： id name age
而实体类属性名： id name nianling
可以发现，我们的数据库字段和实体类属性名在最后一项不一致，如果还是使用resultType会导致我们不能从数据库中查到最后一个（年龄）的值，会被赋为空。所以我们需要使用resultMap结果集映射。
<!--结果集映射-->
<resultMap id="UserMap" type="com.zyp.pojo.User">
<!--column对应数据库字段，property对应实体类属性名-->
<result column="id" property="id"/>
<result column="name" property="name"/>
<result column="age" property="nianling"/>
</resultMap>
<select id="getUserById" resultMap="UserMap">
select * from study.user where id=#{id}
</select>
resultMap=""的值，要与前面定义的结果集映射对应。
但是上面的resultMap的使用还可以化简，对于数据库字段和实体类属性名是一致的情况下，则不需要进行映射。所以上面可以改成下面：
<!--结果集映射-->
<resultMap id="UserMap" type="com.zyp.pojo.User">
<!--column对应数据库字段，property对应实体类属性名-->
<result column="age" property="nianling"/>
</resultMap>
<select id="getUserById" resultMap="UserMap">
select * from study.user where id=#{id}
</select>
日志工厂
一个标准日志工厂实现,在核心配置文件中添加
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
log4j
- pom.xml中导入log4j的依赖
<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
- 在resources中添加一个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
#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/zyp.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
- 在核心配置文件中使用log4j
<settings>
<setting name="logImpl" value="LOG4J"/>
</settings>
- 简单使用
- 在配置文件中，我们设置过文件输出的相关设置，设置了输出文件的路径，比如
./log/shun.log，所以我们可以找到日志文件的位置
- 我们可以在程序中，输出信息到该日志文件中。同时，平时操作数据库（增删改查）的信息也会记录在该文件中。 在程序中写入信息的方式如下所示：
@Test
public void TestLog4j(){
Logger logger=Logger.getLogger(UserDaoTest.class);
logger.info("info:进入了TestLog4j");
logger.debug("debug:进入了TestLog4j");
logger.error("error:进入了TestLog4j");
}
Limit分页
有数据库表
我们可以通过select * from user limit 0,2;进行分页查询。表示从第0条数据开始查，查询的数量是2
在Mybatis实现分页
- 接口
List<User> getUserByLimit(Map<String, Integer> map);
- xml
<select id="getUserByLimit" parameterType="map" resultType="com.zyp.pojo.User">
select * from study.user limit #{startIndex},#{size}
</select>
- 测试使用
@Test
public void getUserByLimitTest(){
SqlSession sqlSession=MybatisUtils.getSqlSession();
UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
Map<String, Integer> map=new HashMap<String, Integer>();
map.put("startIndex", 0);
map.put("size", 2);
List<User> users= userMapper.getUserByLimit(map);
for(User user:users){
System.out.println(user);
}
sqlSession.close();
}
使用注解开发
- 接口
在接口中定义的函数上面使用注解， 注解里面是sql语句。
public interface UserMapper {
@Select("SELECT * from study.user")
List<User> getUserList();
}
- 核心配置文件注册mappers
<mappers>
<mapper class="com.zyp.dao.UserMapper"/>
</mappers>
- 测试使用
@Test
public void getUserList(){
SqlSession sqlSession=MybatisUtils.getSqlSession();
UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
List<User> users=userMapper.getUserList();
for (User user : users) {
System.out.println(user);
}
sqlSession.close();
}
注解开发具有局限性，对于稍微复杂一点的sql语句，注解开发会力不从心。其底层主要是 “反射机制” + “动态代理”
- 其他（增删改查）注解以及@Param的使用
@Param() 指定之后，就要按照param指定的参数名使用，其优先级更高
Lombok
Lombok是一个偷懒的工具，使用其的注解可以帮助我们减少写实体类的代码
1. idea添加lombok插件
settings-->plugs,搜索lombok
2. 添加jar包依赖
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.28</version>
<scope>provided</scope>
</dependency>
3. lombok几个常用的注解
- **@Data **** 无参构造 getter setter toString hashcode equals **
- **@AllArgsConstructor **** 有参构造 **
- **@NoArgsConstructor **** 无参构造 **
动态SQL
动态SQL就是根据不同的条件生成不同的sql语句
IF
<if test="">
</if>
在test=""中写判断条件， 中间写在满足条件时，添加的sql语句。例子(有where标签)：
<select id="selectUserIf" parameterType="map" resultType="com.zyp.pojo.User">
select * from study.user
<where>
<if test="myname != null">
and name=#{myname}
</if>
<if test="myage != null">
and age>#{myage}
</if>
</where>
</select>
说明： 我们传入的参数类型parameterType="map"是map。所以我们可以什么都不传，也可以传入多值。当我们什么都不传时，sql语句就是
select * from study.user，当我们传入了一个参数名为myname的参数时，会被if进行判断成不为空，所以sql语句会在后面加上and name=#{myname}，同理，如果传入了参数名是myage的参数，sql语句则会添加上and age>#{myage}。
这里解释一下**<where>**标签的作用，就是替代sql语句中的where，使用**<where>**标签更好，其会自动判断后面添加上来的sql语句需不需要有**and**来连接。
对应接口：
List<User> selectUserIf(Map map);
对应测试：
@Test
public void selectUserIfTest(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
Map<String,Object> map=new HashMap<>();
map.put("myname", "hello"); //如果传myname
map.put("myage", 0); //如果传myage
UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
List<User> users=userMapper.selectUserIf(map);
for (User user : users) {
System.out.println(user);
}
sqlSession.close();
}
choos、when、otherwise
<choose>
<when test="">
</when>
<when test="">
</when>
<otherwise>
</otherwise>
</choose>
没有什么特殊的地方，就是switch语句。
SET
set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号
<update id="updateuser" parameterType="map" resultType="com.zyp.pojo.User">
update user
<set>
<if test="myusername != null">
username=#{myusername},
</if>
<if test="mypassword != null">
password=#{mypassword},
</if>
</set>
where id=#{myid}
</update>
Sql片段
把sql语句抽取出来，方便其他地方多次使用
<sql id="sqlSession1">
</sql>
id=""用于其他地方引用该片段, 如下面例子:
注意：不要把<where>放到sql片段
Foreach
<foreach collection="list" item="item" index="index" open="ID in (" separator="," close=")" >
#{item}
</foreach>
foreach其实就是遍历一个集合，把集合中的元素取出来，然后用于我们拼接sql语句。collection是待循环遍历的集合（通过参数传进来），item是集合中每一个值，index就是遍历时的下标,open是最后拼接出来的字符串是以什么开头，close是以什么结尾，separator是拼接时的每一个项之间用什么分隔。
**例子**
要实现的sql语句：select * from study.user where id in (2,4)。现在数据库中有四条记录，但是我只想查询id为偶数的。类似这种语句可以使用foreach来实现。
<select id="selectUserForeach" parameterType="map" resultType="com.zyp.pojo.User">
select * from study.user
<where>
<foreach collection="id_list" item="item" open="id in (" separator="," close=")" >
#{item}
</foreach>
</where>
</select>
测试使用：
注意：collection="id_list"是从map传进去的
@Test
public void selectUserForeachTest(){
SqlSession sqlSession=MybatisUtils.getSqlSession();
UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
Map<String , Object> map=new HashMap<>();
List id_list=new ArrayList();
id_list.add(2);
id_list.add(4);
map.put("id_list", id_list);
List<User> users= userMapper.selectUserForeach(map);
for (User user : users) {
System.out.println(user);
}
sqlSession.close();
}
上面拼接完成后就是select * from study.user where id in (2,4)
缓存
缓存是存在内存中的临时数据，将用户经常需要查询的数据放到缓存中，就不需要每次都从数据库中查询，提高查询效率，解决高并发系统的性能问题。
mybatis缓存
- MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。
- MyBatis系统中默认定义了两级缓存:一级缓存和二级缓存
- 默认情况下，只有一级缓存开启。(SqlSession级别的缓存，也称为本地缓存)。
- 二级缓存需要手动开启和配置，他是基于namespace级别的缓存。
- 为了提高扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存
mybatis一级缓存
- 一级缓存也叫本地缓存： Sqlsession 从sqlsession的创建到sqlsession的关闭之间，即一次会话存在的期间，一级缓存一直存在，如果中间执行两次数据库读操作，第二次的数据就是直接从缓存中读取。
缓存失效（刷新）的情况：
- 在进行了
增删改操作后。 - 手动刷新
sqlSession.clearCache();
mybatis二级缓存
- 二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存·
- 基于namespace级别的缓存，也就是说同一个Mapper用的是同一个二级缓存，不管开了多少个sqlsession会话。
- 工作机制
- 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中;
- 如果当前会话关闭了，这个会话对应的一级缓存就没了;但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中;
- 新的会话查询信息，就可以从二级缓存中获取内容;
- 不同的mapper查出的数据会放在自己对应的缓存(map）中;
开启二级缓存
- 在mybatis核心配置文件中，添加
<settings>
<setting name="cacheEnabled" value="true"/>
</settings>
虽然，但是，这个默认是开启的，为了可读性，还是显式的写上。
- 在需要开启的对应的xml映射文件中添加
<cache/>则启用了全局二级缓存 - 如果需要修改一些缓存的属性，可以像下面这样：
<cache
eviction="FIFO"
flushInterval="60000"
size="512"
readOnly="true"/>
这个更高级的配置创建了一个 FIFO 缓存，每隔 60 秒刷新，最多可以存储结果对象或列表的 512 个引用，而且返回的对象被认为是只读的，因此对它们进行修改可能会在不同线程中的调用者产生冲突。
小结：
- 所有数据都是先放到一级缓存中
- 只有当sqlsession会话提交，或者关闭的时候，才会被提交到二级缓存中！
缓存原理
用户使用查询数据库时：
- 先看二级缓存中有没有
- 再看一级缓存有没有
- 最后查数据库
