AI 助理
备案控制台
开发者社区 数据库 文章 正文

Mybatis缓存

2022-06-09 104
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
RDS MySQL Serverless 基础系列，0.5-2RCU 50GB
推荐场景：
学生管理系统数据库设计 搭建个人博客
RDS MySQL Serverless 高可用系列，价值2615元额度，1个月
云数据库 RDS PostgreSQL，高可用系列 2核4GB
简介： Mybatis缓存

缓存的基本概念


缓存是存在于内存中的临时数据。

使用缓存减少和数据库的交互次数，提高执行效率。

适用于缓存：

(1)经常查询并且不经常改变的。

(2)数据的正确与否对最终结果影响不大的。

不适用于缓存：

(1)经常改变的数据

(2)数据的正确与否对最终结果影响很大的。

例如：商品的库存，银行的汇率，股市的牌价。


Mybatis一级缓存


一级缓存：

它指的是Mybatis中SqlSession对象的缓存。

当我们执行查询之后，查询的结果会同时存入到SqlSession为我们提供一块区域中。

该区域的结构是一个Map。当我们再次查询同样的数据，mybatis会先去sqlsession中

查询是否有，有的话直接拿出来用。

当SqlSession对象消失时，mybatis的一级缓存也就消失了。

一级缓存是 SqlSession 级别的缓存，只要 SqlSession 没有 flush 或 close，它就存在。


证明一级缓存的存在


编写用户持久层 Dao 接口


IUserDao：


package com.keafmd.dao;
import com.keafmd.domain.User;
import java.util.List;
/**
 * Keafmd
 *
 * @ClassName: IUserDao
 * @Description: 用户的持久层接口
 * @author: 牛哄哄的柯南
 * @date: 2021-02-06 19:29
 */
public interface IUserDao {
    /**
     * 查询所有用户，同时获取到用户下所有账户的信息
     * @return
     */
    List<User> findAll();
    /**
     * 根据id查新用户信息
     * @param id
     * @return
     */
    User findById(Integer id);
}

编写用户持久层映射文件


IUserDao.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.keafmd.dao.IUserDao">
    <!--配置查询所有-->
    <select id="findAll" resultType="user">
        select * from user
    </select>
    <!--根据id查询用户-->
    <select id="findById" parameterType="Integer" resultType="user">
        select * from user where id = #{id}
    </select>
</mapper>

编写测试方法


MybatisTest：


package com.keafmd.test;
import com.keafmd.dao.IUserDao;
import com.keafmd.domain.User;
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.After;
import org.junit.Before;
import org.junit.Test;
import java.io.InputStream;
import java.util.List;
/**
 * Keafmd
 *
 * @ClassName: MybatisTest
 * @Description: 测试类，测试crud操作
 * @author: 牛哄哄的柯南
 * @date: 2021-02-08 15:24
 */
public class UserTest {
    private InputStream in;
    private SqlSessionFactory factory;
    private SqlSession sqlSession;
    private IUserDao userDao;
    @Before // 用于在测试方法执行前执行
    public void init()throws Exception{
        //1.读取配置文件,生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        factory = builder.build(in);
        //3.使用工厂生产SqlSession对象
        sqlSession = factory.openSession(true); //里面写个true，下面每次就不用了写 sqlsession.commit(); 了
        //4.使用SqlSession创建Dao接口的代理对象
        userDao = sqlSession.getMapper(IUserDao.class);
    }
    @After // 用于在测试方法执行后执行
    public void destory() throws Exception{
        //提交事务
        //sqlSession.commit();
        //6.释放资源
        sqlSession.close();
        in.close();
    }
    /**
     * 测试一级缓存
     */
    @Test
    public void testFirstLevelCache(){
        User user1 = userDao.findById(41);
        System.out.println(user1);
        User user2 = userDao.findById(41);
        System.out.println(user2);
        System.out.println(user1==user2);
    }
}

运行结果：


2021-02-16 15:52:44,863 359    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Opening JDBC Connection
2021-02-16 15:52:45,164 660    [           main] DEBUG source.pooled.PooledDataSource  - Created connection 905735620.
2021-02-16 15:52:45,168 664    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==>  Preparing: select * from user where id = ?
2021-02-16 15:52:45,200 696    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==> Parameters: 41(Integer)
2021-02-16 15:52:45,227 723    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - <==      Total: 1
com.keafmd.domain.User@400cff1a
com.keafmd.domain.User@400cff1a
true

