缓存框架jetcache+本地缓存Caffeine

已于 2024-02-17 21:55:14 修改
阅读量1.2k 收藏 17
点赞数 11
文章标签： 缓存 jetcache框架
于 2024-02-02 21:54:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/usa_washington/article/details/135998827
版权

在实际应用中，并不是单一的使用本地缓存或者redis，更多是组合使用来满足不同的业务场景。
jetcache组件实现了优雅的组合本地缓存和远程缓存。

支持多种缓存类型：本地缓存、分布式缓存、多级缓存。

官网地址：https://github.com/alibaba/jetcache

官方文档：https://github.com/alibaba/jetcache/tree/master/docs/CN

一、依赖

非SpringBoot项目参考官网配置
在这里插入图片描述
SpringBoot依赖

<dependency>
    <groupId>com.alicp.jetcache</groupId>
    <artifactId>jetcache-starter-redis</artifactId>
    <version>2.7.0</version>
</dependency>

<!--  jetcache2.7.x版本需要额外添加该依赖-->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.3.1</version>
</dependency>

在这里插入图片描述

二、修改配置文件，配置redis地址和线程数

jetcache:
  ## 统计间隔，0表示不统计，开启后定期在控制台输出缓存信息
  statIntervalMinutes: 15
  ## 是否把cacheName作为远程缓存key前缀
  areaInCacheName: false
  ## 本地缓存配置
  local:
    default: ## default表示全部生效，也可以指定某个cacheName
      ## 本地缓存类型，其他可选：caffeine/linkedhashmap
      type: linkedhashmap
      keyConvertor: fastjson
  ## 远程缓存配置
  remote:
    default: ## default表示全部生效，也可以指定某个cacheName
      type: redis
      ## key转换器方式n
      keyConvertor: fastjson
      broadcastChannel: projectA
      ## redis序列化方式
      valueEncoder: java
      valueDecoder: java
      ## redis线程池
      poolConfig:
        minIdle: 5
        maxIdle: 20
        maxTotal: 50
      ## redis地址与端口
      host: 127.0.0.1
      port: 6379

在这里插入图片描述

三、启动类添加注解@EnableCreateCacheAnnotation开启缓存

@EnableMethodCache(basePackages = “com.example.jetcachedemo”)注解，配置缓存方法扫描路径

四、使用缓存，通过三种方式

方式一：AOP模式，通过@Cached,@CacheUpdate,@CacheInvalidate

@RestController
@RequestMapping("user")
public class UserController{
	
	@GetMapping("getRemote")
	@Cached(name="userCache:",key="#id",expire=3600,timeUnit=TimeUnit.SECONDS,cacheType = CacheType.REMOTE)
	public User getRemote(Long id){
		//直接新建用户，模拟从数据库获取数据
		User user = new User();
		user.setId(id);
        user.setName("用户remote"+id);
        user.setAge(23);
        user.setSex(1);
        System.out.println("第一次获取数据，未走缓存："+id);
        return user;
	}

	@GetMapping("getLocal")
	@Cached(name="userCache:", key = "#id", expire = 3600, timeUnit = TimeUnit.SECONDS, cacheType = CacheType.LOCAL)
	public User getLocal(Long id){
		// 直接新建用户，模拟从数据库获取数据
        User user = new User();
        user.setId(id);
        user.setName("用户local"+id);
        user.setAge(23);
        user.setSex(1);
        System.out.println("第一次获取数据，未走缓存："+id);
        return user;
	}

	 @GetMapping("getBoth")
    @Cached(name="userCache:", key = "#id", expire = 3600, timeUnit = TimeUnit.SECONDS, cacheType = CacheType.BOTH)
    public User getBoth(Long id){
        // 直接新建用户，模拟从数据库获取数据
        User user = new User();
        user.setId(id);
        user.setName("用户both"+id);
        user.setAge(23);
        user.setSex(1);
        System.out.println("第一次获取数据，未走缓存："+id);
        return user;
    }

	@PostMapping("updateUser")
    @CacheUpdate(name = "userCache:", key = "#user.id", value = "#user")
    public Boolean updateUser(@RequestBody User user){
        // TODO 更新数据库
        return true;
    }

