【数据篇】SpringBoot 整合 MyBatis 组合 Redis 作为数据源缓存

最新推荐文章于 2023-10-21 16:17:53 发布
最新推荐文章于 2023-10-21 16:17:53 发布
阅读量581 收藏 4
点赞数
文章标签： mybatis redis 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csp732171109/article/details/130243030
版权

写在最前

MyBatis 是常见的 Java 数据库访问层框架。在日常工作中，开发人员多数情况下是使用 MyBatis 的默认缓存配置，但是 MyBatis 缓存机制有一些不足之处，在使用中容易引起脏数据，形成一些潜在的隐患。

本文介绍的是 Redis 组合 MyBatis 作为数据源缓存。**并不是用 Redis 作为 Mybatis 的二级缓存类型！，也不是使用 Mybatis 一级缓存或二级缓存作为数据源缓存 **。

本文不再重复介绍 SpringBoot 如何整合 MyBatis。想学习 SpringBoot 整合 MyBatis 的同学可以参考下面文章，希望对您有所帮助：

【数据篇】SpringBoot 整合 MyBatis 操作 MySql

MyBatis 一级缓存与二级缓存

虽然本文不是使用 Mybatis 一级缓存或二级缓存作为数据源缓存，但还是要简单介绍一下 MyBatis 一级缓存与二级缓存，以及为什么不使用其一级缓存或二级缓存，而是推荐使用 Redis 组合 Mybatis 的可控制的缓存代替二级缓存！

推荐阅读文章：https://tech.meituan.com/2018/01/19/mybatis-cache.html，写的非常好！！！

一级缓存

在应用运行过程中，我们有可能在一次数据库会话中，执行多次查询条件完全相同的SQL，MyBatis 提供了一级缓存的方案优化这部分场景，如果是相同的 SQL 语句，会优先命中一级缓存，避免直接对数据库进行查询，提高性能。具体执行过程如下图所示。

image-20230418143921501

一级缓存小结：

  1. MyBatis 一级缓存的生命周期和 SqlSession 一致。
  2. MyBatis 一级缓存内部设计简单，只是一个没有容量限定的 HashMap，在缓存的功能性上有所欠缺。
  3. MyBatis 的一级缓存最大范围是 SqlSession 内部，有多个 SqlSession 或者分布式的环境下，数据库写操作会引起脏数据，建议设定缓存级别为 Statement。

二级缓存

在上文中提到的一级缓存中，其最大的共享范围就是一个 SqlSession 内部，如果多个 SqlSession 之间需要共享缓存，则需要使用到二级缓存。开启二级缓存后，会使用 CachingExecutor 装饰 Executor，进入一级缓存的查询流程前，先在CachingExecutor 进行二级缓存的查询，具体的工作流程如下所示。

image-20230419133936172

二级缓存开启后，同一个 namespace 下的所有操作语句，都影响着同一个 Cache，即二级缓存被多个 SqlSession 共享，是一个全局的变量。

当开启缓存后，数据的查询执行的流程就是 二级缓存 -> 一级缓存 -> 数据库。

二级缓存小结：

  1. MyBatis 的二级缓存相对于一级缓存来说，实现了SqlSession之间缓存数据的共享，同时粒度更加的细，能够到namespace级别，通过 Cache 接口实现类不同的组合，对 Cache 的可控性也更强。

  2. MyBatis 在多表查询时，极大可能会出现脏数据，有设计上的缺陷，安全使用二级缓存的条件比较苛刻。

  3. 在分布式环境下，由于默认的 MyBatis Cache 实现都是基于本地的，分布式环境下必然会出现读取到脏数据，需要使用集中式缓存将 MyBatis 的 Cache 接口实现，有一定的开发成本，直接使用 Redis、Memcached 等分布式缓存可能成本更低，安全性也更高。

SpringBoot MyBatis 整合 Redis Cache

本工程基于 mingyue-springboot-mybatis 改造

1. 增加 Redis 依赖

<!--redis-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2. 增加 Redis 修改配置

spring:
  redis:
    host: 127.0.0.1
    password: 123456
    port: 6379

3. 添加 Redis 配置类

import org.springframework.cache.CacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

/**
 * Redis 配置
 *
 * @author Strive
 * @date 2023/4/18 18:53
 */
