SpringCache支持模糊匹配

Gloduck 发布于

文章访问量

    • 在开发中如果是使用SpringCache来控制缓存的话，经常会遇到需要清除缓存的情况。我们希望其清除缓存时能支持模糊匹配，但是Spring自带的CacheManage是不支持模糊匹配的。

    • 使用Redis为例。常用的缓存注解有：

      • @CachePut
      • @Cacheable
      • @CacheEvict

    • 其中@CacheEvict是用于清除缓存的。但是其并不支持模糊匹配。这几个注解的功能是由类RedisCache提供的。而清除缓存的功能是由evict方法提供的。

    • @Override
public void evict(Object key) {
    cacheWriter.remove(name, createAndConvertCacheKey(key));
}

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12

      + 很明显这个并不支持模糊匹配。

      + 这时我们注意到了其中的`clear`方法

      + ```java
        @Override
        public void clear() {
        
            byte[] pattern = conversionService.convert(createCacheKey("*"), byte[].class);
            cacheWriter.clean(name, pattern);
        }

    • clear方法清除缓存的方法是通过模糊匹配清除的。这证明SpringCache是支持模糊匹配清除缓存的。而想调用clear方法需要使用注解@CacheEvict(allEntries = true)

    • 我们可以通过重写evict方法来使得清除缓存支持模糊匹配。

    代码

    重写RedisCache

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    /**
         * 重写RedisCache使其支持模糊匹配
         */
    private static final class CustomizedRedisCache extends RedisCache{
        private final String name;
        private final RedisCacheWriter cacheWriter;
        private final ConversionService conversionService;
        protected CustomizedRedisCache(String name, RedisCacheWriter cacheWriter, RedisCacheConfiguration cacheConfig) {
            super(name, cacheWriter, cacheConfig);
            this.name = name;
            this.cacheWriter = cacheWriter;
            this.conversionService = cacheConfig.getConversionService();
        }

        @Override
        public void evict(Object key) {
            byte[] pattern = this.conversionService.convert(this.createCacheKey(key), byte[].class);
            this.cacheWriter.clean(this.name, pattern);
        }
    }

    重写RedisCacheManager

    • 由于RedisCacheManage中默认创建的是RedisCache

    • ```java
      protected RedisCache createRedisCache(String name, @Nullable RedisCacheConfiguration cacheConfig) {
      return new RedisCache(name, cacheWriter, cacheConfig != null ? cacheConfig : defaultCacheConfig);
      }

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
      69
      70

      + 所以我们需要重写`RedisCacheManager`来注入我们自己的RedisCache

      + 在创建CacheManager的时候记得换成我们自己定义的CacheManager

      ```java
      /**
           * 重写RedisCacheManager，使得CustomizedRedisCache能够替换RedisCache
           */
      private static final class CustomizedRedisCacheManager extends RedisCacheManager{

          private final RedisCacheWriter cacheWriter;
          private final RedisCacheConfiguration defaultCacheConfig;
          private final Map<String, RedisCacheConfiguration> initialCaches = new LinkedHashMap<>();
          private boolean enableTransactions;


          public CustomizedRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration) {
              super(cacheWriter, defaultCacheConfiguration);
              this.cacheWriter = cacheWriter;
              this.defaultCacheConfig = defaultCacheConfiguration;
          }

          public CustomizedRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, String... initialCacheNames) {
              super(cacheWriter, defaultCacheConfiguration, initialCacheNames);
              this.cacheWriter = cacheWriter;
              this.defaultCacheConfig = defaultCacheConfiguration;
          }

          public CustomizedRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, boolean allowInFlightCacheCreation, String... initialCacheNames) {
              super(cacheWriter, defaultCacheConfiguration, allowInFlightCacheCreation, initialCacheNames);
              this.cacheWriter = cacheWriter;
              this.defaultCacheConfig = defaultCacheConfiguration;
          }

          public CustomizedRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, Map<String, RedisCacheConfiguration> initialCacheConfigurations) {
              super(cacheWriter, defaultCacheConfiguration, initialCacheConfigurations);
              this.cacheWriter = cacheWriter;
              this.defaultCacheConfig = defaultCacheConfiguration;
          }

          public CustomizedRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, Map<String, RedisCacheConfiguration> initialCacheConfigurations, boolean allowInFlightCacheCreation) {
              super(cacheWriter, defaultCacheConfiguration, initialCacheConfigurations, allowInFlightCacheCreation);
              this.cacheWriter = cacheWriter;
              this.defaultCacheConfig = defaultCacheConfiguration;
          }

          /**
               * 这个构造方法最重要
               **/
          public CustomizedRedisCacheManager(RedisConnectionFactory redisConnectionFactory, RedisCacheConfiguration cacheConfiguration) {
              this(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),cacheConfiguration);
          }

          //覆盖父类创建RedisCache
          @Override
          protected RedisCache createRedisCache(String name, @Nullable RedisCacheConfiguration cacheConfig) {
              return new CustomizedRedisCache(name, cacheWriter, cacheConfig != null ? cacheConfig : defaultCacheConfig);
          }

          @Override
          public Map<String, RedisCacheConfiguration> getCacheConfigurations() {
              Map<String, RedisCacheConfiguration> configurationMap = new HashMap<>(getCacheNames().size());
              getCacheNames().forEach(it -> {
                  RedisCache cache = CustomizedRedisCache.class.cast(lookupCache(it));
                  configurationMap.put(it, cache != null ? cache.getCacheConfiguration() : null);
              });
              return Collections.unmodifiableMap(configurationMap);
          }
      }

    完整代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    package cn.gloduck.onlinetest.config;

    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cache.CacheManager;
    import org.springframework.cache.annotation.CachingConfigurerSupport;
    import org.springframework.cache.interceptor.*;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.DependsOn;
    import org.springframework.core.convert.ConversionService;
    import org.springframework.data.redis.cache.RedisCache;
    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.*;
    import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
    import org.springframework.lang.Nullable;

    import java.io.Serializable;
    import java.lang.reflect.Method;
    import java.util.*;

    public class CacheConfig extends CachingConfigurerSupport {
        @Autowired
        private RedisConnectionFactory factory;
        @Autowired
        private CacheManager cacheManager;

        /**
         * 初始化redis
         *
         * @param redisConnectionFactory
         * @return
         */
        @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;
        }


        @Bean
        @Override
        public CacheErrorHandler errorHandler() {
            // 用于捕获从Cache中进行CRUD时的异常的回调处理器。
            return new SimpleCacheErrorHandler();
        }


        @Bean
        @Override
        public CacheManager cacheManager() {
            RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration.
                    defaultCacheConfig()
                    .disableCachingNullValues()
                    .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(valueSerializer()));
            return new CustomizedRedisCacheManager(factory, cacheConfiguration);
        }

        @Bean
        @Override
        @DependsOn("cacheManager")
        public CacheResolver cacheResolver() {
            return new SimpleCacheResolver(cacheManager);
        }

        @Bean("customizedKeyGenerator")
        public CustomizedKeyGenerator myKeyGenerator(){
            return new CustomizedKeyGenerator();
        }

        /**
         * Redis键序列化器
         * @return
         */
        private RedisSerializer keySerializer(){
            return new StringRedisSerializer();
        }

        /**
         * Redis值序列化器
         * @return
         */
        private RedisSerializer valueSerializer(){
            return new Jackson2JsonRedisSerializer<Serializable>(Serializable.class);
        }

        /**
         * 自定义Redis的KeyGenerator，取代自带的SimpleKeyGenerator
         */
        private static final class CustomizedKeyGenerator implements KeyGenerator{
            @Override
            public Object generate(Object target, Method method, Object... params) {
                if(params.length == 0){
                    return "defaultKey";
                }
                int length = params.length - 1;
                StringBuilder keyBuilder = new StringBuilder();
                for (int i = 0; i < length; i++) {
                    keyBuilder.append(params[i]).append("-");
                }
                keyBuilder.append(params[length]);
                return keyBuilder.toString();
            }

        }

        /**
         * 重写RedisCache使其支持模糊匹配
         */
        private static final class CustomizedRedisCache extends RedisCache{
            private final String name;
            private final RedisCacheWriter cacheWriter;
            private final ConversionService conversionService;
            protected CustomizedRedisCache(String name, RedisCacheWriter cacheWriter, RedisCacheConfiguration cacheConfig) {
                super(name, cacheWriter, cacheConfig);
                this.name = name;
                this.cacheWriter = cacheWriter;
                this.conversionService = cacheConfig.getConversionService();
            }

            @Override
            public void evict(Object key) {
                byte[] pattern = this.conversionService.convert(this.createCacheKey(key), byte[].class);
                this.cacheWriter.clean(this.name, pattern);
            }
        }
        /**
         * 重写RedisCacheManager，使得CustomizedRedisCache能够替换RedisCache
         */
        private static final class CustomizedRedisCacheManager extends RedisCacheManager{

            private final RedisCacheWriter cacheWriter;
            private final RedisCacheConfiguration defaultCacheConfig;
            private final Map<String, RedisCacheConfiguration> initialCaches = new LinkedHashMap<>();
            private boolean enableTransactions;


            public CustomizedRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration) {
                super(cacheWriter, defaultCacheConfiguration);
                this.cacheWriter = cacheWriter;
                this.defaultCacheConfig = defaultCacheConfiguration;
            }

            public CustomizedRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, String... initialCacheNames) {
                super(cacheWriter, defaultCacheConfiguration, initialCacheNames);
                this.cacheWriter = cacheWriter;
                this.defaultCacheConfig = defaultCacheConfiguration;
            }

            public CustomizedRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, boolean allowInFlightCacheCreation, String... initialCacheNames) {
                super(cacheWriter, defaultCacheConfiguration, allowInFlightCacheCreation, initialCacheNames);
                this.cacheWriter = cacheWriter;
                this.defaultCacheConfig = defaultCacheConfiguration;
            }

            public CustomizedRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, Map<String, RedisCacheConfiguration> initialCacheConfigurations) {
                super(cacheWriter, defaultCacheConfiguration, initialCacheConfigurations);
                this.cacheWriter = cacheWriter;
                this.defaultCacheConfig = defaultCacheConfiguration;
            }

            public CustomizedRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration, Map<String, RedisCacheConfiguration> initialCacheConfigurations, boolean allowInFlightCacheCreation) {
                super(cacheWriter, defaultCacheConfiguration, initialCacheConfigurations, allowInFlightCacheCreation);
                this.cacheWriter = cacheWriter;
                this.defaultCacheConfig = defaultCacheConfiguration;
            }

            /**
             * 这个构造方法最重要
             **/
            public CustomizedRedisCacheManager(RedisConnectionFactory redisConnectionFactory, RedisCacheConfiguration cacheConfiguration) {
                this(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),cacheConfiguration);
            }

            //覆盖父类创建RedisCache
            @Override
            protected RedisCache createRedisCache(String name, @Nullable RedisCacheConfiguration cacheConfig) {
                return new CustomizedRedisCache(name, cacheWriter, cacheConfig != null ? cacheConfig : defaultCacheConfig);
            }

            @Override
            public Map<String, RedisCacheConfiguration> getCacheConfigurations() {
                Map<String, RedisCacheConfiguration> configurationMap = new HashMap<>(getCacheNames().size());
                getCacheNames().forEach(it -> {
                    RedisCache cache = CustomizedRedisCache.class.cast(lookupCache(it));
                    configurationMap.put(it, cache != null ? cache.getCacheConfiguration() : null);
                });
                return Collections.unmodifiableMap(configurationMap);
            }
        }
    }

    Gloduck

    Gloduck

    努力赶上大佬

    96
    0
    33
    TOC
    1. 1. 代码
      1. 1.1. 重写RedisCache
      2. 1.2. 重写RedisCacheManager
    2. 2. 完整代码
    NOTICE

    一个菜鸡JAVA后端的博客～

    CATEGORYS
      TAGS
      Bat Blog Code DesignPartten Git Gridea HTML Idea JVM Java Linux Multithreading Netty Network OpenWrt Other SQL Shell Software SourceCode Spring SpringBoot Sring Tool WebSite Windows XiaoMi Zookeeper java 其他 记录 路由器 闲杂