    @PostMapping("deleteUser")
    @CacheInvalidate(name = "userCache:", key = "#id")
    public Boolean deleteUser(Long id){
        // TODO 从数据库删除
        return true;
    }
}

实体类User一定要实现序列化，即声明Serializable

@Data
public class User implements Serializable {

    private Long id;
    private String name;
    private Integer age;
    private Integer sex;
}

访问localhost:8088/user/getRemote?id=1
在这里插入图片描述
因为配置的是远程缓存，在redis中也能看到对应的key
在这里插入图片描述
访问localhost:8088/user/getLocal?id=1，这个方法是从本地缓存获取的，现在只有远程缓存上有数据，我们调用发现缓存数据还是拿到了，这说明当我们在配置文件中配置了本地缓存和远程缓存后，方式一中本地缓存和远程缓存会自动相互调用
比如本地缓存有这个key，redis中没有，通过远程缓存方式访问时，会先从redis获取，如果没有会自动获取本地缓存，但是数据还是存储在本地缓存，并不会同步到redis上，这样更加灵活的实现了多级缓存架构
在这里插入图片描述

方式二，API模式，通过@CreateCache，注：在jetcache 2.7 版本CreateCache注解已废弃，不推荐使用

@RestController
@RequestMapping("user2")
public class User2Controller {

    @CreateCache(name= "userCache:", expire = 3600, timeUnit = TimeUnit.SECONDS, cacheType = CacheType.BOTH)
    private Cache<Long, Object> userCache;

    @GetMapping("get")
    public User get(Long id){
        if(userCache.get(id) != null){
            return (User) userCache.get(id);
        }
        User user = new User();
        user.setId(id);
        user.setName("用户both"+id);
        user.setAge(23);
        user.setSex(1);
        userCache.put(id, user);
        System.out.println("第一次获取数据，未走缓存："+id);
        return user;
    }

    @PostMapping("updateUser")
    public Boolean updateUser(@RequestBody User user){
        // TODO 更新数据库
        userCache.put(user.getId(), user);
        return true;
    }

    @PostMapping("deleteUser")
    public Boolean deleteUser(Long id){
        // TODO 从数据库删除
        userCache.remove(id);
        return true;
    }

}

测试下CreateCache的形式：localhost:8088/user2/get?id=4
在这里插入图片描述
正常获取了，并且redis中也有了对应的值
在这里插入图片描述
而当我们把缓存方式更改为LOCAL后，再访问localhost:8088/user2/get?id=5

@CreateCache(name= "userCache:", expire = 3600, timeUnit = TimeUnit.SECONDS, cacheType = CacheType.LOCAL)

会发现redis中就没有对应缓存了，只在本地缓存存在，说明我们指定本地缓存的形式成功了
在这里插入图片描述

方式三，高级API模式：通过CacheManager，2.7 版本才可使用

①、添加依赖

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

②、配置类

@Configuration
public class JetcacheConfig{
	
	@Autowired
	private CacheManager cacheManager;
	private Cache<Long,Object> userCache;

	@PostConstruct
	public void init(){
		QuickConfig qc = QuickConfig.newBuilder("userCache:")
			.expire(Duration.ofSeconds(3600))
			.cacheType(CacheType.BOTH)
			//本地缓存更新后，将在所有的节点中删除缓存，以保持强一致性
			.syncLocal(false)
			.build();
		userCache = cacheManager.getOrCreateCache(qc);
	}

	@Bean
	public Cache<Long,Object> getUserCache(){
		return userCache;
	}
}

③、调用

@RestController
@RequestMapping("user")
public class UserController{
	
	@Autowired
	JetcheConfig jetcacheConfig;
	@Autowired
	private Cache<Long,Object> userCache;

	@GetMapping("get")
    public User get(Long id){
        if(userCache.get(id) != null){
            return (User) userCache.get(id);
        }
        User user = new User();
        user.setId(id);
        user.setName("用户both"+id);
        user.setAge(23);
        user.setSex(1);
        userCache.put(id, user);
        System.out.println("第一次获取数据，未走缓存："+id);
        return user;
    }

	@PostMapping("updateUser")
    public Boolean updateUser(@RequestBody User user){
        // TODO 更新数据库
        userCache.put(user.getId(), user);
        return true;
    }

