Windows环境下springboot集成redis的安装与使用

一，redis安装

首先我们需要下载Windows版本的redis压缩包地址如下：

https://github.com/MicrosoftArchive/redis/releases

连接打开后如下图所示

我们选择64位的压缩包，下载后需要解压，我们解压至D盘，如下图所示：

接下来我们需要执行一些安装命令

1，在如上图的目录中，直接键入“cmd“

2，在打开的cmd命令窗口中输入 “redis-server.exe redis.windows.conf” 用于启动redis服务

（注意采用这个命令相当于启动一个临时服务，如果当前窗口被关闭，则服务也会被关闭）

3，我们再打开一个同样的cmd命令窗口，在其中键入 “redis-cli” ，这个命令的作用是启动一个redis客户端。客户端默认的端口号是6379 如果我们要修改端口号，需要打开我们前面执行的命令中的conf文件redis.windows.conf 找到port 修改其后的端口号

4，在启动的客户端中检查redis服务是否正常，我们可以进行数据的设置和读取等操作，比如我们可以执行一个命令 “set redis jj”，然后我们再执行一个命令“get redis” 就可以将前面设置的123 查询出来 ，如下图所示

5，将redis服务注册到我们的Windows，我们继续新打开一个cmd窗口，执行命令 “redis-server --service-install redis.windows.conf” 这个时候呢，提示：Redis successfully installed as a service. 表示加入服务成功！

6，启动注册到Windows的redis服务。键入命令“redis-server.exe  --service-start”  可能会报错，如下图。原因是我们已经在这个端口绑定了一个服务，就是我们前面启动的那个所谓的临时服务，这个时候我们需要关闭刚才启动的临时服务的窗口。

7，再启动如果还是报上面的错误，那可能需要我们调整注册到Windows的服务为本地系统服务，而不是网络服务，如下图所示。除此之外可能还会有防火墙等问题导致redis服务启动失败。

8，如下图所示，服务启动ok，这个时候我们在继续操作redis客户端是没有问题的。

二，springboot 集成redis

1，新建springboot工程，如果有不清楚如何新建的，请移步 https://www.cnblogs.com/JJJ1990/p/8384386.html

2，在pom文件中加入redis jar包的引用

我的整个工程的pom文件如下，注意第34-38行，即为引入的redis jar包

 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>

   <groupId>com</groupId>
   <artifactId>redis</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>redis</name>
   <url>http://maven.apache.org</url>

   <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   </properties>

   <parent>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
         <version>1.5.8.RELEASE</version>
    </parent>

   <dependencies>
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>3.8.1</version>
       <scope>test</scope>
     </dependency>
       <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-web</artifactId>
         </dependency>
       <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-data-redis</artifactId>
         </dependency>
   </dependencies>
 </project>