我们可以看到，只发起了一次查询，相当于第一次是查询，而第二次是从缓存中取得。


一级缓存的分析


一级缓存是 SqlSession 范围的缓存，当调用 SqlSession 的修改，添加，删除，commit()，close()等方法时，就会清空一级缓存。


举个例子：

13.png

第一次发起查询用户 id 为 1 的用户信息，先去找缓存中是否有 id 为 1 的用户信息，如果没有，从数据库查询用户信息。

得到用户信息，将用户信息存储到一级缓存中。

如果 sqlSession 去执行 commit 操作（执行插入、更新、删除），清空 SqlSession 中的一级缓存，这样做的目的为了让缓存中存储的是最新的信息，避免脏读。

第二次发起查询用户 id 为 1 的用户信息，先去找缓存中是否有 id 为 1 的用户信息，缓存中有，直接从缓存中获取用户信息。


测试一级缓存的清空


改变下测试代码：


/**
 * 测试一级缓存
 */
@Test
public void testFirstLevelCache(){
    User user1 = userDao.findById(41);
    System.out.println(user1);
    /*sqlSession.close();
    //再次获取sqlSession对象
    sqlSession = factory.openSession();*/
    sqlSession.clearCache();//此方法也可以清空缓存
    userDao = sqlSession.getMapper(IUserDao.class);
    User user2 = userDao.findById(41);
    System.out.println(user2);
    System.out.println(user1==user2);
}

运行结果：


2021-02-16 16:14:57,171 194    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Opening JDBC Connection
2021-02-16 16:14:57,498 521    [           main] DEBUG source.pooled.PooledDataSource  - Created connection 93314457.
2021-02-16 16:14:57,503 526    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==>  Preparing: select * from user where id = ?
2021-02-16 16:14:57,541 564    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==> Parameters: 41(Integer)
2021-02-16 16:14:57,560 583    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - <==      Total: 1
com.keafmd.domain.User@57175e74
2021-02-16 16:14:57,561 584    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==>  Preparing: select * from user where id = ?
2021-02-16 16:14:57,561 584    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==> Parameters: 41(Integer)
2021-02-16 16:14:57,562 585    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - <==      Total: 1
com.keafmd.domain.User@c540f5a
false
2021-02-16 16:14:57,563 586    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@58fdd99]
2021-02-16 16:14:57,563 586    [           main] DEBUG source.pooled.PooledDataSource  - Returned connection 93314457 to pool.
Process finished with exit code 0

我们可以看到这样就发起了两次查询，我们用这两种方式都可以清空缓存。


添加updateUser方法


IUserDao：


package com.keafmd.dao;
import com.keafmd.domain.User;
import java.util.List;
/**
 * Keafmd
 *
 * @ClassName: IUserDao
 * @Description: 用户的持久层接口
 * @author: 牛哄哄的柯南
 * @date: 2021-02-06 19:29
 */
public interface IUserDao {
    /**
     * 查询所有用户，同时获取到用户下所有账户的信息
     * @return
     */
    List<User> findAll();
    /**
     * 根据id查新用户信息
     * @param id
     * @return
     */
    User findById(Integer id);
    /**
     * 更新用户信息
     * @param user
     */
    void updateUser(User user);
}

IUserDao.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.keafmd.dao.IUserDao">
    <!--配置查询所有-->
    <select id="findAll" resultType="user">
        select * from user
    </select>
    <!--根据id查询用户-->
    <select id="findById" parameterType="Integer" resultType="user">
        select * from user where id = #{id}
    </select>
    <!--更新用户信息-->
    <select id="updateUser"  resultType="user">
        update user set username=#{username},address=#{address} where id=#{id}
    </select>
</mapper>

测试缓存的同步


UserTest：


package com.keafmd.test;
import com.keafmd.dao.IUserDao;
import com.keafmd.domain.User;
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.After;
import org.junit.Before;
import org.junit.Test;
import java.io.InputStream;
import java.util.List;
/**
 * Keafmd
 *
 * @ClassName: MybatisTest
 * @Description: 测试类
 * @author: 牛哄哄的柯南
 * @date: 2021-02-08 15:24
 */
