2. 程式人生 > >SPRING CACHE REDIS 註解式實現快取策略

SPRING CACHE REDIS 註解式實現快取策略

阿新 • • 發佈：2018-12-19

為了解決資料庫查詢效率瓶頸，提升併發系統能力，快取的應用已經非常普遍和必要了。剛接觸REDIS時，如何使SPRING框架與REDIS更高效地整合，困擾了我很長時間。 先說下不使用SPRING CACHE時的兩種快取應用模式： 1.使用redis作為持久層的二級快取 特點： 快取策略全部由框架實現，配置少，使用方便，快取key為執行過的SQL語句，value為查詢結果。 缺點： 過於不靈活，作用範圍一般為持久層二級快取的作用範圍，無法精確管理快取粒度。 2.直接操作redis 特點： 控制靈活，想怎麼快取，快取什麼資料完全由開發人員決定。 缺點： 開發量大，如果不實現快取策略，service層侵入性高，並且快取內容雜亂無章難以管理。

下面是SPRING CACHE與REDIS整合的程式碼片段： 在這裡插入圖片描述 新增依賴：

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

在一個service的方法中開啟快取：

@Cacheable(keyGenerator ="cacheKeyGenerator"
 
)
@CacheExpire(expire = 60)
public List<UserVo> listUser(String departmentID)

CacheExpire： 自定義快取超時的註解

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface CacheExpire {
    /**
     * expire time, default 60s
     */
    @AliasFor
 
("expire")
    long value() default 60L;

    /**
     * expire time, default 60s
     */
    @AliasFor("value")
    long expire() default 60L;

}

CacheKeyGenerator： 快取key生成器 將目標方法類名，方法名，引數拼接的字串生成MD5，不直接用字串做key主要是為了提升redis檢索快取項的速度，用過長的字串作key並不是一個理想的做法。

public class CacheKeyGenerator implements KeyGenerator {
    public static final int NO_PARAM_KEY = 0;
    public static final int DEFAULT_KEY = 53;
    @Override
    public Object generate(Object o, Method method, Object... objects) {
        StringBuilder key = new StringBuilder();
        key.append(o.getClass().getSimpleName()).append(".").append(method.getName()).append(":");
        if (objects.length == 0) {
            return key.append(NO_PARAM_KEY).toString();
        }else{
            try{
                return MD5Util.getObjectsMD5(objects,key.toString());
            }catch(Exception e){
                return key.append(DEFAULT_KEY).toString();
            }
        }
    }
}

RedisConfiguration： 主要用來定義redis序列化器，完成一些配置工作 使用jackson作為redis的資料的預設序列化工具。

@Configuration
@EnableCaching
public class RedisConfiguration  extends CachingConfigurerSupport {

    private final RedisConnectionFactory redisConnectionFactory;
    RedisConfiguration(RedisConnectionFactory redisConnectionFactory) {
        this.redisConnectionFactory = redisConnectionFactory;
    }

    @Bean
    public KeyGenerator cacheKeyGenerator() {
        CacheKeyGenerator cacheKeyGenerator = new CacheKeyGenerator();
        return cacheKeyGenerator;
    }


    @Bean
    public RedisTemplate<Object, Object> redisTemplate() {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();

        //key的string序列化器
        StringRedisSerializer serializer = new StringRedisSerializer();

        //value序列化器jackson
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        //設定key序列化器
        redisTemplate.setKeySerializer(serializer);
        redisTemplate.setHashKeySerializer(serializer);

        //設定value序列化器
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);

        //預設序列化器
        redisTemplate.setDefaultSerializer(jackson2JsonRedisSerializer);

        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    /**
     * 配置 RedisCacheManager，使用 cache 註解管理 redis 快取
     */
    @Bean
    @Override
    public CacheManager cacheManager() {
        // 初始化一個RedisCacheWriter
        RedisCacheWriter cacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);
        // 設定預設過期時間
        RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofDays(7))
                // 使用註解時的序列化、反序列化
                .serializeKeysWith(TedisCacheManager.STRING_PAIR)
                .serializeValuesWith(TedisCacheManager.JACKSON__PAIR);
        return new TedisCacheManager(cacheWriter, defaultCacheConfig);
    }
}

TedisCacheManager： 處理快取超時，解決異常

public class TedisCacheManager extends RedisCacheManager implements ApplicationContextAware, InitializingBean {
    private ApplicationContext applicationContext;
    private static Logger log = LogManager.getLogger("TedisCacheManager");
    private Map<String, RedisCacheConfiguration> initialCacheConfiguration = new LinkedHashMap<>();

