脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → springboot集成本地缓存Caffeine

springboot集成本地缓存Caffeine的三种使用方式(小结)

 更新时间：2022年06月02日 16:04:00   作者：冬风孤立  
本文主要介绍了springboot集成本地缓存Caffeine的三种使用方式，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧

第一种方式（只使用Caffeine）

gradle添加依赖

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-jdbc'
    implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:2.1.3'
    runtimeOnly 'mysql:mysql-connector-java'
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation('org.springframework.boot:spring-boot-starter-test') {
        exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
    }
    compile group: 'com.github.ben-manes.caffeine', name: 'caffeine', version: '2.8.4'
//    compile('org.springframework.boot:spring-boot-starter-cache')
}

编写配置类

package org.example.base.config;

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.TimeUnit;

/**
 * @author l
 * @date Created in 2020/10/27 11:05
 */
@Configuration
//@EnableCaching
public class CacheConfig {


    @Bean(value = "caffeineCache")
    public Cache<String, Object> caffeineCache() {
        return Caffeine.newBuilder()
                // 设置最后一次写入或访问后经过固定时间过期
                .expireAfterWrite(60, TimeUnit.SECONDS)
                // 初始的缓存空间大小
                .initialCapacity(1000)
                // 缓存的最大条数
                .maximumSize(10000)
                .build();

    }

    @Bean(value = "caffeineCache2")
    public Cache<String, Object> caffeineCache2() {
        return Caffeine.newBuilder()
                // 设置最后一次写入或访问后经过固定时间过期
                .expireAfterWrite(120, TimeUnit.SECONDS)
                // 初始的缓存空间大小
                .initialCapacity(1000)
                // 缓存的最大条数
                .maximumSize(10000)
                .build();

    }


}

测试

package org.example.base;

import com.github.benmanes.caffeine.cache.Cache;
import org.example.base.bean.User;
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;

@SpringBootTest
class BaseApplicationTests {

	@Qualifier("caffeineCache")
	@Autowired
    Cache<String, Object> cache;


	@Qualifier("caffeineCache2")
	@Autowired
	Cache<String, Object> cache2;

    @Test
    public void test() {
        User user = new User(1, "张三", 18);
        cache.put("123", user);
        User user1 = (User) cache.getIfPresent("123");
        assert user1 != null;
        System.out.println(user1.toString());
        User user2 = (User) cache2.getIfPresent("1234");
        System.out.println(user2 == null);
    }

}

输出

第二种方式(使用Caffeine和spring cache)

gradle添加依赖

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-jdbc'
    implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:2.1.3'
    runtimeOnly 'mysql:mysql-connector-java'
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation('org.springframework.boot:spring-boot-starter-test') {
        exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
    }
    compile group: 'com.github.ben-manes.caffeine', name: 'caffeine', version: '2.8.4'
    compile('org.springframework.boot:spring-boot-starter-cache')
}

编写配置类

package org.example.base.config;

import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.caffeine.CaffeineCache;
import org.springframework.cache.support.SimpleCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.time.Duration;
import java.util.ArrayList;


/**
 * @author l
 * @date Created in 2020/10/27 11:05
 */
@Configuration
@EnableCaching
public class CacheConfig {


    public enum CacheEnum {
        /**
         * @date 16:34 2020/10/27
         * 第一个cache
         **/
        FIRST_CACHE(300, 20000, 300),
        /**
         * @date 16:35 2020/10/27
         * 第二个cache
         **/
        SECOND_CACHE(60, 10000, 200);

        private int second;
        private long maxSize;
        private int initSize;

        CacheEnum(int second, long maxSize, int initSize) {
            this.second = second;
            this.maxSize = maxSize;
            this.initSize = initSize;
        }

    }

    @Bean("caffeineCacheManager")
    public CacheManager cacheManager() {
        SimpleCacheManager cacheManager = new SimpleCacheManager();
        ArrayList<CaffeineCache> caffeineCaches = new ArrayList<>();
        for (CacheEnum cacheEnum : CacheEnum.values()) {
            caffeineCaches.add(new CaffeineCache(cacheEnum.name(),
                    Caffeine.newBuilder().expireAfterWrite(Duration.ofSeconds(cacheEnum.second))
                            .initialCapacity(cacheEnum.initSize)
                            .maximumSize(cacheEnum.maxSize).build()));
        }
        cacheManager.setCaches(caffeineCaches);
        return cacheManager;
    }

//    @Bean("FIRST_CACHE")
//    public Cache firstCache(CacheManager cacheManager) {
//        return cacheManager.getCache("FIRST_CACHE");
//    }
//
//    @Bean("SECOND_CACHE")
//    public Cache secondCache(CacheManager cacheManager) {
//        return cacheManager.getCache("SECOND_CACHE");
//    }

}

编写service层

package org.example.base;