public class UserTest {
    private InputStream in;
    private SqlSessionFactory factory;
    private SqlSession sqlSession;
    private IUserDao userDao;
    @Before // 用于在测试方法执行前执行
    public void init()throws Exception{
        //1.读取配置文件,生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        factory = builder.build(in);
        //3.使用工厂生产SqlSession对象
        sqlSession = factory.openSession(true); //里面写个true，下面每次就不用了写 sqlsession.commit(); 了
        //4.使用SqlSession创建Dao接口的代理对象
        userDao = sqlSession.getMapper(IUserDao.class);
    }
    @After // 用于在测试方法执行后执行
    public void destory() throws Exception{
        //提交事务
        //sqlSession.commit();
        //6.释放资源
        sqlSession.close();
        in.close();
    }
    /**
     * 测试一级缓存
     */
    @Test
    public void testFirstLevelCache(){
        User user1 = userDao.findById(41);
        System.out.println(user1);
        /*sqlSession.close();
        //再次获取sqlSession对象
        sqlSession = factory.openSession();*/
        sqlSession.clearCache();//此方法也可以清空缓存
        userDao = sqlSession.getMapper(IUserDao.class);
        User user2 = userDao.findById(41);
        System.out.println(user2);
        System.out.println(user1==user2);
    }
    /**
     * 测试缓存的同步
     */
    @Test
    public void testClearCache(){
        //1.根据id查询用户
        User user1 = userDao.findById(41);
        System.out.println(user1);
        //2.更新用户信息
        user1.setUsername("update user clear cache");
        user1.setAddress("上海");
        userDao.updateUser(user1);
        //手动提交
        sqlSession.commit();
        //3.再次查询id为41的用户
        User user2 = userDao.findById(41);
        System.out.println(user2);
        System.out.println(user1==user2);
    }
}

运行testClearCache()：


2021-02-16 16:13:04,277 209    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Opening JDBC Connection
2021-02-16 16:13:04,560 492    [           main] DEBUG source.pooled.PooledDataSource  - Created connection 93314457.
2021-02-16 16:13:04,565 497    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==>  Preparing: select * from user where id = ?
2021-02-16 16:13:04,618 550    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==> Parameters: 41(Integer)
2021-02-16 16:13:04,645 577    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - <==      Total: 1
com.keafmd.domain.User@57175e74
2021-02-16 16:13:04,646 578    [           main] DEBUG keafmd.dao.IUserDao.updateUser  - ==>  Preparing: update user set username=?,address=? where id=?
2021-02-16 16:13:04,646 578    [           main] DEBUG keafmd.dao.IUserDao.updateUser  - ==> Parameters: update user clear cache(String), 上海(String), 41(Integer)
2021-02-16 16:13:04,647 579    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==>  Preparing: select * from user where id = ?
2021-02-16 16:13:04,648 580    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==> Parameters: 41(Integer)
2021-02-16 16:13:04,649 581    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - <==      Total: 1
com.keafmd.domain.User@c540f5a
false
2021-02-16 16:13:04,650 582    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@58fdd99]
2021-02-16 16:13:04,650 582    [           main] DEBUG source.pooled.PooledDataSource  - Returned connection 93314457 to pool.
Process finished with exit code 0

我们在第一次查询后进行的更新操作，所以会清空一级缓存，然后第二次会在进行查询。


Mybatis二级缓存


二级缓存:

它指的是Mybatis中SqlSessionFactory对象的缓存。由同一个SqlSessionFactory对象创建的SqlSession共享其缓存。

二级缓存的使用步骤：

第一步：让Mybatis框架支持二级缓存（在SqlMapConfig.xml中配置）

第二步：让当前的映射文件支持二级缓存（在IUserDao.xml中配置）

第三步：让当前的操作支持二级缓存（在select标签中配置）

二级缓存是 mapper 映射级别的缓存，多个 SqlSession 去操作同一个 Mapper 映射的 sql 语句，多个SqlSession 可以共用二级缓存，二级缓存是跨 SqlSession 的。


二级缓存结构图

14.png

首先开启 mybatis 的二级缓存。

sqlSession1 去查询用户信息，查询到用户信息会将查询数据存储到二级缓存中。

如果 SqlSession3 去执行相同 mapper 映射下 sql，执行 commit 提交，将会清空该 mapper 映射下的二级缓存区域的数据。

sqlSession2 去查询与 sqlSession1 相同的用户信息，首先会去缓存中找是否存在数据，如果存在直接从缓存中取出数据。


二级缓存的开启与关闭


第一步：在 SqlMapConfig.xml 文件开启二级缓存

