首页手记 Mybatis二级缓存项目实战：从入门到简单应用

Mybatis二级缓存项目实战：从入门到简单应用

标签：

SSM

概述

本文将详细介绍Mybatis二级缓存的配置与使用，通过实例演示如何在项目中启用和优化二级缓存。文章将详细探讨二级缓存的工作原理、配置步骤以及在实际项目中的应用场景，并提供解决二级缓存常见问题的优化建议。通过这些内容，你将能够提高系统的性能和效率。

Mybatis缓存机制入门

Mybatis一级缓存简介

Mybatis一级缓存是会话级别的缓存，与数据库会话相关。每当创建一个新的SqlSession对象时，都会创建一个新的一级缓存实例。一级缓存是内置的，无需配置即可开启。

一级缓存的作用

减少数据库访问次数，提高程序执行效率。
在同一个SqlSession中，执行相同的SQL语句，只会执行一次查询，后续的相同查询都会从缓存中直接获取结果。

一级缓存的工作原理

执行查询操作时，Mybatis会检查缓存中是否有对应的记录，如果有，则直接从缓存中读取数据，不再执行数据库查询。
执行INSERT、UPDATE或DELETE操作时，Mybatis会将这些操作产生的新数据刷新到缓存中，并清空缓存中对应的数据。

一级缓存的生命周期

一级缓存的生命周期与SqlSession的生命周期一致。当SqlSession执行commit操作或关闭时，一级缓存会失效。

一级缓存的清除

执行commit操作或关闭SqlSession时，一级缓存会被清空。
可以通过SqlSession的clearCache()方法手动清除一级缓存。

以下是一个简单的例子，展示了如何使用SqlSession来操作数据库，一级缓存会在执行查询时使用。

// 创建SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 查询操作
List<User> users = sqlSession.selectList("com.example.mapper.UserMapper.selectAllUsers");
// 一级缓存会保存查询结果，下次查询时直接从缓存中获取
List<User> usersAgain = sqlSession.selectList("com.example.mapper.UserMapper.selectAllUsers");
// 执行更新操作，更新结果会刷新到缓存中
sqlSession.update("com.example.mapper.UserMapper.updateUser", user);
sqlSession.commit();

Mybatis二级缓存简介

Mybatis二级缓存是基于Mapper级别的缓存，同一个Mapper的所有SqlSession可以使用相同的二级缓存。二级缓存是全局性的，对于所有SqlSession都有效，但需要手动开启。

二级缓存的作用

减少数据库访问次数，提高程序执行效率。
当多个SqlSession查询相同的数据时，可以通过二级缓存共享数据，减少数据库的查询次数。

二级缓存的工作原理

执行查询操作时，Mybatis会检查二级缓存中是否有对应的记录，如果有，则直接从缓存中读取数据，不再执行数据库查询。
执行INSERT、UPDATE或DELETE操作时，Mybatis会将这些操作产生的新数据刷新到缓存中，并清空缓存中对应的数据。

二级缓存的生命周期

二级缓存的生命周期与整个应用的生命周期一致。通常在应用关闭时才会清空二级缓存。

二级缓存的清除

二级缓存的清除可以通过SqlSession的clearCache()方法或Mapper的flushCache()方法手动清除。
当执行flushCache()方法时，会将所有对应的二级缓存清除。

以下是一个简单的例子，展示了如何开启和使用二级缓存。

<!-- 开启二级缓存 -->
<cache />

// 创建SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 查询操作
List<User> users = sqlSession.selectList("com.example.mapper.UserMapper.selectAllUsers");
// 二级缓存会保存查询结果，下次查询时直接从缓存中获取
SqlSession sqlSessionAgain = sqlSessionFactory.openSession();
List<User> usersAgain = sqlSessionAgain.selectList("com.example.mapper.UserMapper.selectAllUsers");
// 执行更新操作，更新结果会刷新到缓存中
sqlSession.update("com.example.mapper.UserMapper.updateUser", user);
sqlSession.commit();

一级缓存与二级缓存的区别