import org.example.base.bean.User;
import org.example.base.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class BaseApplicationTests {

    @Autowired
    private UserService userService;

    @Test
    public void test() {
        User user = new User(123,"jack l",18);
        userService.setUser(user);
        System.out.println(userService.getUser("123"));
    }


}

测试

package org.example.base;

import org.example.base.bean.User;
import org.example.base.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class BaseApplicationTests {

    @Autowired
    private UserService userService;

    @Test
    public void test() {
        User user = new User(123,"jack l",18);
        userService.setUser(user);
        System.out.println(userService.getUser("123"));
    }


}

输出结果

第三种方式(使用Caffeine和spring cache)

  • gradle依赖添加同方式二
  • 配置类添加方式同方式二
  • 编写service层
package org.example.base.service.impl;

import org.example.base.bean.User;
import org.example.base.service.UserService;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;


/**
 * @author l
 * @date Created in 2020/10/23 14:47
 */
@Service
//@CacheConfig(cacheNames = "SECOND_CACHE",cacheManager = "caffeineCacheManager")
public class UserServiceImpl implements UserService {

    /**
     * 使用@CachePut注解的方法，一定要有返回值，该注解声明的方法缓存的是方法的返回结果。
     * it always causes the
     * method to be invoked and its result to be stored in the associated cache
     **/
    @Override
    @CachePut(key = "#user.getId()", value = "SECOND_CACHE", cacheManager = "caffeineCacheManager")
    public User setUser(User user) {
        System.out.println("已经存储进缓存了");
        return user;
    }

    @Override
    @CacheEvict(value = "SECOND_CACHE",cacheManager = "caffeineCacheManager")
    public void deleteUser(Integer id) {
        System.out.println("缓存删除了");
    }

    @Override
    @Cacheable(key = "#id", value = "SECOND_CACHE", cacheManager = "caffeineCacheManager")
    public User getUser(Integer id) {
        System.out.println("从数据库取值");
        //模拟数据库中的数据
       return null;
    }


}

测试

package org.example.base;

import org.example.base.bean.User;
import org.example.base.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class BaseApplicationTests {

    @Autowired
    private UserService userService;


    @Test
    public void test4(){
        User user1 = new User(123, "jack l", 18);
        userService.setUser(user1);
        System.out.println("从缓存中获取 "+userService.getUser(123));
        System.out.println(userService.getUser(123322222));
        userService.deleteUser(123);
        System.out.println(userService.getUser(123));

    }


}

输出结果

到此这篇关于springboot集成本地缓存Caffeine的三种使用方式(小结)的文章就介绍到这了,更多相关springboot集成本地缓存Caffeine内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • Servlet连接数据库实现用户登录的实现示例

    Servlet连接数据库实现用户登录的实现示例

    本文主要介绍了Servlet连接数据库实现用户登录的实现示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2022-06-06
  • SpringBoot中的Logging详解

    SpringBoot中的Logging详解

    这篇文章主要介绍了SpringBoot中的Logging详解,log配置可能是被忽视的一个环节,一般的项目中日志配置好了基本上很少去改动,我们常规操作是log.info来记录日志内容,很少会有人注意到springBoot中日志的配置,需要的朋友可以参考下
    2023-09-09
  • spring boot国际化之MessageSource的使用方法

    spring boot国际化之MessageSource的使用方法

    这篇文章主要给大家介绍了spring boot国际化之MessageSource使用的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2020-11-11
  • java 线程池的实现方法

    java 线程池的实现方法

    在本篇文章里小编给大家整理了关于java 线程池的实现方法，有兴趣的朋友们可以学习参考下。
    2020-02-02
  • 浅谈Java中方法参数传递的问题

    浅谈Java中方法参数传递的问题

    下面小编就为大家带来一篇浅谈Java中方法参数传递的问题。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2017-08-08
  • Java中图像锐化操作的方法详解

    Java中图像锐化操作的方法详解

    这篇文章主要给大家介绍了关于Java中图像锐化操作的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2020-11-11
  • Java和C#下的参数验证方法

    Java和C#下的参数验证方法

    下面小编就为大家带来一篇Java和C#下的参数验证实现方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2016-09-09
  • Java实现登录与注册页面

    Java实现登录与注册页面

    这篇文章主要为大家详细介绍了Java实现登录与注册页面，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2022-04-04
  • SpringMVC4.3 HandlerExceptionResolver异常处理源码解析

    SpringMVC4.3 HandlerExceptionResolver异常处理源码解析

    这篇文章主要为大家介绍了SpringMVC4.3 HandlerExceptionResolver异常处理源码解析,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪<BR>
    2023-09-09
  • JAVA面试题 从源码角度分析StringBuffer和StringBuilder的区别

    JAVA面试题 从源码角度分析StringBuffer和StringBuilder的区别

    这篇文章主要介绍了JAVA面试题 从源码角度分析StringBuffer和StringBuilder的区别,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，下面我们来一起学习下吧
    2019-07-07

最新评论