<settings>
    <!--开启二级缓存的支持-->
    <setting name="cacheEnabled" value="true"/>
</settings>

因为 cacheEnabled 的取值默认就为 true，所以这一步可以省略不配置。为 true 代表开启二级缓存；为false 代表不开启二级缓存。


第二步：配置相关的 Mapper 映射文件


IUserDao.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.keafmd.dao.IUserDao">
    <!--开启user支持二级缓存-->
    <cache/>
    <!--配置查询所有-->
    <select id="findAll" resultType="user">
        select * from user
    </select>
    <!--根据id查询用户-->
    <select id="findById" parameterType="Integer" resultType="user" useCache="true">
        select * from user where id = #{id}
    </select>
    <!--更新用户信息-->
    <select id="updateUser"  resultType="user">
        update user set username=#{username},address=#{address} where id=#{id}
    </select>
</mapper>

第三步：配置 statement 上面的 useCache 属性


<!--根据id查询用户-->
<select id="findById" parameterType="Integer" resultType="user" useCache="true">
    select * from user where id = #{id}
</select>

将 UserDao.xml 映射文件中的标签中设置 useCache=”true”代表当前这个statement 要使用二级缓存，如果不使用二级缓存可以设置为 false。

注意：针对每次查询都需要最新的数据 sql，要设置成 useCache=false，禁用二级缓存。


二级缓存测试


SecondLevelCacheTest：


package com.keafmd.test;
import com.keafmd.dao.IUserDao;
import com.keafmd.domain.User;
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.After;
import org.junit.Before;
import org.junit.Test;
import java.io.InputStream;
/**
 * Keafmd
 *
 * @ClassName: MybatisTest
 * @Description: 测试类，测试crud操作
 * @author: 牛哄哄的柯南
 * @date: 2021-02-08 15:24
 */
public class SecondLevelCacheTest {
    private InputStream in;
    private SqlSessionFactory factory;
    @Before // 用于在测试方法执行前执行
    public void init()throws Exception{
        //1.读取配置文件,生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        factory = builder.build(in);
    }
    @After // 用于在测试方法执行后执行
    public void destory() throws Exception{
        in.close();
    }
    /**
     * 测试二级缓存
     */
    @Test
    public void testSecondLevelCache(){
        SqlSession sqlSession1 = factory.openSession();
        IUserDao dao1 = sqlSession1.getMapper(IUserDao.class);
        User user1 = dao1.findById(41);
        System.out.println(user1);
        sqlSession1.close(); //一级缓存消失
        SqlSession sqlSession2 = factory.openSession();
        IUserDao dao2 = sqlSession2.getMapper(IUserDao.class);
        User user2 = dao2.findById(41);
        System.out.println(user2);
        sqlSession2.close();
        System.out.println(user1==user2);
    }
}

运行结果：


2021-02-16 17:07:05,474 179    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Opening JDBC Connection
2021-02-16 17:07:05,723 428    [           main] DEBUG source.pooled.PooledDataSource  - Created connection 905735620.
2021-02-16 17:07:05,723 428    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@35fc6dc4]
2021-02-16 17:07:05,726 431    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==>  Preparing: select * from user where id = ?
2021-02-16 17:07:05,752 457    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - ==> Parameters: 41(Integer)
2021-02-16 17:07:05,770 475    [           main] DEBUG m.keafmd.dao.IUserDao.findById  - <==      Total: 1
com.keafmd.domain.User@400cff1a
2021-02-16 17:07:05,777 482    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@35fc6dc4]
2021-02-16 17:07:05,778 483    [           main] DEBUG ansaction.jdbc.JdbcTransaction  - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@35fc6dc4]
2021-02-16 17:07:05,778 483    [           main] DEBUG source.pooled.PooledDataSource  - Returned connection 905735620 to pool.
2021-02-16 17:07:05,782 487    [           main] DEBUG        com.keafmd.dao.IUserDao  - Cache Hit Ratio [com.keafmd.dao.IUserDao]: 0.5
com.keafmd.domain.User@75c072cb
false
Process finished with exit code 0

经过上面的测试，我们发现执行了两次查询，并且在执行第一次查询后，我们关闭了一级缓存，再去执行第二次查询时，我们发现并没有对数据库发出 sql 语句，所以此时的数据就只能是来自于我们所说的二级缓存。

注意：二级缓存中存放的内容是数据，而不是对象，内容虽然是同样的，但是存放的是数据，第二次虽然没有发起查询，但从二级缓存中获取时，会把内容封装到新的对象返回，所以是false。


