Spring Boot Redis 集成配置详解

spring Boot 熟悉后，集成一个外部扩展是一件很容易的事，集成Redis也很简单，看下面步骤配置：

一、添加pom依赖

   <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-redis</artifactId>
   </dependency>

二、创建 RedisClient.java

注意该类存放的package

package org.springframework.data.redis.connection.jedis;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.UnsupportedEncodingException;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Protocol;
import redis.clients.jedis.exceptions.JedisException;

/**
* 工具类 RedisClient
* 因为本类中获取JedisPool调用的是JedisConnectionFactory中protected修饰的方法fetchJedisConnector()
* 所以该类需要与JedisConnectionFactory在同一个package中
*
* @author 单红宇(CSDN CATOOP)
* @create 2017年4月9日
*/
public class RedisClient {

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

private JedisConnectionFactory factory;

public RedisClient(JedisConnectionFactory factory) {
   super();
   this.factory = factory;
 }

/**
  * put操作（存储序列化对象）+ 生效时间
  *
  * @param key
  * @param value
  * @return
  */
 public void putObject(final String key, final Object value, final int cacheSeconds) {
   if (StringUtils.isNotBlank(key)) {
     redisTemplete(key, new RedisExecute<Object>() {
       @Override
       public Object doInvoker(Jedis jedis) {
         try {
           jedis.setex(key.getBytes(Protocol.CHARSET), cacheSeconds, serialize(value));
         } catch (UnsupportedEncodingException e) {
         }

return null;
       }
     });
   }
 }

/**
  * get操作（获取序列化对象）
  *
  * @param key
  * @return
  */
 public Object getObject(final String key) {
   return redisTemplete(key, new RedisExecute<Object>() {
     @Override
     public Object doInvoker(Jedis jedis) {
       try {
         byte[] byteKey = key.getBytes(Protocol.CHARSET);
         byte[] byteValue = jedis.get(byteKey);
         if (byteValue != null) {
           return deserialize(byteValue);
         }
       } catch (UnsupportedEncodingException e) {
         return null;
       }
       return null;
     }
   });
 }

/**
  * setex操作
  *
  * @param key
  *      键
  * @param value
  *      值
  * @param cacheSeconds
  *      超时时间，0为不超时
  * @return
  */
 public String set(final String key, final String value, final int cacheSeconds) {
   return redisTemplete(key, new RedisExecute<String>() {
     @Override
     public String doInvoker(Jedis jedis) {
       if (cacheSeconds == 0) {
         return jedis.set(key, value);
       }
       return jedis.setex(key, cacheSeconds, value);
     }
   });
 }

/**
  * get操作
  *
  * @param key
  *      键
  * @return 值
  */
 public String get(final String key) {
   return redisTemplete(key, new RedisExecute<String>() {
     @Override
     public String doInvoker(Jedis jedis) {
       String value = jedis.get(key);
       return StringUtils.isNotBlank(value) && !"nil".equalsIgnoreCase(value) ? value : null;
     }
   });
 }

/**
  * del操作
  *
  * @param key
  *      键
  * @return
  */
 public long del(final String key) {
   return redisTemplete(key, new RedisExecute<Long>() {
     @Override
     public Long doInvoker(Jedis jedis) {
       return jedis.del(key);
     }
   });
 }

/**
  * 获取资源
  *
  * @return
  * @throws JedisException
  */
 public Jedis getResource() throws JedisException {
   Jedis jedis = null;
   try {
     jedis = factory.fetchJedisConnector();
   } catch (JedisException e) {
     logger.error("getResource.", e);
     returnBrokenResource(jedis);
     throw e;
   }
   return jedis;
 }

/**
  * 获取资源
  *
  * @return
  * @throws JedisException
  */
 public Jedis getJedis() throws JedisException {
   return getResource();
 }

/**
  * 归还资源
  *
  * @param jedis
  * @param isBroken
  */
 public void returnBrokenResource(Jedis jedis) {
   if (jedis != null) {
     jedis.close();
   }
 }

/**
  * 释放资源
  *
  * @param jedis
  * @param isBroken
  */
 public void returnResource(Jedis jedis) {
   if (jedis != null) {
     jedis.close();
   }
 }

/**
  * 操作jedis客户端模板
  *
  * @param key
  * @param execute
  * @return
  */
 public <R> R redisTemplete(String key, RedisExecute<R> execute) {
   Jedis jedis = null;
   try {
     jedis = getResource();
     if (jedis == null) {
       return null;
     }

return execute.doInvoker(jedis);
   } catch (Exception e) {
     logger.error("operator redis api fail,{}", key, e);
   } finally {
     returnResource(jedis);
   }
   return null;
 }

/**
  * 功能简述: 对实体Bean进行序列化操作.
  *
  * @param source
  *      待转换的实体
  * @return 转换之后的字节数组
  * @throws Exception
  */
 public static byte[] serialize(Object source) {
   ByteArrayOutputStream byteOut = null;
   ObjectOutputStream ObjOut = null;
   try {
     byteOut = new ByteArrayOutputStream();
     ObjOut = new ObjectOutputStream(byteOut);
     ObjOut.writeObject(source);
     ObjOut.flush();
   } catch (IOException e) {
     e.printStackTrace();
   } finally {
     try {
       if (null != ObjOut) {
         ObjOut.close();
       }
     } catch (IOException e) {
       ObjOut = null;
     }
   }
   return byteOut.toByteArray();
 }

/**
  * 功能简述: 将字节数组反序列化为实体Bean.
  *
  * @param source
  *      需要进行反序列化的字节数组
  * @return 反序列化后的实体Bean
  * @throws Exception
  */
 public static Object deserialize(byte[] source) {
   ObjectInputStream ObjIn = null;
   Object retVal = null;
   try {
     ByteArrayInputStream byteIn = new ByteArrayInputStream(source);
     ObjIn = new ObjectInputStream(byteIn);
     retVal = ObjIn.readObject();
   } catch (Exception e) {
     e.printStackTrace();
   } finally {
     try {
       if (null != ObjIn) {
         ObjIn.close();
       }
     } catch (IOException e) {
       ObjIn = null;
     }
   }
   return retVal;
 }

interface RedisExecute<T> {
   T doInvoker(Jedis jedis);
 }
}

