Mybatis入门简介

MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

Mybatis官方文档
Mybatis下载地址

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. 新建项目

1. 新建一个普通的maven项目，删除普通的maven项目的src目录
2. 在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&amp;useUnicode=true&amp;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.编写程序代码

1. pojo实体类
2. 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

1. Usermapper接口（增删改查）

public interface UserMapper {
    List<User> getUserList();   //获取用户列表

    User getUserById(int id);   //根据id找用户

    int addUser(User user);     //增添用户

    int updateUser(User user);  //修改

    int deleteUser(int id);     //删除
}

2. 对应用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是表名

3. 使用

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

1. pom.xml中导入log4j的依赖

<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

2. 在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

3. 在核心配置文件中使用log4j

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

4. 简单使用

• 在配置文件中，我们设置过文件输出的相关设置，设置了输出文件的路径，比如./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();
}

使用注解开发

1. 接口
   在接口中定义的函数上面使用注解， 注解里面是sql语句。

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

2. 核心配置文件注册mappers

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

3. 测试使用

@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语句，注解开发会力不从心。其底层主要是 “反射机制” + “动态代理”

4. 其他（增删改查）注解以及@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的关闭之间，即一次会话存在的期间，一级缓存一直存在，如果中间执行两次数据库读操作，第二次的数据就是直接从缓存中读取。

缓存失效（刷新）的情况：

1. 在进行了增删改操作后。
2. 手动刷新 sqlSession.clearCache();

mybatis二级缓存

• 二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存·
• 基于namespace级别的缓存，也就是说同一个Mapper用的是同一个二级缓存，不管开了多少个sqlsession会话。
• 工作机制
  • 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中;
  • 如果当前会话关闭了，这个会话对应的一级缓存就没了;但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中;
  • 新的会话查询信息，就可以从二级缓存中获取内容;
  • 不同的mapper查出的数据会放在自己对应的缓存(map）中;

开启二级缓存

1. 在mybatis核心配置文件中，添加

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

虽然，但是，这个默认是开启的，为了可读性，还是显式的写上。

1. 在需要开启的对应的xml映射文件中添加<cache/>则启用了全局二级缓存
2. 如果需要修改一些缓存的属性，可以像下面这样：

<cache
  eviction="FIFO"
  flushInterval="60000"
  size="512"
  readOnly="true"/>

这个更高级的配置创建了一个 FIFO 缓存，每隔 60 秒刷新，最多可以存储结果对象或列表的 512 个引用，而且返回的对象被认为是只读的，因此对它们进行修改可能会在不同线程中的调用者产生冲突。

小结：

• 所有数据都是先放到一级缓存中
• 只有当sqlsession会话提交，或者关闭的时候，才会被提交到二级缓存中！

缓存原理

用户使用查询数据库时：

1. 先看二级缓存中有没有
2. 再看一级缓存有没有
3. 最后查数据库

本栏目推荐文章
• Mybatis之TypeHandler使用教程
• 简单说一下mybatis的多表映射的使用
• mybatis-generator:generate生成器将另外的数据库内同名表生成
• 一些Mybatis的知识点&易错点总结
• mybatis一级缓存的实现及其问题
• Mybatis
• mybatis提示com.microsoft.sqlserver.jdbc.SQLServerException: 列名 'xxxx' 无效。
• MyBatis-1
• mybatis的foreach标签初使用
• Mybatis是什么？

Mybatismybatis-plus mybatis3 mybatis_plus mybatis-plus mybatis plus mybatis数据 mybatis文件 mybatis plus mybatis-flex mybatis-spring mybatis简介