二级缓存注意事项


当我们在使用二级缓存时，所缓存的类一定要实现 java.io.Serializable 接口，这种就可以使用序列化方式来保存对象。


User：


package com.keafmd.domain;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
/**
 * Keafmd
 *
 * @ClassName: User
 * @Description:
 * @author: 牛哄哄的柯南
 * @date: 2021-02-08 15:16
 */
public class User implements Serializable {
    private Integer id;
    private String username;
    private String sex;
    private String address;
    private Date birthday;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
}

以上就是Mybatis缓存的全部内容。

文章标签：
云数据库 RDS MySQL 版
Java
SQL
mybatis
数据库
缓存
存储
数据库连接
关键词：
MyBatis缓存
缓存mybatis
相关实践学习
每个IT人都想学的“Web应用上云经典架构”实战
本实验从Web应用上云这个最基本的、最普遍的需求出发，帮助IT从业者们通过“阿里云Web应用上云解决方案”，了解一个企业级Web应用上云的常见架构，了解如何构建一个高可用、可扩展的企业级应用架构。
MySQL数据库入门学习
本课程通过最流行的开源数据库MySQL带你了解数据库的世界。 &nbsp; 相关的阿里云产品：云数据库RDS MySQL 版 阿里云关系型数据库RDS（Relational Database Service）是一种稳定可靠、可弹性伸缩的在线数据库服务，提供容灾、备份、恢复、迁移等方面的全套解决方案，彻底解决数据库运维的烦恼。 了解产品详情:&nbsp;https://www.aliyun.com/product/rds/mysql&nbsp;
牛哄哄的柯南8151
目录
相关文章
游客tdul3lsfndxwi
|
3月前
|
存储 缓存 NoSQL
mybatisplus一二级缓存
MyBatis-Plus 继承并优化了 MyBatis 的一级与二级缓存机制。一级缓存默认开启，作用于 SqlSession，适用于单次会话内的重复查询；二级缓存需手动开启，跨 SqlSession 共享，适合提升多用户并发性能。支持集成 Redis 等外部存储，增强缓存能力。
游客tdul3lsfndxwi
238 0
蓝易云
|
5月前
|
缓存 Java 数据库连接
Mybatis一级缓存详解
Mybatis一级缓存为开发者提供跨数据库操作的一致性保证，有效减轻数据库负担，提高系统性能。在使用过程中，需要结合实际业务场景选择性地启用一级缓存，以充分发挥其优势。同时，开发者需注意其局限性，并做好事务和并发控制，以确保系统的稳定性和数据的一致性。
蓝易云
168 20
杀死一只知更鸟debug
|
缓存 Java 数据库连接
mybatis复习05,mybatis的缓存机制（一级缓存和二级缓存及第三方缓存）
文章介绍了MyBatis的缓存机制，包括一级缓存和二级缓存的配置和使用，以及如何整合第三方缓存EHCache。详细解释了一级缓存的生命周期、二级缓存的开启条件和配置属性，以及如何通过ehcache.xml配置文件和logback.xml日志配置文件来实现EHCache的整合。
杀死一只知更鸟debug
355 1
mybatis复习05,mybatis的缓存机制（一级缓存和二级缓存及第三方缓存）
互联网课堂
|
7月前
|
缓存 Java 数据库连接
Mybatis一级缓存、二级缓存详讲
本文介绍了MyBatis中的查询缓存机制，包括一级缓存和二级缓存。一级缓存基于同一个SqlSession对象，重复查询相同数据时可直接从缓存中获取，减少数据库访问。执行`commit`操作会清空SqlSession缓存。二级缓存作用于同一namespace下的Mapper对象，支持数据共享，需手动开启并实现序列化接口。二级缓存通过将数据存储到硬盘文件中实现持久化，为优化性能，通常在关闭Session时批量写入缓存。文章还说明了缓存的使用场景及注意事项。
互联网课堂
226 7
Mybatis一级缓存、二级缓存详讲
刘大猫.
|
8月前
|
缓存 Java 数据库连接
十、MyBatis的缓存
十、MyBatis的缓存
刘大猫.
144 6
智物科技库
|
9月前
|
缓存 NoSQL Java
Mybatis学习：Mybatis缓存配置
MyBatis缓存配置包括一级缓存（事务级）、二级缓存（应用级）和三级缓存（如Redis，跨JVM）。一级缓存自动启用，二级缓存需在`mybatis-config.xml`中开启并配置映射文件或注解。集成Redis缓存时，需添加依赖、配置Redis参数并在映射文件中指定缓存类型。适用于查询为主的场景，减少增删改操作，适合单表操作且表间关联较少的业务。
智物科技库
171 6
蓝染-惣右介
|
11月前
|
SQL 缓存 Java
【详细实用のMyBatis教程】获取参数值和结果的各种情况、自定义映射、动态SQL、多级缓存、逆向工程、分页插件
本文详细介绍了MyBatis的各种常见用法MyBatis多级缓存、逆向工程、分页插件 包括获取参数值和结果的各种情况、自定义映射resultMap、动态SQL
蓝染-惣右介
498 1
【详细实用のMyBatis教程】获取参数值和结果的各种情况、自定义映射、动态SQL、多级缓存、逆向工程、分页插件
蓝易云
|
10月前
|
缓存 Java 数据库连接
深入探讨：Spring与MyBatis中的连接池与缓存机制
Spring 与 MyBatis 提供了强大的连接池和缓存机制，通过合理配置和使用这些机制，可以显著提升应用的性能和可扩展性。连接池通过复用数据库连接减少了连接创建和销毁的开销，而 MyBatis 的一级缓存和二级缓存则通过缓存查询结果减少了数据库访问次数。在实际应用中，结合具体的业务需求和系统架构，优化连接池和缓存的配置，是提升系统性能的重要手段。
蓝易云
387 4
WangBai
|
10月前
|
缓存 Java 数据库连接
MyBatis缓存机制
MyBatis提供两级缓存机制：一级缓存（Local Cache）默认开启，作用范围为SqlSession，重复查询时直接从缓存读取；二级缓存（Second Level Cache）需手动开启，作用于Mapper级别，支持跨SqlSession共享数据，减少数据库访问，提升性能。
WangBai
162 1
刘大猫.
|
11月前
|
SQL 缓存 Java
MyBatis如何关闭一级缓存(分注解和xml两种方式)
MyBatis如何关闭一级缓存(分注解和xml两种方式)
刘大猫.
408 5