@Configuration
public class RedisConfig {

    @Bean(name = "redisTemplate")
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
        RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>();

        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setKeySerializer(keySerializer());
        redisTemplate.setHashKeySerializer(keySerializer());
        redisTemplate.setValueSerializer(valueSerializer());
        redisTemplate.setHashValueSerializer(valueSerializer());
        return redisTemplate;
    }

    @Primary
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory){
        //缓存配置对象
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();

        redisCacheConfiguration = redisCacheConfiguration
                //设置缓存的默认超时时间：30分钟
                .entryTtl(Duration.ofMinutes(30L))
                //如果是空值，不缓存
                .disableCachingNullValues()
                //设置key序列化器
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(keySerializer()))
                //设置value序列化器
           .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer((valueSerializer())));

        return RedisCacheManager
                .builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
                .cacheDefaults(redisCacheConfiguration).build();
    }

    private RedisSerializer<String> keySerializer() {
        return new StringRedisSerializer();
    }

    private RedisSerializer<Object> valueSerializer() {
        return new GenericJackson2JsonRedisSerializer();
    }
}

4. 改造 queryUserById 方法

/**
   * 根据用户ID查询用户信息
   *
   * @param userId 用户ID
   * @return 用户信息
   */
  @Cacheable(cacheNames = "userInfo",key = "#userId")
  public MingYueUser queryUserById(Long userId) {
    return sysUserMapper.queryUserById(userId);
  }

5. 开启 @EnableCaching 注解

@SpringBootApplication
@EnableCaching
public class MingYueSpringbootMybatisRedisCacheApplication {
  public static void main(String[] args) {
    SpringApplication.run(MingYueSpringbootMybatisRedisCacheApplication.class, args);
  }
}

6. 启动项目，测试接口

1.调用接口 http://127.0.0.1:8080/user/1，可以看到控制台有如下打印：

JDBC Connection [HikariProxyConnection@1552674017 wrapping com.mysql.cj.jdbc.ConnectionImpl@315ae5d4] will not be managed by Spring
==>  Preparing: select * from sys_user where user_id = ?
==> Parameters: 1(Long)
<==    Columns: user_id, username
<==        Row: 1, mingyue
<==      Total: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@71d19455]

2.再次调用 http://127.0.0.1:8080/user/1，控制台无打印，查看 Redis 数据库

image-20230418194912359

Redis Cache 增删改

1. 增加用户

编写添加用户方法

@CachePut(cacheNames = "mybatis_cache_userInfo", key = "#user.userId")
public MingYueUser addUser(MingYueUser user) {
    boolean flag = sysUserMapper.addUser(user);

  	return flag ? user : null;
}

执行添加接口

curl --location --request POST 'http://127.0.0.1:8080/user' \
--header 'User-Agent: Apifox/1.0.0 (https://www.apifox.cn)' \
--header 'Content-Type: application/json' \
--header 'Accept: */*' \
--header 'Host: 127.0.0.1:8080' \
--header 'Connection: keep-alive' \
--data-raw '{"userId":5,"username":"Strive5"}'

控制台打印如下：

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@149aa2d7] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@509790631 wrapping com.mysql.cj.jdbc.ConnectionImpl@41af2f20] will not be managed by Spring
==>  Preparing: insert sys_user(user_id,username) values(?,?)
==> Parameters: 4(Long), Strive4(String)
<==    Updates: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@149aa2d7]

查看缓存

image-20230418202244458

2. 修改用户

编写修改用户方法

@CachePut(cacheNames = "mybatis_cache_userInfo", key = "#user.userId")
public MingYueUser updateUser(MingYueUser user) {
    boolean flag = sysUserMapper.updateUser(user);
    System.out.println(JSONUtil.toJsonStr(user));

    return flag ? user : null;
}

执行修改接口

curl --location --request PUT 'http://127.0.0.1:8080/user' \
--header 'User-Agent: Apifox/1.0.0 (https://www.apifox.cn)' \
--header 'Content-Type: application/json' \
--header 'Accept: */*' \
--header 'Host: 127.0.0.1:8080' \
--header 'Connection: keep-alive' \
--data-raw '{"userId":2,"username":"Strive Update 2023 33"}'