    @PostMapping("deleteUser")
    public Boolean deleteUser(Long id){
        // TODO 从数据库删除
        userCache.remove(id);
        return true;
    }

}

多级缓存的形式，会先从本地缓存获取数据，本地获取不到会从远程缓存获取；

④、启动redis

如果启动出现NoClassDefFoundError: redis/clients/util/Pool或NoClassDefFoundError: redis/clients/jedis/UnifiedJedis报错，说明springboot与jetcache版本不一致，对应关系可参考上述第一步中的说明 同时如果使用的是jetcache2.7.x版本，因为该版本中有jedis包的依赖，需要额外添加如下依赖，或者将jetcache版本将至2.6.5以下

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.3.1</version>
</dependency>

调用localhost:8088/user/get?id=11
在这里插入图片描述
redis中缓存设置成功！
在这里插入图片描述

常见打的报错

1、ClassNotFoundException: com.alibaba.fastjson.JSON 解决：添加依赖

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

2、NoClassDefFoundError: redis/clients/jedis/UnifiedJedis 解决：添加依赖

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.3.1</version>
</dependency>

或者将jetcache版本降低至2.6.5以下。

本地缓存Caffeine

官方：https://github.com/ben-manes/caffeine

基于Java 1.8的高性能本地缓存库，由Guava改进而来，而且在Spring5开始的默认缓存实现就将Caffeine代替原来的Google Guava

实际上Caffeine这样的本地缓存和ConcurrentMap很像，即支持并发，并且支持O(1)时间复杂度的数据存取。

区别：

  • ConcurrentMap将存储所有存入的数据，直到你显式将其移除
  • Caffeine将通过给定的配置，自动移除“不常用”的数据，以保持内存的合理占用

一、依赖

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>3.0.5</version>
</dependency>

二、缓存加载策略

①、Cache手动创建

Cache<Object,Object> cache = Caffeine.newBuilder()
	.initialCapacity(10)//初始化数据
	.maximumSize()//最大条数
	.expireAfterWriter(1,TimeUnit.SECONDS)//最后一次写操作经过指定时间过期
	.expireAfterAccess(1,TimeUnit.SECONDS)//最后一次读或写操作经过指定时间过期（两者同时存在，以expireAfterWrite为准）
	.removalListener((key,val,removalCause) -> {})//监听缓存被移除
	.recordStats()//记录命中
	.build();

cache.put("1","张三");//手动调用put()进行加载,对于已存在的key将进行覆盖
//而若另一线程调用getIfPresent()方法，则会立即返回null，不会被阻塞。
System.out.println(cache.getIfPresent("1"));
//存储的是默认值，如果有另一个线程同时调用本方法进行竞争，则后一线程会被阻塞，直到前一线程更新缓存完成；
System.out.println(cache.get("2",o -> "默认值"));//在获取缓存值时，如果想要在缓存值不存在时，原子地将值写入缓存

②、Loading Cache自动创建

一种自动加载的缓存。其和普通缓存不同的地方在于，当缓存不存在/缓存已过期时，若调用get()方法，则会自动调用CacheLoader.load()方法加载最新值。
调用getAll()方法将遍历所有的key调用get()，除非实现了CacheLoader.loadAll()方法。使用LoadingCache时，需要指定CacheLoader，并实现其中的load()方法供缓存缺失时自动加载。
在多线程情况下，当两个线程同时调用get()，则后一线程将被阻塞，直至前一线程更新缓存完成。

LoadingCache<String,String> loadingCache = Caffeine.newBuilder()
	.refreshAfterWrite(10,TimeUnit.SECONDS)
	.expireAfterWrite(10,TimeUnit.SECONDS)
	.expireAfterAccess(10,TimeUnit.SECONDS)
	.maximumSize(10)
	//根据key查询数据库里面的值
	.build(key -> new Date().toString());

③、Async Cache异步获取

AsyncCache是Cache的一个变体，其响应结果均为CompletableFuture

默认情况下，缓存计算使用ForkJoinPool.commonPool()作为线程池，如果想要指定线程池，则可以覆盖并实现Caffeine.executor(Executor)方法。
synchronous()提供了阻塞直到异步缓存生成完毕的能力，它将以Cache进行返回。

