Spring 中使用redis缓存方法记录

背景

　　在平时项目中，可能会有某个条件的查询，会多次进到db里面去查，这样就会重复的查询相同的数据，但是我们的数据又不是需要更改及显示的，这时候就可以用到

　　方法的缓存了。例如在我们调用微信小程序时，需要获取access_token，并且其有效时间为7200秒，过期后再次获取，我们就可以把获取access_token的方法作为

　　缓存。以下为我实现的过程记录。

1、重写 RedisSerializer 中的 serialize 和 deserialize

public class GenericFastJson2JsonRedisSerializer<T> implements RedisSerializer<T> {
    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
    public GenericFastJson2JsonRedisSerializer() {
        super();
    }
   @Override
    public byte[] serialize(T t) throws SerializationException {
        if (t == null) {
            return new byte[0];
        }
       FastJsonWraper<T> wraperSet =new FastJsonWraper<>(t);
       return JSON.toJSONString(wraperSet, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
   }
    @Override
    public T deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length <= 0) {
            return null;
        }
        String deserializeStr = new String(bytes, DEFAULT_CHARSET);
        FastJsonWraper<T> wraperGet=JSON.parseObject(deserializeStr,FastJsonWraper.class);
        return wraperGet.getValue();
    }
}

2、实现缓存的获取和设置

public class RedisCache implements Cache {

    private Logger logger = Logger.getLogger(RedisCache.class);
    private RedisTemplate<String, Object> redisTemplate;

    private String name;

    private String resultType;

    private long expireInSencods;

    public static final String KEY_PREFIX = "wx:";


    @Override
    public Object getNativeCache() {
        return this.redisTemplate;
    }


    @Override
    public ValueWrapper get(Object key) {
        if (logger.isDebugEnabled()) {
            logger.debug("------缓存获取-------" + key.toString());
        }
        final String keyf = KEY_PREFIX + key.toString();
        Object object = null;
        object = redisTemplate.execute(new RedisCallback<Object>() {
            @Override
            public Object doInRedis(RedisConnection connection) throws DataAccessException {
                byte[] key = keyf.getBytes();
                byte[] value = connection.get(key);
                if (value == null) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("------缓存不存在-------");
                    }
                    return null;
                }
                try {
                    Class<?> class1 = null;
                    if (StringUtils.isNotEmpty(resultType)) {
                        class1 = Class.forName(resultType);
                    } else {
                        class1 = String.class;
                    }
                    String resultJson = new String(value, Charset.forName("utf-8"));
                    Object result = JSONObject.parseObject(resultJson, class1);
                    return result;
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
                return null;
            }
        });
        ValueWrapper obj = (object != null ? new SimpleValueWrapper(object) : null);
        if (logger.isDebugEnabled()) {
            logger.debug("------获取到内容-------" + obj);
        }
        return obj;
    }


    @Override
    public <T> T get(Object key, Class<T> type) {
        // TODO Auto-generated method stub
        return null;
    }


    @Override
    public <T> T get(Object key, Callable<T> valueLoader) {
        // TODO Auto-generated method stub
        return null;
    }


    @Override
    public void put(Object key, Object value) {
        if (logger.isDebugEnabled()) {
            logger.debug("-------加入缓存------");
            logger.debug("key----:" + key);
            logger.debug("key----:" + value);
        }
        final String keyString = KEY_PREFIX + key.toString();
        final Object valuef = value;
        redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                byte[] keyb = keyString.getBytes();
                String valuejson = JSONObject.toJSONString(valuef);
                byte[] valueb = valuejson.getBytes(Charset.forName("utf-8"));
                connection.set(keyb, valueb);
                if (expireInSencods > 0) {
                    connection.expire(keyb, expireInSencods);
                }
                return 1L;
            }
        });
    }


    @Override
    public ValueWrapper putIfAbsent(Object key, Object value) {
        // TODO Auto-generated method stub
        return null;
    }


    @Override
    public void evict(Object key) {
        if (logger.isDebugEnabled()) {
            logger.debug("-------緩存刪除------");
        }
        final String keyf = KEY_PREFIX + key.toString();
        redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.del(keyf.getBytes());
            }

        });
    }


    @Override
    public void clear() {
        if (logger.isDebugEnabled()) {
            logger.debug("-------緩存清理------");
        }
        redisTemplate.execute(new RedisCallback<String>() {
            @Override
            public String doInRedis(RedisConnection connection) throws DataAccessException {
                connection.flushDb();
                return "ok";
            }
        });
    }

    /**
     * @return redisTemplate
     */
    public RedisTemplate<String, Object> getRedisTemplate() {
        return redisTemplate;
    }

    /**
     * @param redisTemplate the redisTemplate to set
     */
    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * @return name
     */
    @Override
    public String getName() {
        return name;
    }

    /**
     * @return resultType
     */
    public String getResultType() {
        return resultType;
    }

    /**
     * @param resultType the resultType to set
     */
    public void setResultType(String resultType) {
        this.resultType = resultType;
    }

    /**
     * @return expireInSencods
     */
    public long getExpireInSencods() {
        return expireInSencods;
    }

    /**
     * @param expireInSencods the expireInSencods to set
     */
    public void setExpireInSencods(long expireInSencods) {
        this.expireInSencods = expireInSencods;
    }

}

3、在spring-redis.xml中配置 spring mvc自定义缓存，bean 中的class为我们缓存实现类的包路径，属性均为缓存实现类中的属性。

<bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
        <property name="caches">
            <set>
                <bean class="xxxx.xxx.xxx.RedisCache">
                    <property name="redisTemplate" ref="redisTemplate"/>
                    <property name="name" value="wechatapp"/>
                    <property name="expireInSencods" value="7200"/>
                    <property name="resultType"
                              value="xxxx.xx.xxx.xx"/>
                </bean>
            </set>
        </property>
    </bean>

4、启用缓存

　

<cache:annotation-driven
            cache-manager="cacheManager"/>

5、在代码中使用缓存，使用注解 @Cacheable，其中缓存名字cacheNames需要与我们spring redis中配置bean的<property name="name" value="xxx"/>对应起来

    @Cacheable(cacheNames = CACHE_NAME,key = "#appid+':'+#secret",unless = "#result == null")
    @Override
    public WeChatAppResponseDto getAccessToken(String appid, String secret) {
        
    }

然后执行代码可以发现，在第一次进入的时候，进入方法内部，然后返回结果，再次访问就没有进入方法内部了，可以打断点在缓存获取方法中查看，后面的都直接在缓存中获取了。其实通过引入的相关依赖也可以看出来，该注解功能是利用AOP来实现的。