范围：一级缓存是会话级别的缓存，二级缓存是Mapper级别的缓存。
默认状态：一级缓存默认开启，二级缓存默认关闭。
生命周期：一级缓存的生命周期与SqlSession的生命周期一致，二级缓存的生命周期与整个应用的生命周期一致。
清除时机：
- 一级缓存会在执行commit或关闭SqlSession时清除。
- 二级缓存需要手动清除，通常在执行flushCache操作时清除。
适用场景：
- 一级缓存在单个SqlSession中重复查询相同的数据时非常有用。
- 二级缓存在多个SqlSession中重复查询相同的数据时非常有用。

Mybatis二级缓存的配置步骤

二级缓存启用配置

Mybatis的二级缓存默认是关闭的，需要手动开启。在Mybatis配置文件mybatis-config.xml中，可以通过添加<cache>标签来开启二级缓存。

<configuration>
  <!-- 其他配置项 -->
  <cache />
  <!-- 其他配置项 -->
</configuration>

在Mapper XML文件中，也可以通过添加<cache>标签来开启二级缓存。

<mapper namespace="com.example.mapper.UserMapper">
  <cache />
  <!-- SQL映射语句 -->
</mapper>

配置全局缓存工厂

Mybatis支持使用自定义的缓存工厂来管理二级缓存。可以通过配置<cache-ref>标签来引用其他Mapper的缓存。

<configuration>
  <!-- 其他配置项 -->
  <cache-ref namespace="com.example.mapper.OtherMapper" />
  <!-- 其他配置项 -->
</configuration>

也可以在Mapper XML文件中使用<cache-ref>标签来引用其他Mapper的缓存。

<mapper namespace="com.example.mapper.UserMapper">
  <cache-ref namespace="com.example.mapper.OtherMapper" />
  <!-- SQL映射语句 -->
</mapper>

配置Mapper XML文件中的缓存

在Mapper XML文件中，可以通过配置<cache>标签来设置二级缓存的属性。

<mapper namespace="com.example.mapper.UserMapper">
  <cache
    eviction="FIFO"           <!-- 驱逐策略 -->
    flushInterval="60000"     <!-- 刷新间隔 -->
    size="512"                <!-- 缓存大小 -->
    readOnly="true"           <!-- 只读缓存 -->
  />
  <!-- SQL映射语句 -->
</mapper>

配置项说明：

eviction：设置缓存的驱逐策略，可选值为FIFO（先进先出）、LRU（最近最少使用）、SOFT（软引用）、WEAK（弱引用）。
flushInterval：设置缓存刷新间隔，单位为毫秒。
size：设置缓存大小，即缓存可以存储的最大对象数量。
readOnly：设置缓存是否为只读，如果为true，则缓存中的对象不能被修改。

Mybatis二级缓存的使用场景

常见使用场景介绍

二级缓存适用于以下场景：

当多个SqlSession查询相同的数据时，可以通过二级缓存共享数据。
在频繁读取相同数据的场景下，可以减少数据库的查询次数，提高程序执行效率。
当数据更新频率较低且读取频率较高时，二级缓存可以显著提高性能。

示例场景

假设有一个用户管理系统，用户信息表中有大量用户数据。在系统中，每个用户的信息会被多次查询，例如，查看用户信息、更新用户信息等。在这种情况下，开启二级缓存可以显著提高系统的性能，减少数据库的访问次数。

示例代码

// 开启二级缓存
<cache />
// 创建SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 查询用户信息
List<User> users = sqlSession.selectList("com.example.mapper.UserMapper.selectAllUsers");
// 更新用户信息
User user = new User();
user.setId(1);
user.setName("NewName");
sqlSession.update("com.example.mapper.UserMapper.updateUser", user);
sqlSession.commit();

二级缓存带来的性能提升

当多个SqlSession查询相同的数据时，可以通过二级缓存共享数据，减少数据库的查询次数。
二级缓存可以缓存查询结果，避免每次查询都访问数据库。

注意事项与限制

并发访问问题：如果多个线程同时访问同一个缓存，可能会导致数据不一致的问题。
数据更新问题：当数据更新时，需要确保缓存中的数据也被更新，否则可能会导致数据不一致的问题。
缓存大小：需要合理设置缓存的大小，避免缓存占用过多的内存资源。
缓存刷新策略：需要根据实际需求选择合适的缓存刷新策略，以确保缓存中的数据是最新的。
数据一致性：如果需要确保数据的一致性，可能需要额外的机制来处理缓存中的数据。

Mybatis二级缓存的实战案例

实战项目搭建

为了演示二级缓存的实际应用，我们搭建一个简单的用户管理系统。该系统包括以下部分：

