spring boot配置redis

1、maven依赖

        <!-- redis -->
		<dependency>
		    <groupId>org.springframework.boot</groupId>
		    <artifactId>spring-boot-starter-redis</artifactId>
		    <version>1.4.7.RELEASE</version>
		</dependency>

2、yml配置

  # redis 公共配置
  redis:
    hostName: 127.0.0.1
    password:
    # Redis数据库索引（默认为0）
    database: 0
    # Redis服务器连接端口
    port: 6379
    # 连接超时时间 单位 ms（毫秒）
    timeout: 3000
    # 连接池最大连接数（使用负值表示没有限制）
    pool:
      max-active: 600
      # 连接池最大阻塞等待时间（使用负值表示没有限制）/等待可用连接的最大时间，单位ms.(超过等待时间，则直接抛出JedisConnectionException)
      max-wait: 1500
      # 连接池中的最大空闲连接(默认8)
      max-idle: 300
      # 连接池中的最小空闲连接(默认0)
      min-idle: 0

3、RedisConfig类

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cache.Cache;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.interceptor.CacheErrorHandler;
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.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import com.ejoyst.publicserv.restservice.restcontroller.MessageController;

import redis.clients.jedis.JedisPoolConfig;

@Configuration
@EnableAutoConfiguration
public class RedisConfig extends CachingConfigurerSupport {

	private final static Logger logger = LoggerFactory.getLogger(RedisConfig.class);
	
	@Bean    
    @ConfigurationProperties(prefix="spring.redis.poolConfig")    
    public JedisPoolConfig getRedisConfig(){    
        JedisPoolConfig config = new JedisPoolConfig();  
        return config;    
    }    
        
    @Bean    
    @ConfigurationProperties(prefix="spring.redis")    
    public JedisConnectionFactory getConnectionFactory(){    
        JedisConnectionFactory factory = new JedisConnectionFactory();    
        factory.setUsePool(true);  
        JedisPoolConfig config = getRedisConfig();    
        factory.setPoolConfig(config);    
        return factory;    
    }    
        
        
    @Bean    
    public RedisTemplate<?, ?> getRedisTemplate(){
    	JedisConnectionFactory factory = getConnectionFactory();
        RedisTemplate<?,?> template = new StringRedisTemplate(factory);    
        return template;    
    } 
    
    @Override
    public CacheErrorHandler errorHandler() {
         //本地或特殊环境使具体方法连不了redis读缓存也能执行下去连db，不抛出异常
        CacheErrorHandler cacheErrorHandler = new CacheErrorHandler() {
            @Override
            public void handleCacheGetError(RuntimeException e, Cache cache, Object key) {
                System.out.println("===handleCacheGetError:" + key);
            }

            @Override
            public void handleCachePutError(RuntimeException e, Cache cache, Object key, Object value) {
                System.out.println("===handleCachePutError:" + key);
            }

            @Override
            public void handleCacheEvictError(RuntimeException e, Cache cache, Object key) {
                System.out.println("===handleCacheEvictError:" + key);

            }

            @Override
            public void handleCacheClearError(RuntimeException e, Cache cache) {
                System.out.println("===handleCacheClearError");
            }
        };
        return cacheErrorHandler;
    }
}

4、redis具体操作的接口类和实现类

import java.util.List;

import org.springframework.cloud.netflix.feign.FeignClient;

import com.ejoyst.common.ServiceConstant;

/**
 * redis服务
 * @author liuzhenpeng
 *
 */
public interface IRedisService {
	
	public boolean set(String key, String value);
	
	public String get(String key);
	
	public Long del(String key);
	
	public boolean expire(String key,long expire);
	
	public <T> boolean setList(String key ,List<T> list);
	
	public <T> List<T> getList(String key,Class<T> clz);
	
	public long lpush(String key,Object obj);
	
	public long rpush(String key,Object obj);
	
	public String lpop(String key);

}

import java.util.List;
import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.stereotype.Service;

import com.ejoyst.common.util.JacksonUtils;
import com.ejoyst.publicserv.restservice.redis.service.IRedisService;

@Service
public class RedisServiceImpl implements IRedisService{

	@Autowired
	private RedisTemplate<String, ?> redisTemplate;
	
	@Override
	public boolean set(final String key, final String value) {
		boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
            	RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                connection.set(serializer.serialize(key), serializer.serialize(value));
                return true;
            }
	    });
		return result;
	}

	@Override
	public String get(final String key){
		String result = redisTemplate.execute(new RedisCallback<String>() {
            @Override
            public String doInRedis(RedisConnection connection) throws DataAccessException {
            	RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                byte[] value =  connection.get(serializer.serialize(key));
                return serializer.deserialize(value);
            }
	    });
		return result;
	}
	
	@Override
	public Long del(final String key){
		Long result = redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
            	RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                Long value =  connection.del(serializer.serialize(key));
                return value;
            }
	    });
		return result;
	}

	@Override
	public boolean expire(final String key, long expire) {
		return redisTemplate.expire(key, expire, TimeUnit.SECONDS);
	}

	@Override
	public <T> boolean setList(String key, List<T> list) {
		String value = JacksonUtils.object2Json(list);
		return set(key,value);
	}

	@Override
	public <T> List<T> getList(String key,Class<T> clz) {
		String json = get(key);
		if(json!=null){
			List<T> list = JacksonUtils.json2List(json, clz);
			return list;
		}
		return null;
	}

	@Override
	public long lpush(final String key, Object obj) {
		final String value = JacksonUtils.object2Json(obj);
		long result = redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
            	RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                long count = connection.lPush(serializer.serialize(key), serializer.serialize(value));
                return count;
            }
	    });
		return result;
	}

	@Override
	public long rpush(final String key, Object obj) {
		final String value = JacksonUtils.object2Json(obj);
		long result = redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
            	RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                long count = connection.rPush(serializer.serialize(key), serializer.serialize(value));
                return count;
            }
	    });
		return result;
	}

	@Override
	public String lpop(final String key) {
		String result = redisTemplate.execute(new RedisCallback<String>() {
            @Override
            public String doInRedis(RedisConnection connection) throws DataAccessException {
            	RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                byte[] res =  connection.lPop(serializer.serialize(key));
                return serializer.deserialize(res);
            }
	    });
		return result;
	}

}