spring boot + redis 配置

1.引入reids包

spring-boot-starter-redis(springboot版本1.4版本前)，spring-boot-starter-data-redis（1.4版本后）

选择合适的API：

这个主要是根据redis存储的数据类型需求决定，key一般都是String，但是value可能不一样，一般有两种，String和 Object； 
如果k-v都是String类型，我们可以直接用 StringRedisTemplate，这个是官方建议的，也是最方便的，直接导入即用，无需多余配置！ 
如果k-v是Object类型，则需要自定义 RedisTemplate，在这里我们都研究下！

2.配置文件application.yml中redis的配置信息

1. redis:

2. host: 127.0.0.1

3. port: 6379

4. #连接超时时间(毫秒)

5. timeout: 2000

6. pool:

7. #最大连接数(负数表示没有限制)

8. max-active: 100

9. #最大空闲连接

10. max-idle: 10

11. #最大阻塞等待时间(负数表示没有限制)

12. max-wait: 100000

13. database: 0

3.Redis配置类

1. @Configuration

2. @EnableCaching //配置cache Manager

3. //继承CachingConfigurerSupport类是为了自定义redis key的生成策略（复写keyGenerator方法）

4. public class RedisConfig extends CachingConfigurerSupport{

5. //从配置文件中读取配置信息

6. @Value("${redis.timeout}")

7. private Long redisTimeout;

8.  

9. /*生成key的策略 根据类名+方法名+所有参数的值生成唯一的一个key **/

10. @Bean

11. @Override

12. public KeyGenerator keyGenerator() {

13. return new KeyGenerator() {

14. public Object generate(Object target, Method method, Object... params) {

15. StringBuilder sb = new StringBuilder();

16. sb.append(target.getClass().getName());

17. sb.append(method.getName());

18. for (Object obj : params) {

19. sb.append(obj.toString());

20. }

21. return sb.toString();

22. }

23. };

24. }

25.  

26. /**

27. * 管理缓存

28. * @param redisTemplate

29. * @return

30. */

31. @Bean

32. public CacheManager cacheManager(RedisTemplate<?,?> redisTemplate) {

33. RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);

34. //设置redis缓存过期时间

35. cacheManager.setDefaultExpiration(redisTimeout);

36. return cacheManager;

37. }

38.  

39. /**

40. * RedisTemplate配置

41. * jdk序列方式，用来保存对象(key=对象)

42. * @param factory

43. * @return

44. */

45. /*@Bean

46. public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {

47.  

48. StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

49. //自定义的redis序列化工具类（对object序列化）

50. RedisObjectSerializer redisObjectSerializer = new RedisObjectSerializer();

51.  

52. RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();

53. template.setConnectionFactory(factory);

54. template.setKeySerializer(stringRedisSerializer);

55. template.setValueSerializer(redisObjectSerializer);

56.  

57. return template;

58. } */

59. /**

60. * RedisTemplate配置

61. * string的序列化方式，存储string格式（key=value）

62. * @param factory

63. * @return

64. */

65. /*@Bean

66. public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {

67. StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();

68. stringRedisTemplate.setConnectionFactory(factory);

69. setSerializer(stringRedisTemplate);

70. stringRedisTemplate.afterPropertiesSet();

71. return stringRedisTemplate;

72. }*/

73.  

74. /*private void setSerializer(StringRedisTemplate template){

75. Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new

76. Jackson2JsonRedisSerializer(Object.class);

77. ObjectMapper om = new ObjectMapper();

78. om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);

79. om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

80. jackson2JsonRedisSerializer.setObjectMapper(om);

81. template.setValueSerializer(jackson2JsonRedisSerializer);

82. }*/

83.  

84. /**

85. * redis模板，存储关键字是字符串，值是Jdk序列化,这个写法和我com.jary.util中的RedisObjectSerializer写法更简单，测试后选择使用那个

86. * @Description:

87. * @param factory

88. * @return

89. */

90. @Bean

91. public RedisTemplate<?,?> redisTemplate(RedisConnectionFactory factory) {

92. RedisTemplate<?,?> redisTemplate = new RedisTemplate<>();

93. redisTemplate.setConnectionFactory(factory);

94. //key序列化方式;但是如果方法上有Long等非String类型的话，会报类型转换错误；

95. RedisSerializer<String> redisSerializer = new StringRedisSerializer();//Long类型不可以会出现异常信息;

96. redisTemplate.setKeySerializer(redisSerializer);

97. redisTemplate.setHashKeySerializer(redisSerializer);

98.  

99. //JdkSerializationRedisSerializer序列化方式;

100. JdkSerializationRedisSerializer jdkRedisSerializer=new JdkSerializationRedisSerializer();

101. redisTemplate.setValueSerializer(jdkRedisSerializer);

102. redisTemplate.setHashValueSerializer(jdkRedisSerializer);

103. redisTemplate.afterPropertiesSet();

104. return redisTemplate;

105. }

