springboot+redis+caffeine多级缓存

最新推荐文章于 2024-05-23 11:49:22 发布
最新推荐文章于 2024-05-23 11:49:22 发布
阅读量603 收藏 1
点赞数
分类专栏： springboot redis 文章标签： 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/g3230863/article/details/119275948
版权

自定义key

import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.stereotype.Component;
import org.springframework.util.ClassUtils;

import java.lang.reflect.Array;
import java.lang.reflect.Method;

@Component //标记为组件
public class CacheKeyGenerator implements KeyGenerator {
    public static final int NO_PARAM_KEY = 0;
    public static final int NULL_PARAM_KEY = 53;
    @Override
    public Object generate(Object target, Method method, Object... params) {
        StringBuilder key = new StringBuilder();
        key.append(target.getClass().getSimpleName()).append(".").append(method.getName()).append(":");
        if (params.length == 0) {
            return key.append(NO_PARAM_KEY).toString();
        }
        for (Object param : params) {
            if (param == null) {
                key.append(NULL_PARAM_KEY);
            } else if (ClassUtils.isPrimitiveArray(param.getClass())){
                int length = Array.getLength(param);
                for (int i = 0; i < length; i++) {
                    key.append(Array.get(param, i));
                    key.append(',');
                }
            }else if (ClassUtils.isPrimitiveOrWrapper(param.getClass()) || param instanceof String){
                key.append(param);
            }else {
                key.append(param.hashCode());
            }
            key.append('-');
        }
        return key.toString();
    }
}

自定义CacheManager

import com.github.benmanes.caffeine.cache.Caffeine;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;


@Component
@Slf4j
public class RedisCaffeineCacheManager implements CacheManager {

    @Autowired
    private RedisTemplate<String, Object> template;

    @Value("${redisCaffeine.redisCacheExpire:86400}")
    private Long redisCacheExpire;

    @Value("${redisCaffeine.cachePrefix:gatewayCache}")
    private String cachePrefix;


    private ConcurrentMap<String, Cache> cacheMap = new ConcurrentHashMap<String, Cache>();

    private Set<String> cacheNames=new HashSet<String>();
    @Override
    public Cache getCache(String name) {
        Cache cache = cacheMap.get(name);
        if (cache != null) {
            return cache;
        }
        cache=new RedisCaffeineCache(true,getCaffeineCache(),name,template,cachePrefix,redisCacheExpire);
        Cache oldCache = cacheMap.putIfAbsent(name, cache);
        log.debug("create cache instance, the cache name is : {}", name);
        cacheNames.add(name);
        return oldCache == null ? cache : oldCache;
    }

    @Override
    public Collection<String> getCacheNames() {
        return this.cacheNames;
    }

    public com.github.benmanes.caffeine.cache.Cache<Object, Object> getCaffeineCache() {
        return Caffeine.newBuilder()
                // 设置最后一次写入或访问后经过固定时间过期
                .expireAfterWrite(60, TimeUnit.SECONDS)
                // 初始的缓存空间大小
                .initialCapacity(100)
                // 缓存的最大条数
                .maximumSize(10000)
                .build();
    }
}

继承AbstractValueAdaptingCache 接口

import com.github.benmanes.caffeine.cache.Cache;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cache.support.AbstractValueAdaptingCache;
import org.springframework.data.redis.core.ConvertingCursor;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;


@Component
@Slf4j
public class RedisCaffeineCache extends AbstractValueAdaptingCache {

    @Getter
    private  Cache<Object, Object> caffeineCache;

    @Getter
    private  String name;

    @Getter
    private String cachePrefix;

    private RedisTemplate<String,Object> redisTemplate;

    private Map<String, ReentrantLock> keyLockMap = new ConcurrentHashMap<>();

    private Long redisCacheExpire;

    RedisCaffeineCache(){
        super(true);
    }


    public RedisCaffeineCache(boolean allowNullValues, Cache<Object, Object> caffeineCache,String name,RedisTemplate<String,Object> redisTemplate,String cachePrefix,Long redisCacheExpire) {
        super(allowNullValues);
        this.caffeineCache=caffeineCache;
        this.name=name;
        this.redisTemplate=redisTemplate;
        this.cachePrefix=cachePrefix;
        this.redisCacheExpire=redisCacheExpire;
    }

    @Override
    protected Object lookup(Object key) {

        Object cacheKey = getKey(key);
        Object value = caffeineCache.getIfPresent(key);
        if (value != null) {
            log.debug("get cache from caffeine, the key is : {}", cacheKey);
            return value;
        }

        // 避免自动一个 RedisTemplate 覆盖失效
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        value = redisTemplate.opsForValue().get(cacheKey);

        if (value != null) {
            log.debug("get cache from redis and put in caffeine, the key is : {}", cacheKey);
            caffeineCache.put(key, value);
        }
        return value;
    }

