索取营销诊断书
021-80394720QQ
您的位置：上海毫米网络优化公司 > 小程序 > 百度小程序 >
相关推荐recommended
SpringBoot整合Caffeine
作者：mmseoamin日期：2023-12-19

SpringBoot整合Caffeine

1. 简介

Caffeine 是基于Java 8 开发的、提供了近乎最佳命中率的高性能本地缓存组件，Spring5 开始不再支持 Guava Cache，改为使用 Caffeine。Caffeine与其他本地缓存的性能比较如下：

SpringBoot整合Caffeine,在这里插入图片描述,第1张

Caffeine具有以下功能：

1. 自动加载条目到缓存中，可选异步方式
2. 可以基于大小剔除
3. 可以设置过期时间，时间可以从上次访问或上次写入开始计算
4. 异步刷新
5. keys自动包装在弱引用中
6. values自动包装在弱引用或软引用中
7. 条目剔除通知
8. 缓存访问统计

2. SpringBoot整合Caffeine

下面介绍SpringBoot使用Caffeine的简单案例

pom.xml



    4.0.0
    com.young
    caffeine02
    1.0-SNAPSHOT
    
        spring-boot-starter-parent
        org.springframework.boot
        2.7.0
    
    
        
            org.springframework.boot
            spring-boot-starter-web
        
        
            org.springframework.boot
            spring-boot-starter-test
        
        
            mysql
            mysql-connector-java
        
        
            com.baomidou
            mybatis-plus-boot-starter
            3.4.3
        
        
        
            com.github.ben-manes.caffeine
            caffeine
        
        
            org.projectlombok
            lombok
        
    
    
        11
        11

数据库内容如下图：

SpringBoot整合Caffeine,在这里插入图片描述,第2张

User实体类

package com.young.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.ToString;
import java.io.Serializable;
@Data
@TableName(value = "t_user")
@ToString
public class User implements Serializable {
    @TableId(type = IdType.AUTO)
    private Integer id;
    private String username;
    private String password;
    private String sex;
    private Integer age;
}

UserMapper.java

package com.young.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.young.entity.User;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface UserMapper extends BaseMapper {
}

UserService.java

package com.young.service;
import com.young.entity.User;
public interface UserService {
    Boolean saveUser(User user);
    Boolean updateUser(User user);
    Boolean deleteUserById(Integer id);
    User getUserById(Integer id);
}

UserServiceImpl.java

package com.young.service.impl;
import com.github.benmanes.caffeine.cache.Cache;
import com.young.entity.User;
import com.young.mapper.UserMapper;
import com.young.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;
    @Resource
    private CachecaffeineCache;
    @Override
    public Boolean saveUser(User user) {
        return userMapper.insert(user)>0;
    }
    @Override
    public Boolean updateUser(User user) {
        if (user.getId()==null){
            return false;
        }
        if(userMapper.updateById(user)>0){
            //删除缓存
            caffeineCache.asMap().remove(user.getId()+"");
            return true;
        }
        return false;
    }
    @Override
    public Boolean deleteUserById(Integer id) {
        if (userMapper.deleteById(id)>0){
            //删除缓存
            caffeineCache.asMap().remove(id+"");
            return true;
        }
        return false;
    }
    @Override
    public User getUserById(Integer id) {
        User user=(User)caffeineCache.asMap().get(id+"");
        if (user!=null){
            log.info("从缓存中获取==============");
            return user;
        }
        log.info("从数据库中获取===============");
        user=userMapper.selectById(id);
        if (user==null){
            log.info("数据为空===========");
            return null;
        }
        caffeineCache.put(id+"",user);
        return user;
    }
}

常用的配置参数

