【Java 使用LoadingCache 内存缓存】

前言

在开发中，遇见一些固定的数据，经常会被sql Selete查询。特别是数据量大的时候，会发现功能效率明显的不足，执行的速度很慢，不断的访问数据库，也会造成一定的压力。当然，可以通过一些缓存手段来降低数据库的压力，提供查询的效率，例如redis数据库。
本章主要是略介绍一下LoadingCache的使用。LoadingCache适合将一些经常被访问的固定的数据缓存到我们的内存中来，下一次在设置的时间内被访问，会直接从内存中读取数据。

LoadingCache 依赖

pom.xml文件需要导入google的依赖，如下

        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>23.6-jre</version>
        </dependency>

Controller 访问层

做一个简单的案例，前端请求访问用户数据。假设用户数据长期不变的前提下，将用户对象缓存至内存中。

/**
 * 查询用户数据
 * @author huangdy
 * @date
 */
@RestController
public class UserController {

    @Resource
    private UserService userService;

    @GetMapping("/getUserById")
    public User greeting(@RequestParam(value = "userId", defaultValue = "1") Integer userId) {

        User user = userService.selectUser(userId);


        return new User(userId, user.getUserName());
    }
}

Service 业务层

selectUser()方法为controller到service查询用户的方法。并且该方法，调用loadingCacheService.selectUser()，如果缓存中，能查询到用户信息，则直接从缓存中获取，否则查询数据库中用户信息。

/**
 * 用户业务层
 * @Author huangdy
 * @Date 2022/2/14 10:44
 */
@Service
public class UserService {

    @Resource
    private LoadingCacheService loadingCacheService;

    /**
     * 查询用户信息
     * @return
     */
    public User selectUser(Integer userId){
        return loadingCacheService.selectUser(userId);
    }

}

Mapper层

getUserById()方法，模仿从数据库中获取用户信息

/**
 * 用户mapper层
 * @Author huangdy
 * @Date 2022/2/14 12:14
 */
@Repository
public class UserServiceMapper {

    /**
     * 假设该方法从数据库中查询用户数据
     * @param key
     * @return
     */
    public User getUserById(Integer key){


        Map<Integer, User> userMap = new HashMap<>();
        User zhangSan = new User(1, "zhangSan");
        User liSi = new User(2, "liSi");
        User wangWu = new User(3, "wangWu");
        User zhaoLiu = new User(4, "zhaoLiu");

        userMap.put(1,zhangSan);
        userMap.put(2,liSi);
        userMap.put(3,wangWu);
        userMap.put(4,zhaoLiu);

        return userMap.get(key);
    }
}

LoadingCacheService

属性cache缓存用户数据

/**
 * LoadingCache业务
 * @Author huangdy
 * @Date 2022/2/10 22:10
 */
@Service
public class LoadingCacheService {

    private final static Logger logger = LoggerFactory.getLogger(LoadingCacheService.class);

    @Resource
    private UserServiceMapper userServiceMapper;

    /**
     * 缓存用户数据
     * 优先从缓存中获取用户信息 否则查询数据库
     */
    private final LoadingCache<Integer, User> cache = CacheBuilder.newBuilder()
            //初始化大小
            .initialCapacity(3)
            //最大缓存大小，缓存到内存中的个数超过该值，将会回收最old的数据(即先缓存的数据)
            .maximumSize(3)
            //刷新时间，缓存的数据在该时间内没有被命中，将回收缓存的该数据。如果命中后，则会重新计算时间。
            .refreshAfterWrite(1, TimeUnit.MINUTES)
            //过期时间
            .expireAfterWrite(2, TimeUnit.MINUTES)
            //构建
            .build(new CacheLoader<Integer, User>() {
                @Override
                public User load(Integer key) throws Exception {

                    //从数据库中查询符合条件的数据
                    User currentUser = userServiceMapper.getUserById(key);
                    logger.info("key -> {},数据库查询当前用户对象为 -> {}",key,JSON.toJSONString(currentUser));

                    //并缓存到内存中
                    return currentUser;
                }
            });


    public User selectUser(Integer key){
        User user = new User();
        try {

            user = cache.get(key);

        } catch (ExecutionException e) {
            logger.error("未查询到用户数据");
        }
        return user;
    }
}

请求访问测试 案例

请求url -> {localhost:8080/getUserById?userId=1}

由于第一次访问userId = 1的用户数据，会直接从数据库中获取。因此LoadingCacheService中会打印查询数据库的logger

2022-02-14 14:03:55.001  INFO 9632 --- [nio-8080-exec-6] c.e.s.restservice.LoadingCacheService    : key -> 1,数据库查询当前用户对象为 -> {"id":1,"userName":"zhangSan"}

LoadingCacheService中cache设置的缓存刷新时间为1分钟，在1分钟之内访问，会发现，不会再打印该日志，超过一分钟访问则会重新访问数据库。

再次访问userId = 2

请求url -> {localhost:8080/getUserById?userId=2}

会继续打印日志

2022-02-14 14:14:01.761  INFO 9632 --- [nio-8080-exec-8] c.e.s.restservice.LoadingCacheService    : key -> 1,数据库查询当前用户对象为 -> {"id":1,"userName":"zhangSan"}
2022-02-14 14:14:18.279  INFO 9632 --- [nio-8080-exec-9] c.e.s.restservice.LoadingCacheService    : key -> 2,数据库查询当前用户对象为 -> {"id":2,"userName":"liSi"}

我们可以看一下此时的cache数据，是一种（key,value）的结构

注意点

当我们的请求访问为userId = 999时，会发现，我们模仿数据库查询的数据，会返回null。

请求url -> {localhost:8080/getUserById?userId=1}

控制台日志打印

2022-02-14 14:17:04.010  INFO 9632 --- [nio-8080-exec-1] c.e.s.restservice.LoadingCacheService    : key -> 999,数据库查询当前用户对象为 -> null

此时loadingCache将会抛出异常，不允许将null值设置到缓存中。

com.google.common.cache.CacheLoader$InvalidCacheLoadException: CacheLoader returned null for key 999.
	at com.google.common.cache.LocalCache$Segment.getAndRecordStats(LocalCache.java:2286) ~[guava-23.6-jre.jar:na]
	at com.google.common.cache.LocalCache$Segment.loadSync(LocalCache.java:2250) ~[guava-23.6-jre.jar:na]
	at com.google.common.cache.LocalCache$Segment.lockedGetOrLoad(LocalCache.java:2132) ~[guava-23.6-jre.jar:na]
	at com.google.common.cache.LocalCache$Segment.get(LocalCache.java:2045) ~[guava-23.6-jre.jar:na]
	at com.google.common.cache.LocalCache.get(LocalCache.java:3962) ~[guava-23.6-jre.jar:na]
	at com.google.common.cache.LocalCache.getOrLoad(LocalCache.java:3966) ~[guava-23.6-jre.jar:na]
	at com.google.common.cache.LocalCache$LocalLoadingCache.get(LocalCache.java:4951) ~[guava-23.6-jre.jar:na]
	at com.example.springstudy.restservice.LoadingCacheService.selectUser(LoadingCacheService.java:60) ~[classes/:na]
	at com.example.springstudy.restservice.UserService.selectUser(UserService.java:24) ~[classes/:na]
	at com.example.springstudy.restservice.UserController.greeting(UserController.java:24) ~[classes/:na]

那如果我们不返回null，而是返回一个空的User对象，那cache也会将key为999的user缓存起来。cache不会无限制的缓存数据，取决于我们设置的最大容量maximumSize，数据超过该值时，将会默认回收cache中最久未被访问的数据。