里面写的有点乱，主要是使用几种序列化的方式不同，不用的都注释掉了，其中有一个<String，Object>的RedisTemplate，里面使用了自定义的序列化方式工具类redisObjectSerializer:

1. /**

2. * @Author: jaryle

3. * @CreateDate: 2018/6/3 14:24

4. * @Version: 1.0

5. */

6. public class RedisObjectSerializer implements RedisSerializer<Object> {

7.  

8. static final byte[] EMPTY_ARRAY = new byte[0];

9.  

10. @Override

11. public Object deserialize(byte[] bytes) {

12. if (isEmpty(bytes)) {

13. return null;

14. }

15. ObjectInputStream oii = null;

16. ByteArrayInputStream bis = null;

17. bis = new ByteArrayInputStream(bytes);

18. try {

19. oii = new ObjectInputStream(bis);

20. Object obj = oii.readObject();

21. return obj;

22. } catch (Exception e) {

23.  

24. e.printStackTrace();

25. }

26. return null;

27. }

28.  

29. @Override

30. public byte[] serialize(Object object) {

31. if (object == null) {

32. return EMPTY_ARRAY;

33. }

34. ObjectOutputStream obi = null;

35. ByteArrayOutputStream bai = null;

36. try {

37. bai = new ByteArrayOutputStream();

38. obi = new ObjectOutputStream(bai);

39. obi.writeObject(object);

40. byte[] byt = bai.toByteArray();

41. return byt;

42. } catch (IOException e) {

43. e.printStackTrace();

44. }

45. return null;

46. }

47.  

48. private boolean isEmpty(byte[] data) {

49. return (data == null || data.length == 0);

50. }

51. }

刚开始使用此方法进行测试的，测试成功，后来觉得太麻烦，还要自己写个序列化工具类，就使用现在没有注释的RedisTemplate<?,?>更简单一些，功能也可以实现。

4.编写一个  redis封装工具类：（内部导入的是StringRedisTemplate，RedisTemplate也可以）

1. import lombok.extern.slf4j.Slf4j;

2. import org.springframework.beans.factory.annotation.Autowired;

3. import org.springframework.data.redis.core.StringRedisTemplate;

4. import org.springframework.data.redis.core.ValueOperations;

5. import org.springframework.stereotype.Service;

6.  

7. import java.util.concurrent.TimeUnit;

8.  

9. /**

10. * @Author: jaryle

11. * @Date: 2018/08/08 17:30

12. */

13. @Service

14. @Slf4j

15. public class IRedisService {

16. //这里我们注入了我自定义的Redistemplate,而且支持<String,Object>存储，上面写出自定义序列化

17. @Autowired

18. protected RedisTemplate redisTemplate;

19. private final static Logger log = LoggerFactory.getLogger(RedisUtils.class);

20. /**

21. * 写入redis缓存（不设置expire存活时间）

22. * @param key

23. * @param value

24. * @return

25. */

26. public boolean set(final String key, String value){

27. boolean result = false;

28. try {

29. ValueOperations operations = redisTemplate.opsForValue();

30. operations.set(key, value);

31. result = true;

32. } catch (Exception e) {

33. log.error("写入redis缓存失败！错误信息为：" + e.getMessage());

34. }

35. return result;

36. }

37.  

38. /**

39. * 写入redis缓存（设置expire存活时间）

40. * @param key

41. * @param value

42. * @param expire

43. * @return

44. */

45. public boolean set(final String key, String value, Long expire){

46. boolean result = false;

47. try {

48. ValueOperations operations = redisTemplate.opsForValue();

49. operations.set(key, value);

50. redisTemplate.expire(key, expire, TimeUnit.SECONDS);

51. result = true;

52. } catch (Exception e) {

53. log.error("写入redis缓存（设置expire存活时间）失败！错误信息为：" + e.getMessage());

54. }

55. return result;

56. }

57.  
58.  

59. /**

60. * 读取redis缓存

61. * @param key

62. * @return

63. */

64. public Object get(final String key){

65. Object result = null;

66. try {

67. ValueOperations operations = redisTemplate.opsForValue();

68. result = operations.get(key);

69. } catch (Exception e) {

70. log.error("读取redis缓存失败！错误信息为：" + e.getMessage());

71. }

72. return result;

73. }

74.  

75. /**

76. * 判断redis缓存中是否有对应的key

77. * @param key

78. * @return

79. */

80. public boolean exists(final String key){

81. boolean result = false;

82. try {

83. result = redisTemplate.hasKey(key);

84. } catch (Exception e) {

85. log.error("判断redis缓存中是否有对应的key失败！错误信息为：" + e.getMessage());

86. }

87. return result;

88. }

89.  

90. /**

91. * redis根据key删除对应的value

92. * @param key

93. * @return

94. */

95. public boolean remove(final String key){

96. boolean result = false;

97. try {

98. if(exists(key)){

99. redisTemplate.delete(key);

100. }

101. result = true;

102. } catch (Exception e) {

103. log.error("redis根据key删除对应的value失败！错误信息为：" + e.getMessage());

104. }

105. return result;

106. }

107.  

108. /**

109. * redis根据keys批量删除对应的value

110. * @param keys

111. * @return

112. */

113. public void remove(final String... keys){

114. for(String key : keys){

115. remove(key);

116. }

117. }

118. }

