第6篇 springboot2 集成缓存jetcache（不是s

2019-08-14 本文已影响31人 allen1683

1、JetCache简介

JetCache 是由阿里巴巴开源的一款通用缓存访问框架。官方文档说明JetCache 提供的核心能力包括：

提供统一的，类似jsr-107风格的API访问Cache，并可通过注解创建并配置Cache实例
通过注解实现声明式的方法缓存，支持TTL和两级缓存
分布式缓存自动刷新，分布式锁 (2.2+)
支持异步Cache API
Spring Boot支持
Key的生成策略和Value的序列化策略是可以定制的
针对所有Cache实例和方法缓存的自动统计

详细可查看JetCache的github地址：https://github.com/alibaba/jetcache

2、企业开发过程缓存的选择

在企业开发过程中，使用cache的常规操作对应增删改查，

增加操作时，不使用缓存
删除操作时，删除原有缓存
修改操作时，删除原有缓存（不建议更新缓存）
查看操作时，添加缓存信息
最开始使用的spring cache，但是由于springcache只支持全局的缓存过期时间设置，不支持单个设置缓存过期时间，且jetcache支持三种缓存方式LOCAL/REMOTE/BOTH 三种选择，分别代表本地内存/远程 Cache Server（如Redis）/两级缓存,下面以redis为存储，springboot整合jetcache

3、集成JetCache实现缓存

3.1增加jetCache的缓存配置

# 统计间隔，默认0：表示不统计
jetcache.statIntervalMinutes: 1
# areaName是否作为缓存key前缀，默认True
jetcache.areaInCacheName: false
# 已支持可选：linkedhashmap、caffeine
jetcache.local.default.type: linkedhashmap
# key转换器的全局配置，当前只有：fastjson, @see com.alicp.jetcache.support.FastjsonKeyConvertor
jetcache.local.default.keyConvertor: fastjson
# 每个缓存实例的最大元素的全局配置，仅local类型的缓存需要指定
jetcache.local.default.limit: 100
# jetcache2.2以上，以毫秒为单位，指定多长时间没有访问，就让缓存失效，当前只有本地缓存支持。0表示不使用这个功能
jetcache.local.default.expireAfterAccessInMillis: 30000
# 已支持可选：redis、tair
jetcache.remote.default.type: redis
jetcache.remote.default.database=1
jetcache.remote.default.host: 10.0.40.235
jetcache.remote.default.port: 6379
jetcache.remote.default.password=sundata
jetcache.remote.default.poolConfig.minIdle: 5
jetcache.remote.default.poolConfig.maxIdle: 20
jetcache.remote.default.poolConfig.maxTotal: 50
jetcache.remote.default.keyConvertor: fastjson
# 序列化器的全局配置。仅remote类型的缓存需要指定，可选java和kryo
jetcache.remote.default.valueEncoder: java
jetcache.remote.default.valueDecoder: java
# 以毫秒为单位指定超时时间的全局配置
jetcache.remote.default.expireAfterWriteInMillis: 5000

3.2启用缓存注解

在NatureEduWebApplication启动类增加两个注解@EnableCreateCacheAnnotation
@EnableMethodCache(basePackages = "com.nature.edu.service")
表示启用jetcache的注解和缓存作用的方法的范围，需要指定缓存类的包路径

package com.nature.edu;

import com.alicp.jetcache.anno.config.EnableCreateCacheAnnotation;
import com.alicp.jetcache.anno.config.EnableMethodCache;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

/**
 * @author wangck
 * @date 2019/8/6
 */
@SpringBootApplication
@EnableCreateCacheAnnotation
@EnableMethodCache(basePackages = "com.nature.edu.service")
public class NatureEduWebApplication extends SpringBootServletInitializer {

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

    @Autowired
    private RestTemplateBuilder builder;

    @Bean
    public RestTemplate restTemplate() {
        return builder.build();
    }

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(NatureEduWebApplication.class);
    }

    public static void main(String[] args) throws Exception {
        logger.info("开始启动！");
        SpringApplication.run(NatureEduWebApplication.class, args);
        logger.info("启动完成！");
    }

}

3.3 实现类添加缓存操作

在UserServiceImpl的修改、删除、单个查询中指定缓存操作

修改用户清除缓存,增加@CacheInvalidate注解

 @Override
    @CacheInvalidate(name="nature.edu.user",key="#user.userId")
    public Response<Boolean> modifyUser(UserVO user) {
        if (user == null) {
            logger.error("修改用户时，用户信息不能为空'");
            return Response.failResult("用户信息不能为空");
        }
        String userId = user.getUserId();
        if (StringUtils.isBlank(userId)) {
            logger.error("修改用户时，userId不能为空'");
            return Response.failResult("用户Id不能为空");
        }
        BasUser basUser = new BasUser();
        basUser.setUserId(userId);
        basUser.setUserNo(user.getUserNo());
        basUser.setUserName(user.getUserName());
        basUser.setPersonName(user.getPersonName());
        Integer count = basUserMapper.updateById(basUser);
        if (count > 0) {
            logger.info("修改用户成功，用户信息：{}", basUser);
            return Response.successResult("修改用户成功", true);
        } else {
            logger.error("修改用户失败，用户信息：{}", basUser);
            return Response.failResult("修改用户失败", false);
        }
    }

删除用户清除缓存 ,增加@CacheInvalidate注解

 @Override
    @CacheInvalidate(name="nature.edu.user",key="#userId")
    public Response<Boolean> deleteUser(String userId) {
        if (StringUtils.isBlank(userId)) {
            logger.error("删除用户时，userId不能为空'");
            return Response.failResult("用户Id不能为空");
        }
        Integer count = basUserMapper.deleteById(userId);
        if (count > 0) {
            logger.info("删除用户成功，用户Id：{}", userId);
            return Response.successResult("删除用户成功", true);
        } else {
            logger.error("删除用户失败，用户id：{}", userId);
            return Response.failResult("删除用户失败", false);
        }
    }

查询用户增加缓存，增加@Cached注解

@Override
    @Cached(name="nature.edu.user",key="#userId",expire = 3600, cacheType = CacheType.REMOTE)
    public Response<UserVO> getUser(String userId) {
        if (StringUtils.isBlank(userId)) {
            logger.error("查询用户信息时，userId不能为空'");
            return Response.failResult("用户Id不能为空");
        }
        BasUser basUser = basUserMapper.selectById(userId);
        if (basUser != null) {
            UserVO user = new UserVO();
            user.setUserId(basUser.getUserId());
            user.setUserNo(basUser.getUserNo());
            user.setUserName(basUser.getUserName());
            user.setUserHead(basUser.getUserHead());
            user.setPersonName(basUser.getPersonName());
            user.setPinyName(basUser.getPinyName());
            logger.info("查询用户成功，用户Id：{}", userId);
            return Response.successResult("查询用户成功", user);
        } else {
            logger.error("查询用户失败，用户Id：{}", userId);
            return Response.failResult("查询用户失败", null);
        }
    }