Spring集成Redis

阳光穿透心脏的1/2处 2022-05-20 01:48 312阅读 0赞

最近在做一个关于群聊的项目，由于聊天要求实时性，不可能直接访问数据库，所以使用了Redis来做缓存，这里将使用过程中遇到的问题记录一下。
使用Redis之前需要合理设计存储在其中的数据结构，比如聊天系统，就需要存储包括用户登录状态信息，可以使用Hash数据结构，以用户Id做键，状态做值，还可以存储每个用户在每个群的未读消息计数，
客户端使用长轮询拉取。
最主要的就是群里的聊天记录的缓存了，这里可以使用Redis的List数据结构来做消息队列，其中按顺序存储消息实体对象（序列化后存入Redis）。还可以维护一个List存储聊天记录的主键便于定位聊天记录，等等的一系列数据都可以缓存到Redis。
Redis在Java中的实现是Jedis，其中封装了连接Redis的连接池实现、对Redis数据库的各种操作等。
在JavaWeb项目中使用Redis做缓存时有两种实现方式，第一种是使用原生的Jedis包，其中封装的方法可以直接操作Redis。第二种方法是使用Spring框架集成的Redis，其中封装Jedis对Redis的各种操作，包括事务、连接、连接池的维护等，其对Redis的操作进行了很多封装。
这个聊天项目一开始采用的是Spring封装的Redis，使用过程中发现，经常会报一些类型转换异常的问题，后来发现这种错误经常在网络连接异常或是长轮询的地方出现。深入底层发现是由于Redis底层的Socket连接使用了缓冲区，导致有些时候如果前面的连接出现问题，后面的请求再使用前面的连接会获取到前面连接的数据，导致类型转换异常的出现，
尤其是长轮询不断请求Redis服务器的时候，问题出现的频率尤其高，而且一旦出现问题，后面的连接都会出问题，这也许是由于Redis连接池中出问题的连接没有完全释放的原因。
因此建议大家如果使用Redis做缓存，最好使用原生的Jedis，这样可以在连接异常时自己实现异常连接的处理，而使用Spring集成的Redis由于连接已经被封装了，限制了自己对异常连接的处理。
下面就将两种集成Redis的方法分别介绍一下。
第一种是使用Spring集成的Redis。

1、首先是Jar包，需要jedis包、Spring集成Redis的包spring-data-redis、Redis连接池需要的commons-pool2包，其中spring-data-redis包和jedis包的版本需要适配，否则会报错，具体要求网上可以查到，这3个包的下载可以从Maven仓库获取。

  1. <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-pool2 -->
  2.     <dependency>
  3.     <groupId>org.apache.commons</groupId>
  4.     <artifactId>commons-pool2</artifactId>
  5.     <version>2.4.2</version>
  6.     </dependency>
  7. <!-- spring-data-redis2.0.7版本下载失败 -->
  8.     <dependency>
  9.        <groupId>org.springframework.data</groupId>
  10.        <artifactId>spring-data-redis</artifactId>
  11.        <version>1.8.4.RELEASE</version>
  12.     </dependency>
  13.     <dependency>
  14.        <groupId>redis.clients</groupId>
  15.        <artifactId>jedis</artifactId>
  16.        <version>2.9.0</version>
  17.     </dependency>

2、Spring集成Redis的Xml配置

2.1、Redis.properties配置（相当于jdbc.properties）

  1. #============================#
  2. #==== Redis settings ====#
  3. #============================#
  4. #redis 服务器 IP
  5. redis.host=192.168.1.222
  6. #192.168.1.222
  8. #格式：redis://:[密码]@[服务器地址]:[端口]/[db index]
  9. redis.uri = redis://:12345@127.0.0.1:6379/0
  11. #redis 服务器端口
  12. redis.port=6379
  14. #redis 密码
  15. redis.pass=
  16. #redis#2018
  18. #超时时间
  19. redis.timeOut=2000
  20. #redis 支持16个数据库（相当于不同用户）可以使不同的应用程序数据彼此分开同时又存储在相同的实例上
  21. redis.dbIndex=0
  23. #redis 缓存数据过期时间单位秒
  24. redis.expiration=3000
  26. #连接池中最大连接数。高版本：maxTotal，低版本：maxActive
  27. #控制一个 pool 可分配多少个jedis实例
  28. redis.maxActive=6
  30. #连接池中最少空闲的连接数
  31. redis.minIdle=1
  33. #连接池中最大空闲的连接数，控制一个 pool 最多有多少个状态为 idle 的jedis实例
  34. redis.maxIdle=300
  36. #当连接池资源耗尽时，调用者最大阻塞的时间，超时将抛出异常。单位，毫秒数;默认为-1.表示永不超时。高版本：maxWaitMillis，低版本：maxWait
  37. #当borrow一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException；
  38. redis.maxWait=1000
  40. #连接空闲的最小时间，达到此值后空闲连接将可能会被移除。负值(-1)表示不移除
  41. redis.minEvictableIdleTimeMillis=60000
  43. #对于“空闲链接”检测线程而言，每次检测的链接资源的个数。默认为3
  44. redis.numTestsPerEvictionRun=3
  46. #“空闲链接”检测线程，检测的周期，毫秒数。如果为负值，表示不运行“检测线程”。默认为-1
  47. redis.timeBetweenEvictionRunsMillis=30000
  49. #testOnBorrow:向调用者输出“链接”资源时，是否检测是有有效，如果无效则从连接池中移除，并尝试获取继续获取。默认为false。建议保持默认值
  50. #在borrow一个jedis实例时，是否提前进行alidate操作；如果为true，则得到的jedis实例均是可用的；
  51. redis.testOnBorrow=true
  53. #testOnReturn:向连接池“归还”链接时，是否检测“链接”对象的有效性。默认为false。建议保持默认值
  54. #testWhileIdle:向调用者输出“链接”对象时，是否检测它的空闲超时；默认为false。如果“链接”空闲超时，将会被移除。建议保持默认值
  55. #whenExhaustedAction:当“连接池”中active数量达到阀值时，即“链接”资源耗尽时，连接池需要采取的手段, 默认为1(0:抛出异常。1:阻塞，直到有可用链接资源。2:强制创建新的链接资源)

2.2、applicationContext.xml引入redis.properties文件

  1. <!-- 这里配置数据库properties文件位置 -->
  2.     <!-- 使用PropertyPlaceholderConfigurer加载redis.properties文件失败改用PropertySourcesPlaceholderConfigurer -->
  3.     <bean id="propertyConfigurer" class="org.springframework.context.support.PropertySourcesPlaceholderConfigurer">
  4.         <property name="locations">
  5.             <list>
  6.                 <value>classpath:jdbc.properties</value>
  7.                 <value>classpath:system.properties</value>    
  8.                 <value>classpath:redis.properties</value>
  9.             </list>
  10.         </property>
  11.     </bean>

将Redis相关配置单独放在一个配置文件中：

  1. <import resource="spring-redis-context.xml" />