3，编写RedisConfig 类代码

 package com.redis;

 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.PropertySource;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
 import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
 import org.springframework.data.redis.serializer.StringRedisSerializer;

 import redis.clients.jedis.JedisPoolConfig;

 @Configuration
 @PropertySource("classpath:config/redis.properties")
 public class RedisConfig {

     @Value("${redis.maxIdle}")
     private Integer maxIdle;

     @Value("${redis.maxTotal}")
     private Integer maxTotal;

     @Value("${redis.maxWaitMillis}")
     private Integer maxWaitMillis;

     @Value("${redis.minEvictableIdleTimeMillis}")
     private Integer minEvictableIdleTimeMillis;

     @Value("${redis.numTestsPerEvictionRun}")
     private Integer numTestsPerEvictionRun;

     @Value("${redis.timeBetweenEvictionRunsMillis}")
     private long timeBetweenEvictionRunsMillis;

     @Value("${redis.testOnBorrow}")
     private boolean testOnBorrow;

     @Value("${redis.testWhileIdle}")
     private boolean testWhileIdle;

     @Value("${spring.redis.cluster.nodes}")
     private String clusterNodes; 

     @Value("${spring.redis.cluster.max-redirects}")
     private Integer mmaxRedirectsac;

     /**
      * JedisPoolConfig 连接池
      * @return
      */
     @Bean
     public JedisPoolConfig jedisPoolConfig() {
         JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
         // 最大空闲数
         jedisPoolConfig.setMaxIdle(maxIdle);
         // 连接池的最大数据库连接数
         jedisPoolConfig.setMaxTotal(maxTotal);
         // 最大建立连接等待时间
         jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
         // 逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
         jedisPoolConfig.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
         // 每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
         jedisPoolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
         // 逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
         jedisPoolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
         // 是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
         jedisPoolConfig.setTestOnBorrow(testOnBorrow);
         // 在空闲时检查有效性, 默认false
         jedisPoolConfig.setTestWhileIdle(testWhileIdle);
         System.out.println("redis 连接池配置完成！");
         return jedisPoolConfig;
     }
     /**
      * 单机版配置
     * @throws
      */
     @Bean
     public JedisConnectionFactory JedisConnectionFactory(JedisPoolConfig jedisPoolConfig){
         JedisConnectionFactory JedisConnectionFactory = new JedisConnectionFactory(jedisPoolConfig);
         //连接池
         JedisConnectionFactory.setPoolConfig(jedisPoolConfig);
         //IP地址
         JedisConnectionFactory.setHostName("127.0.0.1");
         //端口号
         JedisConnectionFactory.setPort(6379);
         //如果Redis设置有密码
         //JedisConnectionFactory.setPassword(password);
         //客户端超时时间单位是毫秒
         JedisConnectionFactory.setTimeout(5000);
         System.out.println("jedis  连接工厂配置完成！");
         return JedisConnectionFactory;
     }

     /**
      * 实例化 RedisTemplate 对象
      * @return
      */
     @Bean
     public RedisTemplate<String, Object> functionDomainRedisTemplate(JedisConnectionFactory redisConnectionFactory) {
         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
         initDomainRedisTemplate(redisTemplate, redisConnectionFactory);
         System.out.println("functionDomainRedisTemplates 配置完成！");
         return redisTemplate;
     }
     /**
      * 设置数据存入 redis 的序列化方式,并开启事务
      * @param redisTemplate
      * @param factory
      */
     private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate, RedisConnectionFactory factory) {
         //如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to String！
         redisTemplate.setKeySerializer(new StringRedisSerializer());
         redisTemplate.setHashKeySerializer(new StringRedisSerializer());
         redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
         redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
         // 开启事务
         redisTemplate.setEnableTransactionSupport(true);
         redisTemplate.setConnectionFactory(factory);
     }
     /**
      * 注入封装RedisTemplate
     * @Title: redisUtil
     * @return RedisUtil
     * @throws
      */
     @Bean(name = "redisUtil")
     public RedisUtil redisUtil(RedisTemplate<String, Object> redisTemplate) {
         RedisUtil redisUtil = new RedisUtil();
         redisUtil.setRedisTemplate(redisTemplate);
         System.out.println("redisUtil 配置完成！");
         return redisUtil;
     }
 }