User实体类：表示用户信息。
UserMapper接口：定义了对用户信息的操作方法。
UserMapper.xml：定义了对用户信息的SQL映射语句。
UserService：业务逻辑层，提供用户管理的业务逻辑。
UserDao：数据访问层，负责与数据库交互。

示例代码

// User实体类
public class User {
    private int id;
    private String name;
    private String email;
    // Getter和Setter方法
}

// UserMapper接口
public interface UserMapper {
    List<User> selectAllUsers();
    User getUserById(int id);
    void insertUser(User user);
    void updateUser(User user);
    void deleteUser(int id);
}

// UserMapper.xml
<mapper namespace="com.example.mapper.UserMapper">
  <cache />
  <!-- SQL映射语句 -->
  <select id="selectAllUsers" resultType="com.example.entity.User">
    SELECT * FROM users
  </select>
  <select id="getUserById" resultType="com.example.entity.User">
    SELECT * FROM users WHERE id = #{id}
  </select>
  <insert id="insertUser" parameterType="com.example.entity.User">
    INSERT INTO users(name, email) VALUES(#{name}, #{email})
  </insert>
  <update id="updateUser" parameterType="com.example.entity.User">
    UPDATE users SET name=#{name}, email=#{email} WHERE id=#{id}
  </update>
  <delete id="deleteUser" parameterType="int">
    DELETE FROM users WHERE id=#{id}
  </delete>
</mapper>

// UserService业务逻辑层
public class UserService {
    private UserMapper userMapper;

    public UserService(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    public List<User> getAllUsers() {
        return userMapper.selectAllUsers();
    }

    public User getUserById(int id) {
        return userMapper.getUserById(id);
    }

    public void insertUser(User user) {
        userMapper.insertUser(user);
    }

    public void updateUser(User user) {
        userMapper.updateUser(user);
    }

    public void deleteUser(int id) {
        userMapper.deleteUser(id);
    }
}

// UserDao数据访问层
public class UserDao {
    private SqlSessionFactory sqlSessionFactory;

    public UserDao(SqlSessionFactory sqlSessionFactory) {
        this.sqlSessionFactory = sqlSessionFactory;
    }

    public UserMapper getUserMapper() {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        return sqlSession.getMapper(UserMapper.class);
    }
}

二级缓存配置实例

在UserMapper.xml文件中，我们已经开启了二级缓存。接下来，我们配置缓存的具体属性。

<mapper namespace="com.example.mapper.UserMapper">
  <cache
    eviction="FIFO"
    flushInterval="60000"
    size="512"
    readOnly="true"
  />
  <!-- SQL映射语句 -->
  <select id="selectAllUsers" resultType="com.example.entity.User">
    SELECT * FROM users
  </select>
  <select id="getUserById" resultType="com.example.entity.User">
    SELECT * FROM users WHERE id = #{id}
  </select>
  <insert id="insertUser" parameterType="com.example.entity.User">
    INSERT INTO users(name, email) VALUES(#{name}, #{email})
  </insert>
  <update id="updateUser" parameterType="com.example.entity.User">
    UPDATE users SET name=#{name}, email=#{email} WHERE id=#{id}
  </update>
  <delete id="deleteUser" parameterType="int">
    DELETE FROM users WHERE id=#{id}
  </delete>
</mapper>

测试缓存功能的有效性

我们可以通过编写测试用例来验证二级缓存功能的有效性。

测试用例

public class CacheTest {
    private UserService userService;

    @Before
    public void setUp() {
        SqlSessionFactory sqlSessionFactory = // 初始化SqlSessionFactory
        UserDao userDao = new UserDao(sqlSessionFactory);
        UserMapper userMapper = userDao.getUserMapper();
        userService = new UserService(userMapper);
    }

    @Test
    public void testCache() {
        List<User> users = userService.getAllUsers();
        System.out.println("第一次查询结果：" + users);

        // 模拟用户信息更新
        User user = userService.getUserById(1);
        user.setName("NewName");
        userService.updateUser(user);

        // 再次查询用户信息，验证缓存是否有效
        List<User> usersAgain = userService.getAllUsers();
        System.out.println("第二次查询结果：" + usersAgain);
    }
}

在测试用例中，我们首先查询所有用户信息，并打印结果。然后，我们更新一个用户的信息，并再次查询用户信息，验证缓存是否有效。如果缓存有效，第二次查询的结果应该与第一次查询的结果一致。

Mybatis二级缓存的优化技巧

调整缓存时间

可以通过设置flushInterval属性来调整缓存刷新的时间间隔。例如，设置为60秒：

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

当设置flushInterval时，缓存会在指定的时间间隔后自动刷新，清除所有缓存的数据。

示例代码

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

选择合适的数据结构

缓存的数据结构选择也非常关键。Mybatis支持以下几种数据结构：

FIFO：先进先出，适用于内存资源有限的场景。
LRU：最近最少使用，适用于频繁访问的数据。
SOFT：软引用，适用于需要回收时能被回收的场景。
WEAK：弱引用，适用于不需要持久化的数据。

示例代码

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

优化并发访问

在多线程环境下，需要确保缓存的并发访问安全。可以通过以下方法优化并发访问：

线程安全的缓存实现：使用线程安全的缓存实现，例如ConcurrentHashMap。
锁机制：在对缓存进行读写操作时，使用锁机制确保线程安全。

示例代码

public class SafeCache {
    private ConcurrentHashMap<String, Object> cache = new ConcurrentHashMap<>();

    public Object get(String key) {
        return cache.get(key);
    }

    public void put(String key, Object value) {
        cache.put(key, value);
    }

    public void remove(String key) {
        cache.remove(key);
    }
}

Mybatis二级缓存常见问题与解决方案

常见问题汇总

缓存失效：当缓存中的数据与数据库中的数据不一致时。
缓存击穿：高并发情况下，缓存中没有数据，直接访问数据库导致压力过大。
缓存雪崩：大量缓存同时失效，导致大量请求直接访问数据库。
缓存穿透：缓存中没有数据，直接访问数据库，导致缓存无效。
缓存一致性：多个地方写入缓存，导致数据不一致。
缓存更新策略：更新缓存时，需要确保缓存中的数据是最新的。

常见问题的解决方案

缓存失效：可以通过设置合理的flushInterval和size来减少缓存失效的频率。
缓存击穿：可以通过设置缓存的超时时间，或者使用布隆过滤器等技术来避免缓存击穿。
缓存雪崩：可以通过设置缓存的超时时间，或者使用分段缓存等技术来避免缓存雪崩。
缓存穿透：可以通过设置缓存的超时时间，或者使用布隆过滤器等技术来避免缓存穿透。
缓存一致性：可以通过设置合理的缓存更新策略，或者使用分布式缓存等技术来确保缓存一致性。
缓存更新策略：可以通过设置合理的缓存刷新策略，或者使用分布式缓存等技术来确保缓存中的数据是最新的。

解决方案的实践案例

示例代码

假设我们有一个用户信息管理系统，需要确保用户信息的缓存一致性。


public class UserService {
    private UserMapper userMapper;

    public UserService(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    public List<User> getAllUsers() {
        return userMapper.selectAllUsers();
    }

    public User getUserById(int id) {
        return userMapper.getUserById(id);
    }

    public void insertUser(User user) {
        userMapper.insertUser(user);
        // 更新缓存
        Cache cache = userMapper.getCache();
        cache.put("user:" + user.getId(), user);
    }

    public void updateUser(User user) {
        userMapper.updateUser(user);
        // 更新缓存
        Cache cache = userMapper.getCache();
        cache.put("user:" + user.getId(), user);
    }

    public void deleteUser(int id) {
        userMapper.deleteUser(id);
        // 删除缓存
        Cache cache = userMapper.getCache();
        cache.remove("user:" + id);
    }
}
``

在上述代码中，我们在插入、更新和删除用户信息时，都会更新缓存，确保缓存中的数据是最新的。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

慕沐林林

手记
篇

粉丝

29

获赞与收藏

116

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 30809 345

网络编程入门教程

20个小节 12721 239

Pandas 入门教程

25个小节 18600 342

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

Mybatis二级缓存项目实战：从入门到简单应用

一级缓存的作用

一级缓存的工作原理

一级缓存的生命周期

一级缓存的清除

二级缓存的作用

二级缓存的工作原理

二级缓存的生命周期

二级缓存的清除

示例场景

示例代码

示例代码

测试用例

示例代码

示例代码

示例代码

示例代码

阅读免费教程