服务器之家：专注于VPS、云服务器配置技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - Java教程 - springboot集成本地缓存Caffeine的三种使用方式(小结)

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

2023-02-14 14:23冬风孤立 Java教程

本文主要介绍了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);
  }

}

输出

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

 

第二种方式(使用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"));
  }


}

输出结果

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

 

第三种方式(使用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的三种使用方式(小结)的文章就介绍到这了,更多相关springboot集成本地缓存Caffeine内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/qq_41921994/article/details/109313445

  • springboot
  • 本地缓存
  • Caffeine

    • 延伸 · 阅读

    精彩推荐
    最近更新
    编辑推荐
    阅读排行
    热门标签
    501 　 406 　 415 　 2000 　 1433 　 204 　 401 　 330 　 选择排序法 　 随机抽取 　 内存卡 　 下载器 　 十六进制字符 　 响应 　 静态工厂 　 构造函数 　 swt 　 Overview 　 对象池模式 　 跨库事务 　 支票 　 金额大写转换 　 空心菱形 　 AspectJ 　 面向切面编程 　 方法名 　 网址信息 　 动态代理模式 　 线程安全 　 htmlparser 　
    © 2019-2023 服务器之家(www.tuohang.net) 版权所有关于我们联系我们版权申明网站地图