Spring Boot 整合 Redis

新建分共项目，编写工具类，打包导入别的项目，方便别的项目调用

一，引入依赖

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

二，配置RedisConnectionFactory

       编写application.properties文件

#Redis数据库索引（默认为0），配置了多个数据库指定用那一个
spring.redis.database=0
#Redis服务器地址
spring.redis.host=192.168.57.128
#Redis服务器连接端口
spring.redis.port=6379
#Redis服务器连接密码（默认为空）
spring.redis.user=root
spring.redis.password=123456
#连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
#连接池最大阻塞时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
#连接池中的最大空闲连接
spring.redis.pool.max-idle=8
#连接池中的最小空闲连接
spring.redis.pool.min-idle=0
#连接超时时间（毫秒）
spring.redis.timeout=3000

三，创建Redis Template的Bean组件

       新建一个提供Redis Template的类

     

package com.example.demo.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;

//让当前类等介于XML配置文件
@Configuration
public class RedisConfig(){
    /**
     *提供RedisTemaplate的bean实例  
     *@param factory
     *@return
     */
    @Bean
    public RedisTemaplate<String, Object> redisTemplate(RedisConnectionFactory factory){
        RedisTemaplate<String, Object> redisTemplate=new RedisTemaplate<String, Object>();
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }
}

四，创建工具类进行Redis操作

       创建工具类

package org.springframework.stereotype.Component;

import javax.annotation.Resource;
import springframework.data.redis.*;

//可以让其它类注入调用
@Component
public class RedisUtil{
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    
    /**
     *往redis中缓存数据  
     *@param key
     *@param object
     *@return
     */
    public Boolean set(String key, Object object){
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //设置序列化Value的实例化对象
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        ValueOperations<String, Object> vo = redisTemplate.opsForValue();
        vo.set(key, object);
        return true;
    }

    /**
     *往redis中缓存数据,添加有效期  
     *@param key
     *@param seconds 有效期
     *@param object
     *@return
     */
    public Boolean set(String key, ling seconds, Object object){
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //设置序列化Value的实例化对象
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        ValueOperations<String, Object> vo = redisTemplate.opsForValue();
        vo.set(key, object);
        expire(key, seconds);
        return true;
    }

    /**
     *判断key值是否存在  
     *@param key
     *@return
     */
    public Boolean exist(String key){
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //设置序列化Value的实例化对象
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        ValueOperations<String, Object> vo = redisTemplate.opsForValue();
        Object value = vo.get(key);
        return EmptyUtils.isEmpty(value) ? false : true;
    }
    
    /**
     *根据key从redis服务器中获取value值
     *@param key
     *@param object
     *@return
     */
    public Object get(String key){
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //设置序列化Value的实例化对象
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        ValueOperations<String, Object> vo = redisTemplate.opsForValue();
        return vo.get(key);
    }

     /**
     *删除
     *@param key
     *@return
     */
    public void delete(String key){
        try{
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            //设置序列化Value的实例化对象
            redisTemplate.setValueSerializer(new StringRedisSerializer());
            redisTemplate.delete(key);
        }catch(Exception e){
            e.printStackTRACE();
        }        
    }

     /**
     *用setnx命令往redis中缓存数据，用于做分布式锁的 持有锁
     *@param key
     *@param object
     *@return
     */
    public Boolean setnx(final String key, final String value) throws Exception {
        return redisTemplate.execute(new RedisCallback<Boolean>() {
            @Override
            public Boolean doInRedis(RedisConnection redisConnection) {
                boolean flag = false;
                try{
                    redisTemplate.setKeySerializer(new StringRedisSerializer());
                    //设置序列化Value的实例化对象
                    redisTemplate.setValueSerializer(new StringRedisSerializer());
                    StringRedisSerializer redisSerializer=new StringRedisSerializer();
                    byte keys[] = redisSerializer.serialize(key);
                    byte values[] redisSerializer.serialize(value);  //value可以随意设置
                    flag = redisConnection.setNX(keys, values);   
                }catch(Exception e){
                    e.printStackTRACE();
                }finally{
                    return flag;
                }    
            }
        }                   
    }

     /**
     *对setnx命令往redis中缓存的数据添加有效期
     *@param key
     *@param expireTime
     *@return
     */
    public Boolean expire(final String key, final Long expireTime) {
        return redisTemplate.execute(new RedisCallback<Boolean>() {
            @Override
            public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {
                boolean flag = false;
                try{
                    redisTemplate.setKeySerializer(new StringRedisSerializer());
                    //设置序列化Value的实例化对象
                    redisTemplate.setValueSerializer(new Strin