4，编写RedisUtil类，用于操作redis数据库

 package com.redis;

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

 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.util.CollectionUtils;

 public class RedisUtil {

 private RedisTemplate<String, Object> redisTemplate;  

     public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
         this.redisTemplate = redisTemplate;
     }  

     /**
      * 指定缓存失效时间
      * @param key 键
      * @param time 时间(秒)
      * @return
      */
     public boolean expire(String key,long time){
         try {
             if(time>0){
                 redisTemplate.expire(key, time, TimeUnit.SECONDS);
             }
             return true;
         } catch (Exception e) {
             e.printStackTrace();
             return false;
         }
     }  

     /**
      * 根据key 获取过期时间
      * @param key 键 不能为null
      * @return 时间(秒) 返回0代表为永久有效
      */
     public long getExpire(String key){
         return redisTemplate.getExpire(key,TimeUnit.SECONDS);
     }  

     /**
      * 判断key是否存在
      * @param key 键
      * @return true 存在 false不存在
      */
     public boolean hasKey(String key){
         try {
             return redisTemplate.hasKey(key);
         } catch (Exception e) {
             e.printStackTrace();
             return false;
         }
     }  

     /**
      * 删除缓存
      * @param key 可以传一个值 或多个
      */
     @SuppressWarnings("unchecked")
     public void del(String ... key){
         if(key!=null&&key.length>0){
             if(key.length==1){
                 redisTemplate.delete(key[0]);
             }else{
                 redisTemplate.delete(CollectionUtils.arrayToList(key));
             }
         }
     }  

     //============================String=============================
     /**
      * 普通缓存获取
      * @param key 键
      * @return 值
      */
     public Object get(String key){
         return key==null?null:redisTemplate.opsForValue().get(key);
     }  

     /**
      * 普通缓存放入
      * @param key 键
      * @param value 值
      * @return true成功 false失败
      */
     public boolean set(String key,Object value) {
          try {
             redisTemplate.opsForValue().set(key, value);
             return true;
         } catch (Exception e) {
             e.printStackTrace();
             return false;
         }  

     }  

     /**
      * 普通缓存放入并设置时间
      * @param key 键
      * @param value 值
      * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
      * @return true成功 false 失败
      */
     public boolean set(String key,Object value,long time){
         try {
             if(time>0){
                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
             }else{
                 set(key, value);
             }
             return true;
         } catch (Exception e) {
             e.printStackTrace();
             return false;
         }
     }  

     /**
      * 递增
      * @param key 键
      * @param by 要增加几(大于0)
      * @return
      */
     public long incr(String key, long delta){
         if(delta<0){
             throw new RuntimeException("递增因子必须大于0");
         }
         return redisTemplate.opsForValue().increment(key, delta);
     }  

     /**
      * 递减
      * @param key 键
      * @param by 要减少几(小于0)
      * @return
      */
     public long decr(String key, long delta){
         if(delta<0){
             throw new RuntimeException("递减因子必须大于0");
         }
         return redisTemplate.opsForValue().increment(key, -delta);
     }    

     //================================Map=================================
     /**
      * HashGet
      * @param key 键 不能为null
      * @param item 项 不能为null
      * @return 值
      */
     public Object hget(String key,String item){
         return redisTemplate.opsForHash().get(key, item);
     }  

     /**
      * 获取hashKey对应的所有键值
      * @param key 键
      * @return 对应的多个键值
      */
     public Map<Object,Object> hmget(String key){
         return redisTemplate.opsForHash().entries(key);
     }  

     /**
      * HashSet
      * @param key 键
      * @param map 对应多个键值
      * @return true 成功 false 失败
      */
     public boolean hmset(String key, Map<String,Object> map){
         try {
             redisTemplate.opsForHash().putAll(key, map);
             return true;
         } catch (Exception e) {
             e.printStackTrace();
             return false;
         }
     }  

     /**
      * HashSet 并设置时间
      * @param key 键
      * @param map 对应多个键值
      * @param time 时间(秒)
      * @return true成功 false失败
      */
     public boolean hmset(String key, Map<String,Object> map, long time){
         try {
             redisTemplate.opsForHash().putAll(key, map);
             if(time>0){
                 expire(key, time);
             }
             return true;
         } catch (Exception e) {
             e.printStackTrace();
             return false;
         }
     }  

     /**
      * 向一张hash表中放入数据,如果不存在将创建
      * @param key 键
      * @param item 项
      * @param value 值
      * @return true 成功 false失败
      */
     public boolean hset(String key,String item,Object value) {
          try {
             redisTemplate.opsForHash().put(key, item, value);
             return true;
         } catch (Exception e) {
             e.printStackTrace();
             return false;
         }
     }  

     /**
      * 向一张hash表中放入数据,如果不存在将创建
      * @param key 键
      * @param item 项
      * @param value 值
      * @param time 时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
      * @return true 成功 false失败
      */
     public boolean hset(String key,String item,Object value,long time) {
          try {
             redisTemplate.opsForHash().put(key, item, value);
             if(time>0){
                 expire(key, time);
             }
             return true;
         } catch (Exception e) {
             e.printStackTrace();
             return false;
         }
     }  

     /**
      * 删除hash表中的值
      * @param key 键 不能为null
      * @param item 项 可以使多个 不能为null
      */
     public void hdel(String key, Object... item){
         redisTemplate.opsForHash().delete(key,item);
     }   

     /**
      * 判断hash表中是否有该项的值
      * @param key 键 不能为null
      * @param item 项 不能为null
      * @return true 存在 false不存在
      */
     public boolean hHasKey(String key, String item){
         return redisTemplate.opsForHash().hasKey(key, item);
     }   

     /**
      * hash递增 如果不存在,就会创建一个 并把新增后的值返回
      * @param key 键
      * @param item 项
      * @param by 要增加几(大于0)
      * @return
      */
     public double hincr(String key, String item,double by){
         return redisTemplate.opsForHash().increment(key, item, by);
     }  

     /**
      * hash递减
      * @param key 键
      * @param item 项
      * @param by 要减少记(小于0)
      * @return
      */
     public double hdecr(String key, String item,double by){
         return redisTemplate.opsForHash().increment(key, item,-by);
     }    

     //============================set=============================
     /**
      * 根据key获取Set中的所有值
      * @param key 键
      * @return
      */
     public Set<Object> sGet(String key){
         try {
             return redisTemplate.opsForSet().members(key);
         } catch (Exception e) {
             e.printStackTrace();
             return null;
         }
     }  

     /**
      * 根据value从一个set中查询,是否存在
      * @param key 键
      * @param value 值
      * @return true 存在 false不存在
      */
     public boolean sHasKey(String key,Object value){
         try {
             return redisTemplate.opsForSet().isMember(key, value);
         } catch (Exception e) {
             e.printStackTrace();
             return false;
         }
     }  

     /**
      * 将数据放入set缓存
      * @param key 键
      * @param values 值 可以是多个
      * @return 成功个数
      */
     public long sSet(String key, Object...values) {
         try {
             return redisTemplate.opsForSet().add(key, values);
         } catch (Exception e) {
             e.printStackTrace();
             return 0;
         }
     }  

     /**
      * 将set数据放入缓存
      * @param key 键
      * @param time 时间(秒)
      * @param values 值 可以是多个
      * @return 成功个数
      */
     public long sSetAndTime(String key,long time,Object...values) {
         try {
             Long count = redisTemplate.opsForSet().add(key, values);
             if(time>0) expire(key, time);
             return count;
         } catch (Exception e) {
             e.printStackTrace();
             return 0;
         }
     }  

     /**
      * 获取set缓存的长度
      * @param key 键
      * @return
      */
     public long sGetSetSize(String key){
         try {
             return redisTemplate.opsForSet().size(key);
         } catch (Exception e) {
             e.printStackTrace();
             return 0;
         }
     }  

     /**
      * 移除值为value的
      * @param key 键
      * @param values 值 可以是多个
      * @return 移除的个数
      */
     public long setRemove(String key, Object ...values) {
         try {
             Long count = redisTemplate.opsForSet().remove(key, values);
             return count;
         } catch (Exception e) {
             e.printStackTrace();
             return 0;
         }
     }
     //===============================list=================================  

     /**
      * 获取list缓存的内容
      * @param key 键
      * @param start 开始
      * @param end 结束  0 到 -1代表所有值
      * @return
      */
     public List<Object> lGet(String key,long start, long end){
         try {
             return redisTemplate.opsForList().range(key, start, end);
         } catch (Exception e) {
             e.printStackTrace();
             return null;
         }
     }  

     /**
      * 获取list缓存的长度
      * @param key 键
      * @return
      */
     public long lGetListSize(String key){
         try {
             return redisTemplate.opsForList().size(key);
         } catch (Exception e) {
             e.printStackTrace();
             return 0;
         }
     }  

     /**
      * 通过索引 获取list中的值
      * @param key 键
      * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
      * @return
      */
     public Object lGetIndex(String key,long index){
         try {
             return redisTemplate.opsForList().index(key, index);
         } catch (Exception e) {
             e.printStackTrace();
             return null;
         }
     }  

     /**
      * 将list放入缓存
      * @param key 键
      * @param value 值
      * @param time 时间(秒)
      * @return
      */
     public boolean lSet(String key, Object value) {
         try {
             redisTemplate.opsForList().rightPush(key, value);
             return true;
         } catch (Exception e) {
             e.printStackTrace();
             return false;
         }
     }  

     /**
      * 将list放入缓存
      * @param key 键
      * @param value 值
      * @param time 时间(秒)
      * @return
      */
     public boolean lSet(String key, Object value, long time) {
         try {
             redisTemplate.opsForList().rightPush(key, value);
             if (time > 0) expire(key, time);
             return true;
         } catch (Exception e) {
             e.printStackTrace();
             return false;
         }
     }  

     /**
      * 将list放入缓存
      * @param key 键
      * @param value 值
      * @param time 时间(秒)
      * @return
      */
     public boolean lSet(String key, List<Object> value) {
         try {
             redisTemplate.opsForList().rightPushAll(key, value);
             return true;
         } catch (Exception e) {
             e.printStackTrace();
             return false;
         }
     }  

     /**
      * 将list放入缓存
      * @param key 键
      * @param value 值
      * @param time 时间(秒)
      * @return
      */
     public boolean lSet(String key, List<Object> value, long time) {
         try {
             redisTemplate.opsForList().rightPushAll(key, value);
             if (time > 0) expire(key, time);
             return true;
         } catch (Exception e) {
             e.printStackTrace();
             return false;
         }
     }  

     /**
      * 根据索引修改list中的某条数据
      * @param key 键
      * @param index 索引
      * @param value 值
      * @return
      */
     public boolean lUpdateIndex(String key, long index,Object value) {
         try {
             redisTemplate.opsForList().set(key, index, value);
             return true;
         } catch (Exception e) {
             e.printStackTrace();
             return false;
         }
     }   

     /**
      * 移除N个值为value
      * @param key 键
      * @param count 移除多少个
      * @param value 值
      * @return 移除的个数
      */
     public long lRemove(String key,long count,Object value) {
         try {
             Long remove = redisTemplate.opsForList().remove(key, count, value);
             return remove;
         } catch (Exception e) {
             e.printStackTrace();
             return 0;
         }
     }
 }