在多线程情况下，当两个线程同时调用get(key, k -> value)，则会返回同一个CompletableFuture对象。由于返回结果本身不进行阻塞，可以根据业务设计自行选择阻塞等待或者非阻塞。

AsyncLoadingCache<String,String> asyncLoadingCache = Caffeine.newBuilder()
	.refreshAfterWrite(1, TimeUnit.SECONDS)
	.expireAfterWrite(1, TimeUnit.SECONDS)
    .expireAfterAccess(1, TimeUnit.SECONDS)
    .maximumSize(10)
    //根据key查询数据库里面的值
    .buildAsync(key -> {
    	Thread.sleep(1000);
    	return new Date().toString();
    });

//异步缓存返回的是CompletableFuture
CompletableFuture<String> future = asyncLoadingCache.get("1");
future.thenAccept(System.out::println);

三、驱逐策略

驱逐策略在创建缓存的时候进行指定。

常用的有基于容量的驱逐和基于时间的驱逐：

  • 基于容量的驱逐需要指定缓存容量的最大值，当缓存容量达到最大时，Caffeine将使用LRU策略对缓存进行淘汰；
  • 基于时间的驱逐策略如字面意思，可以设置在最后访问/写入一个缓存经过指定时间后，自动进行淘汰。

驱逐策略可以组合使用，任意驱逐策略生效后，该缓存条目即被驱逐

  • LRU 最近最少使用，淘汰最长时间没有被使用的页面
  • LFU 最不经常使用，淘汰一段时间内使用次数最少的页面
  • FIFO 先进先出

Caffeine有4种缓存淘汰设置

  • 大小 （LFU算法进行淘汰）
  • 权重 （大小与权重 只能二选一）
  • 时间
  • 引用 （不常用，本文不介绍）
@Slf4j
public class CacheTest{

	@Test
	public void maximumSizeTest()throws InterruptdException{
		
		/**
			缓存大小淘汰
		*/
		Cache<Integer, Integer> cache = Caffeine.newBuilder()
                //超过10个后会使用W-TinyLFU算法进行淘汰
                .maximumSize(10)
                .evictionListener((key, val, removalCause) -> {
                    log.info("淘汰缓存：key:{} val:{}", key, val);
                })
                .build();

        for (int i = 1; i < 20; i++) {
            cache.put(i, i);
        }
        Thread.sleep(500);//缓存淘汰是异步的

        // 打印还没被淘汰的缓存
        System.out.println(cache.asMap());
	}

	/**
		权重淘汰
	*/
	@Test
	public void maximumWeightTest()throws InterruptedException{
		
		Cache<Integer, Integer> cache = Caffeine.newBuilder()
                //限制总权重，若所有缓存的权重加起来>总权重就会淘汰权重小的缓存
                .maximumWeight(100)
                .weigher((Weigher<Integer, Integer>) (key, value) -> key)
                .evictionListener((key, val, removalCause) -> {
                    log.info("淘汰缓存：key:{} val:{}", key, val);
                })
                .build();

        //总权重其实是=所有缓存的权重加起来
        int maximumWeight = 0;
        for (int i = 1; i < 20; i++) {
            cache.put(i, i);
            maximumWeight += i;
        }
        System.out.println("总权重=" + maximumWeight);
        Thread.sleep(500);//缓存淘汰是异步的

        // 打印还没被淘汰的缓存
        System.out.println(cache.asMap());
	}

	/**
		访问后到期（每次访问都会重置时间，也就是说如果一直被访问就不会被淘汰）
	*/
	@Test
	public void expireAfterAccessTest() throws InterruptedException {
		
		Cache<Integer, Integer> cache = Caffeine.newBuilder()
                .expireAfterAccess(1, TimeUnit.SECONDS)
                //可以指定调度程序来及时删除过期缓存项，而不是等待Caffeine触发定期维护
                //若不设置scheduler，则缓存会在下一次调用get的时候才会被动删除
                .scheduler(Scheduler.systemScheduler())
                .evictionListener((key, val, removalCause) -> {
                    log.info("淘汰缓存：key:{} val:{}", key, val);

                })
                .build();
        cache.put(1, 2);
        System.out.println(cache.getIfPresent(1));
        Thread.sleep(3000);
        System.out.println(cache.getIfPresent(1));//null
	}