expireAfterWrite：写入间隔多久淘汰；
expireAfterAccess：最后访问后间隔多久淘汰；
refreshAfterWrite：写入后间隔多久刷新，该刷新是基于访问被动触发的，支持异步刷新和同步刷新，如果和 expireAfterWrite 组合使用，能够保证即使该缓存访问不到、也能在固定时间间隔后被淘汰，否则如果单独使用容易造成OOM；
expireAfter：自定义淘汰策略，该策略下 Caffeine 通过时间轮算法来实现不同key 的不同过期时间；
maximumSize：缓存 key 的最大个数；
weakKeys：key设置为弱引用，在 GC 时可以直接淘汰；
weakValues：value设置为弱引用，在 GC 时可以直接淘汰；
softValues：value设置为软引用，在内存溢出前可以直接淘汰；
executor：选择自定义的线程池，默认的线程池实现是 ForkJoinPool.commonPool()；
maximumWeight：设置缓存最大权重；
weigher：设置具体key权重；
recordStats：缓存的统计数据，比如命中率等；
removalListener：缓存淘汰监听器；
writer：缓存写入、更新、淘汰的监听器。

CaffeineCache的配置类，我们配置过期时间为10秒，初始容量100，最大容量200

package com.young.config;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.CacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.concurrent.TimeUnit;
@Configuration
public class CaffeineConfig {
    @Bean
    public Cache caffeineCache(){
        return Caffeine.newBuilder()
                //设置10秒后过期,方便后续观察现象
                .expireAfterWrite(10, TimeUnit.SECONDS)
                //初始容量为100
                .initialCapacity(100)
                //最大容量为200
                .maximumSize(200)
                .build();
    }
}

然后创建测试类，进行测试：

package com.young;
import com.young.entity.User;
import com.young.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
@Slf4j
public class Caffine02ApplicationTest {
    @Autowired
    private UserService userService;
    @Test
    public void testCache(){
        //获取缓存
        User user = userService.getUserById(1);
        log.info("第一次从数据库获取缓存：{}",user);
        user=userService.getUserById(1);
        log.info("第二次从缓存中获取：{}",user);
        //过期时间为10秒，我们10秒后再获取
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        user=userService.getUserById(1);
        log.info("10秒后再次获取user：{}",user);
    }
}

第一次获取user时，因为缓存中没有内容，所以会从数据库中查询，第二次会从缓存中获取到内容，然后睡眠10秒，此时缓存过期了，因此再次获取user的时候，会从数据库中获取，运行结果如下图所示：

SpringBoot整合Caffeine,在这里插入图片描述,第3张

3. Caffeine的四种类型的加载策略

3.1 Manual手动加载

我们修改CaffeineConfig.java

package com.young.config;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.cache.CacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.concurrent.TimeUnit;
@Configuration
public class CaffeineConfig {
    @Bean
    @Qualifier(value = "caffeineCache")
    public Cache caffeineCache(){
        return Caffeine.newBuilder()
                //设置10秒后过期,方便后续观察现象
                .expireAfterWrite(10, TimeUnit.SECONDS)
                //初始容量为100
                .initialCapacity(100)
                //最大容量为200
                .maximumSize(200)
                .build();
    }
	//定义manualCaffeineCache，用来演示手动加载
    @Bean
    @Qualifier(value = "manualCaffeineCache")
    public Cache manualCaffeineCache(){
        return Caffeine.newBuilder()
                .expireAfterWrite(10,TimeUnit.SECONDS)
                .initialCapacity(50)
                .maximumSize(100)
                .build();
    }
}

修改Caffeine02ApplicationTest.java,添加测试用例