spring-redis-context.xml中的配置包括，连接池的配置、连接工厂的配置以及RedisTemplate类的相关配置。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.       xmlns:context="http://www.springframework.org/schema/context"
  5.       xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.                        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
  7.                        http://www.springframework.org/schema/context
  8.                        http://www.springframework.org/schema/context/spring-context.xsd">
  9.    <description>Spring容器管理redis连接和使用 </description>
  11.    <!--载入 redis 配置文件-->
  12.    <!-- Spring容器仅允许最多定义一个PropertyPlaceholderConfigurer 或 <content:property-placeholder>其余的会被Spring忽略 -->
  13.    <!-- <context:property-placeholder location="classpath:redis.properties" ignore-unresolvable="true"/> -->
  15.    <!-- 高版本Jedis没有maxActive变量，具体有哪些可以看JedisPoolConfig继承的类GenericObjectPoolConfig -->
  16.    <!-- 连接池配置 -->
  17.    <!-- 配置 JedisPoolConfig 实例 -->
  18.    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
  19.        <property name="maxIdle" value="${redis.maxIdle}"/>
  20.        <property name="maxTotal" value="${redis.maxActive}"/>
  21.        <property name="maxWaitMillis" value="${redis.maxWait}"/>
  22.        <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
  23.    </bean>
  25.    <!-- <bean id="clusterRedisNodes1" class="org.springframework.data.redis.connection.RedisNode">
  26.            <constructor-arg value="${redis.host}" />
  27.            <constructor-arg value="${redis.port}" type="int"/>
  28.    </bean> -->
  30.    <!-- ERR This instance has cluster support disabled -->
  31.    <!-- <bean id="redisClusterConfiguration" class="org.springframework.data.redis.connection.RedisClusterConfiguration">
  32.            <property name="maxRedirects" value="3"></property>
  33.            节点配置
  34.            <property name="clusterNodes">
  35.                <set>
  36.                    <bean class="org.springframework.data.redis.connection.RedisClusterNode">
  37.                        <constructor-arg name="host" value="${redis.host}"/>
  38.                        <constructor-arg name="port" value="${redis.port}"/>
  39.                    </bean>
  40.                    <bean class="org.springframework.data.redis.connection.RedisClusterNode">
  41.                        <constructor-arg name="host" value="192.168.1.111"/>
  42.                        <constructor-arg name="port" value="6380"/>
  43.                    </bean>
  44.                </set>
  45.            </property>
  46.    </bean> -->
  48.     <!-- Spring提供的Redis连接工厂 -->
  49.    <!-- 配置JedisConnectionFactory -->
  50.    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" destroy-method="destroy">
  51.        <property name="hostName" value="${redis.host}"/>
  52.        <property name="port" value="${redis.port}"/>
  53.        <property name="password" value="${redis.pass}"/>
  54.        <property name="database" value="${redis.dbIndex}"/> 
  55.        <property name="poolConfig" ref="poolConfig"/>
  56.        <!-- <constructor-arg ref="redisClusterConfiguration"></constructor-arg>
  57.        <constructor-arg ref="poolConfig"></constructor-arg> -->
  58.        <!-- <property name="clusterConfig" ref="redisClusterConfiguration"></property> -->
  59.    </bean>
  60.     <bean id="redisConfig" class="com.teriste.redis.util.RedisConfig"></bean>
  61.    <!-- Spring提供的访问Redis类 -->
  62.    <!-- 配置RedisTemplate -->
  63.    <!-- <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" scope="prototype">
  64.        <property name="connectionFactory" ref="jedisConnectionFactory"/>
  65.        下面是设置key和value序列化的方式，不同方式导致存入的字节序列不一样，什么样的序列化方式就要使用相应的反序列化方式查询，否则差不多redis存入的数据
  66.        由此也可以知道spring对redis序列化有很多种方式
  67.        <property name="keySerializer">
  68.             <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
  69.         </property>
  70.         <property name="valueSerializer">
  71.             defaultSerializer是JdkSerializationRedisSerializer在调试时看不出来键是什么样的
  72.             <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
  73.             <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer" />
  74.             fastjson序列化
  75.             <bean class="com.teriste.redis.util.FastJson2JsonRedisSerializer">
  76.                 <constructor-arg name="clazz" value=Object.class></constructor-arg>
  77.             </bean>
  78.         </property>
  79.         <property name="hashKeySerializer">
  80.             <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
  81.         </property>
  82.         配置true可以使用transactional控制事务，spring已经提供支持
  83.         <property name="enableTransactionSupport" value="true"/>
  84.    </bean> -->
  86.    <!-- 配置RedisCacheManager -->
  87.    <bean id="redisCacheManager" class="org.springframework.data.redis.cache.RedisCacheManager">
  88.        <constructor-arg name="redisOperations" ref="redisTemplate"/>
  89.        <property name="defaultExpiration" value="${redis.expiration}"/>
  90.    </bean>
  92.    <!-- 配置RedisCacheConfig -->
  93.    <!-- <bean id="redisCacheConfig" class="com.teriste.redis.util.RedisCacheConfig">
  94.        <constructor-arg ref="jedisConnectionFactory"/>
  95.        <constructor-arg ref="redisTemplate"/>
  96.        <constructor-arg ref="redisCacheManager"/>
  97.    </bean> -->
  99.    <!-- Redis sentinel集群配置 -->
  100.     <!-- <bean id="sentinelConfig" class="org.springframework.data.redis.connection.RedisSentinelConfiguration">
  101.         <constructor-arg index="0" type="java.lang.String" value="host6379" />
  102.         <constructor-arg index="1" type="java.util.Set">
  103.             <set>
  104.                 <value>192.168.1.111:6380</value>
  105.                 <value>192.168.1.111:6381</value>
  106.             </set>
  107.         </constructor-arg>
  108.     </bean> -->
  109.     <!-- Spring提供的Redis连接工厂 -->
  110.     <!-- <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" destroy-method="destroy">
  111.         Redis sentinel集群配置
  112.         <constructor-arg index="0" type="org.springframework.data.redis.connection.RedisSentinelConfiguration" ref="sentinelConfig" />
  113.         连接池配置.
  114.         <constructor-arg index="1" type="redis.clients.jedis.JedisPoolConfig" ref="poolConfig" />
  116.         Redis服务主机.
  117.         <property name="hostName" value="192.168.1.111" />
  118.         Redis服务端口号.
  119.         <property name="port" value="26379" />
  120.         Redis服务连接密码.
  121.         <property name="password" value="${redis.pass}" />
  122.         连超时设置.
  123.         <property name="timeout" value="15000" />
  124.         是否使用连接池.
  125.         <property name="usePool" value="true" />
  126.     </bean> -->
  127. </beans>

RedisTemplate相关的配置在RedisConfig类中统一管理，再由容器注入，其中主要包括的是Java对象序列化存入Redis和从Redis反序列化到java对象的配置，因为Spring集成的redis默认是

JdkSerializationRedisSerializer，序列化后是字节数组，存入Redis不便于查看，所以需要自己配置键值的序列化方式，这里使用的是alibaba的fastjson2：

  1. //RedisConfig.java
  2. import org.springframework.context.annotation.Bean;
  3. import org.springframework.context.annotation.Configuration;
  4. import org.springframework.data.redis.connection.RedisConnectionFactory;
  5. import org.springframework.data.redis.core.RedisTemplate;
  6. import org.springframework.data.redis.serializer.RedisSerializer;
  7. import org.springframework.data.redis.serializer.StringRedisSerializer;
  9. import com.alibaba.fastjson.parser.ParserConfig;
  11. @Configuration
  12. public class RedisConfig
  13. {
  14.     /**
  15.      * 重写Redis序列化方式，使用Json方式:
  16.      * 当我们的数据存储到Redis的时候，我们的键（key）和值（value）都是通过Spring提供的Serializer序列化到数据库的。RedisTemplate默认使用的是JdkSerializationRedisSerializer，StringRedisTemplate默认使用的是StringRedisSerializer。
  17.      * Spring Data JPA为我们提供了下面的Serializer：
  18.      * GenericToStringSerializer、Jackson2JsonRedisSerializer、JacksonJsonRedisSerializer、JdkSerializationRedisSerializer、OxmSerializer、StringRedisSerializer。
  19.      * 在此我们将自己配置RedisTemplate并定义Serializer。
  20.      * com.teriste.redis.util.FastJson2JsonRedisSerializer
  21.      * @param redisConnectionFactory
  22.      * @return
  23.      */
  24.     @Bean(name="fastJson2JsonRedisSerializer")
  25.     @SuppressWarnings("rawtypes")
  26.     public RedisSerializer fastJson2JsonRedisSerializer(){
  27.         return new FastJson2JsonRedisSerializer<Object>(Object.class);
  28.     }
  30.     @Bean(name="redisTemplate")
  31.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory){
  32.         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
  33.         redisTemplate.setConnectionFactory(factory);
  34.         FastJson2JsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJson2JsonRedisSerializer<Object>(Object.class);
  35.         // 全局开启AutoType，不建议使用
  36.         // ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
  37.         // 建议使用这种方式，小范围指定白名单
  38.         ParserConfig.getGlobalInstance().addAccept("com.teriste.");
  39.         //设置键值序列化方式
  40.         redisTemplate.setKeySerializer(new StringRedisSerializer());
  41.         redisTemplate.setValueSerializer(fastJsonRedisSerializer);
  42.         //设置hash键值序列化方式
  43.         redisTemplate.setHashKeySerializer(new StringRedisSerializer());
  44.         redisTemplate.setHashValueSerializer(fastJsonRedisSerializer);
  45.         redisTemplate.setEnableTransactionSupport(true);
  46.         redisTemplate.afterPropertiesSet();
  47.         return redisTemplate;
  48.     }
  49. }
  51. //FastJson2JsonRedisSerializer.java
  53. import java.nio.charset.Charset;
  55. import org.springframework.data.redis.serializer.RedisSerializer;
  56. import org.springframework.data.redis.serializer.SerializationException;
  58. import com.alibaba.fastjson.JSON;
  59. import com.alibaba.fastjson.serializer.SerializerFeature;
  60. /**
  61.  * 自定义序列化配置类
  62.  * @author Administrator
  63.  * @version 2018年5月24日
  64.  * @see FastJson2JsonRedisSerializer
  65.  * @since
  66.  */
  67. public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T>
  68. {
  69.     public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
  70.     private Class<T> clazz;
  72.     public FastJson2JsonRedisSerializer(Class<T> clazz) {
  73.         super();
  74.         this.clazz = clazz;
  75.     }
  77.     @Override
  78.     public byte[] serialize(T t)
  79.         throws SerializationException
  80.     {
  81.         if (null==t)
  82.         {
  83.             return new byte[0];
  84.         }
  85.         return JSON.toJSONString(t,SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
  86.     }
  88.     @Override
  89.     public T deserialize(byte[] bytes)
  90.         throws SerializationException
  91.     {
  92.         if (null==bytes||bytes.length<=0)
  93.         {
  94.             return null;
  95.         }
  96.         String str=new String(bytes,DEFAULT_CHARSET);
  97.         return (T)JSON.parseObject(str, clazz);
  98.     }
  100. }

还可以根据需要配置Redis键生成规则： 

  1. //RedisCacheConfig.java
  2. import org.springframework.cache.CacheManager;
  3. import org.springframework.cache.annotation.CachingConfigurerSupport;
  4. import org.springframework.cache.annotation.EnableCaching;
  5. import org.springframework.cache.interceptor.KeyGenerator;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8. import org.springframework.data.redis.cache.RedisCacheManager;
  9. import org.springframework.data.redis.connection.RedisConnectionFactory;
  10. import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
  11. import org.springframework.data.redis.core.RedisTemplate;
  12. import org.slf4j.Logger;
  13. import org.slf4j.LoggerFactory;
  15. import java.lang.reflect.Method;
  17. /**
  18.  * 
  19.  *  spring-context since 4.1 才有CachingConfigurerSupport类
  20.  * @author Administrator
  21.  * @version 2018年5月21日
  22.  * @see RedisCacheConfig
  23.  * @since
  24.  */
  25. @Configuration
  26. @EnableCaching
  27. public class RedisCacheConfig extends CachingConfigurerSupport {
  28.    protected final static Logger log = LoggerFactory.getLogger(RedisCacheConfig.class);
  30.    private volatile JedisConnectionFactory mJedisConnectionFactory;
  31.    private volatile RedisTemplate<String, String> mRedisTemplate;
  32.    private volatile RedisCacheManager mRedisCacheManager;
  34.    public RedisCacheConfig() {
  35.        super();
  36.    }
  38.    public RedisCacheConfig(JedisConnectionFactory mJedisConnectionFactory, RedisTemplate<String, String> mRedisTemplate, RedisCacheManager mRedisCacheManager) {
  39.        super();
  40.        this.mJedisConnectionFactory = mJedisConnectionFactory;
  41.        this.mRedisTemplate = mRedisTemplate;
  42.        this.mRedisCacheManager = mRedisCacheManager;
  43.    }
  45.    public JedisConnectionFactory redisConnectionFactory() {
  46.        return mJedisConnectionFactory;
  47.    }
  49.    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory cf) {
  50.        return mRedisTemplate;
  51.    }
  53.    public CacheManager cacheManager(RedisTemplate<?, ?> redisTemplate) {
  54.        return mRedisCacheManager;
  55.    }
  57.    /**
  58.     * 该类告诉 spring 当前使用的缓存服务为 redis 并自定义了缓存 key 生成的规则。
  59.     */
  60.    @Bean
  61.    public KeyGenerator keyGenerator() {
  62.        return new KeyGenerator() {
  63.            public Object generate(Object o, Method method, Object... objects) {
  64.                StringBuilder sb = new StringBuilder();
  65.                sb.append(o.getClass().getName());
  66.                sb.append(method.getName());
  67.                for (Object obj : objects) {
  68.                    sb.append(obj.toString());
  69.                }
  70.                return sb.toString();
  71.            }
  72.        };
  73.    }
  74. }

