spring+redis的集成，使用spring-data-redis来集成

1、参考：https://www.cnblogs.com/qlqwjy/p/8562703.html

2、首先创建一个maven项目。然后加入依赖的jar包就行了。我加入的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/maven-v4_0_0.xsd">
   <modelVersion>4.0.</modelVersion>
   <groupId>com.charts</groupId>
   <artifactId>com.fline.aic.charts</artifactId>
   <packaging>war</packaging>
   <version>0.0.-SNAPSHOT</version>
   <name>com.fline.aic.charts Maven Webapp</name>
   <url>http://maven.apache.org</url>

   <dependencies>
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>3.8.</version>
       <scope>test</scope>
     </dependency>
     <!-- https://mvnrepository.com/artifact/log4j/log4j -->
     <dependency>
         <groupId>log4j</groupId>
         <artifactId>log4j</artifactId>
         <version>1.2.</version>
     </dependency>
     <!-- https://mvnrepository.com/artifact/com.github.kstyrc/embedded-redis -->
     <dependency>
         <groupId>com.github.kstyrc</groupId>
         <artifactId>embedded-redis</artifactId>
         <version>0.6</version>
         <scope>test</scope>
     </dependency>
     <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
     <dependency>
         <groupId>redis.clients</groupId>
         <artifactId>jedis</artifactId>
         <version>2.9.</version>
     </dependency>
     <!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-redis -->
     <dependency>
         <groupId>org.springframework.data</groupId>
         <artifactId>spring-data-redis</artifactId>
         <version>1.7..RELEASE</version>
     </dependency>
     <!-- https://mvnrepository.com/artifact/commons-pool/commons-pool -->
     <dependency>
         <groupId>commons-pool</groupId>
         <artifactId>commons-pool</artifactId>
         <version>1.5.</version>
     </dependency>
     <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
           <version>2.1.</version>
    </dependency>
    <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.1.</version>
    </dependency>
    <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.1.</version>
    </dependency>

     <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-core</artifactId>
         <version>4.3..RELEASE</version>
     </dependency>
     <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-context</artifactId>
         <version>4.3..RELEASE</version>
     </dependency>
     <!-- https://mvnrepository.com/artifact/org.springframework/spring-web -->
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-web</artifactId>
         <version>4.3..RELEASE</version>
     </dependency>
     <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-aop</artifactId>
         <version>4.3..RELEASE</version>
     </dependency>
     <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-webmvc</artifactId>
         <version>4.3..RELEASE</version>
     </dependency>
     <!-- https://mvnrepository.com/artifact/org.springframework/spring-beans -->
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-beans</artifactId>
         <version>4.3..RELEASE</version>
     </dependency>
     <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-jdbc</artifactId>
         <version>4.3..RELEASE</version>
     </dependency>
     <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-webmvc</artifactId>
         <version>4.3..RELEASE</version>
     </dependency>
     <!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-test</artifactId>
         <version>4.3..RELEASE</version>
         <scope>test</scope>
     </dependency>
     <dependency>
         <groupId>org.aspectj</groupId>
         <artifactId>aspectjweaver</artifactId>
         <version>1.8.</version>
     </dependency>

   </dependencies>
   <build>
     <finalName>com.fline.aic.charts</finalName>
   </build>

 </project>

3、然后在web.xml里面配置一下Spring框架listener配置。

 <?xml version="1.0" encoding="UTF-8"?>
 <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
   <display-name>Spring_Struts2_20170313</display-name>
   <welcome-file-list>
     <welcome-file>index.html</welcome-file>
     <welcome-file>index.htm</welcome-file>
     <welcome-file>index.jsp</welcome-file>
     <welcome-file>default.html</welcome-file>
     <welcome-file>default.htm</welcome-file>
     <welcome-file>default.jsp</welcome-file>
   </welcome-file-list>

   <!-- ：spring配置 ,在spring-framework-3.2..RELEASE\docs\spring-framework-reference\htmlsingle
                              搜索context-param找到下面这段话即可。记得就该param-value的值，如下所示；
          ：param-value的值最好使用bean，这样方便引用如/WEB-INF/classes/bean-*.xml
   -->
   <context-param>
     <param-name>contextConfigLocation</param-name>
     <!-- <param-value>classpath:applicationContext.xml</param-value> -->
     <param-value>/WEB-INF/applicationContext.xml</param-value>
   </context-param>
   <listener>
     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
   </listener>

 </web-app>

4、然后配置一下Spring的配置文件。

 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:p="http://www.springframework.org/schema/p"
     xmlns:context="http://www.springframework.org/schema/context"
     xsi:schemaLocation="
         http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd">

     <!-- 开启注解扫描 -->
     <context:annotation-config/>
     <context:component-scan base-package="com.fline.*"></context:component-scan> 

     <!-- <import resource="classpath:applicationContext-redis.xml" />  -->

 </beans>