    @Override
    public Object getNativeCache() {
        return this;
    }

    @Override
    public <T> T get(Object key, Callable<T> valueLoader) {
        Object value = lookup(key);
        if (value != null) {
            return (T) value;
        }

        ReentrantLock lock = keyLockMap.computeIfAbsent(key.toString(), s -> {
            log.trace("create lock for key : {}", s);
            return new ReentrantLock();
        });

        try {
            lock.lock();
            value = lookup(key);
            if (value != null) {
                return (T) value;
            }
            value = valueLoader.call();
            Object storeValue = toStoreValue(value);
            put(key, storeValue);
            return (T) value;
        }
        catch (Exception e) {
            throw new ValueRetrievalException(key, valueLoader, e.getCause());
        }
        finally {
            lock.unlock();
        }
    }

    @Override
    public void put(Object key, Object value) {
        if (!super.isAllowNullValues() && value == null) {
            this.evict(key);
            return;
        }

        if (redisCacheExpire > 0) {
            redisTemplate.opsForValue().set(String.valueOf(getKey(key)), toStoreValue(value), redisCacheExpire, TimeUnit.SECONDS);
        }

        caffeineCache.put(key, value);
    }

    @Override
    public void evict(Object key) {
        // 先清除redis中缓存数据，然后清除caffeine中的缓存，避免短时间内如果先清除caffeine缓存后其他请求会再从redis里加载到caffeine中
        redisTemplate.delete(String.valueOf(getKey(key)));

        caffeineCache.invalidate(key);
    }

    @Override
    public void clear() {
        // 先清除redis中缓存数据，然后清除caffeine中的缓存，避免短时间内如果先清除caffeine缓存后其他请求会再从redis里加载到caffeine中
       // Set<String> keys = redisTemplate.keys(this.name.concat(":*"));
        List<String> keys=getKeys();
        if (!CollectionUtils.isEmpty(keys)){
            redisTemplate.delete(keys);
        }

        caffeineCache.invalidateAll();
    }

    private Object getKey(Object key) {
        return this.name.concat(":").concat(
                StringUtils.isEmpty(cachePrefix) ? key.toString() : cachePrefix.concat(":").concat(key.toString()));
    }

    public List<String> getKeys() {
        long start = System.currentTimeMillis();
        //需要匹配的key
        String patternKey = "pay:*";
        ScanOptions options = ScanOptions.scanOptions()
                //这里指定每次扫描key的数量
                .count(10000)
                .match(patternKey).build();
        RedisSerializer<String> redisSerializer = (RedisSerializer<String>) redisTemplate.getKeySerializer();
        Cursor cursor = (Cursor) redisTemplate.executeWithStickyConnection(redisConnection -> new ConvertingCursor<>(redisConnection.scan(options), redisSerializer::deserialize));
        List<String> result = new ArrayList<>();
        while(cursor.hasNext()){
            result.add(cursor.next().toString());
        }
        //切记这里一定要关闭，否则会耗尽连接数。
        try {
            cursor.close();
        } catch (IOException e) {
            log.error("关闭cursor异常");
        }
        log.info("scan扫描共耗时：{} ms key数量：{}",System.currentTimeMillis()-start,result.size());

        return result;
    }
}

当实现了spring cache后，如果引用了spring-boot-starter-actuator，需要实现下面的两个类

import io.micrometer.core.instrument.Tag;
import io.micrometer.core.instrument.binder.MeterBinder;
import io.micrometer.core.instrument.binder.cache.CaffeineCacheMetrics;
import lombok.NoArgsConstructor;
import org.springframework.boot.actuate.metrics.cache.CacheMeterBinderProvider;


@NoArgsConstructor
public class RedisCaffeineCacheMeterBinderProvider implements CacheMeterBinderProvider<RedisCaffeineCache> {

    @Override
    public MeterBinder getMeterBinder(RedisCaffeineCache cache, Iterable<Tag> tags) {
        return new CaffeineCacheMetrics(cache.getCaffeineCache(), cache.getName(), tags);
    }
}

import io.micrometer.core.instrument.binder.MeterBinder;
import org.springframework.boot.actuate.metrics.cache.CacheMeterBinderProvider;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({MeterBinder.class, CacheMeterBinderProvider.class})
public class RedisCaffeineCacheMeterConfiguration {