	/**
		写入后到期
	*/
	@Test
	public void expireAfterWriteTest() throws InterruptedException {
        Cache<Integer, Integer> cache = Caffeine.newBuilder()
                .expireAfterWrite(1, TimeUnit.SECONDS)
                //可以指定调度程序来及时删除过期缓存项，而不是等待Caffeine触发定期维护
                //若不设置scheduler，则缓存会在下一次调用get的时候才会被动删除
                .scheduler(Scheduler.systemScheduler())
                .evictionListener((key, val, removalCause) -> {
                    log.info("淘汰缓存：key:{} val:{}", key, val);
                })
                .build();
        cache.put(1, 2);
        Thread.sleep(3000);
        System.out.println(cache.getIfPresent(1));//null
    }
}

四、刷新机制

refreshAfterWrite()表示x秒后自动刷新缓存的策略可以配合淘汰策略使用，注意的是刷新机制只支持LoadingCache和AsyncLoadingCache

private static int NUM = 0;

@Test
public void refreshAfterWriteTest() throws InterruptedException {
    LoadingCache<Integer, Integer> cache = Caffeine.newBuilder()
            .refreshAfterWrite(1, TimeUnit.SECONDS)
            //模拟获取数据，每次获取就自增1
            .build(integer -> ++NUM);

    //获取ID=1的值，由于缓存里还没有，所以会自动放入缓存
    System.out.println(cache.get(1));// 1

    // 延迟2秒后，理论上自动刷新缓存后取到的值是2
    // 但其实不是，值还是1，因为refreshAfterWrite并不是设置了n秒后重新获取就会自动刷新
    // 而是x秒后&&第二次调用getIfPresent的时候才会被动刷新
    Thread.sleep(2000);
    System.out.println(cache.getIfPresent(1));// 1

    //此时才会刷新缓存，而第一次拿到的还是旧值
    System.out.println(cache.getIfPresent(1));// 2
}

五、统计

LoadingCache<String, String> cache = Caffeine.newBuilder()
        //创建缓存或者最近一次更新缓存后经过指定时间间隔，刷新缓存；refreshAfterWrite仅支持LoadingCache
        .refreshAfterWrite(1, TimeUnit.SECONDS)
        .expireAfterWrite(1, TimeUnit.SECONDS)
        .expireAfterAccess(1, TimeUnit.SECONDS)
        .maximumSize(10)
        //开启记录缓存命中率等信息
        .recordStats()
        //根据key查询数据库里面的值
        .build(key -> {
            Thread.sleep(1000);
            return new Date().toString();
        });


cache.put("1", "shawn");
cache.get("1");

/*
 * hitCount :命中的次数
 * missCount:未命中次数
 * requestCount:请求次数
 * hitRate:命中率
 * missRate:丢失率
 * loadSuccessCount:成功加载新值的次数
 * loadExceptionCount:失败加载新值的次数
 * totalLoadCount:总条数
 * loadExceptionRate:失败加载新值的比率
 * totalLoadTime:全部加载时间
 * evictionCount:丢失的条数
 */
System.out.println(cache.stats());

上述一些策略在创建时都可以进行自由组合，一般情况下有两种方法

  • 设置 maxSize、refreshAfterWrite，不设置 expireAfterWrite/expireAfterAccess
  • 设置expireAfterWrite当缓存过期时会同步加锁获取缓存，所以设置expireAfterWrite时性能较好，但是某些时候会取旧数据,适合允许取到旧数据的场景
  • 设置 maxSize、expireAfterWrite/expireAfterAccess，不设置 refreshAfterWrite 数据一致性好，不会获取到旧数据，但是性能没那么好（对比起来），适合获取数据时不耗时的场景

SpringBoot整合Caffeine

如果要使用@Cacheable注解，需要引入相关依赖，并在任一配置类文件上添加@EnableCaching注解

  • @Cacheable：表示该方法支持缓存。当调用被注解的方法时，如果对应的键已经存在缓存，则不再执行方法体，而从缓存中直接返回。当方法返回null时，将不进行缓存操作
  • @CachePut：表示执行该方法后，其值将作为最新结果更新到缓存中，每次都会执行该方法
  • @CacheEvict：表示执行该方法后，将触发缓存清除操作
  • @Caching：用于组合前三个注解，例如：
