• springboot-mybatisplus-redis二级缓存

    前言

    mybatis可以自己带有二级缓存的实现，这里加上redis是想把东西缓存到redis中，而不是mybaits自带的map中。这也就构成了我们看到的springboot + mybatisplus +redis实现二级缓存的题目。

    具体步骤如下：

    首先加入需要的依赖

    1.  <dependency>
    2.     <groupId>org.springframework.boot</groupId>
    3.     <artifactId>spring-boot-starter-data-redis</artifactId>
    4.  </dependency>
    5.  
    6. <dependency>
    7.     <groupId>org.springframework.boot</groupId>
    8.     <artifactId>spring-boot-starter-cache</artifactId>
    9. </dependency>
    10. <dependency>
    11.     <groupId>org.projectlombok</groupId>
    12.     <artifactId>lombok</artifactId>
    13. </dependency>

    第二步：在application.properties或者yml中配置redis属性和设置开启二级缓存(默认是关闭的)

    1. spring.cache.type=redis
    2. spring.redis.host=192.168.9.82
    3. spring.redis.jedis.pool.max-active=10
    4. spring.redis.jedis.pool.max-idle=10
    5. spring.redis.jedis.pool.max-wait=3000
    6. spring.redis.jedis.pool.min-idle=20
    7. spring.redis.port=6379
    8. spring.redis.timeout=3000
    9.  
    10. mybatis-plus.configuration.cache-enabled=true  #开启二级缓存

    第三步：编写redis缓存的配置类，大体需要如下三个类，先截图在上代码

     ApplicationContextHolder.java类主要用于在另外另个类中可以通过context获取spring容器中注入的redisTemplate来操作redis。代码如下：

    1.  
    2. import org.springframework.context.ApplicationContext;
    3.  
    4. //@Component
    5. public class ApplicationContextHolder {
    6.  
    7.     private static ApplicationContext applicationContext = null;
    8.  
    9.     public static void setApplicationContext(ApplicationContext applicationContext) {
    10.         ApplicationContextHolder.applicationContext = applicationContext;
    11.     }
    12.  
    13.     public static ApplicationContext getApplicationContext() {
    14.         return applicationContext;
    15.     }
    16.  
    17.     public static  T getBean(String name) {
    18.         return (T)applicationContext.getBean(name);
    19.     }
    20.  
    21.     public static  T getBean(Class clz) {
    22.         return (T)applicationContext.getBean(clz);
    23.     }
    24.  
    25. }

    MybatisRedisCache.java类实现了Mybatis的Cache接口，这样才能在执行数据库操作前调用缓存。代码如下：

    1. import org.apache.ibatis.cache.Cache;
    2. import org.springframework.data.redis.core.RedisCallback;
    3. import org.springframework.data.redis.core.RedisTemplate;
    4. import org.springframework.data.redis.core.ValueOperations;
    5.  
    6. import java.util.concurrent.TimeUnit;
    7. import java.util.concurrent.locks.ReadWriteLock;
    8. import java.util.concurrent.locks.ReentrantReadWriteLock;
    9.  
    10. public class MybatisRedisCache implements Cache {
    11.     private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    12.     private final String id; // cache instance id
    13.     private RedisTemplate redisTemplate;
    14.  
    15.     private static final long EXPIRE_TIME_IN_MINUTES = 30; // redis过期时间
    16.  
    17.     public MybatisRedisCache(String id) {
    18.         if (id == null) {
    19.             throw new IllegalArgumentException("Cache instances require an ID");
    20.         }
    21.         this.id = id;
    22.     }
    23.  
    24.     @Override
    25.     public String getId() {
    26.         return id;
    27.     }
    28.  
    29.     /**
    30.      * Put query result to redis
    31.      *
    32.      * @param key
    33.      * @param value
    34.      */
    35.     @Override
    36.     @SuppressWarnings("unchecked")
    37.     public void putObject(Object key, Object value) {
    38.         try {
    39.             RedisTemplate redisTemplate = getRedisTemplate();
    40.             ValueOperations opsForValue = redisTemplate.opsForValue();
    41.             opsForValue.set(key, value, EXPIRE_TIME_IN_MINUTES, TimeUnit.MINUTES);
    42.         }
    43.         catch (Throwable t) {
    44.             t.printStackTrace();
    45.         }
    46.     }
    47.  
    48.     /**
    49.      * Get cached query result from redis
    50.      *
    51.      * @param key
    52.      * @return
    53.      */
    54.     @Override
    55.     public Object getObject(Object key) {
    56.         try {
    57.             RedisTemplate redisTemplate = getRedisTemplate();
    58.             ValueOperations opsForValue = redisTemplate.opsForValue();
    59.             return opsForValue.get(key);
    60.         }
    61.         catch (Throwable t) {
    62.  
    63.             return null;
    64.         }
    65.     }
    66.  
    67.     /**
    68.      * Remove cached query result from redis
    69.      *
    70.      * @param key
    71.      * @return
    72.      */
    73.     @Override
    74.     @SuppressWarnings("unchecked")
    75.     public Object removeObject(Object key) {
    76.         try {
    77.             RedisTemplate redisTemplate = getRedisTemplate();
    78.             redisTemplate.delete(key);
    79.         }
    80.         catch (Throwable t) {
    81.             t.getMessage();
    82.         }
    83.         return null;
    84.     }
    85.  
    86.     /**
    87.      * Clears this cache instance
    88.      */
    89.     @Override
    90.     public void clear() {
    91.         RedisTemplate redisTemplate = getRedisTemplate();
    92.         redisTemplate.execute((RedisCallback) connection -> {
    93.             connection.flushDb();
    94.             return null;
    95.         });
    96.     }
    97.  
    98.     /**
    99.      * This method is not used
    100.      *
    101.      * @return
    102.      */
    103.     @Override
    104.     public int getSize() {
    105.         return 0;
    106.     }
    107.  
    108.     @Override
    109.     public ReadWriteLock getReadWriteLock() {
    110.         return readWriteLock;
    111.     }
    112.  
    113.     private RedisTemplate getRedisTemplate() {
    114.         if (redisTemplate == null) {
    115.             // 这里用到了ApplicationContextHolder.java
    116.             redisTemplate = ApplicationContextHolder.getBean("redisTemplate");
    117.         }
    118.         return redisTemplate;
    119.     }
    120. }
    RedisCacheConfig.java类主要用来配置redis的一些属性，里面这里主要配置了reids序列化。代码如下：
    1.  
    2. import org.springframework.beans.factory.annotation.Value;
    3. import org.springframework.cache.CacheManager;
    4. import org.springframework.cache.annotation.CachingConfigurerSupport;
    5. import org.springframework.cache.interceptor.CacheErrorHandler;
    6. import org.springframework.cache.interceptor.CacheResolver;
    7. import org.springframework.cache.interceptor.SimpleCacheErrorHandler;
    8. import org.springframework.cache.interceptor.SimpleCacheResolver;
    9. import org.springframework.context.annotation.Bean;
    10. import org.springframework.context.annotation.Configuration;
    11. import org.springframework.data.redis.cache.RedisCacheConfiguration;
    12. import org.springframework.data.redis.cache.RedisCacheManager;
    13. import org.springframework.data.redis.connection.RedisConnectionFactory;
    14. import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
    15. import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
    16. import org.springframework.data.redis.core.RedisTemplate;
    17. import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
    18. import org.springframework.data.redis.serializer.RedisSerializationContext;
    19. import org.springframework.data.redis.serializer.StringRedisSerializer;
    20.  
    21. import java.time.Duration;
    22. import java.util.HashMap;
    23. import java.util.Map;
    24.  
    25. /**
    26.  * ignit改redis缓存
    27.  * @author  lhb
    28.  * @since 2022/11/24
    29.  */
    30. @Configuration
    31. public class RedisCacheConfig extends CachingConfigurerSupport {
    32.     @Value("${spring.redis.host}")
    33.     private String redisHost;
    34.  
    35.     @Value("${spring.redis.port}")
    36.     private int redisPort;
    37.  
    38.     @Bean
    39.     public RedisTemplate redisTemplate() {
    40.         RedisTemplate redisTemplate = new RedisTemplate<>();
    41.         redisTemplate.setConnectionFactory(redisConnectionFactory());
    42.         GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
    43.         redisTemplate.setKeySerializer(genericJackson2JsonRedisSerializer);
    44.         redisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);
    45.         redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    46.         redisTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer);
    47.         return redisTemplate;
    48.     }
    49.  
    50.     @Override
    51.     public CacheResolver cacheResolver() {
    52.         return new SimpleCacheResolver(cacheManager());
    53.     }
    54.  
    55.     @Override
    56.     public CacheErrorHandler errorHandler() {
    57.         return new SimpleCacheErrorHandler();
    58.     }
    59.  
    60.     @Override
    61.     public CacheManager cacheManager() {
    62.         Map cacheConfigurationMap = generateCacheConfigMap();
    63.         RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
    64.                 .disableCachingNullValues()
    65.                 .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
    66.         return RedisCacheManager.builder(redisConnectionFactory())
    67.                 .cacheDefaults(redisCacheConfiguration)
    68.                 .withInitialCacheConfigurations(cacheConfigurationMap)
    69.                 .build();
    70.     }
    71.      public Map generateCacheConfigMap() {
    72.         Map initialCacheConfiguration = new HashMap<>();
    73.         initialCacheConfiguration.put("hourCache", RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofHours(1)));//1小时
    74.         initialCacheConfiguration.put("minCache", RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofMinutes(1)));
    75.         initialCacheConfiguration.put("dayCache", RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofDays(1)));
    76.         return initialCacheConfiguration;
    77.     }
    78.  
    79.     public RedisConnectionFactory redisConnectionFactory() {
    80.         RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();
    81.         configuration.setHostName(redisHost);
    82.         configuration.setPort(redisPort);
    83.         configuration.setDatabase(0);
    84.         LettuceConnectionFactory factory = new LettuceConnectionFactory(configuration);
    85.         factory.afterPropertiesSet();
    86.         return factory;
    87.     }
    88.  
    89.  
    90. }

    第四步：在mapper.xml中添加cache标签，来告诉mybtisplus这个mapper中的内容使用二级缓存，这个cache标签放在mapper表中的什么位置都行

    1. "hisense.HiDevMng.code.hidevConfigManager.web.dao.DevBusRouterelViewDao">
    2.     
    3.     "hisense.HiDevMng.code.base.config.cache.MybatisRedisCache"/>
    4.  
    5.

    第五步：在启动类中实现ApplicationContextAware接口，目的是拿到spring容器的context，然后给ApplicationContextHolder，这样我们的redis缓存的配置类中就可以通过applicationContext来得到容器中中的redisTemplate进行redis操作了。添加如下代码：

    1. public class StartApplication extends SpringBootServletInitializer implements ApplicationContextAware {
    2.     public static void main(String[] args) {
    3.         SpringApplication.run(StartApplication.class, args);
    4.     }
    5.  
    6.     @Override
    7.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    8.         //重点在此，通过这个赋值context
    9.         ApplicationContextHolder.setApplicationContext(applicationContext);
    10.     }
    11. }

    网上很多帖子给出的方式是自己单独写一个类来实现ApplicationContextAware接口，但是因为我的项目中用到了@PostConstruct注解，那样会导致ApplicationContrext为空，所以我选择了通过上面在启动类给ApplicationContextHolder赋值的方式。

    第六步，测试，创建测试类例如

    1. RunWith(SpringRunner.class)
    2. @SpringBootTest(classes = StartApplication.class, webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
    3. public class test {
    4.  
    5.     @Autowired
    6.     private MyDao dao;
    7.  
    8.     @Test
    9.     public void testOne() {
    10.         Set ids = new HashSet<>();
    11.         ids.add("25191027172915794000");
    12.         List busOrgList = dao.getBusOrgList(ids);
    13.         System.out.println(busOrgList.size());
    14.         System.out.println("====================================================");
    15.         List busOrgList1 = dao.getBusOrgList(ids);
    16.         System.out.println(busOrgList1.size());
    17.  
    18.     }
    19.  
    20. }
    21.

     运行2次查询，但是只出现一次如下图的log，就说明第二次执行使用redis缓存中的数据了

     出现一次Preparing：就说明执行的是数据库查询，没走redis缓存。当我们多次执行都不在显示这个Preparing：了就说明缓存成功了。

    总结：

    这里就不把代码放git上了，直接从上面把代码都拷贝下来，就可以执行了。关于什么是二级缓存网上可以自行百度。

    代码中还存在完善的空间，比如多久后自动从缓存删除等，大家可以自行了解下。这里只是为了给初学者使用，写多了怕容易乱。谢谢支持

  • 相关阅读:
    Java学习笔记(二)
    DHTMLX To Do List 1.0 亮点功能：高级任务分配、内联编辑、便捷的键盘导航
    基于Stable Diffusion的AIGC服饰穿搭实践
    【无标题】
    五、ROS2接口及其使用
    Ruoyi-vue项目新建模块的SQL输出的配置
    从零开始之了解电机及其控制（11）实现空间矢量调制
    Servlet——文件上传
    【一】Mac 本地部署大模型
    单体JOB向分布式JOB迁移案例
  • 原文地址：https://blog.csdn.net/liuhaibo_ljf/article/details/128116625