	@Bean
	public RedisCaffeineCacheMeterBinderProvider redisCaffeineCacheMeterBinderProvider() {
		return new RedisCaffeineCacheMeterBinderProvider();
	}

}

下面是pom.xml ,springboot ：2.2.6.RELEASE，spring-cloud-dependencies ：Hoxton.SR9

      <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>ch.qos.logback</groupId>
                    <artifactId>logback-classic</artifactId>
                </exclusion>
                <exclusion>
                    <artifactId>log4j-to-slf4j</artifactId>
                    <groupId>org.apache.logging.log4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>1.14</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.60</version>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.9</version>
        </dependency>

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

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

        <dependency>
            <groupId>com.ctrip.framework.apollo</groupId>
            <artifactId>apollo-client</artifactId>
            <version>1.8.0</version>
        </dependency>

        <!-- mp -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.3.2</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.48</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.21</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.4</version>
        </dependency>
        <dependency>
            <groupId>com.github.ben-manes.caffeine</groupId>
            <artifactId>caffeine</artifactId>
            <version>2.8.1</version>
        </dependency>

        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.7.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
        </dependency>

参考代码：https://github.com/pig-mesh/multilevel-cache-spring-boot-starter

g3230863
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Springboot+redis+mybatisplus实例
03-07
Springboot+redis+mybatisplus
SpringBoot Cache使用Caffeine + Redis 支持多级缓存
zzhongcy的专栏
10-19 3724
今天发现一篇多级缓存文章，觉得很有参考价值，虽然目前还没有用这种架构，但是值得学习，再这里记录一下 为什么多级缓存 缓存的引入是现在大部分系统所必须考虑的 redis 作为常用中间件，虽然我们一般业务系统（毕竟业务量有限）不会遇到如下图 在随着 data-size 的增大和数据结构的复杂的造成性能下降，但网络 IO 消耗会成为整个调用链路中不可忽视的部分。尤其在 微服务架构中，一次调用往往会涉及多次调用 例如pig oauth2.0 的 client 认证[1] Caffeine 来自
【SpringBoot整合缓存】-----spring-boot-starter-cache篇
Learning_xzj的博客
06-28 7445
缓存在企业级应用主要作用是信息处理，当需要读取数据时，由于受限于数据库的访问效率，导致整体系统性能偏低。 ​ 应用程序直接与数据库打交道，访问效率低​ 为了改善上述现象，开发者通常会在应用程序与数据库之间建立一种临时的数据存储机制，该区域中的数据在内存中保存，读写速度较快，可以有效解决数据库访问效率低下的问题。这一块临时存储数据的区域就是缓存。使用缓存后，应用程序与缓存打交道，缓存与数据库打交道，数据访问效率提高。​ 缓存是什么？缓存是一种介于数据永久存储
Spring Boot多级缓存实现方案
justlpf的专栏
08-10 250
以上全部就是关于多级缓存的实现方案总结，多级缓存就是为了解决项目服务中单一缓存使用不足的缺点。应用场景有：接口权限校验，每次请求接口都需要根据当前登录人有哪些角色，角色有哪些权限，如果每次都去查数据库性能开销比较严重，再加上权限一般不怎么会频繁变更，所以使用多级缓存是最合适不过了；还有就是很多管理系统列表界面都有组织架构信息(所属部门、小组等)，这些信息同样可以使用多级缓存来完美提升性能。
SpringBoot 集成 Caffeine、Redis实现双重缓存方式(一)
weixiaohuai的博客
11-14 6062
一、本地缓存Caffeine介绍 一般情况下，缓存针对的主要是读操作。当你的功能遇到下面的场景时，就可以选择使用缓存组件进行性能优化： 存在数据热点，缓存的数据能够被频繁使用； 读操作明显比写操作要多； 下游功能存在着比较悬殊的性能差异，下游服务能力有限； 加入缓存以后，不会影响程序的正确性，或者引入不可预料的复杂性； 日常开发中，基本上每个项目中都会使用到Redis、MongoDB等缓存中间件，它能够很好的作为分布式缓存组件提供多个服务间的缓存，但是还是需要网络开销，增加时耗。 除了分布式缓存
【Spring Boot】使用 Redis + Cafeine 实现二级缓存
最新发布
hui_zai_的博客
05-23 567
使用 Redis 实现二级缓存
vue+springboot+redis+kaptcha实现登录验证码
04-10
vue+springboot+redis+kaptcha实现登录页验证码
基于 Springboot + Redis + Kafka 的秒杀系统，乐观锁 + 缓存 + 限流 + 异步
06-14
利用缓存：创建订单时，每次都需要先查询判断库存，只有少部分成功的请求才会创建订单，因此可以将商品信息放在缓存中，减少数据库查询 负载均衡：利用 Nginx 等使用多个服务器并发处理请求，减少单个服务器压力 ...
springboot+redis(luttuce)+Protobuf
10-18
springboot整合redis选用 `Lettuce` 作为redis框架，选用 `Protobuf` 作为序列化框架
前后端分离vue前端项目---员工管理系统（vue+springboot+redis）
06-28
后端技术栈：SpringBoot、MyBatis、Spring Security、Jwt 系统划分了超级管理员、HR人事、经理与普通员工四大角色和员工与部门、出勤管理、业绩考核、项目跟进、数据分析、系统管理、系统监控与系统工具八大功能模块...
spring boot+spring cache实现两级缓存(redis+caffeine)
08-27
主要介绍了spring boot+spring cache实现两级缓存(redis+caffeine)，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
spring boot + spring cache 实现两级缓存（redis + caffeine）
chyk1414的博客
01-31 1541
spring boot中集成了spring cache，并有多种缓存方式的实现，如：Redis、Caffeine、JCache、EhCache等等。但如果只用一种缓存，要么会有较大的网络消耗（如Redis），要么就是内存占用太大（如Caffeine这种应用内存缓存）。在很多场景下，可以结合起...
SpringBoot集成系列--Caffeine
程序员Forlan的博客
12-18 1676
本文介绍了如何使用Spring缓存、Caffeine缓存以及Caffeine与Redis结合实现二级缓存。首先，介绍了Spring缓存的基本概念和实现方式，然后详细阐述了如何使用Caffeine缓存库进行缓存操作，包括定义配置类和使用方法。最后，介绍了如何通过Caffeine与Redis结合实现二级缓存，并抽取公共代码以方便重用。
Springboot整合SpringCache+Redis
SampsonKong的博客
01-11 2276
Springboot整合SpringCache+Redis
springboot,redis,caffeine二级缓存搭建
zhuasheng
12-07 594
准备工作 1，springboot项目搭建 2，redis 集成 redis maven依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> redis相关配置 spring: redis:
架构师必备：本地缓存原理和应用
Java烘焙师
02-28 786
先说结论：本地缓存优先选用caffeine，因为性能比guava cache快，api风格与之兼容、能轻松地平滑迁移，并且在spring/spring boot最新版本中已经是默认本地缓存了。下面展开讲讲本地缓存和Spring cache。 本文讨论堆内缓存，暂不讨论堆外缓存。堆内缓存是指缓存与应用程序在一个JVM应用中，会受GC影响，一般业务层面的应用开发用不到堆外缓存。 1、什么场景使用本地缓存 并非所有的缓存场景，redis都适用，以下情况应当优先考虑本地缓存。 数据量不大 修改频率低、甚至是静态的
SpringBoot 集成 Caffeine、Redis实现双重缓存方式(二)
weixiaohuai的博客
11-14 2419
目录 一、简介 二、SpringBoot 集成 Caffeine、Redis实现双重缓存 一、简介 在上一篇文章中，我们介绍了直接引入 Caffeine 依赖，然后使用 Caffeine方法与Redis实现了双重缓存，除了这种方式外，我们还可以引入 Caffeine 和 Spring Cache 依赖，这样我们可以使用 SpringCache 注解方法实现本地缓存。 下面我们引入 Caffeine 和 Spring Cache 依赖，看下如何集成Redis、Caffeine实现多级缓存。 二、S
缓存中间件Caffeine超详细源码解读
琪琪的博客
02-12 2046
读源码是一件非常复杂、困难、枯燥的过程，这个复杂过程我给大家踩了，各位看官躺平看就行啦。
springboot caffeine+redis实现二级缓存笔记
BHSZZY的博客
10-25 1089
一、前言 最近在项目中发现了用到caffeine+redis的地方，感觉写的很好，因此记一波笔记。 caffeine是spring的cache，保存在项目本地。 redis是分布式缓存，保存在redis服务器。 查询数据时，先到caffeine中查，如果没有则查redis，如果还没有再查数据库。 二、主要流程代码样例 1.查询数据库的Java类ExamServiceImpl.java @Service public class ExamServiceImpl implements ExamService {
springBoot+redis 实现缓存
03-28
SpringBoot Redis是一种实现缓存的方法，使用Redis数据库作为缓存的存储介质。下面是SpringBoot Redis实现缓存的步骤： 1. 添加Redis依赖 在pom.xml文件中添加如下依赖： ``` <groupId>org.springframework....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值