5，新建 redis.properties 文件

注意文件位置，在我们新建RedisConfig 的时候有指定 为config/redis.properties ，所以我们的redis.properties 文件位置如下图所示

6，编写redis.properties 文件内容

 #Matser的ip地址
 redis.hostName=172.0.0.1
 #端口号
 redis.port=6379
 #如果有密码
 redis.password=
 #客户端超时时间单位是毫秒 默认是2000
 redis.timeout=10000  

 #最大空闲数
 redis.maxIdle=300
 #连接池的最大数据库连接数。设为0表示无限制,如果是jedis 2.4以后用redis.maxTotal
 #redis.maxActive=600
 #控制一个pool可分配多少个jedis实例,用来替换上面的redis.maxActive,如果是jedis 2.4以后用该属性
 redis.maxTotal=1000
 #最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
 redis.maxWaitMillis=1000
 #连接的最小空闲时间 默认1800000毫秒(30分钟)
 redis.minEvictableIdleTimeMillis=300000
 #每次释放连接的最大数目,默认3
 redis.numTestsPerEvictionRun=1024
 #逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
 redis.timeBetweenEvictionRunsMillis=30000
 #是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
 redis.testOnBorrow=true
 #在空闲时检查有效性, 默认false
 redis.testWhileIdle=true  

 #redis集群配置
 spring.redis.cluster.nodes=192.168.177.128:7001,192.168.177.128:7002,192.168.177.128:7003,192.168.177.128:7004,192.168.177.128:7005,192.168.177.128:7006
 spring.redis.cluster.max-redirects=3

7,编写测试controller

 package com.redis;

 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseBody;

 @Controller
 public class Firstblood {

     @Autowired
     RedisUtil redisUtil;

     @RequestMapping(value="/FristBlood/{name}",method= RequestMethod.GET)
     @ResponseBody
     public String hello(@PathVariable("name") String name) {
         return "查询结果：" + redisUtil.get(name) ;
     }
 }

8，测试验证

打开浏览器，输入 “http://localhost:8080/FristBlood/redis”  这个url中的redis就等于是我们本次请求要查询的key ，

但是这块有一个问题是，我们使用了@ResponseBody 注解，但是我们在redis数据库中，之前存入的时候，我们执行了一个命令"set redis jj" ,

虽然我们认为存入的是一个字符串但是在我们代码中执行获取这个key的value的时候不会这么认为，会导致解析出错。

这个时候我们从新set一下，如下图

然后在浏览器中我们继续输入上面的url，返回的结果页面如下，则说明整个工程ok

如果输入的key不存在 则返回null，如下图所示：