@Caching(cacheable = @Cacheable("CacheConstants.GET_USER"),
         evict = {@CacheEvict("CacheConstants.GET_DYNAMIC",allEntries = true)}
public User find(Integer id) {
    return null;
}

常用注解属性

  • cacheNames/value：缓存组件的名字，即cacheManager中缓存的名称
  • key：缓存数据时使用的key。默认使用方法参数值，也可以使用SpEL表达式进行编写
  • keyGenerator：和key二选一使用
  • cacheManager：指定使用的缓存管理器
  • condition：在方法执行开始前检查，在符合condition的情况下，进行缓存
  • unless：在方法执行完成后检查，在符合unless的情况下，不进行缓存
  • sync：是否使用同步模式。若使用同步模式，在多个线程同时对一个key进行load时，其他线程将被阻塞

缓存同步模式：
sync开启或关闭，在Cache和LoadingCache中的表现是不一致的

  • Cache中，sync表示是否需要所有线程同步等待
  • LoadingCache中，sync表示在读取不存在/已驱逐的key时，是否执行被注解方法

一、依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
</dependency>

二、缓存常量CacheConstants

创建缓存常量类，把公共的常量提取一层复用，这里也可以通过配置文件加载这些数据，例如@ConfigurationProperties和@Value

public class CacheConstants{
	
	public static final int DEFAULT_EXPIRES = 3 * 60;//配置类中我使用的时间单位是秒，所以这里如 3*60 为3分钟
    public static final int EXPIRES_5_MIN = 5 * 60;
    public static final int EXPIRES_10_MIN = 10 * 60;

	public static final String GET_USER = "GET:USER";
    public static final String GET_DYNAMIC = "GET:DYNAMIC";
}

三、缓存配置类CacheConfig

@Configuration
@EnableCaching
public class CacheConfig{

	/**
     * Caffeine配置说明：
     * initialCapacity=[integer]: 初始的缓存空间大小
     * maximumSize=[long]: 缓存的最大条数
     * maximumWeight=[long]: 缓存的最大权重
     * expireAfterAccess=[duration]: 最后一次写入或访问后经过固定时间过期
     * expireAfterWrite=[duration]: 最后一次写入后经过固定时间过期
     * refreshAfterWrite=[duration]: 创建缓存或者最近一次更新缓存后经过固定的时间间隔，刷新缓存
     * weakKeys: 打开key的弱引用
     * weakValues：打开value的弱引用
     * softValues：打开value的软引用
     * recordStats：开发统计功能
     * 注意：
     * expireAfterWrite和expireAfterAccess同事存在时，以expireAfterWrite为准。
     * maximumSize和maximumWeight不可以同时使用
     * weakValues和softValues不可以同时使用
     */
     @Bean
    public CacheManager cacheManager() {
        SimpleCacheManager cacheManager = new SimpleCacheManager();
        List<CaffeineCache> list = new ArrayList<>();
        //循环添加枚举类中自定义的缓存，可以自定义
        for (CacheEnum cacheEnum : CacheEnum.values()) {
            list.add(new CaffeineCache(cacheEnum.getName(),
                    Caffeine.newBuilder()
                            .initialCapacity(50)
                            .maximumSize(1000)
                            .expireAfterAccess(cacheEnum.getExpires(), TimeUnit.SECONDS)
                            .build()));
        }
        cacheManager.setCaches(list);
        return cacheManager;
    }
}

四、调用缓存

/**
 * value：缓存key的前缀。
 * key：缓存key的后缀。
 * sync：设置如果缓存过期是不是只放一个请求去请求数据库，其他请求阻塞，默认是false（根据个人需求）。
 * unless：不缓存空值,这里不使用，会报错
 * 查询用户信息类
 * 如果需要加自定义字符串，需要用单引号
 * 如果查询为null，也会被缓存
 */
@Cacheable(value = CacheConstants.GET_USER,key = "'user'+#userId",sync = true)
@CacheEvict
public UserEntity getUserByUserId(Integer userId){
    UserEntity userEntity = userMapper.findById(userId);
    System.out.println("查询了数据库");
    return userEntity;
}
A尘埃
关注
  • 11
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring boot+spring cache实现两级缓存(redis+caffeine)
08-27
主要介绍了spring boot+spring cache实现两级缓存(redis+caffeine)，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
【开发篇】十二、缓存框架JetCache
llg___的博客
09-29 428
JetCache对SpringCache进行了封装，在原有功能基础上实现了多级缓存、缓存统计、自动刷新、异步调用、数据报表等功能CaffeineRedisTair。
Spring boot2.7整合jetcache 本地linkedhashmap缓存方案
weixin_45966674的博客
03-10 533
那么 技术选择 fastjson 因为它和我们用的 jetcache 都是阿里 开发的 有jetcache 就不需要导坐标了 里面就包括了这个技术了。然后 我们上文中 CreateCache 默认会使用 remote 的方案。也可以选择 直接 application 不配 远程方案 也是一样的。我们技术用的 本地缓存 linkedhashmap。本文 我们来说说 本地 jetcache解决方案。REMOTE 只用远程。我们讲完了 远程实现方案。LOCAL 只用本地。
浅谈HashMap，LinkedHashMap，ConcurrentHashMap、synchronizedMap（二.LinkedHashMap）
都让你们叫老了的博客
04-06 1295
说完HashMap，我们我们如果想要有序的Map怎么办。取出来之后再排序，不是太复杂。 所以我们有LinkedHashMap。 LinkedHashMap 既然LinkedHashMap是有序的，那么为什么是有序的？首先我们从名字上分析，LinkedHashMap和HashMap不是继承就是实现，那么数据结构应该也是类似的，采用hash表（数组+链表的形式）。等下，HashMap中既然存...
jetcache：阿里这款多级缓存框架一定要掌握
55555的博客
05-06 2197
jetcache是阿里开源的基于java开发的缓存框架，支持多种缓存类型：本地缓存、分布式缓存、多级缓存。能够满足不同业务场景的缓存需求。jetcache具有上手简单、性能高效、拓展性强的特点。支持缓存预热 、缓存key前缀等功能。结合spring-cache使用，可以实现十分优雅的缓存类型切换。
jetCache 缓存框架讲解；SpringBoot 整合 jetCache 代码示例；本地缓存、远程缓存、方法缓存代码示例
csdn_bajie
08-05 1765
jetCache 缓存框架讲解；SpringBoot 整合 jetCache 代码示例；本地缓存、远程缓存、方法缓存代码示例
JetCache多级缓存看这篇文章就够了
流浪者的博客
06-15 2681
JetCache是阿里推出的一套替代springcache的缓存方案。JetCache是对SpringCache进行了封装，在原有基础上实现了多级缓存、缓存统计、自动刷新、异步调用、数据报表等功能。JetCache设定了本地缓存与远程缓存的多级缓存方案本地缓存Caffeine远程缓存RedisTair本地缓存和远程缓存可以任意组合jetcache官方源码: https://github.com/alibaba/jetcache。
SpringBoot SpringBoot 开发实用篇 5 整合第三方技术 5.10 jetcache 本地缓存方案
谢谢你们的关注
11-21 536
SpringBoot SpringBoot 开发实用篇 5 整合第三方技术 5.10 jetcache 本地缓存方案
SpringCache、JetCache、CaffeineCache本地缓存和其他工具使用
点点的博客
07-07 2593
一、CaffeineCache 依赖 <dependency> <groupId>com.github.ben-manes.caffeine</groupId> <artifactId>caffeine</artifactId> <version>2.8.4</version> </dependency>
SpringBoot SpringBoot 开发实用篇 5 整合第三方技术 5.11 jetcache 方法缓存
谢谢你们的关注
11-22 515
SpringBoot SpringBoot 开发实用篇 5 整合第三方技术 5.11 jetcache 方法缓存
【SpringBoot整合缓存】-----jetcache以及j2cache篇
Learning_xzj的博客
06-28 2159
​ 目前我们使用的缓存都是要么A要么B，能不能AB一起用呢？这一节就解决这个问题。springboot针对缓存的整合仅仅停留在用缓存上面，如果缓存自身不支持同时支持AB一起用，springboot也没办法，所以要想解决AB缓存一起用的问题，就必须找一款缓存能够支持AB两种缓存一起用，有这种缓存吗？还真有，阿里出品，jetcache。​ jetcache严格意义上来说，并不是一个缓存解决方案，只能说他算是一个缓存框架，然后把别的缓存放到jetcache中管理，这样就可以支持AB缓存一起用了。并且jetca
Caffeine本地缓存
04-27
Caffeine本地缓存的配置与使用
J2Cache两级缓存框架-其他
06-12
J2Cache是OSChina目前正在使用的两级缓存框架（要求至少 Java 8）。第一级缓存使用内存(同时支持 Ehcache 2.x、Ehcache 3.x 和 Caffeine)，第二级缓存使用 Redis(推荐)/Memcached。由于大量的缓存读取会导致L2的网络...
详细介绍高性能Java缓存库Caffeine
08-28
本篇文章主要介绍了详细介绍高性能Java缓存库Caffeine，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
jetcache：JetCache是​​一个Java缓存框架
02-03
JetCache中的注释支持本地TTL，两级缓存和分布式自动刷新，您也可以手动编写Cache实例。 当前有四个工具： RedisCache ， TairCache （在github上不是开源的）， CaffeineCache （在内存中），一个简单的...
Spring Boot 如何实现缓存预热
qq_44721738的博客
04-22 1161
监听 ContextRefreshedEvent 或 ApplicationReadyEvent 等应用上下文初始化完成事件。
链表-LRU缓存
qq_68006585的博客
04-25 724
如果你又从其他地方拿了一本书读完之后，打算放入这堆书中，如果这堆书中还有同名书，只是年份不同，那么就用这本书进行替换，如果没有同名书，由于“空间”不够使用，只能将最底下的书移走，再放入这本书。每当缓存命中时，就将命中的数据移动到列表的头部，每当缓存缺失时，就将新数据插入到列表的头部，并将列表尾部的数据淘汰掉。int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1。LRU是一种常用的缓存淘汰策略，用于管理缓存中的数据。刚开始时，使用一个哨兵节点。
13 如何利用缓存实现万级并发扣减
周大壮的博客
04-25 1577
在上一讲中的纯数据库方案无法完全满足量级要求时，本讲介绍了纯缓存的扣减方案。着重讲解了为什么纯缓存可以满足扣减的功能需求，对于分析的过程希望你能够理解并应用，而不是关注最终提出的方案。作为一名优秀的开发人员，你要知道架构图是一个最终态，是静止的，它并不能 100% 直接应用到你所面对的场景，而分析思路却是可以复制和模仿的。其次，本讲也分析了纯缓存方案存在的一些异常场景。在实战中，正常流程是简单的，而异常流程的思考与处理十分的复杂与烦琐，同时也最能体现技术性，请你务必注意与加强。
探索和构建 LLaMA 3 架构：深入探讨组件、编码和推理技术（三）KV缓存
最新发布
段智华的博客
04-26 691
探索和构建 LLaMA 3 架构：深入探讨组件、编码和推理技术（三）
jetcache分布式 本地缓存
11-03
JetCache是一款开源的分布式本地缓存框架。在分布式系统中，缓存是提高性能和降低系统压力的重要工具之一，它可以将部分数据存储在离用户更近的位置，减少网络开销和数据库访问次数。 JetCache的特点之一是支持多种缓存管理器，如Redis、Caffeine等，用户可以根据需求选择最适合自己的缓存管理器。这样可以在保证性能的同时，兼顾了灵活性和使用方便性。 分布式环境下的缓存更新是一个常见的难题，JetCache提供了基于Cache-Aside模式的缓存更新策略，通过监听数据库的变更事件，自动将缓存失效或更新。这样可以保证缓存与数据库数据的一致性，提供更好的用户体验。 除了基本的缓存功能外，JetCache还提供了一些高级功能，比如分布式锁和动态缓存配置。分布式锁可以在多节点环境中保证对共享资源的互斥访问，防止并发问题。动态缓存配置可以根据业务需求实时调整缓存的参数，比如缓存过期时间、缓存淘汰策略等。 总之，JetCache是一个功能强大的分布式本地缓存框架，通过提供多种缓存管理器、灵活的缓存更新策略和高级功能，可以帮助开发者在分布式系统中有效地使用缓存，提升系统性能和用户体验。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值