热门文章

最新文章

  • 1
    MyBatis分页
  • 2
    Mybatis基础使用知识（注解）
  • 3
    Redis专题-实战篇二-商户查询缓存
  • 4
    135_负载均衡：Redis缓存 - 提高缓存命中率的配置与最佳实践
  • 5
    Redis 7.0 高性能缓存架构设计与优化
  • 6
    Redis缓存和分布式锁
  • 7
    Linux系统清理缓存（buff/cache）的有效方法。
  • 8
    Ubuntu操作系统下清除系统缓存与无用文件的方法
  • 9
    Spring Boot配置优化：Tomcat+数据库+缓存+日志，全场景教程
  • 10
    一次缓存引发的文件系统数据不一致问题排查与深度解析
  • 1
    用好缓存，让你的接口速度飞起来
    378
  • 2
    利用Redis构建高性能的缓存系统
    204
  • 3
    高并发架构设计三大利器：缓存、限流和降级
    384
  • 4
    Spring Cache之本地缓存注解@Cacheable，@CachePut，@CacheEvict使用
    1047
  • 5
    停止AVPlayer并在缓存阶段立即播放其它视频闪退问题及解决方案
    184
  • 6
    【后端面经】【缓存】36｜Redis 单线程：为什么 Redis 用单线程而 Memcached 用多线程？-- Redis多线程
    132
  • 7
    http缓存机制
    193
  • 8
    WKWebView对网页和js，css，png等资源文件的缓存机制及如何刷新缓存
    892
  • 9
    【后端面经】【缓存】36｜Redis 单线程：为什么 Redis 用单线程而 Memcached 用多线程？-- Memcache + Redis 多线程
    194
  • 10
    清除ios的缓存
    99

    • 相关课程

    更多
  • MyBatis持久层框架入门

    • 相关电子书

    更多
  • 基于英特尔 SSD 的虚拟机缓存解决SSD
  • Java Spring Boot开发实战系列课程【第6讲】：Spring Boot 2.0实战MyBatis与优化(Java面试题)
  • 高性能Web架构之缓存体系

    • 相关实验场景

    更多
  • 通过云原生API网关进行AI缓存
    • 下一篇
    阿里云无影云电脑免费使用_免费申请教程