下面就可以使用RedisTemplate类来操作Redis数据库了。
redisTemplate有两个方法经常用到,一个是opsForXXX一个是boundXXXOps,XXX是value的类型,前者获取到一个Opercation,但是没有指定操作的key,可以在一个连接(事务)内操作多个key以及对应的value;后者会获取到一个指定了key的operation,在一个连接内只操作这个key对应的value.
使用中发现一个问题，如果方法使用了Spring的@Transactional注解，那么在该方法里使用读取redis数据的方法获取不到数据，写入redis数据库的方法可以生效。
下面开始介绍第二种使用Redis的方式：原生Jedis。
1、同样还是需要redis.properties，以及在applicationContext.xml中引入redis.properties和单独的spring集成redis的配置文件。

2、配置jedis连接池

spring-redis-context.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.       xmlns:context="http://www.springframework.org/schema/context"
  5.       xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.                        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
  7.                        http://www.springframework.org/schema/context
  8.                        http://www.springframework.org/schema/context/spring-context.xsd">
  9.    <description>Spring容器管理redis连接和使用 </description>
  10.    <!--载入 redis 配置文件-->
  11.    <!-- Spring容器仅允许最多定义一个PropertyPlaceholderConfigurer 或 <content:property-placeholder>其余的会被Spring忽略 -->
  12.    <!-- <context:property-placeholder location="classpath:redis.properties" ignore-unresolvable="true"/> -->
  14.     <!-- 高版本Jedis没有maxActive变量，具体有哪些可以看JedisPoolConfig继承的类GenericObjectPoolConfig -->
  15.    <!-- 连接池配置 -->
  16.    <!--shardedJedisPool的相关配置-->
  17.    <!-- <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
  18.         新版是maxTotal，旧版是maxActive
  19.         <property name="maxTotal">
  20.             <value>${redis.maxActive}</value>
  21.         </property>
  22.         <property name="maxIdle">
  23.             <value>${redis.maxIdle}</value>
  24.         </property>
  25.         <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
  26.         <property name="testOnReturn" value="true"/>
  27.     </bean>
  29.    <bean id="sharedJedisPool" class="redis.clients.jedis.ShardedJedisPool" scope="="singleton">
  30.            <constructor-arg index="0" ref="jedisPoolConfig"></constructor-arg>
  31.            <constructor-arg index="1">
  32.                <list>
  33.                    <bean class="redis.clients.jedis.JedisShardInfo">
  34.                        <constructor-arg name="host" value="${redis.uri}"></constructor-arg>
  35.                    </bean>
  36.                </list>
  37.            </constructor-arg>
  38.    </bean> -->
  40.    <!-- 高版本Jedis没有maxActive变量，具体有哪些可以看JedisPoolConfig继承的类GenericObjectPoolConfig -->
  41.    <!-- 连接池配置 -->
  42.    <!-- 配置 JedisPoolConfig 实例 -->
  43.    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
  44.        <property name="maxIdle" value="${redis.maxIdle}"/>
  45.        <property name="maxTotal" value="${redis.maxActive}"/>
  46.        <property name="maxWaitMillis" value="${redis.maxWait}"/>
  47.        <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
  48.    </bean>
  50.    <bean id="jedisPool" class="redis.clients.jedis.JedisPool">
  51.            <constructor-arg name="poolConfig" ref="jedisPoolConfig" />
  52.            <constructor-arg name="host" value="${redis.host}" />
  53.            <constructor-arg name="port" value="${redis.port}" type="int" />
  54.            <constructor-arg name="timeout" value="${redis.timeOut}" type="int" />
  55.            <!-- <constructor-arg name="password" value="${redis.pass}" />
  56.            <constructor-arg name="database" value="${redis.dbIndex}" type="int" /> -->
  57.    </bean>
  59.     <bean id="jedisClient" class="com.teriste.redis.util.JedisClient">
  60.         <constructor-arg name="jedisPool" ref="jedisPool"></constructor-arg>
  61.         <constructor-arg name="jedisPoolConfig" ref="jedisPoolConfig"></constructor-arg>
  62.         <constructor-arg name="host" value="${redis.host}" />
  63.            <constructor-arg name="port" value="${redis.port}" type="int" />
  64.            <constructor-arg name="timeout" value="${redis.timeOut}" type="int" />
  65.     </bean>
  67.     <bean id="redisClient" class="com.teriste.redis.util.RedisClient">
  68.         <constructor-arg name="jedisClient" ref="jedisClient"></constructor-arg>
  69.     </bean>
  70. </beans>

其中的JedisClient.java类封装了连接和释放redis连接的方法，RedisClient类封装了对redis中各种数据类型的操作。
同样涉及到Java对象存入redis的问题，键是String类型的，所以直接使用String类的getBytes(charset)和new String(bytes, charset)来序列化和反序列化。值使用fastjson2。

StringSerializer.java实现键的序列化

  1. import java.nio.charset.Charset;
  3. /**
  4.  * 读写Hash数据结构数据的序列化与发序列化工具类
  5.  * @author Administrator
  6.  * @version 2018年7月9日
  7.  * @see StringSerializer
  8.  * @since
  9.  */
  10. public class StringSerializer
  11. {
  12.     private static final Charset charset=Charset.forName("UTF-8");
  14.     /*public StringSerializer(Charset charset) {
  15.       Assert.notNull(charset, "Charset must not be null!");
  16.       this.charset = charset;
  17.     }*/
  19.     public static String deserialize(byte[] bytes) {
  20.       return bytes == null ? null : new String(bytes, charset);
  21.     }
  23.     public static byte[] serialize(String string) {
  24.       return string == null ? null : string.getBytes(charset);
  25.     }
  26.   }