    /**
     * key serializer
     */
    public static final StringRedisSerializer STRING_SERIALIZER = new StringRedisSerializer();

    /**
     * value serializer
     */
    public static final GenericJackson2JsonRedisSerializer JACKSON_SERIALIZER = new GenericJackson2JsonRedisSerializer();

    /**
     * key serializer pair
     */
    public static final RedisSerializationContext.SerializationPair<String> STRING_PAIR = RedisSerializationContext
            .SerializationPair.fromSerializer(STRING_SERIALIZER);
    /**
     * value serializer pair
     */
    public static final RedisSerializationContext.SerializationPair<Object> JACKSON__PAIR = RedisSerializationContext
            .SerializationPair.fromSerializer(JACKSON_SERIALIZER);

    public TedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration) {
        super(cacheWriter, defaultCacheConfiguration);
    }

    @Override
    public Cache getCache(String name) {
        Cache cache = super.getCache(name);
        return new RedisCacheWrapper(cache);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    @Override
    public void afterPropertiesSet() {
        String[] beanNames = applicationContext.getBeanNamesForType(Object.class);
        for (String beanName : beanNames) {
            final Class clazz = applicationContext.getType(beanName);
            add(clazz);
        }
        super.afterPropertiesSet();
    }

    @Override
    protected Collection<RedisCache> loadCaches() {
        List<RedisCache> caches = new LinkedList<>();
        for (Map.Entry<String, RedisCacheConfiguration> entry : initialCacheConfiguration.entrySet()) {
            caches.add(super.createRedisCache(entry.getKey(), entry.getValue()));
        }
        return caches;
    }

    private void add(final Class clazz) {
        ReflectionUtils.doWithMethods(clazz, method -> {
            ReflectionUtils.makeAccessible(method);
            CacheExpire cacheExpire = AnnotationUtils.findAnnotation(method, CacheExpire.class);
            if (cacheExpire == null) {
                return;
            }
            Cacheable cacheable = AnnotationUtils.findAnnotation(method, Cacheable.class);
            if (cacheable != null) {
                add(cacheable.cacheNames(), cacheExpire);
                return;
            }
            Caching caching = AnnotationUtils.findAnnotation(method, Caching.class);
            if (caching != null) {
                Cacheable[] cs = caching.cacheable();
                if (cs.length > 0) {
                    for (Cacheable c : cs) {
                        if (cacheExpire != null && c != null) {
                            add(c.cacheNames(), cacheExpire);
                        }
                    }
                }
            } else {
                CacheConfig cacheConfig = AnnotationUtils.findAnnotation(clazz, CacheConfig.class);
                if (cacheConfig != null) {
                    add(cacheConfig.cacheNames(), cacheExpire);
                }
            }
        }, method -> null != AnnotationUtils.findAnnotation(method, CacheExpire.class));
    }

    private void add(String[] cacheNames, CacheExpire cacheExpire) {
        for (String cacheName : cacheNames) {
            if (cacheName == null || "".equals(cacheName.trim())) {
                continue;
            }
            long expire = cacheExpire.expire();
            log.info("cacheName: {}, expire: {}", cacheName, expire);
            if (expire >= 0) {
                // 快取配置
                RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                        .entryTtl(Duration.ofSeconds(expire))
                        .disableCachingNullValues()
                        // .prefixKeysWith(cacheName)
                        .serializeKeysWith(STRING_PAIR)
                        .serializeValuesWith(JACKSON__PAIR);
                initialCacheConfiguration.put(cacheName, config);
            } else {
                log.warn("{} use default expiration.", cacheName);
            }
        }
    }

    protected static class RedisCacheWrapper implements Cache {
        private final Cache cache;

        RedisCacheWrapper(Cache cache) {
            this.cache = cache;
        }

        @Override
        public String getName() {
            // log.info("name: {}", cache.getName());
            try {
                return cache.getName();
            } catch (Exception e) {
                log.error("getName ---> errmsg: {}", e.getMessage(), e);
                return null;
            }
        }

        @Override
        public Object getNativeCache() {
            // log.info("nativeCache: {}", cache.getNativeCache());
            try {
                return cache.getNativeCache();
            } catch (Exception e) {
                log.error("getNativeCache ---> errmsg: {}", e.getMessage(), e);
                return null;
            }
        }

        @Override
        public ValueWrapper get(Object o) {
            // log.info("get ---> o: {}", o);
            try {
                return cache.get(o);
            } catch (Exception e) {
                log.error("get ---> o: {}, errmsg: {}", o, e.getMessage(), e);
                return null;
            }
        }

        @Override
        public <T> T get(Object o, Class<T> aClass) {
            // log.info("get ---> o: {}, clazz: {}", o, aClass);
            try {
                return cache.get(o, aClass);
            } catch (Exception e) {
                log.error("get ---> o: {}, clazz: {}, errmsg: {}", o, aClass, e.getMessage(), e);
                return null;
            }
        }

        @Override
        public <T> T get(Object o, Callable<T> callable) {
            // log.info("get ---> o: {}", o);
            try {
                return cache.get(o, callable);
            } catch (Exception e) {
                log.error("get ---> o: {}, errmsg: {}", o, e.getMessage(), e);
                return null;
            }
        }

        @Override
        public void put(Object o, Object o1) {
            // log.info("put ---> o: {}, o1: {}", o, o1);
            try {
                cache.put(o, o1);
            } catch (Exception e) {
                log.error("put ---> o: {}, o1: {}, errmsg: {}", o, o1, e.getMessage(), e);
            }
        }

        @Override
        public ValueWrapper putIfAbsent(Object o, Object o1) {
            // log.info("putIfAbsent ---> o: {}, o1: {}", o, o1);
            try {
                return cache.putIfAbsent(o, o1);
            } catch (Exception e) {
                log.error("putIfAbsent ---> o: {}, o1: {}, errmsg: {}", o, o1, e.getMessage(), e);
                return null;
            }
        }

        @Override
        public void evict(Object o) {
            // log.info("evict ---> o: {}", o);
            try {
                cache.evict(o);
            } catch (Exception e) {
                log.error("evict ---> o: {}, errmsg: {}", o, e.getMessage(), e);
            }
        }

        @Override
        public void clear() {
            // log.info("clear");
            try {
                cache.clear();
            } catch (Exception e) {
                log.error("clear ---> errmsg: {}", e.getMessage(), e);
            }
        }
    }
}