上面代码，都是key=value形式的操作。如果key=value（object）,stringRedisTemplate就不能使用了，我们要自定义一个redisTemplate来处理。

springboot也提供了RedisTemplate

定义了对5种数据结构操作：

redisTemplate.opsForValue();//操作字符串

redisTemplate.opsForHash();//操作hash

redisTemplate.opsForList();//操作list

redisTemplate.opsForSet();//操作set

redisTemplate.opsForZSet();//操作有序set

5.使用的是mybatis,持久层我就不上代码了，直接上service吧

1. @ComponentScan({"com.jary.mapper"})

2. @Service

3. public class UserServiceImpl implements UserService {

4.  
5.  

6. @Resource

7. UserMapper userMapper;

8.  

9. @Autowired

10. RedisUtils redisUtis;

11.  

12. @Override

13. public List<User> getUsers() {

14. return userMapper.getUsers();

15.  

16. }

17.  

18. @Override

19. public User getUserById(User user) {

20. // TODO Auto-generated method stub

21. return null;

22. }

23.  

24. @Override

25. public User selectUser(String user_name) {

26. User usr = userMapper.selectUser(user_name);

27. //把usr信息写入缓存中

28. redisUtis.set("usr_id", usr);

29. return usr;

30.  

31. }

6.controller层也不用写了吧，太简单浪费时间，直接上测试结果

7.最后说说StringRedisTemplate 和 RedisTemplate 对比分析

总结了一下区别和联系主要有四点：

第一点，StringRedisTemplate继承了RedisTemplate。

第二点，RedisTemplate是一个泛型类，而StringRedisTemplate则不是。

第三点，StringRedisTemplate只能对key=String，value=String的键值对进行操作，RedisTemplate可以对任何类型的key-value键值对操作。

第四点，是他们各自序列化的方式不同，但最终都是得到了一个字节数组，殊途同归，StringRedisTemplate使用的是StringRedisSerializer类；RedisTemplate使用的是JdkSerializationRedisSerializer类。反序列化，则是一个得到String，一个得到Object

8。源码分析：

先看 StringRedisTemplate：

StringRedisTemplate 是继承 RedisTemplate的，一般来说子类继承父类，应该能实现更多的功能，但是此处我们发现 StringRedisTemplate 继承的是 RedisTemplate的泛型类，指定了String-String的泛型！故功能只专注于String类型！

其次我们可以看到 StringRedisTemplate 的构造方法中指定了序列化类为 StringRedisSerializer，我们进去看看

这下就一目了然了！

再看 RedisTemplate： 

可以看到默认序列化方式为 JdkSerializationRedisSerializer： 

而JdkSerializationRedisSerializer又调用了SerializingConverter类的convert方法。在这个方法里其转换主要有三步：

1、ByteArrayOutputStream(1024)，创建一个字节数组输出流缓冲区。

2、DefaultSerializer.serialize(source, byteStream)：把要序列化的数据存储到缓冲区。还想看他是怎么放到缓冲区的，但是，能力有限，水平一般，serialize的细节，实在无能为力，看了半天，还是氐惆。

3、toByteArray：就是把上一步放到缓冲区的数据拷贝到新建的字节数组里。

至此Object的序列化就结束了，返回了一个字节数组。