5、然后配置一下Redis的配置文件redis.properties和applicationContext-redis.xml。

 redis.host=127.0.0.1
 redis.port=
 redis.password=

 redis.maxIdle=
 redis.maxActive=
 redis.maxWait=
 redis.testOnBorrow=true

 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context"
     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd ">

     <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig" >
         <!--最大空闲数-->
         <property name="maxIdle" value="" />
         <!--连接池的最大数据库连接数  -->
         <property name="maxTotal" value="" />
         <!--最大建立连接等待时间-->
         <property name="maxWaitMillis" value="" />
         <!--逐出连接的最小空闲时间 默认1800000毫秒(30分钟)-->
         <property name="minEvictableIdleTimeMillis" value="" />
         <!--每次逐出检查时 逐出的最大数目 如果为负数就是 : /abs(n), 默认3-->
         <property name="numTestsPerEvictionRun" value="" />
         <!--逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认--->
         <property name="timeBetweenEvictionRunsMillis" value="" />
         <!--是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个-->
         <property name="testOnBorrow" value="true" />
         <!--在空闲时检查有效性, 默认false  -->
         <property name="testWhileIdle" value="true" />
     </bean >    

     <!--redis连接工厂 -->
     <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" destroy-method="destroy">
         <property name="poolConfig" ref="jedisPoolConfig"></property>
         <!--IP地址 -->
         <property name="hostName" value="127.0.0.1"></property>
         <!--端口号  -->
         <property name="port" value=""></property>
         <!--如果Redis设置有密码  -->
         <property name="password" value="" />
         <!--客户端超时时间单位是毫秒  -->
         <property name="timeout" value=""></property>
     </bean>    

     <!--redis操作模版,使用该对象可以操作redis  -->
     <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" >
         <property name="connectionFactory" ref="jedisConnectionFactory" />
         <!--如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to String！！  -->
         <property name="keySerializer" >
             <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
         </property>
         <property name="valueSerializer" >
             <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer" />
         </property>
         <property name="hashKeySerializer">
             <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
         </property>
         <property name="hashValueSerializer">
             <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>
         </property>
         <!--开启事务  -->
         <property name="enableTransactionSupport" value="true"></property>
     </bean > 

     <bean id="redisUtil" class="com.fline.aic.utils.RedisUtil">
         <property name="redisTemplate" ref="redisTemplate" />
     </bean>

 </beans>

6、redis的工具类，可以直接拿到项目中使用的。

 package com.fline.aic.utils;

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

 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.stereotype.Component;
 import org.springframework.util.CollectionUtils;

 /**
  *
  * @author QLQ 基于spring和redis的redisTemplate工具类 针对所有的hash 都是以h开头的方法 针对所有的Set
  *         都是以s开头的方法 不含通用方法 针对所有的List 都是以l开头的方法
  */
 @Component // 交给Spring管理(在需要缓存的地方自动注入即可使用)
 public class RedisUtil {

     @Autowired // (自动注入redisTemplet)
     private RedisTemplate<String, Object> redisTemplate;

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

     /**
      * 指定缓存失效时间
      *
      * @param key
      *            键
      * @param time
      *            时间(秒)
      * @return
      */
     public boolean expire(String key, long time) {
         try {
             if (time > ) {
                 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 > ) {
             if (key.length == ) {
                 redisTemplate.delete(key[]);
             } 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 > ) {
                 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 < ) {
             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 < ) {
             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 > ) {
                 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 > ) {
                 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 ;
         }
     }

     /**
      * 将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 > )
                 expire(key, time);
             return count;
         } catch (Exception e) {
             e.printStackTrace();
             return ;
         }
     }

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

     /**
      * 移除值为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 ;
         }
     }
     // ===============================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 ;
         }
     }

     /**
      * 通过索引 获取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 rSet(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 > )
                 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 > )
                 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 ;
         }
     }

 }

7、最后是Redis的测试类，方便自己进行测试使用。

 package com.fline.aic.utils;

 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;

 import org.junit.Before;
 import org.junit.Test;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;

 /**
  *
  * @Description TODO
  * @author biehl
  * @Date 2018年12月7日 下午8:25:34
  *
  *       参考：https://www.cnblogs.com/qlqwjy/p/8562703.html
  */
 public class RedisTest {

     private RedisUtil redisUtils = null;

     @Before
     public void before() {
         ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext-redis.xml");
         redisUtils = (RedisUtil) context.getBean("redisUtil");
     }

     // redis存放String类型的
     @Test
     public void redisString() throws InterruptedException {
         // 从redis数据库中获取到dd的字符串
         String str = (String) redisUtils.get("dd");
         // 如果获取到的str字符串不为空
         if (str != null) {
             // 就删除这个str字符串
             redisUtils.del(str);
         }
         // 将key为dd和value为dd设置到redis里面
         redisUtils.set("dd", "dd");
         // 打印该key为dd的字符串
         System.out.println(redisUtils.get("dd"));
     }

     // redis存放List类型的
     @Test
     public void redisList() throws InterruptedException {
         // 删除key为list1
         redisUtils.del("list1");
         redisUtils.lSet("list1", "list1");
         redisUtils.lSet("list1", "list2");
         redisUtils.lSet("list1", "list3");
         redisUtils.rSet("list1", "list4");
         List<Object> lGet = redisUtils.lGet("list1", , -);
         // redisTemplate.opsForList().range("myList", 0, -1);
         for (Object s : lGet) {
             System.out.println(s);
         }
     }

     // redis存放Set类型的
     @Test
     public void redisSet() throws InterruptedException {
         redisUtils.del("set1");
         redisUtils.sSet("set1", "set1");
         redisUtils.sSet("set1", "set2");
         redisUtils.sSet("set1", "set3");
         redisUtils.sSet("set1", "set4");
         Set<Object> sGet = redisUtils.sGet("set1");
         for (Object s : sGet) {
             System.out.println(s);
         }
     }

     // redis存放Hash类型的
     @Test
     public void redisHash() throws InterruptedException {
         redisUtils.del("hash1");
         redisUtils.hset("hash1", "beijing", "北京");
         redisUtils.hset("hash1", "shanghai", "上海");
         redisUtils.hset("hash1", "chenzhen", "深圳");
         redisUtils.hset("hash1", "xinxiang", "新乡");
         Map<Object, Object> hmget = redisUtils.hmget("hash1");
         Set<Entry<Object, Object>> entrySet = hmget.entrySet();
         for (Map.Entry<Object, Object> hash : entrySet) {
             System.out.println(hash.getKey() + " : " + hash.getValue());
         }
     }

 }

效果如下所示：

待续.....