最後分享一個連結，是redis淘汰策略的配置方式。

相關推薦

SPRING CACHE REDIS 註解式實現快取策略

為了解決資料庫查詢效率瓶頸，提升併發系統能力，快取的應用已經非常普遍和必要了。剛接觸REDIS時，如何使SPRING框架與REDIS更高效地整合，困擾了我很長時間。 先說下不使用SPRING CACHE時的兩種快取應用模式： 1.使用redis作為持久層的二級快

Spring整合Redis註解實現

之前我們說了Spring這個Redis,使用RedisTemplate 實現,不過有些地方也過於麻煩,因此Spring 團隊對 Jedis 進行了封裝，獨立為 spring-data-redis 專案，配合 spring 特性並整合 Jedis 的一些命令和方法。並提供了相關注解,幫助我們快

ssm專案 已純註解的方式 引入spring cache+ redis

通過純註解的方式引入redis，這樣可以簡單的通過 @Cacheable、@CacheEvict、@CachePut 來操作快取 在pom.xml 檔案中引入相關jar 包 <dependency> <groupId

使用Spring Cache + Redis + Jackson Serializer快取資料庫查詢結果中序列化問題的解決

應用場景 我們希望通過快取來減少對關係型資料庫的查詢次數，減輕資料庫壓力。在執行DAO類的select***(), query***()方法時，先從Redis中查詢有沒有快取資料，如果有則直接從Redis拿到結果，如果沒有再向資料庫發起查詢請求取資料。

spring cache redis 高併發下返回null

在使用springdata操作快取中，當訪問量比較大時，有可能返回null導致資料不準確，發生機率在0.01%或以下，雖然已經低於壓測標準，但是還是會影響部分使用者，經過一番篩查，發現原因如下： RedisCache 類中 有get方法，存在明顯的邏輯錯誤 “先判斷是否存在，再去get”，程

關於springboot註解式開發快取問題java.lang.IllegalStateException