控制台打印如下：

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@6751deb0] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@1839838656 wrapping com.mysql.cj.jdbc.ConnectionImpl@c16c966] will not be managed by Spring
==>  Preparing: update sys_user set username = ? where user_id = ?
==> Parameters: Strive Update 2023 33(String), 2(Long)
<==    Updates: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@6751deb0]

查看缓存，多次请求并刷新缓存查看是否更新缓存数据

image-20230419100235746

3. 删除用户

编写删除用户方法

@CacheEvict(cacheNames = "mybatis_cache_userInfo", key = "#userId")
public boolean delUser(Long userId) {
    return sysUserMapper.delUser(userId);
}

执行用户接口

curl --location --request DELETE 'http://127.0.0.1:8080/user/2' \
--header 'User-Agent: Apifox/1.0.0 (https://www.apifox.cn)' \
--header 'Accept: */*' \
--header 'Host: 127.0.0.1:8080' \
--header 'Connection: keep-alive'

控制台打印如下：

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@94198eb] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@62518171 wrapping com.mysql.cj.jdbc.ConnectionImpl@73034169] will not be managed by Spring
==>  Preparing: delete from sys_user where user_id = ?
==> Parameters: 2(Long)
<==    Updates: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@94198eb]

查看缓存对应数据是否已经删除了

4. 删除所有用户

主要就是 @CacheEvict(allEntries = true) 注解

@CacheEvict(cacheNames = "mybatis_cache_userInfo", allEntries = true)
public void delAllUser(Long userId) {
  // TODO sysUserMapper.delAllUser;
}

5. 最佳实践

上面已经介绍了缓存的增删改查如何实现，但这不是最佳实践！推荐使用下面的缓存用法！！！

  • 添加用户是不需要放入缓存的，放入缓存的数据一般是查询能用到的，添加的用户可能也不会查询，直接放入缓存只会占用缓存空间；
  • 更新用户也是一样，更新的数据也有可能不会查询。推荐直接删除对应缓存，查询重新放入即可；
/**
 * 用户缓存增删改查 （推荐）
 * @author Strive 
 */
@Service
@RequiredArgsConstructor
public class MingYueUserNewService {

  private final SysUserMapper sysUserMapper;

  /**
   * 根据用户ID查询用户信息
   *
   * @param userId 用户ID
   * @return 用户信息
   */
  @Cacheable(cacheNames = "mybatis_cache_userInfo",key = "#userId")
  public MingYueUser queryUserById(Long userId) {
    return sysUserMapper.queryUserById(userId);
  }

  /**
   * 添加用户信息
   */
  public boolean addUser(MingYueUser user) {
    return sysUserMapper.addUser(user);
  }

  /**
   * 修改用户信息
   */
  @CacheEvict(cacheNames = "mybatis_cache_userInfo", key = "#userId")
  public boolean updateUser(MingYueUser user) {
    return sysUserMapper.updateUser(user);
  }

  /**
   * 删除用户信息
   * @param userId 用户ID
   */
  @CacheEvict(cacheNames = "mybatis_cache_userInfo", key = "#userId")
  public boolean delUser(Long userId) {
    return sysUserMapper.delUser(userId);
  }

}

总结

在无法保证数据不出现脏读的情况下，建议在业务层使用可控制的缓存代替二级缓存！

