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

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

目录第一种方式（只使用Caffeine）第二种方式(使用Caffeine和spring cache)第三种方式(使用Caffeine和spring cache)

第一种方式（只使用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 caffeineCache() {

return Caffeine.newBuilder()

// 设置最后一次写入或访问后经过固定时间过期

.expireAfterWrite(60, TimeUnit.SECONDS)

// 初始的缓存空间大小

.initialCapacity(1000)

// 缓存的最大条数

.maximumSize(10000)

.build();

}

@Bean(value = "caffeineCache2")

public Cache 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 cache;

@Qualifier("caffeineCache2")

@Autowired

Cache 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 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 http://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) {

SystezvUfqNm.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));

}

}

输出结果

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。