三、创建Redis配置类

RedisConfig.Java

package com.shanhy.example.redis;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.RedisClient;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
* Redis配置
*
* @author 单红宇(CSDN catoop)
* @create 2016年9月12日
*/
@Configuration
public class RedisConfig {

@Bean
 public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory factory) {
   RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
   template.setConnectionFactory(factory);
   template.setKeySerializer(new StringRedisSerializer());
   template.setValueSerializer(new RedisObjectSerializer());
   template.afterPropertiesSet();
   return template;
 }

@Bean
 public RedisClient redisClient(JedisConnectionFactory factory){
   return new RedisClient(factory);
 }
}

RedisObjectSerializer.java

package com.shanhy.example.redis;

import org.springframework.core.convert.converter.Converter;
import org.springframework.core.serializer.support.DeserializingConverter;
import org.springframework.core.serializer.support.SerializingConverter;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;

/**
* 实现对象的序列化接口
* @author  单红宇(365384722)
* @create  2017年4月9日
*/
public class RedisObjectSerializer implements RedisSerializer<Object> {

private Converter<Object, byte[]> serializer = new SerializingConverter();
 private Converter<byte[], Object> deserializer = new DeserializingConverter();

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

@Override
 public Object deserialize(byte[] bytes) {
   if (isEmpty(bytes)) {
     return null;
   }

try {
     return deserializer.convert(bytes);
   } catch (Exception ex) {
     throw new SerializationException("Cannot deserialize", ex);
   }
 }

@Override
 public byte[] serialize(Object object) {
   if (object == null) {
     return EMPTY_ARRAY;
   }

try {
     return serializer.convert(object);
   } catch (Exception ex) {
     return EMPTY_ARRAY;
   }
 }

private boolean isEmpty(byte[] data) {
   return (data == null || data.length == 0);
 }

}

四、创建测试方法

下面代码随便放一个Controller里

 @Autowired
 private RedisTemplate<String, Object> redisTemplate;

/**
  * 缓存测试
  *
  * @return
  * @author SHANHY
  * @create 2016年9月12日
  */
 @RequestMapping("/redisTest")
 public String redisTest() {
   try {
     redisTemplate.opsForValue().set("test-key", "redis测试内容", 2, TimeUnit.SECONDS);// 缓存有效期2秒

logger.info("从Redis中读取数据：" + redisTemplate.opsForValue().get("test-key").toString());

TimeUnit.SECONDS.sleep(3);

logger.info("等待3秒后尝试读取过期的数据：" + redisTemplate.opsForValue().get("test-key"));
   } catch (InterruptedException e) {
     e.printStackTrace();
   }

return "OK";
 }

五、配置文件配置Redis

application.yml

spring:
# Redis配置
redis:
 host: 192.168.1.101
 port: 6379
 password:
 # 连接超时时间（毫秒）
 timeout: 10000
 pool:
  max-idle: 20
  min-idle: 5
  max-active: 20
  max-wait: 2

这样就完成了Redis的配置，可以正常使用 redisTemplate 了。

来源：http://blog.csdn.net/catoop/article/details/71275331