FastJson2JsonSerializer.java实现值的序列化 

  1. import java.nio.charset.Charset;
  3. import org.springframework.data.redis.serializer.SerializationException;
  5. import com.alibaba.fastjson.JSON;
  6. import com.alibaba.fastjson.serializer.SerializerFeature;
  8. public class FastJson2JsonSerializer
  9. {
  10.     public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
  12.     public static byte[] serialize(Object t)
  13.         throws SerializationException
  14.     {
  15.         if (null==t)
  16.         {
  17.             return new byte[0];
  18.         }
  19.         return JSON.toJSONString(t,SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
  20.     }
  22.     @SuppressWarnings(value={"unchecked","rawtypes"})
  23.     public static Object deserialize(byte[] bytes, Class clazz)
  24.         throws SerializationException
  25.     {
  26.         if (null==bytes||bytes.length<=0)
  27.         {
  28.             return null;
  29.         }
  30.         String str=new String(bytes,DEFAULT_CHARSET);
  31.         return JSON.parseObject(str, clazz);
  32.     }
  33. }

下面是对redis连接的封装：JedisClient.java 

  1. import org.apache.log4j.Logger;
  3. import com.teriste.core.utils.SpringContextHolder;
  5. import redis.clients.jedis.Jedis;
  6. import redis.clients.jedis.JedisPool;
  7. import redis.clients.jedis.JedisPoolConfig;
  8. import redis.clients.jedis.exceptions.JedisConnectionException;
  9. import redis.clients.jedis.exceptions.JedisDataException;
  10. import redis.clients.jedis.exceptions.JedisException;
  12. public class JedisClient
  13. {
  14.     /**
  15.      * 日志 
  16.      */
  17.     private static Logger logger = Logger.getLogger(JedisClient.class);
  19.     private JedisPool jedisPool;//注入JedisPool
  21.     private JedisPoolConfig jedisPoolConfig;
  23.     private String host;
  24.     private int port;
  25.     private int timeout;
  27.     public JedisClient(JedisPool jedisPool,JedisPoolConfig jedisPoolConfig,String host, int port,int timeout){
  28.         this.jedisPool=jedisPool;
  29.         this.jedisPoolConfig=jedisPoolConfig;
  30.         this.host=host;
  31.         this.port=port;
  32.         this.timeout=timeout;
  33.     }
  34.     //获取Redis资源
  35.     public synchronized Jedis getJedis(){
  36.         try
  37.         {
  38.             if (jedisPool==null)
  39.             {
  40.                 jedisPool=(JedisPool)SpringContextHolder.getApplicationContext().getBean("jedisPool");
  41.             }
  42.             Jedis jedis=jedisPool.getResource();
  43.             return jedis;
  44.         }
  45.         catch (Exception e)
  46.         {
  47.             e.printStackTrace();
  48.             //获取Redis连接时如果发生异常就重置连接池
  49.             if (null!=jedisPool)
  50.             {
  51.                 jedisPool.destroy();
  52.                 jedisPool=new JedisPool(jedisPoolConfig,host,port,timeout);
  53.             }
  54.             System.out.println(jedisPool.isClosed()+"----------------");
  55.             if (jedisPool!=null)
  56.             {
  57.                 Jedis jedis=jedisPool.getResource();
  58.                 return jedis;
  59.             }
  60.         }
  61.         return null;
  62.     }
  65.   //释放redis资源
  66.     public synchronized void releaseConn(Jedis jedis,Exception exception){
  67.         /*if (null!=exception)
  68.         {
  69.             if (exception instanceof JedisConnectionException) {
  70.                 logger.error("Redis connection " + jedisPool.getResource().getClient().getHost() + " lost.", exception);
  71.             } else if (exception instanceof JedisDataException) {
  72.                 if ((exception.getMessage() != null) && (exception.getMessage().indexOf("READONLY") != -1)) {
  73.                     logger.error("Redis connection " + jedisPool.getResource().getClient().getHost() + " are read-only slave.", exception);
  74.                 } else {
  75.                     // dataException, isBroken=false
  76.                 }
  77.             } else {
  78.                 logger.error("Jedis exception happen.", exception);
  79.             }
  80.         }*/
  82.         try
  83.         {
  84.             if (null!=jedis)
  85.             {
  86.                 //Jedis的close()会先判断连接是否损毁如果是就走释放损毁连接的方法，否则走正常连接的方法。
  87.                 jedis.close();
  88.             }
  89.         }
  90.         catch (Exception e)
  91.         {
  92.             logger.error("return back jedis failed, will fore close the jedis.", e);
  93.             //如果close()方法执行失败就直接将jedis引用置空
  94.             jedis=null;
  95.         }
  97.         /*try
  98.         {
  99.             if (jedis!=null)
  100.             {
  101.                 jedisPool.returnResource(jedis);
  102.             }
  103.         }
  104.         catch (Exception e)
  105.         {
  106.             if (jedis!=null)
  107.             {
  108.                 try
  109.                 {
  110.                     jedisPool.returnBrokenResource(jedis);
  111.                 }
  112.                 catch (Exception e2)
  113.                 {
  114.                     jedis=null;
  115.                 }
  117.             }
  118.         }*/
  120.     }
  122.     /**
  123.      * Handle jedisException, write log and return whether the connection is broken.
  124.      */
  125.     protected boolean handleJedisException(JedisException jedisException) {
  126.         if (jedisException instanceof JedisConnectionException) {
  127.             logger.error("Redis connection " + jedisPool.getResource().getClient().getHost() + " lost.", jedisException);
  128.         } else if (jedisException instanceof JedisDataException) {
  129.             if ((jedisException.getMessage() != null) && (jedisException.getMessage().indexOf("READONLY") != -1)) {
  130.                 logger.error("Redis connection " + jedisPool.getResource().getClient().getHost() + " are read-only slave.", jedisException);
  131.             } else {
  132.                 // dataException, isBroken=false
  133.                 return false;
  134.             }
  135.         } else {
  136.             logger.error("Jedis exception happen.", jedisException);
  137.         }
  138.         return true;
  139.     }
  140.     /**
  141.      * Return jedis connection to the pool, call different return methods depends on the conectionBroken status.
  142.      */
  143.     @SuppressWarnings("deprecation")
  144.     protected void closeResource(Jedis jedis, boolean conectionBroken) {
  145.         try {
  146.             if (conectionBroken) {
  147.                 jedisPool.returnBrokenResource(jedis);
  148.             } else {
  149.                 jedisPool.returnResource(jedis);
  150.             }
  151.         } catch (Exception e) {
  152.             logger.error("return back jedis failed, will fore close the jedis.", e);
  153.             jedis=null;
  154.         }
  155.     }
  157.     public JedisPool getJedisPool()
  158.     {
  159.         return jedisPool;
  160.     }
  162.     public void setJedisPool(JedisPool jedisPool)
  163.     {
  164.         this.jedisPool = jedisPool;
  165.     }
  166.     public JedisPoolConfig getJedisPoolConfig()
  167.     {
  168.         return jedisPoolConfig;
  169.     }
  170.     public void setJedisPoolConfig(JedisPoolConfig jedisPoolConfig)
  171.     {
  172.         this.jedisPoolConfig = jedisPoolConfig;
  173.     }
  175.     public String getHost()
  176.     {
  177.         return host;
  178.     }
  179.     public void setHost(String host)
  180.     {
  181.         this.host = host;
  182.     }
  183.     public int getPort()
  184.     {
  185.         return port;
  186.     }
  187.     public void setPort(int port)
  188.     {
  189.         this.port = port;
  190.     }
  191.     public int getTimeout()
  192.     {
  193.         return timeout;
  194.     }
  195.     public void setTimeout(int timeout)
  196.     {
  197.         this.timeout = timeout;
  198.     }
  199.     public static Logger getLogger()
  200.     {
  201.         return logger;
  202.     }
  203.     public static void setLogger(Logger logger)
  204.     {
  205.         JedisClient.logger = logger;
  206.     }
  208. }

下面是对部分操作Redis数据的封装：RedisClient.java 

  1. import java.util.ArrayList;
  2. import java.util.Collection;
  3. import java.util.Collections;
  4. import java.util.Iterator;
  5. import java.util.LinkedHashMap;
  6. import java.util.LinkedHashSet;
  7. import java.util.List;
  8. import java.util.Map;
  9. import java.util.Set;
  10. import java.util.concurrent.TimeUnit;
  12. import  redis.clients.jedis.BinaryClient.LIST_POSITION;
  14. import org.springframework.data.redis.connection.jedis.JedisConverters;
  15. import org.springframework.data.redis.core.TimeoutUtils;
  16. import org.springframework.util.CollectionUtils;
  17. import org.springframework.util.Assert;
  19. import redis.clients.jedis.Jedis;
  21. public class RedisClient
  22. {
  23.     private JedisClient jedisClient;
  25.     public RedisClient(JedisClient jedisClient){
  26.         this.jedisClient=jedisClient;
  27.     }
  29.     //键序列化与反序列化:StringSerializer
  30.     //值序列化与反序列化:FastJson2JsonSerializer
  31.     /**
  32.      * 数据结构之外的处理
  33.      */
  35.     /**
  36.      * 删除Redis中指定的键
  37.      * @param key 
  38.      * @see
  39.      */
  40.     public void del(String key) {
  41.         final byte[] rawKey = rawString(key);
  42.         Jedis jedis=null;
  43.         try
  44.         {
  45.             jedis=jedisClient.getJedis();
  46.             jedis.del(new byte[][] { rawKey });
  47.         }
  48.         catch (Exception e)
  49.         {
  50.             e.printStackTrace();
  51.         }finally{
  52.             jedisClient.releaseConn(jedis,null);
  53.         }
  54.     }
  56.     /**
  57.      * 删除Redis中多个键
  58.      * @param keys 
  59.      * @see
  60.      */
  61.     public void del(Collection<String> keys) {
  62.         if (CollectionUtils.isEmpty(keys)) {
  63.             return;
  64.         }
  65.         final byte[][] rawKeys = rawKeys(keys);
  66.         Jedis jedis=null;
  67.         try
  68.         {
  69.             jedis=jedisClient.getJedis();
  70.             jedis.del(rawKeys);
  71.         }
  72.         catch (Exception e)
  73.         {
  74.             e.printStackTrace();
  75.         }finally{
  76.             jedisClient.releaseConn(jedis,null);
  77.         }
  78.     }
  80.     /**
  81.      * 判断Redis中键是否存在
  82.      * @param key
  83.      * @return 
  84.      * @see
  85.      */
  86.     public Boolean exists(String key){
  87.         final byte[] rawKey = rawString(key);
  88.         Jedis jedis=null;
  89.         Boolean exists=null;
  90.         try
  91.         {
  92.             jedis=jedisClient.getJedis();
  93.             exists=jedis.exists(rawKey);
  94.             return exists;
  95.         }
  96.         catch (Exception e)
  97.         {
  98.             e.printStackTrace();
  99.             return false;
  100.         }finally{
  101.             jedisClient.releaseConn(jedis,null);
  102.         }
  103.     }
  106.     private byte[][] rawKeys(Collection<String> keys) {
  107.         byte[][] rawKeys = new byte[keys.size()][];
  108.         int i = 0;
  109.         for (String key : keys) {
  110.             rawKeys[(i++)] = rawString(key);
  111.         }
  112.         return rawKeys;
  113.     }
  115.     /**
  116.      * ################Hash##################
  117.      */
  119.     /**
  120.      * Hash数据结构判断值的键是否存在
  121.      * @param key
  122.      * @param hashKey
  123.      * @return 
  124.      * @see
  125.      */
  126.     public Boolean hExists(String key, String hashKey) {
  127.         final byte[] rawKey = rawString(key);
  128.         final byte[] rawHashKey = rawHashKey(hashKey);
  129.         Jedis jedis=null;
  130.         Boolean exists=null;
  131.         try
  132.         {
  133.             jedis=jedisClient.getJedis();
  134.             exists=jedis.hexists(rawKey, rawHashKey);
  135.         }
  136.         catch (Exception e)
  137.         {
  138.             e.printStackTrace();
  139.         }finally{
  140.             jedisClient.releaseConn(jedis,null);
  141.         }
  142.         return exists;
  143.     }
  145.     /**
  146.      * Hash数据结构删除值键
  147.      * @param key
  148.      * @param hashKeys
  149.      * @return 
  150.      * @see
  151.      */
  152.     public Long hDel(String key,Object... hashKeys){
  153.         final byte[] rawKey = rawString(key);
  154.         final byte[][] rawHashKeys = rawHashKeys(hashKeys);
  155.         Jedis jedis=null;
  156.         Long delNum=null;
  157.         try
  158.         {
  159.             jedis=jedisClient.getJedis();
  160.             delNum=jedis.hdel(rawKey, rawHashKeys);
  161.         }
  162.         catch (Exception e)
  163.         {
  164.             e.printStackTrace();
  165.         }finally{
  166.             jedisClient.releaseConn(jedis,null);
  167.         }
  168.         return delNum;
  169.     }
  170.     /**
  171.      * Hash数据结构获取键对应的值键的集合
  172.      * @param key
  173.      * @return 
  174.      * @see
  175.      */
  176.     public Set<String> hKeys(String key){
  177.         final byte[] rawKey = rawString(key);
  178.         Jedis jedis=null;
  179.         Set<byte[]> rawValues=null;
  180.         try
  181.         {
  182.             jedis=jedisClient.getJedis();
  183.             rawValues=jedis.hkeys(rawKey);
  184.         }
  185.         catch (Exception e)
  186.         {
  187.             e.printStackTrace();
  188.         }finally{
  189.             jedisClient.releaseConn(jedis,null);
  190.         }
  191.         return deserializeHashKeys(rawValues);
  192.     }
  194.     /**
  195.      * Hash数据结构获取值键对应的值的集合
  196.      * @param key
  197.      * @param clazz
  198.      * @return 
  199.      * @see
  200.      */
  201.     public List<Object> values(String key,Class clazz){
  202.         final byte[] rawKey = rawString(key);
  203.         Jedis jedis=null;
  204.         List<byte[]> rawValues=null;
  205.         try
  206.         {
  207.             jedis=jedisClient.getJedis();
  208.             rawValues=jedis.hvals(rawKey);
  209.         }
  210.         catch (Exception e)
  211.         {
  212.             e.printStackTrace();
  213.         }finally{
  214.             jedisClient.releaseConn(jedis,null);
  215.         }
  216.         return deserializeHashValues(rawValues,clazz);
  217.     }
  219.     /**
  220.      * Hash数据结构获取键对应的值键的个数
  221.      * @param key
  222.      * @return 
  223.      * @see
  224.      */
  225.     public Long hLen(String key) {
  226.         final byte[] rawKey = rawString(key);
  227.         Jedis jedis=null;
  228.         Long len=null;
  229.         try
  230.         {
  231.             jedis=jedisClient.getJedis();
  232.             len=jedis.hlen(rawKey);
  233.         }
  234.         catch (Exception e)
  235.         {
  236.             e.printStackTrace();
  237.         }finally{
  238.             jedisClient.releaseConn(jedis,null);
  239.         }
  240.         return len;
  241.     }
  242.     /**
  243.      * 获取hash数据结果的值
  244.      * @param key
  245.      * @param hashKey
  246.      * @param clazz
  247.      * @return 
  248.      * @see
  249.      */
  250.     public Object hGet(String key,String hashKey,Class clazz){
  251.         final byte[] rawKey=rawString(key);
  252.         final byte[] rawHashKey=rawHashKey(hashKey);
  253.         byte[] rawHashValue =null;
  254.         Jedis jedis=null;
  255.         try
  256.         {
  257.             jedis=jedisClient.getJedis();
  258.             rawHashValue=jedis.hget(rawKey,rawHashKey);
  259.         }
  260.         catch (Exception e)
  261.         {
  262.             e.printStackTrace();
  263.         }
  264.         finally{
  265.             jedisClient.releaseConn(jedis,null);
  266.         }
  267.         return FastJson2JsonSerializer.deserialize(rawHashValue,clazz);
  268.     }
  270.     /**
  271.      * Hash数据结构获取多个键的值列表
  272.      * @param key
  273.      * @param fields
  274.      * @param clazz
  275.      * @return 
  276.      * @see
  277.      */
  278.     public List<Object> hMGet(String key,List<String> fields,Class clazz){
  279.         if (fields.isEmpty()) {
  280.             return Collections.emptyList();
  281.         }
  282.         final byte[] rawKey = rawString(key);
  283.         final byte[][] rawHashKeys = new byte[fields.size()][];
  284.         int counter = 0;
  285.         for (String hashKey : fields) {
  286.             rawHashKeys[(counter++)] = rawHashKey(hashKey);
  287.         }
  288.         Jedis jedis=null;
  289.         List<byte[]> rawValues=null;
  290.         try
  291.         {
  292.             jedis=jedisClient.getJedis();
  293.             rawValues=jedis.hmget(rawKey, rawHashKeys);
  294.         }
  295.         catch (Exception e)
  296.         {
  297.             e.printStackTrace();
  298.         }finally{
  299.             jedisClient.releaseConn(jedis,null);
  300.         }
  301.         return deserializeHashValues(rawValues,clazz);
  302.     }
  304.     /**
  305.      * 根据键获取hash数据结构所有数据
  306.      * @param key
  307.      * @param hashKey
  308.      * @param clazz:值的类型
  309.      * @return 
  310.      * @see
  311.      */
  312.     public Map<Object, Object> hGetAll(String key,Class clazz){
  313.         final byte[] rawKey=rawString(key);
  314.         Map<byte[], byte[]> rawHashValue =null;
  315.         Jedis jedis=null;
  316.         try
  317.         {
  318.             jedis=jedisClient.getJedis();
  319.             rawHashValue=jedis.hgetAll(rawKey);
  320.         }
  321.         catch (Exception e)
  322.         {
  323.             e.printStackTrace();
  324.         }finally{
  325.             jedisClient.releaseConn(jedis,null);
  326.         }
  327.         return deserializeHashMap(rawHashValue,clazz);
  328.     }
  330.     /**
  331.      * 保存或更新hash数据
  332.      * @param key
  333.      * @param hashKey
  334.      * @param value
  335.      * @return 
  336.      * @see
  337.      */
  338.     public Boolean hSet(String key,String hashKey,Object value){
  339.         final byte[] rawKey = rawString(key);
  340.         final byte[] rawHashKey = rawHashKey(hashKey);
  341.         final byte[] rawHashValue = rawValue(value);
  342.         Jedis jedis=jedisClient.getJedis();
  343.         try
  344.         {
  345.             Boolean result=JedisConverters.toBoolean(jedis.hset(rawKey, rawHashKey, rawHashValue));
  346.             jedisClient.releaseConn(jedis,null);
  347.             return result;
  348.         }
  349.         catch (Exception e)
  350.         {
  351.             jedisClient.releaseConn(jedis,e);
  352.             return false;
  353.         }
  355.     }
  357.     /**
  358.      * hash数据结构保存多个键值对
  359.      * @param key
  360.      * @param m
  361.      * @return 
  362.      * @see
  363.      */
  364.     public Boolean hMSet(String key,Map<String, Object> m){
  365.         if (m.isEmpty()) {
  366.             return false;
  367.         }
  368.         final byte[] rawKey = rawString(key);
  369.         final Map<byte[], byte[]> hashes = new LinkedHashMap<byte[], byte[]>(m.size());
  370.         for (Map.Entry<String, Object> entry : m.entrySet()) {
  371.             hashes.put(rawHashKey(entry.getKey()), rawValue(entry.getValue()));
  372.         }
  373.         Jedis jedis=null;
  374.         try
  375.         {
  376.             jedis=jedisClient.getJedis();
  377.             jedis.hmset(rawKey, hashes);
  378.         }
  379.         catch (Exception e)
  380.         {
  381.             e.printStackTrace();
  382.         }finally{
  383.             jedisClient.releaseConn(jedis,null);
  384.         }
  385.         return true;
  386.     }
  389.     //key序列化
  390.     public byte[] rawString(String key){
  391.         return StringSerializer.serialize(key);
  392.     }
  394.     //hashkey序列化
  395.     public byte[] rawHashKey(Object hashKey){
  396.         return StringSerializer.serialize(hashKey.toString());
  397.     }
  399.     //多个值键序列化
  400.     public byte[][] rawHashKeys(Object... hashKeys) {
  401.         byte[][] rawHashKeys = new byte[hashKeys.length][];
  402.         int i = 0;
  403.         for (Object hashKey : hashKeys) {
  404.             rawHashKeys[(i++)] = rawHashKey(hashKey);
  405.         }
  406.         return rawHashKeys;
  407.     }
  409.     //值序列化
  410.     public byte[] rawValue(Object value){
  411.         return FastJson2JsonSerializer.serialize(value);
  412.     }
  414.     //hash键反序列化
  415.     public Set<String> deserializeHashKeys(Set<byte[]> rawKeys){
  416.         if (rawKeys == null) {
  417.             return null;
  418.         }
  419.         Set<String> values =new LinkedHashSet<String>(rawKeys.size());
  420.         for (byte[] bs : rawKeys) {
  421.             values.add(StringSerializer.deserialize(bs));
  422.         }
  423.         return values;
  424.     }
  426.     //hash结构值是String类型的反序列化
  427.     public List<Object> deserializeHashValues(List<byte[]> rawValues,Class clazz){
  428.         if (rawValues == null) {
  429.             return null;
  430.         }
  431.         List<Object> values =new ArrayList<Object>();
  432.         for (byte[] bs : rawValues) {
  433.             values.add(FastJson2JsonSerializer.deserialize(bs,clazz));
  434.         }
  435.         return values;
  436.     }
  438.     /**
  439.      * ################List##################
  440.      */
  442.     /**
  443.      * List数据结构获取指定索引位置的值
  444.      * @param key
  445.      * @param index
  446.      * @param clazz
  447.      * @return 
  448.      * @see
  449.      */
  450.     public Object lIndex(String key, final long index,Class clazz) {
  451.         final byte[] rawKey = rawString(key);
  452.         Jedis jedis=null;
  453.         byte[] value=null;
  454.         try
  455.         {
  456.             jedis=jedisClient.getJedis();
  457.             value=jedis.lindex(rawKey, index);
  458.             return deserializeValue(value,clazz);
  459.         }
  460.         catch (Exception e)
  461.         {
  462.             e.printStackTrace();
  463.             return null;
  464.         }finally{
  465.             jedisClient.releaseConn(jedis,null);
  466.         }
  467.     }
  469.     /**
  470.      * List数据结构获取键对应的值集合大小
  471.      * @param key
  472.      * @return 
  473.      * @see
  474.      */
  475.     public Long lLen(String key)
  476.     {
  477.       final byte[] rawKey = rawString(key);
  478.       Jedis jedis=null;
  479.       Long len=null;
  480.       try
  481.       {
  482.           jedis=jedisClient.getJedis();
  483.           len=jedis.llen(rawKey);
  484.       }
  485.       catch (Exception e)
  486.       {
  487.           e.printStackTrace();
  488.       }finally{
  489.           jedisClient.releaseConn(jedis,null);
  490.       }
  491.       return len;
  492.     }
  494.     /**
  495.      * List数据结构获取指定范围的值集合
  496.      * @param key
  497.      * @param start
  498.      * @param end
  499.      * @param clazz
  500.      * @return 
  501.      * @see
  502.      */
  503.     public List<Object> lRange(String key, final long start, long end,Class clazz)
  504.     {
  505.       final byte[] rawKey = rawString(key);
  506.       Jedis jedis=null;
  507.       List<byte[]> rawValues=null;
  508.       try
  509.       {
  510.             jedis=jedisClient.getJedis();
  511.             rawValues=jedis.lrange(rawKey, start, end);
  512.             return deserializeValues(rawValues,clazz);
  513.       }
  514.       catch (Exception e)
  515.       {
  516.           e.printStackTrace();
  517.           return null;
  518.       }finally{
  519.           jedisClient.releaseConn(jedis,null);
  520.       }
  521.     }
  523.     /**
  524.      * List数据结构移除指定值
  525.      * @param key
  526.      * @param count
  527.      * @param value
  528.      * @return 
  529.      * @see
  530.      */
  531.     public Long lRem(String key, final long count, Object value)
  532.     {
  533.       final byte[] rawKey = rawString(key);
  534.       byte[] rawValue = rawValue(value);
  535.       Jedis jedis=null;
  536.       Long remNum=null;
  537.       try
  538.       {
  539.             jedis=jedisClient.getJedis();
  540.             remNum=jedis.lrem(rawKey, count, rawValue);
  541.       }
  542.       catch (Exception e)
  543.       {
  544.           e.printStackTrace();
  545.       }finally{
  546.           jedisClient.releaseConn(jedis,null);
  547.       }
  548.       return remNum;
  549.     }
  552.     /**
  553.      * List数据结构从左侧弹出值对象
  554.      * @param key
  555.      * @param clazz
  556.      * @return 
  557.      * @see
  558.      */
  559.     public Object lLPop(String key,Class clazz){
  560.         final byte[] rawKey = rawString(key);
  561.         Jedis jedis=null;
  562.         byte[] value=null;
  563.         try
  564.         {
  565.             jedis=jedisClient.getJedis();
  566.             value=jedis.lpop(rawKey);
  567.             return deserializeValue(value,clazz);
  568.         }
  569.         catch (Exception e)
  570.         {
  571.             e.printStackTrace();
  572.             return null;
  573.         }finally{
  574.             jedisClient.releaseConn(jedis,null);
  575.         }
  576.     }
  578.     /**
  579.      * List数据结构从左侧弹出值的字节数组
  580.      * @param key
  581.      * @param timeout
  582.      * @param unit
  583.      * @return 
  584.      * @see
  585.      */
  586.     public byte[] lLPop(String key, long timeout, TimeUnit unit) 
  587.     { 
  588.         final int tm = (int)TimeoutUtils.toSeconds(timeout, unit);
  589.         final byte[] rawKey = rawString(key);
  590.         Jedis jedis=null;
  591.         try
  592.         {
  593.             jedis=jedisClient.getJedis();
  594.             List<byte[]> bLPop=jedis.blpop(tm, new byte[][] { rawKey });
  595.             return CollectionUtils.isEmpty(bLPop) ? null : (byte[])bLPop.get(1);
  596.         }
  597.         catch (Exception e)
  598.         {
  599.             e.printStackTrace();
  600.             return null;
  601.         }finally{
  602.             jedisClient.releaseConn(jedis,null);
  603.         }
  604.     }
  606.     /**
  607.      * List数据结构从左侧插入数据
  608.      * @param key
  609.      * @param value
  610.      * @return 
  611.      * @see
  612.      */
  613.     public Long lLeftPush(String key, Object value)
  614.     {
  615.       final byte[] rawKey = rawString(key);
  616.       final byte[] rawValue = rawValue(value);
  617.       Jedis jedis=null;
  618.       Long pushNum=null;
  619.       try
  620.       {
  621.             jedis=jedisClient.getJedis();
  622.             pushNum=jedis.lpush(rawKey, new byte[][] { rawValue });
  623.       }
  624.       catch (Exception e)
  625.       {
  626.           e.printStackTrace();
  627.       }finally{
  628.           jedisClient.releaseConn(jedis,null);
  629.       }
  630.       return pushNum;
  631.     }
  633.     /**
  634.      * List数据结构左侧插入值数组
  635.      * @param key
  636.      * @param values
  637.      * @return 
  638.      * @see
  639.      */
  640.     public Long lLeftPushAll(String key, Object[] values)
  641.     {
  642.       final byte[] rawKey = rawString(key);
  643.       final byte[][] rawValues = rawValues(values);
  644.       Jedis jedis=null;
  645.       Long pushNum=null;
  646.       try
  647.       {
  648.             jedis=jedisClient.getJedis();
  649.             pushNum=jedis.lpush(rawKey, rawValues);
  650.       }
  651.       catch (Exception e)
  652.       {
  653.           e.printStackTrace();
  654.       }finally{
  655.           jedisClient.releaseConn(jedis,null);
  656.       }
  657.       return pushNum;
  658.     }
  660.     /**
  661.      * List数据结构左侧插入值集合
  662.      * @param key
  663.      * @param values
  664.      * @return 
  665.      * @see
  666.      */
  667.     public Long lLeftPushAll(String key, Collection<Object> values)
  668.     {
  669.       final byte[] rawKey = rawString(key);
  670.       final byte[][] rawValues = rawValues(values);
  671.       Jedis jedis=null;
  672.       Long pushNum=null;
  673.       try
  674.       {
  675.             jedis=jedisClient.getJedis();
  676.             pushNum=jedis.lpush(rawKey, rawValues);
  677.       }
  678.       catch (Exception e)
  679.       {
  680.           e.printStackTrace();
  681.       }finally{
  682.           jedisClient.releaseConn(jedis,null);
  683.       }
  684.       return pushNum;
  685.     }
  687.     /**
  688.      * List数据结构如果值存在从左侧插入
  689.      * @param key
  690.      * @param value
  691.      * @return 
  692.      * @see
  693.      */
  694.     public Long lLeftPushIfPresent(String key, Object value)
  695.     {
  696.       final byte[] rawKey = rawString(key);
  697.       final byte[] rawValue = rawValue(value);
  698.       Jedis jedis=null;
  699.       Long pushNum=null;
  700.       try
  701.       {
  702.             jedis=jedisClient.getJedis();
  703.             pushNum=jedis.lpushx(rawKey, rawValue);
  704.       }
  705.       catch (Exception e)
  706.       {
  707.           e.printStackTrace();
  708.       }finally{
  709.           jedisClient.releaseConn(jedis,null);
  710.       }
  711.       return pushNum;
  712.     }
  714.     /**
  715.      * List数据结构按优先级从左侧插入
  716.      * @param key
  717.      * @param pivot
  718.      * @param value
  719.      * @return 
  720.      * @see
  721.      */
  722.     public Long lLeftPush(String key, Object pivot, Object value)
  723.     {
  724.       final byte[] rawKey = rawString(key);
  725.       final byte[] rawPivot = rawValue(pivot);
  726.       final byte[] rawValue = rawValue(value);
  727.       Jedis jedis=null;
  728.       Long pushNum=null;
  729.       try
  730.       {
  731.             jedis=jedisClient.getJedis();
  732.             pushNum=jedis.linsert(rawKey, LIST_POSITION.BEFORE, rawPivot, rawValue);
  733.       }
  734.       catch (Exception e)
  735.       {
  736.           e.printStackTrace();
  737.       }finally{
  738.           jedisClient.releaseConn(jedis,null);
  739.       }
  740.       return pushNum;
  741.     }
  743.     /**
  744.      * List数据结构从右侧弹出值对象
  745.      * @param key
  746.      * @param clazz
  747.      * @return 
  748.      * @see
  749.      */
  750.     public Object lRPop(String key,Class clazz){
  751.         final byte[] rawKey = rawString(key);
  752.         Jedis jedis=null;
  753.         byte[] value=null;
  754.         try
  755.         {
  756.             jedis=jedisClient.getJedis();
  757.             value=jedis.rpop(rawKey);
  758.             return deserializeValue(value,clazz);
  759.         }
  760.         catch (Exception e)
  761.         {
  762.             e.printStackTrace();
  763.             return null;
  764.         }finally{
  765.             jedisClient.releaseConn(jedis,null);
  766.         }
  767.     }
  769.     /**
  770.      * List数据结构从右侧弹出值的字节数组
  771.      * @param key
  772.      * @param timeout
  773.      * @param unit
  774.      * @return 
  775.      * @see
  776.      */
  777.     public byte[] lRPop(String key, long timeout, TimeUnit unit) 
  778.     { 
  779.         final int tm = (int)TimeoutUtils.toSeconds(timeout, unit);
  780.         final byte[] rawKey = rawString(key);
  781.         Jedis jedis=null;
  782.         try
  783.         {
  784.             jedis=jedisClient.getJedis();
  785.             List<byte[]> bRPop=jedis.brpop(tm, new byte[][] { rawKey });
  786.             return CollectionUtils.isEmpty(bRPop) ? null : (byte[])bRPop.get(1);
  787.         }
  788.         catch (Exception e)
  789.         {
  790.             e.printStackTrace();
  791.             return null;
  792.         }finally{
  793.             jedisClient.releaseConn(jedis,null);
  794.         }
  795.     }
  797.     /**
  798.      * List数据结构右侧插入值
  799.      * @param key
  800.      * @param values
  801.      * @return 
  802.      * @see
  803.      */
  804.     public Long lRightPush(String key, Object value)
  805.     {
  806.         final byte[] rawKey = rawString(key);
  807.         final byte[] rawValue = rawValue(value);
  808.         Jedis jedis=null;
  809.         Long pushNum=null;
  810.         try
  811.         {
  812.               jedis=jedisClient.getJedis();
  813.               pushNum=jedis.rpush(rawKey, new byte[][] { rawValue });
  814.         }
  815.         catch (Exception e)
  816.         {
  817.             e.printStackTrace();
  818.         }finally{
  819.             jedisClient.releaseConn(jedis,null);
  820.         }
  821.         return pushNum;
  822.     }
  824.     /**
  825.      * List数据结构右侧插入值数组
  826.      * @param key
  827.      * @param values
  828.      * @return 
  829.      * @see
  830.      */
  831.     public Long lRightPushAll(String key, Object[] values)
  832.     {
  833.         final byte[] rawKey = rawString(key);
  834.         final byte[][] rawValues = rawValues(values);
  835.         Jedis jedis=null;
  836.         Long pushNum=null;
  837.         try
  838.         {
  839.               jedis=jedisClient.getJedis();
  840.               pushNum=jedis.rpush(rawKey, rawValues);
  841.         }
  842.         catch (Exception e)
  843.         {
  844.             e.printStackTrace();
  845.         }finally{
  846.             jedisClient.releaseConn(jedis,null);
  847.         }
  848.         return pushNum;
  849.     }
  851.     /**
  852.      * List数据结构右侧插入值集合
  853.      * @param key
  854.      * @param values
  855.      * @return 
  856.      * @see
  857.      */
  858.     public Long lRightPushAll(String key, Collection<Object> values)
  859.     {
  860.         final byte[] rawKey = rawString(key);
  861.         final byte[][] rawValues = rawValues(values);
  862.         Jedis jedis=null;
  863.         Long pushNum=null;
  864.         try
  865.         {
  866.               jedis=jedisClient.getJedis();
  867.               pushNum=jedis.rpush(rawKey, rawValues);
  868.         }
  869.         catch (Exception e)
  870.         {
  871.             e.printStackTrace();
  872.         }finally{
  873.             jedisClient.releaseConn(jedis,null);
  874.         }
  875.         return pushNum;
  876.     }
  879.     /**
  880.      * List数据结构如果值存在从右侧插入
  881.      * @param key
  882.      * @param value
  883.      * @return 
  884.      * @see
  885.      */
  886.     public Long lRightPushIfPresent(String key, Object value)
  887.     {
  888.       final byte[] rawKey = rawString(key);
  889.       final byte[] rawValue = rawValue(value);
  890.       Jedis jedis=null;
  891.       Long pushNum=null;
  892.       try
  893.       {
  894.             jedis=jedisClient.getJedis();
  895.             pushNum=jedis.rpushx(rawKey, rawValue);
  896.       }
  897.       catch (Exception e)
  898.       {
  899.           e.printStackTrace();
  900.       }finally{
  901.           jedisClient.releaseConn(jedis,null);
  902.       }
  903.       return pushNum;
  904.     }
  906.     /**
  907.      * List数据结构按优先级从右侧插入
  908.      * @param key
  909.      * @param pivot
  910.      * @param value
  911.      * @return 
  912.      * @see
  913.      */
  914.     public Long lRightPush(String key, Object pivot, Object value)
  915.     {
  916.       final byte[] rawKey = rawString(key);
  917.       final byte[] rawPivot = rawValue(pivot);
  918.       final byte[] rawValue = rawValue(value);
  919.       Jedis jedis=null;
  920.       Long pushNum=null;
  921.       try
  922.       {
  923.             jedis=jedisClient.getJedis();
  924.             pushNum=jedis.linsert(rawKey, LIST_POSITION.AFTER, rawPivot, rawValue);
  925.       }
  926.       catch (Exception e)
  927.       {
  928.           e.printStackTrace();
  929.       }finally{
  930.           jedisClient.releaseConn(jedis,null);
  931.       }
  932.       return pushNum;
  933.     }
  935.     /**
  936.      * List数据结构从一个列表的右侧弹出值从另一个列表的左侧插入
  937.      * @param sourceKey
  938.      * @param destinationKey
  939.      * @return 
  940.      * @see
  941.      */
  942.     public byte[] rightPopAndLeftPush(String sourceKey, String destinationKey){
  943.         final byte[] rawSourceKey = rawString(sourceKey);
  944.         final byte[] rawDestKey = rawString(destinationKey);
  945.         Jedis jedis=null;
  946.         try
  947.         {
  948.             jedis=jedisClient.getJedis();
  949.             return jedis.rpoplpush(rawSourceKey, rawDestKey);
  950.         }
  951.         catch (Exception e)
  952.         {
  953.             e.printStackTrace();
  954.             return null;
  955.         }finally{
  956.             jedisClient.releaseConn(jedis,null);
  957.         }
  958.     }
  960.     /**
  961.      * List数据结构从一个列表的右侧弹出值从另一个列表的左侧插入
  962.      * @param sourceKey
  963.      * @param destinationKey
  964.      * @param timeout
  965.      * @param unit
  966.      * @return 
  967.      * @see
  968.      */
  969.     public byte[] rightPopAndLeftPush(String sourceKey, String destinationKey, long timeout, TimeUnit unit){
  970.         final int tm = (int)TimeoutUtils.toSeconds(timeout, unit);
  971.         final byte[] rawSourceKey = rawString(sourceKey);
  972.         final byte[] rawDestKey = rawString(destinationKey);
  973.         Jedis jedis=null;
  974.         try
  975.         {
  976.             jedis=jedisClient.getJedis();
  977.             return jedis.brpoplpush(rawSourceKey, rawDestKey,tm);
  978.         }
  979.         catch (Exception e)
  980.         {
  981.             e.printStackTrace();
  982.             return null;
  983.         }finally{
  984.             jedisClient.releaseConn(jedis,null);
  985.         }
  986.     }
  988.     /**
  989.      * List数据结构替换掉在键的指定索引处的值
  990.      * @param key
  991.      * @param index
  992.      * @param value 
  993.      * @see
  994.      */
  995.     public void set(String key, final long index, Object value){
  996.         final byte[] rawKey = rawString(key);
  997.         final byte[] rawValue = rawValue(value);
  998.         Jedis jedis=null;
  999.         try
  1000.         {
  1001.             jedis=jedisClient.getJedis();
  1002.             jedis.lset(rawKey, index, rawValue);
  1003.         }
  1004.         catch (Exception e)
  1005.         {
  1006.             e.printStackTrace();
  1007.         }finally{
  1008.             jedisClient.releaseConn(jedis,null);
  1009.         }
  1010.     }
  1012.     /**
  1013.      * List数据结构按索引位置截取指定键的列表
  1014.      * @param key
  1015.      * @param start
  1016.      * @param end 
  1017.      * @see
  1018.      */
  1019.     public void trim(String key, final long start, long end){
  1020.         final byte[] rawKey = rawString(key);
  1021.         Jedis jedis=null;
  1022.         try
  1023.         {
  1024.             jedis=jedisClient.getJedis();
  1025.             jedis.ltrim(rawKey, start, end);
  1026.         }
  1027.         catch (Exception e)
  1028.         {
  1029.             e.printStackTrace();
  1030.         }finally{
  1031.             jedisClient.releaseConn(jedis,null);
  1032.         }
  1033.     }
  1036.     /**
  1037.      * List数据结构序列化值
  1038.      * @param values
  1039.      * @return 
  1040.      * @see
  1041.      */
  1042.     public byte[][] rawValues(Collection<Object> values)
  1043.     {
  1044.       Assert.notEmpty(values, "Values must not be 'null' or empty.");
  1045.       Assert.noNullElements(values.toArray(), "Values must not contain 'null' value.");
  1046.       byte[][] rawValues = new byte[values.size()][];
  1047.       int i = 0;
  1048.       for (Iterator<Object> localIterator = values.iterator(); localIterator.hasNext(); ) {
  1049.           Object value = localIterator.next();
  1050.           rawValues[(i++)] = rawValue(value);
  1051.       }
  1052.       return rawValues;
  1053.     }
  1055.     /**
  1056.      * List数据结构值反序列化
  1057.      * @param value
  1058.      * @param clazz
  1059.      * @return 
  1060.      * @see
  1061.      */
  1062.     public Object deserializeValue(byte[] value,Class clazz)
  1063.     {
  1064.       if (value == null) {
  1065.         return null;
  1066.       }
  1067.       return FastJson2JsonSerializer.deserialize(value,clazz);
  1068.     }
  1070.     /**
  1071.      * List数据结构值集合反序列化
  1072.      * @param rawValues
  1073.      * @param clazz
  1074.      * @return 
  1075.      * @see
  1076.      */
  1077.     public List<Object> deserializeValues(List<byte[]> rawValues,Class clazz){
  1078.         if (rawValues == null) {
  1079.             return null;
  1080.         }
  1081.         List<Object> values =new ArrayList<Object>();
  1082.         for (byte[] bs : rawValues) {
  1083.             values.add(FastJson2JsonSerializer.deserialize(bs,clazz));
  1084.         }
  1085.         return values;
  1086.     }
  1087.     /**
  1088.      * ################Set##################
  1089.      */
  1090.     /**
  1091.      * Set数据结构中是否存在某个值
  1092.      * @param key
  1093.      * @param o
  1094.      * @return 
  1095.      * @see
  1096.      */
  1097.     public Boolean sIsMember(String key, Object o)
  1098.     {
  1099.       final byte[] rawKey = rawString(key);
  1100.       final byte[] rawValue = rawValue(o);
  1101.       Jedis jedis=null;
  1102.       Boolean isMember=null;
  1103.       try
  1104.       {
  1105.           jedis=jedisClient.getJedis();
  1106.           isMember=jedis.sismember(rawKey, rawValue);
  1107.           return isMember;
  1108.       }
  1109.       catch (Exception e)
  1110.       {
  1111.           e.printStackTrace();
  1112.           return false;
  1113.       }finally{
  1114.           jedisClient.releaseConn(jedis,null);
  1115.       }
  1116.     }
  1118.     /**
  1119.      * Set数据结构中值的集合
  1120.      * @param key
  1121.      * @param clazz
  1122.      * @return 
  1123.      * @see
  1124.      */
  1125.     public Set<Object> sMembers(String key,Class clazz)
  1126.     {
  1127.       final byte[] rawKey = rawString(key);
  1128.       Jedis jedis=null;
  1129.       Set<byte[]> rawValues=null;
  1130.       try
  1131.       {
  1132.           jedis=jedisClient.getJedis();
  1133.           rawValues=jedis.smembers(rawKey);
  1134.       }
  1135.       catch (Exception e)
  1136.       {
  1137.           e.printStackTrace();
  1138.       }finally{
  1139.           jedisClient.releaseConn(jedis,null);
  1140.       }
  1141.       return deserializeValues(rawValues,clazz);
  1142.     }
  1144.     /**
  1145.      * Set数据结构移除指定值
  1146.      * @param key
  1147.      * @param values
  1148.      * @return 
  1149.      * @see
  1150.      */
  1151.     public Long sRem(String key, Object[] values) {
  1152.         final byte[] rawKey = rawString(key);
  1153.         final byte[][] rawValues = rawValues(values);
  1154.         Jedis jedis=null;
  1155.         Long remNum=null;
  1156.         try
  1157.         {
  1158.             jedis=jedisClient.getJedis();
  1159.             remNum=jedis.srem(rawKey, rawValues);
  1160.         }
  1161.         catch (Exception e)
  1162.         {
  1163.             e.printStackTrace();
  1164.         }finally{
  1165.             jedisClient.releaseConn(jedis,null);
  1166.         }
  1167.         return remNum;
  1168.     }
  1170.     /**
  1171.      * Set数据结构获取键包含的值集合大小
  1172.      * @param key
  1173.      * @return 
  1174.      * @see
  1175.      */
  1176.     public Long sCard(String key) { 
  1177.         final byte[] rawKey = rawString(key);
  1178.         Jedis jedis=null;
  1179.         Long size=null;
  1180.         try
  1181.         {
  1182.             jedis=jedisClient.getJedis();
  1183.             size=jedis.scard(rawKey);
  1184.         }
  1185.         catch (Exception e)
  1186.         {
  1187.             e.printStackTrace();
  1188.         }finally{
  1189.             jedisClient.releaseConn(jedis,null);
  1190.         }
  1191.         return size;
  1192.     }
  1194.     /**
  1195.      * Set数据结构反序列化值集合
  1196.      * @param rawValues
  1197.      * @param clazz
  1198.      * @return 
  1199.      * @see
  1200.      */
  1201.     public Set<Object> deserializeValues(Set<byte[]> rawValues,Class clazz){
  1202.         if (rawValues == null) {
  1203.             return null;
  1204.         }
  1205.         Set<Object> values =new LinkedHashSet<Object>(rawValues.size());
  1206.         for (byte[] bs : rawValues) {
  1207.             values.add(FastJson2JsonSerializer.deserialize(bs,clazz));
  1208.         }
  1209.         return values;
  1210.     }
  1212.     //Set值序列化
  1213.     public byte[][] rawValues(Object[] values){
  1214.         if (null==values)
  1215.         {
  1216.             return null;
  1217.         }
  1218.         byte[][] rawValues = new byte[values.length][];
  1219.         int i = 0;
  1220.         for (Object value : values) {
  1221.             rawValues[(i++)] = rawValue(value);
  1222.         }
  1223.         return rawValues;
  1224.     }
  1226.     //序列化Map数据结构
  1227.     public Map<Object, Object> deserializeHashMap(Map<byte[], byte[]> entries,Class clazz){
  1228.         if (entries == null) {
  1229.             return null;
  1230.         }
  1231.         Map<Object, Object> map = new LinkedHashMap<Object, Object>(entries.size());
  1232.         for (Map.Entry<byte[], byte[]> entry : entries.entrySet()) {
  1233.             map.put(StringSerializer.deserialize((byte[])entry.getKey()), FastJson2JsonSerializer.deserialize((byte[])entry.getValue(), clazz));
  1234.         }
  1235.         return map;
  1236.     }
  1238.     public JedisClient getJedisClient()
  1239.     {
  1240.         return jedisClient;
  1241.     }
  1242.     public void setJedisClient(JedisClient jedisClient)
  1243.     {
  1244.         this.jedisClient = jedisClient;
  1245.     }
  1246. }

发表评论

表情：
评论列表 （有 0 条评论，312人围观）

还没有评论，来说两句吧...

相关阅读

    相关 spring集成redis

        sprig集成redis，我的项目架构是springMVC+spring+ibatis 用maven管理 ，下面看代码 1. 在pom文件引入redis依赖包

    亦凉亦凉/ 0 赞/ 259 阅读

    相关 Spring集成Redis

    最近在做一个关于群聊的项目，由于聊天要求实时性，不可能直接访问数据库，所以使用了Redis来做缓存，这里将使用过程中遇到的问题记录一下。 使用Redis之前需要合理设计存储

    阳光穿透心脏的1/2处阳光穿透心脏的1/2处/ 0 赞/ 313 阅读