Spring boot使用Redis作為緩存的配置方法

項目使用的Spring boot版本是1.5.9，Redis是5.0版本，Jdk1.8

先在application.yml裡面配置：

<code>spring:
  #緩存
  cache:
    type: NONE/<code>

注意實體類都必須可序列化，也就是implements Serializable

當我們的數據存儲到Redis的時候，我們的鍵（key）和值（value）都是通過Spring提供的Serializer序列化到數據庫的。RedisTemplate默認使用的是JdkSerializationRedisSerializer，StringRedisTemplate默認使用的是StringRedisSerializer。Spring Data JPA為我們提供了下面的Serializer：

GenericToStringSerializer、Jackson2JsonRedisSerializer、JacksonJsonRedisSerializer、JdkSerializationRedisSerializer、OxmSerializer、StringRedisSerializer。序列化方式對比： JdkSerializationRedisSerializer: 使用JDK提供的序列化功能。優點是反序列化時不需要提供類型信息(class)，但缺點是需要實現Serializable接口，還有序列化後的結果非常龐大，是JSON格式的5倍左右，這樣就會消耗redis服務器的大量內存。Jackson2JsonRedisSerializer： 使用Jackson庫將對象序列化為JSON字符串。優點是速度快，序列化後的字符串短小精悍，不需要實現Serializable接口。但缺點也非常致命，那就是此類的構造函數中有一個類型參數，必須提供要序列化對象的類型信息(.class對象)。通過查看源代碼，發現其只在反序列化過程中用到了類型信息。

用Spring data redis做redis緩存的時候，指定RedisTemplate的key和value序列化時遇到的問題。1.RedisTemplate的key指定成StringRedisSerializer序列化會報類型轉換錯誤，如XXX類不能轉換成String。2.使用Jackson2JsonRedisSerializer序列化的時候,如果實體類上沒有set方法反序列化會報錯。

問題分析問題1：使用StringRedisSerializer做key的序列化時，StringRedisSerializer的泛型指定的是String，傳其他對象就會報類型轉換錯誤，在使用@Cacheable註解是key屬性就只能傳String進來。把這個序列化方式重寫了，將泛型改成Object。源碼：

<code>import com.alibaba.fastjson.JSON;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.util.Assert;

import java.nio.charset.Charset;

/**
 * 使用StringRedisSerializer做key的序列化時，StringRedisSerializer的泛型指定的是String，傳其他對象就會報類型轉換錯誤，
 * 在使用@Cacheable註解是key屬性就只能傳String進來。把這個序列化方式重寫了，將泛型改成Object。
 */
public class StringRedisSerializer implements RedisSerializer<object> {
    private final Charset charset;

    private final String target = "\"";

    private final String replacement = "";

    public StringRedisSerializer() {
        this(Charset.forName("UTF8"));
    }

    public StringRedisSerializer(Charset charset) {
        Assert.notNull(charset, "Charset must not be null!");
        this.charset = charset;
    }

    @Override
    public String deserialize(byte[] bytes) {
        return (bytes == null ? null : new String(bytes, charset));
    }

    @Override
    public byte[] serialize(Object object) {
        String string = JSON.toJSONString(object); 

        if (null == string) {
            return null;
        }
        string = string.replace(target, replacement);
        return string.getBytes(charset);
    }
}/<object>/<code>

問題2：我們放棄用jackjson來做value的序列化，使用FastJson來做。重寫一些序列化器，並實現RedisSerializer接口。源碼如下：

<code>import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;

import java.nio.charset.Charset;

/**
 * 我們放棄用jackjson來做value的序列化，使用FastJson來做。重寫一些序列化器，並實現RedisSerializer接口
 * @param 
 */
public class FastJsonRedisSerializer implements RedisSerializer {
    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

    private Class clazz;

    public FastJsonRedisSerializer(Class clazz) {
        super();
        this.clazz = clazz;
    }

    @Override
    public byte[] serialize(T t) throws SerializationException {
        if (t == null) {
            return new byte[0];
        }
        return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
    } 


    @Override
    public T deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length <= 0) {
            return null;
        }
        String str = new String(bytes, DEFAULT_CHARSET);
        return (T) JSON.parseObject(str, clazz);

    }
}/<code>

新加入一種序列化KryoRedisSerializer。速度很快，源碼如下：

<code>import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;

import java.io.ByteArrayOutputStream;