在使用springboot中的註解快取開發時；需要給cacheNames這個屬性值，不然會丟擲下面異常 java.lang.IllegalStateException:org.java.service.impl.StudentServiceImpl.getStudentById(ja

Spring的IOC註解方式實現

1. 步驟一：匯入註解開發所有需要的jar包 * 引入IOC容器必須的6個jar包 * 多引入一個：Spring框架的AOP的jar包，spring-aop的jar包 2. 步驟二：建立對應的包結構，編寫Java的類 * UserService          

spring用Scheduled註解方式實現定時任務

1.spring配置檔案中寫：<!-spring掃描註解包的配置--> <context:component-scan base-package="XXX" /> <!—開

Spring Session+Redis零侵入實現單點登入

Spring Session 實現單點登入 此種方式相對於上節所說使用原生（Jedis+Jackson+Cookie+Filter）的方式實現起來更加簡便，同時對業務程式碼的侵入性也十分之小，其原理與原生方式類似，並通過對HttpServletRequest和HttpSer

Spring定時任務——註解@Scheduled實現定時任務

Scheduled的註解定義了一個特定的方法執行的時間。可以使用fixedRate指定從呼叫開始每次延遲多少毫秒繼續呼叫。還有其他選項，比如fixedDelay，它指定從呼叫開始延時多少毫秒繼續呼叫下一個週期。您還可以使用@Scheduled(cron

spring AOP 之 註解 配置實現（附 Java 程式碼例項）

轉載自http://blog.csdn.net/qq_27093465/article/details/53381527 匯入類掃描的註解解析器名稱空間：xmlns:context="http://www.springframework.org/schema/cont

Spring mvc基於註解方式實現簡單HelloWorld

實現spring MVC有兩種不同的方式：基於XML配置檔案和基於註解。 上篇部落格介紹了基於XML配置檔案的方式，這裡我們使用基於註解的方式來實現。 下面只重點介紹與XML配置檔案方式不同的兩個地方：Spring配置檔案（springmvc-servlet.xml）

Spring Cache常用註解【轉】

ner 頻率 blog https face ict 解析 map let 轉自博客:https://www.cnblogs.com/kingsonfu/p/10409596.html 原文博主:傻不拉幾貓 作參考儲備用 1、@CacheConfig 主

Spring Aop基於註解的實現

一.AspectOriented Programing，面向切面程式設計。   AOP主要用於日誌記錄，效能統計，安全控制（許可權控制），事務處理，異常處理等。將日誌記錄，效能統計，安全控制，事務處理，異常處理等程式碼從業務邏輯程式碼中劃分出來，通過對這些行為的分離，我們希望可以將它們獨立

SpringMVC+Spring+mybatis+redis專案從零開始--redis快取策略和配置實現

三.SSM專案-redis快取策略和配置實現  距離上兩篇文章已過去蠻久了，為了響應各位網友的需求，最近把這個系列重新整理下。如有不足之處，請指正。 本章將實現redis快取策略和Spring整合redis配置。 1.     Redis簡單介紹 redis是

【開源專案系列】如何基於 Spring Cache 實現多級快取（同時整合本地快取 Ehcache 和分散式快取 Redis）

## 一、快取 當系統的併發量上來了，如果我們頻繁地去訪問資料庫，那麼會使資料庫的壓力不斷增大，在高峰時甚至可以出現數據庫崩潰的現象。所以一般我們會使用快取來解決這個資料庫併發訪問問題，使用者訪問進來，會先從快取裡查詢，如果存在則返回，如果不存在再從資料庫裡查詢，最後新增到快取裡，然後返回給使用者，當然了，接

【Spring】—AOP之AspectJ註解方式實現聲明式事務管理

source xml配置 blog org 僅支持 選擇 imp 獨立 col 前言 這回來說下註解方式的聲明式事務管理。 正文 Demo 1、引入相關的jar包這裏寫圖片描述 2、引入AOP約束<beans xmlns:xsi="http://www.w3

Spring Boot Cache + redis 設定有效時間和自動重新整理快取，時間支援在配置檔案中配置

分享一下我老師大神的人工智慧教程吧。零基礎，通俗易懂！風趣幽默！http://www.captainbed.net/ 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

Spring Cloud微服務架構實現+Guava快取+redis+資料庫設計+微服務原理改造房產銷售

Spring Cloud微服務架構實現+Guava快取+redis+資料庫設計+微服務原理改造房產銷售 一、分散式服務框架的發展 1.1 第一代服務框架 　　代表：Dubbo(Java)、Orleans(.Net)等 　　特點：和語言繫結緊密 1.2 第二代服務框架 　　代表：Spring Clo

Spring Boot 結合 Redis實現快取

當Redis作為快取使用時，我們可以將它作為Spring Cache的實現，直接通過註解使用@CacheConfig，@Cacheable，@CachePut，@CacheEvict。 引入依賴（SpringBoot從1.4版本開始，spring-boot-starter-redis依賴改名了。