Strive_MY
关注
springboot如何吧mysql数据存到缓存区redis里？@Cacheable讲解
zhhhhhh1213的博客
01-06 511
主函数写开区缓冲的注解@EnableCaching 不写没用！ @SpringBootApplication //开启缓存 @EnableCaching public class SpringbootHospital2019Application { public static void main(String[] args) { SpringApplication.run(SpringbootHospital2019Application.class, args); }
我用SpringBoot 整合 MyBatis 组合 Redis 作为数据源缓存
wdj_yyds的博客
05-28 233
在无法保证数据不出现脏读的情况下，建议在业务层使用可控制的缓存代替二级缓存！
SpringBoot 整合MyBatis 使用Radis做缓存
心猿意码
05-11 965
项目目录结构 代码地址： GitHub: SpringBootRedisCache POM <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-i...
springboot中将redis作为mysql缓存层
a219219219219的博客
10-25 444
Property文件配置 # redis缓存管理配置 #设置缓存类型位redis spring.cache.type=redis #配置缓存名称 spring.cache.cache-names=redisCache #是否允许redis缓存空值 spring.cache.redis.cache-null-values=true #redis的键前缀 spring.cache.redis.key.prefix= #缓存超时时间戳，配置为0则不设置超时时间 spring.cache.r
springboot+mybatis整合redis缓存（亲测有效）
weixin_46178852的博客
03-24 1567
springboot+mybatis整合redis缓存（亲测有效） Springboot + mybatis整合redis实现缓存，主要是redis为了提升访问速度，一般会将经常查询且不会经常发生改变的数据存入缓存，然后从缓存中查询数据，提升查询速度。并且采用Mybatis作为我们的ORM框架。为了提升性能，我们将Redis作为Mybatis的二级缓存。 ORM框架： ORM（Object Relational Mapping）框架采用元数据来描述对象与关系映射的细节，元数据一般采用XML格式，并且存放在专
怎样将mysql中的数据导入redis
web15286201346的博客
08-29 2375
Redis其实就是内存数据库，而其中最常用的就是hash结构，key-value，查询时需要使用到key，所以key的设计决定了查询的效率，第一行的 *10 : *表示数组，10表示数组元素个数*（可以看下面的SQL查询语句标红的字段有10个，所以为10）， 是规定分隔符。通过将要导入的命令转换为Resp格式，然后通过MySQL的concat()来整理出最终导入的命令集合，以达到快速导入的目的。1. 根据需求设计好Redis的hash结构，关键是Key的设计。还是规定字符串(window的redis是 ).
SpringBoot + Mybatis + Redis 整合
06-27
对于Mybatis的配置，我们需要创建一个`mybatis-config.xml`文件，定义数据源和Mapper扫描路径。同时，在SpringBoot的主配置类上使用`@MapperScan`注解扫描Mapper接口。 为了在应用中使用Redis，我们可以创建一个...
springboot+mybatis+redis+thymeleaf学习整合web项目demo源码
10-30
它预设了许多默认配置，如数据源、服务器端点、日志等，使得开发者可以快速启动项目，而无需过多关注基础设置。在本项目中，Spring Boot作为核心框架，负责整个应用的生命周期管理和依赖注入。 **MyBatis** MyBatis...
SpringBoot整合MyBatis和Redis
weixin_47541976的博客
09-07 667
SpringBoot整合Mybatis和Redis
springboot-mybatis-redis
05-01
【标题】"springboot-mybatis-redis"是一个项目名称，暗示了这个项目是关于整合Spring Boot、MyBatis和Redis的。Spring Boot是Spring框架的一个轻量级版本，旨在简化新Spring应用的初始搭建以及开发过程。MyBatis是...
SpringBoot+Mybatis整合redis
张先森
08-12 994
SpringBoot&MyBatis整合Redis
springboot缓存篇之mybatis一级缓存和二级缓存
最新发布
gzmyh的博客
10-21 1453
相信很多人都用过mybatis，这篇文章主要是介绍mybatis的缓存，了解一下mybatis缓存是如何实现，以及它在实际中的应用。
Spring Boot整合Redis实现缓存(实战详细)
weixin_38568503的博客
08-02 6109
springboot整合redis实现缓存
SpringBoot+Mybatis+Redis缓存实战总结
FlyingFish868的博客
01-03 2003
Redis 是一个高性能的key-value内存数据库。它支持常用的5种数据结构：String字符串、Hash哈希表、List列表、Set集合、Zset有序集合 等数据类型。 Redis它解决了2个问题： 1）性能 通常数据库的读操作，一般都要几十毫秒，而redisd的读操作一般仅需不到1毫秒。通常只要把数据库的数据缓存进redis，就能得到几十倍甚至上百倍的性能提升。 2）并发 在大并发的情况下，所有的请求直接访问数据库，数据库会出现连接异常，甚至卡死在数据库中。
springboot整合mybatis，mysql做数据库存储，redis做缓存
热门推荐
wanderlustLee的博客
02-26 1万+
redis应用的场景 通过缓存来减少对关系型数据库的查询次数，减轻数据库压力。在执行DAO类的select***(), query***()方法时，先从Redis中查询有没有缓存数据，如果有则直接从Redis拿到结果，如果没有再向数据库发起查询请求取数据。   springboot已经集成了redis缓存，只需要在pom.xml中加载redis，然后通过注解即可完成配置。 首先在配置类...
mybatis的延迟加载，一级缓存，二级缓存
u012102536的博客
07-25 1134
MyBatis 延迟加载，一级缓存，二级缓存设置 什么是延迟加载          resultMap中的association和collection标签具有延迟加载的功能。         延迟加载的意思是说，在关联查询时，利用延迟加载，先加载主信息。使用关联信息时再去加载关联信息。 设置延迟加载         需要在SqlMapConfig.
mybatis整合 SpringBoot（缓存机制）
坚持就是胜利的博客
01-16 2356
有了mybatis公司给我们整合的工具类那么我们就不用像以前还得去配置数据源 我们在这里只需引入依赖即可： 我们首先先创建一个简单的数据库 create database springbootmapper； CREATE TABLE `user` ( `id` int(16) unsigned NOT NULL AUTO_INCREMENT, `name` varchar(16) NOT...
SpringBoot 下 mybatis 的缓存
mengsofts的专栏
03-02 3652
背景： 说起 mybatis，作为 Java 程序员应该是无人不知，它是常用的数据库访问框架。与 Spring 和 Struts 组成了 Java Web 开发的三剑客--- SSM。当然随着 Spring Boot 的发展，现在越来越多的企业采用的是 SpringBoot + mybatis 的模式开发，我们公司也不例外。而 mybatis 对于我也仅仅停留在会用而已，没想过怎么去了解它，更不...
SpringBoot整合MyBatis注解版并开启二级缓存
小小默：进无止境
06-26 1万+
【1】pom文件添加依赖 依赖如下所示： &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;dependency&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;groupId&amp;amp;amp;amp;amp;amp;amp;amp;a
SpringBoot整合Mybatis和Redis原理
04-28
SpringBoot整合Mybatis和Redis的原理主要包括以下几个方面： 1. SpringBoot整合Mybatis：SpringBoot提供了Mybatis的自动配置功能，只需要在pom.xml中引入相关的依赖，配置好数据源，就可以使用Mybatis进行数据库操作。 2. SpringBoot整合Redis：SpringBoot提供了对Redis的支持，只需要在pom.xml中引入相关的依赖，配置好Redis的连接信息，就可以使用Redis进行缓存操作。 3. 整合过程：在整合过程中，需要将Mybatis的查询结果进行序列化，存入Redis缓存中，同时在查询数据时，先从Redis缓存中获取数据，如果获取不到再从数据库中获取数据，并将结果存入Redis缓存中。 具体实现可以参考以下步骤： 1. 配置数据源和Mybatis：在application.properties文件中配置数据源和Mybatis相关信息，例如： ``` spring.datasource.url=jdbc:mysql://localhost:3306/test?useSSL=false spring.datasource.username=root spring.datasource.password=123456 mybatis.mapper-locations=classpath:mapper/*.xml ``` 2. 配置Redis：在application.properties文件中配置Redis相关信息，例如： ``` spring.redis.host=localhost spring.redis.port=6379 spring.redis.password= spring.redis.database=0 ``` 3. 配置RedisTemplate：使用RedisTemplate进行Redis操作，可以在配置类中进行配置，例如： ``` @Configuration public class RedisConfig { @Autowired private RedisConnectionFactory redisConnectionFactory; @Bean public RedisTemplate<String, Object> redisTemplate() { RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>(); redisTemplate.setConnectionFactory(redisConnectionFactory); redisTemplate.setKeySerializer(new StringRedisSerializer()); redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer()); return redisTemplate; } } ``` 4. 编写缓存操作代码：在查询数据时，先从Redis缓存中获取数据，如果获取不到再从数据库中获取数据，并将结果存入Redis缓存中，例如： ``` @Service public class UserServiceImpl implements UserService { private static final String REDIS_KEY_PREFIX = "user:"; @Autowired private UserMapper userMapper; @Autowired private RedisTemplate<String, Object> redisTemplate; @Override public User getUserById(Integer id) { String key = REDIS_KEY_PREFIX + id; User user = (User) redisTemplate.opsForValue().get(key); if (user == null) { user = userMapper.getUserById(id); if (user != null) { redisTemplate.opsForValue().set(key, user); } } return user; } } ``` 以上就是SpringBoot整合Mybatis和Redis的原理及实现步骤。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Strive_MY

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值