public class KryoRedisSerializer implements RedisSerializer {
    Logger logger = LoggerFactory.getLogger(KryoRedisSerializer.class);

    public static final byte[] EMPTY_BYTE_ARRAY = new byte[0];

    private static final ThreadLocal<kryo> kryos = ThreadLocal.withInitial(Kryo::new);

    private Class clazz;

    public KryoRedisSerializer(Class clazz) {
        super();
        this.clazz = clazz;
    }

    @Override 

    public byte[] serialize(T t) throws SerializationException {
        if (t == null) {
            return EMPTY_BYTE_ARRAY;
        }

        Kryo kryo = kryos.get();
        kryo.setReferences(false);
        kryo.register(clazz);

        try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
             Output output = new Output(baos)) {
            kryo.writeClassAndObject(output, t);
            output.flush();
            return baos.toByteArray();
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }

        return EMPTY_BYTE_ARRAY;
    }

    @Override
    public T deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length <= 0) {
            return null;
        }

        Kryo kryo = kryos.get();
        kryo.setReferences(false);
        kryo.register(clazz);

        try (Input input = new Input(bytes)) {
            return (T) kryo.readClassAndObject(input);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }

        return null;
    }


}/<kryo>/<code>

Java配置代碼如下：

<code>import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.ParserConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.cache.interceptor.KeyGenerator;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;


/**
 * 2. * Redis配置
 * 3. *
 * 4. * @author fengshuonan
 * 5. * @date 2018年1月28日 11:49:12
 * 6.
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
    private static final Logger logger = LoggerFactory.getLogger(RedisConfig.class);

    /**
     * 採用RedisCacheManager作為緩存管理器
     *
     * @param redisTemplate
     * @return SpringBoot項目啟動時就會去找自定義配置的CacheManager對象並且自動應用到項目中
     */
    @Bean
    public CacheManager cacheManager(RedisTemplate redisTemplate) {
        logger.debug("生成RedisCacheManager緩存管理器...");
        RedisCacheManager redisCacheManager = new RedisCacheManager(redisTemplate);
        //默認超時時間，單位秒
        redisCacheManager.setDefaultExpiration(7200); 

        //緩存超時時間Map，key為cacheName，value為超時,單位是秒
        Map<string> expiresMap = new HashMap<>();
        // 緩存用戶信息的cacheName和超時時間
        expiresMap.put("user", 1800L);
        //緩存default的cacheName和超時時間
        expiresMap.put("default", 600L);
        redisCacheManager.setExpires(expiresMap);
        // 最好是帶上前綴，否則id重複的話會有問題
        redisCacheManager.setUsePrefix(true);
        return redisCacheManager;
    }

    /**
     * key的生成方式
     *
     * @return
     */
    @Bean
    @Override
    public KeyGenerator keyGenerator() {
        logger.info("RedisCacheConfig.keyGenerator()");
        return new KeyGenerator() {
            @Override
            public Object generate(Object o, Method method, Object... objects) {
                // This will generate a unique key of the class name, the method name
                //and all method parameters appended.
/*                HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
                String token = request.getHeader("token");*/
                StringBuilder sb = new StringBuilder();
                sb.append(o.getClass().getSimpleName())
                        .append(":")
                        .append(method.getName())
                        .append(":");
                for (Object obj : objects) {
                    if (null != obj) {
                        // 替換字符串
                        String objKey = JSON.toJSONString(obj);
                        objKey = objKey.replace(":", "=");
                        sb.append(objKey);
                    }
                }
                logger.debug("keyGenerator=" + sb.toString());
                return sb.toString();
            } 

        };
    }


    @Bean
    public RedisTemplate<string> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<string> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        FastJsonRedisSerializer<object> fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);
        // 全局開啟AutoType，不建議使用
        // ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
        // 建議使用這種方式，小範圍指定白名單
        ParserConfig.getGlobalInstance().addAccept("com.shangshiwendao.web.");
        // 設置值（value）的序列化採用FastJsonRedisSerializer
        redisTemplate.setValueSerializer(fastJsonRedisSerializer);
        redisTemplate.setHashValueSerializer(fastJsonRedisSerializer);
        // 設置鍵（key）的序列化採用StringRedisSerializer。
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

}/<object>/<string>/<string>/<string>/<code>

-----------------------------------------------

↓ 點擊下面的“瞭解更多”鏈接可查看完整的詳細

閱讀更多 上士聞道技術學習 的文章

關鍵字: JSON 數據庫 緩存