package com.young;
import com.github.benmanes.caffeine.cache.Cache;
import com.young.entity.User;
import com.young.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;
import javax.annotation.Resource;
@SpringBootTest
@Slf4j
public class Caffine02ApplicationTest {
    @Autowired
    private UserService userService;
    @Resource
    @Qualifier(value = "manualCaffeineCache")
    private Cache manualCaffineCache;
    @Test
    public void testCache(){
        //获取缓存
        User user = userService.getUserById(1);
        log.info("第一次从数据库获取缓存：{}",user);
        user=userService.getUserById(1);
        log.info("第二次从缓存中获取：{}",user);
        //过期时间为10秒，我们10秒后再获取
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        user=userService.getUserById(1);
        log.info("10秒后再次获取user：{}",user);
    }
    @Test
    public void testManualCaffeineCache(){
        //将数据放入缓存
        manualCaffineCache.put("The best language","java");
        //获取key对应的value，如果不存在，返回null
        String the_best_language = manualCaffineCache.getIfPresent("The best language");
        System.out.println(the_best_language);
        //删除entry
        manualCaffineCache.invalidate("The best language");
        the_best_language= manualCaffineCache.getIfPresent("The best language");
        System.out.println(the_best_language);
        //以map的形式进行增删改查==================
        manualCaffineCache.asMap().put("best","java");
        manualCaffineCache.asMap().put("best1","SpringBoot");
        String best = manualCaffineCache.asMap().get("best");
        String best1 = manualCaffineCache.asMap().get("best1");
        System.out.println("best:"+best);
        System.out.println("best1:"+best1);
        //删除entry
        manualCaffineCache.asMap().remove("best");
        manualCaffineCache.asMap().remove("best1");
        best = manualCaffineCache.asMap().get("best");
        best1 = manualCaffineCache.asMap().get("best1");
        System.out.println("best:"+best);
        System.out.println("best1:"+best1);
    }
}

常用的方法：

getIfPresent(Object key): 获取value值，如果entry不存在，返回null
put(Object key,Object value): 添加entry到缓存中
invalidate(Object key): 删除entry
asMap(): 将cache以map的形式进行操作

测试testManualCaffeineCache，结果如下：

SpringBoot整合Caffeine,在这里插入图片描述,第4张

3.2 loading

LoadingCache通过关联一个CacheLoader来构建Cache, 当缓存未命中会调用CacheLoader的load方法生成V，还可以通过LoadingCache的getAll方法批量查询, 当CacheLoader未实现loadAll方法时, 会批量调用load方法聚合会返回。当CacheLoader实现loadAll方法时, 则直接调用loadAll返回。

我们在CaffeineConfig中添加下面的bean

   @Bean
    @Qualifier(value = "loadingCaffeineCache")
    public LoadingCache loadingCaffeineCache(){
        return Caffeine.newBuilder()
                .expireAfterWrite(60, TimeUnit.SECONDS)
                .maximumSize(500)
                .build(new CacheLoader() {
                    //缓存未命中时，使用下面的方法生成value
                    @Override
                    public @Nullable Object load(@NonNull String key) throws Exception {
                        User user=new User();
                        user.setId(-1);
                        user.setUsername(key);
                        user.setPassword(key);
                        return user;
                    }
                    @Override
                    public MaploadAll(Iterablekeys){
                        Mapmap=new HashMap<>();
                        for (String key:keys){
                            User user=new User();
                            user.setId(-1);
                            user.setUsername(key);
                            user.setPassword(key);
                            map.put(key,user);
                        }
                        return map;
                    }
                });
    }

然后添加测试方法

 @Resource
    @Qualifier(value = "loadingCaffeineCache")
    private LoadingCache loadingCaffeineCache;
    @Test
    public void testLoadingCaffeineCache(){
        User user=new User();
        user.setId(1);
        user.setUsername("cxy");
        user.setPassword("123456");
        user.setAge(20);
        user.setSex("男");
        loadingCaffeineCache.put("1",user);
        User res=(User)loadingCaffeineCache.getIfPresent("1");
        System.out.println("res:"+res);
        res=(User)loadingCaffeineCache.getIfPresent("2");
        System.out.println("res:"+res);
        Listlist= Arrays.asList("1","2","3");
        Map<@NonNull String, @NonNull Object> resMap = loadingCaffeineCache.getAllPresent(list);
        System.out.println("resMap:"+resMap);
        System.out.println("上面调用的都是IfPresent(),即存在才返回，因此不会触发我们刚才的两个load函数==========");
        res=(User)loadingCaffeineCache.get("2");
        System.out.println("res:"+res);
        resMap= loadingCaffeineCache.getAll(list);
        System.out.println("resMap:"+resMap);
    }

