使用缓存来优化服务性能的两种方式

1. 引言

在一个项目在使用的过程中，随着数据或者用户的增多，慢慢就会了出现老化；当请求个别接口就出现了返回缓慢的情景，严重影响了用户的使用体验，随之就需要对服务进行优化升级。

优化不是我们重新去编写这个项目，而是用一些中间件去优化，常见的就是去缓存啦，因为很多时候我们的项目的瓶颈不是cpu等这些硬件，而是IO操作，因此对IO优化后会很好地提高项目能力。

2. Redis的一般实现方式

在Java领域常见的就是添加redis缓存器来实现优化，如果手动去实现redis的话，我们首先要去写一个redisUtil的工具类，在我们需要添加缓存的地方把数据手动放到redis中；

`redis`的工具类：

@Service
public class RedisUtil {

    @Autowired
    private RedisTemplate redisTemplate;

    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    public Object get(final String key) {
        return redisTemplate.opsForValue().get(key);
    }

    public void setWithTime(String key, Object obj, long minute) {
        redisTemplate.opsForValue().set(key, obj, minute, TimeUnit.MINUTES);
    }

    public boolean putHash(String key, Object field, Object value) {
        boolean result = false;
        try {
            redisTemplate.opsForHash().put(key, field, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    public Object getHash(String key, Object field) {
        return redisTemplate.opsForHash().get(key, field);
    }

    public void setExpire(String key, long timeout, TimeUnit unit) {
        redisTemplate.expire(key, timeout, unit);
    }

    public boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    public void deleteKey(String key) {
        redisTemplate.delete(key);
    }

}

使用方式：

// token存入redis，设置过期时间
redisUtil.set("xxl:music:" + dsn + ":token", token);
redisUtil.setExpire("xxl:music:" + dsn + ":token", Long.parseLong(expiresIn) - 300L, TimeUnit.SECONDS);

这需要我们手动去实现，非常的麻烦。

那有没有比较丝滑的实现方式呢？

3. JetCache工具实现缓存

这里我们就引入了阿里开发的JetCache这个工具，JetCache是一个基于Java的缓存系统封装，提供统一的API和注解来简化缓存的使用。JetCache提供了比SpringCache更加强大的注解，可以原生的支持TTL、两级缓存、分布式自动刷新，还提供了Cache接口用于手工缓存操作。

那如何实现呢？

首先是引入依赖：

新建`JetCacheConfig`配置类

@Configuration
@EnableMethodCache(basePackages = "com.codejames.*.service")
@EnableCreateCacheAnnotation
public class JetCacheConfig {

    @Bean
    public Pool<Jedis> pool(){
        GenericObjectPoolConfig pc = new GenericObjectPoolConfig();
        pc.setMinIdle(2);
        pc.setMaxIdle(10);
        pc.setMaxTotal(10);
        return new JedisPool(pc, "localhost", 6379);
    }

    @Bean
    public SpringConfigProvider springConfigProvider() {
        return new SpringConfigProvider();
    }

    @Bean
    public GlobalCacheConfig config(SpringConfigProvider configProvider,     Pool<Jedis> pool){
        Map localBuilders = new HashMap();
        EmbeddedCacheBuilder localBuilder = LinkedHashMapCacheBuilder
                .createLinkedHashMapCacheBuilder()
                .keyConvertor(FastjsonKeyConvertor.INSTANCE);
        localBuilders.put(CacheConsts.DEFAULT_AREA, localBuilder);

        Map remoteBuilders = new HashMap();
        RedisCacheBuilder remoteCacheBuilder = RedisCacheBuilder.createRedisCacheBuilder()
                .keyConvertor(FastjsonKeyConvertor.INSTANCE)
                .valueEncoder(JavaValueEncoder.INSTANCE)
                .valueDecoder(JavaValueDecoder.INSTANCE)
                .jedisPool(pool);
        remoteBuilders.put(CacheConsts.DEFAULT_AREA, remoteCacheBuilder);

        GlobalCacheConfig globalCacheConfig = new GlobalCacheConfig();
        globalCacheConfig.setConfigProvider(configProvider);
        globalCacheConfig.setLocalCacheBuilders(localBuilders);
        globalCacheConfig.setRemoteCacheBuilders(remoteBuilders);
        //日志输出统计信息
        globalCacheConfig.setStatIntervalMinutes(15);
        globalCacheConfig.setAreaInCacheName(false);

        return globalCacheConfig;
    }
}

其中注解@EnableMethodCache中的路径，表示对该包下的方法添加缓存，@EnableCreateCacheAnnotation表示开启缓存注解；在如上的配置中使用了JavaValueEncoder.INSTANCE，因此实体类需要进行序列化，即实现Serializable这个接口。

以上配置好之后就是在方法上添加缓存注解啦

@Cached(expire = 120, name = "f.s.*.*.getbyapplianceid.", cacheType = CacheType.REMOTE)
public ApplianceFirmware getByApplianceId(Long applianceId, Byte type){
 return applianceFirmwareDao.getByApplianceIdAndType(applianceId, type);
}

如上在该方法上添加了@Cached注解，过期时间为120s，使用redis缓存。打开redis发现可存在该key，并且key获取对应的value。