测试结果如下：

SpringBoot整合Caffeine,在这里插入图片描述,第5张

3.3 Asynchronous Manual异步手动

AsyncCache是另一种Cache，它基于Executor计算Entry，并返回一个CompletableFuture

和Cache的区别是, AsyncCache计算Entry的线程是ForkJoinPool线程池. 手动Cache缓存是调用线程进行计算

private static void demo() throws ExecutionException, InterruptedException {
		AsyncCache cache = Caffeine.newBuilder()
			.maximumSize(500)
			.expireAfterWrite(10, TimeUnit.SECONDS)
			.buildAsync();
		// Lookup and asynchronously compute an entry if absent
		CompletableFuture future = cache.get("hello", k -> createExpensiveGraph(k));
		System.out.println(future.get());
	}
	private static String createExpensiveGraph(String key){
		System.out.println("begin to query db..."+Thread.currentThread().getName());
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
		}
		System.out.println("success to query db...");
		return UUID.randomUUID().toString();
	}
3.4 异步自动

AsyncLoadingCache 是关联了 AsyncCacheLoader 的 AsyncCache

public static void demo() throws ExecutionException, InterruptedException {
		AsyncLoadingCache cache = Caffeine.newBuilder()
			.expireAfterWrite(10, TimeUnit.SECONDS)
			.maximumSize(500)
			.buildAsync(k -> createExpensiveGraph(k));
		CompletableFuture future = cache.get("hello");
		System.out.println(future.get());
	}
	private static String createExpensiveGraph(String key){
		System.out.println("begin to query db..."+Thread.currentThread().getName());
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
		}
		System.out.println("success to query db...");
		return UUID.randomUUID().toString();
	}

4. 配置监听器

修改caffeineConfig，添加监听器

 @Bean
    @Qualifier(value = "listenerCaffeineCache")
    public Cache listenerCaffeineCache(){
        return Caffeine.newBuilder()
                .expireAfterWrite(10,TimeUnit.SECONDS)
                .initialCapacity(100)
                .maximumSize(200)
                .evictionListener(new RemovalListener() {
                    @Override
                    public void onRemoval(@Nullable String key, @Nullable Object value, @NonNull RemovalCause removalCause) {
                        System.out.println("evictionListener:key="+key+",value="+value+",removalCause="+removalCause);
                    }
                }).removalListener((key,value,cause)->{
                    System.out.println("removalListener:key="+key+",value="+value+",cause="+cause);
                })
                .build();
    }

测试代码

@Resource
    @Qualifier(value = "listenerCaffeineCache")
    private CachelistenerCaffeineCache;
    @Test
    public void testListenerCaffeineCache() throws InterruptedException {
        listenerCaffeineCache.put("cxy","程序员");
        listenerCaffeineCache.put("best","java");
        listenerCaffeineCache.invalidate("cxy");
        listenerCaffeineCache.asMap().remove("best");
    }

测试结果如下：

SpringBoot整合Caffeine,在这里插入图片描述,第6张

参考文章：

Caffeine本地缓存详解

高性能缓存 Caffeine 原理及实战

上一篇：爬虫基本原理

下一篇：仓库管理系统

网站优化运营
整站seo优化
网络营销运营
成功案例
品牌创意网站
营销型网站
小程序
微信小程序
微信公众号
百度熊掌号
网站优化分享
关于我们
公司概况
公司新闻
公司文化
结构体系
企业资质
加入我们
关注我们
扫描二维码
获取更多信息
精彩一手掌握
Copyright © 2014-2019 seo,上海网站优化_网络制作_网站seo排名_网站建设推广_上海网络公司 版权所有 沪ICP备19022315号