Redis入门很简单之五【Jedis和Spring的整合】

时间:2022-06-09 17:29:20
在上一篇文章中,简单介绍了Jedis的连接池使用方式。

如果和Spring进行整合的话,我们将获得更好的简洁性、灵活性,显然是一种更加优雅(graceful)的方式。

 

[一]. 搭建环境:
 1. 在之前版本的基础之上,添加如下的依赖:
   spring.jar
   commons-logging.jar
   log4j-1.2.15.jar
   同时添加日志配置文件:log4j.properties到classpath下面。
 2. 配置Spring文件:applicationContext.xml
  注意:连接池jedisPool的配置,这里使用了构造方式注入,这是和Jedis的API一致的;
   在注入port时,需要使用使用type = "int"指定注入的参数类型,否则出现异常。

Xml代码   Redis入门很简单之五【Jedis和Spring的整合】
  1. <beans xmlns="http://www.springframework.org/schema/beans"  
  2.       xmlns:context="http://www.springframework.org/schema/context"  
  3.       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
  5.              http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">  
  6.     
  7.       <!-- 加载redis配置文件 -->  
  8.       <context:property-placeholder location="classpath:redis.properties"/>  
  9.         
  10.       <!-- redis连接池的配置 -->  
  11.       <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">  
  12.           <property name="maxActive" value="${redis.pool.maxActive}"/>  
  13.           <property name="maxIdle" value="${redis.pool.maxIdle}"/>  
  14.           <property name="minIdle" value="${redis.pool.minIdle}"/>  
  15.           <property name="maxWait" value="${redis.pool.maxWait}"/>  
  16.           <property name="testOnBorrow" value="${redis.pool.testOnBorrow}"/>  
  17.           <property name="testOnReturn" value="${redis.pool.testOnReturn}"/>  
  18.       </bean>  
  19.         
  20.       <!-- redis的连接池pool,不是必选项:timeout/password  -->  
  21.       <bean id = "jedisPool" class="redis.clients.jedis.JedisPool">  
  22.           <constructor-arg index="0" ref="jedisPoolConfig"/>  
  23.           <constructor-arg index="1" value="${redis.host}"/>  
  24.           <constructor-arg index="2" value="${redis.port}" type="int"/>  
  25.           <constructor-arg index="3" value="${redis.timeout}" type="int"/>  
  26.           <constructor-arg index="4" value="${redis.password}"/>  
  27.       </bean>  
  28.         
  29.   </beans>  

 

[二]. 从SPring容器中获取JedisPool:

Java代码   Redis入门很简单之五【Jedis和Spring的整合】
  1. ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");  
  2. JedisPool pool = (JedisPool) context.getBean("jedisPool");  
  3. Jedis jedis = pool.getResource();  
  4.  ...  
  5. pool.returnResource(jedis);  

 

[三]. 缓存JavaBean:
 上一篇文章中,已经有了对Jedis使用的基本说明。 

  当然很多时候我们都希望Redis能够对JavaBean进行缓存,这需要借助于JDK提供的序列化技术。
   1. 要求缓存实体实现了序列化Serializable接口:这里以Userinfo为例。
   2. 序列化工具类:Jedis对序列化的支持,是提供了字节数组byte[]作为参数;
  为此编写SerializingUtil工具类负责byte[]和JavaBean之间的相互转换。该方法的API如下所示:

Java代码   Redis入门很简单之五【Jedis和Spring的整合】
  1. public static byte[] serialize(Object source);   
  2. public static Object deserialize(byte[] source);  

   该工具类的具体实现:

Java代码   Redis入门很简单之五【Jedis和Spring的整合】
  1. /** 
  2.  * 功能简述: 序列化工具类,负责byte[]和Object之间的相互转换. 
  3.  * @author Nick Xu 
  4.  * @version 1.0 
  5.  */  
  6. public class SerializingUtil {  
  7.       
  8.     private static Log logger = LogFactory.getLog(SerializingUtil.class);  
  9.       
  10.     /** 
  11.      * 功能简述: 对实体Bean进行序列化操作. 
  12.      * @param source 待转换的实体 
  13.      * @return 转换之后的字节数组 
  14.      * @throws Exception 
  15.      */  
  16.     public static byte[] serialize(Object source) {  
  17.         ByteArrayOutputStream byteOut = null;  
  18.         ObjectOutputStream ObjOut = null;  
  19.         try {  
  20.             byteOut = new ByteArrayOutputStream();  
  21.             ObjOut = new ObjectOutputStream(byteOut);  
  22.             ObjOut.writeObject(source);  
  23.             ObjOut.flush();  
  24.         }  
  25.         catch (IOException e) {  
  26.             logger.error(source.getClass().getName()  
  27.                 + " serialized error !", e);  
  28.         }  
  29.         finally {  
  30.             try {  
  31.                 if (null != ObjOut) {  
  32.                     ObjOut.close();  
  33.                 }  
  34.             }  
  35.             catch (IOException e) {  
  36.                 ObjOut = null;  
  37.             }  
  38.         }  
  39.         return byteOut.toByteArray();  
  40.     }  
  41.       
  42.     /** 
  43.      * 功能简述: 将字节数组反序列化为实体Bean. 
  44.      * @param source 需要进行反序列化的字节数组 
  45.      * @return 反序列化后的实体Bean 
  46.      * @throws Exception 
  47.      */  
  48.     public static Object deserialize(byte[] source) {  
  49.         ObjectInputStream ObjIn = null;  
  50.         Object retVal = null;  
  51.         try {  
  52.             ByteArrayInputStream byteIn = new ByteArrayInputStream(source);  
  53.             ObjIn = new ObjectInputStream(byteIn);  
  54.             retVal = ObjIn.readObject();  
  55.         }  
  56.         catch (Exception e) {  
  57.             logger.error("deserialized error  !", e);  
  58.         }  
  59.         finally {  
  60.             try {  
  61.                 if(null != ObjIn) {  
  62.                     ObjIn.close();  
  63.                 }  
  64.             }  
  65.             catch (IOException e) {  
  66.                 ObjIn = null;  
  67.             }  
  68.         }  
  69.         return retVal;  
  70.     }  
  71. }  

 3. 对JavaBean的存储和获取:
        定义实体:借助于Timestamp类,获取ms值。

Java代码   Redis入门很简单之五【Jedis和Spring的整合】
  1. Userinfo actual = new Userinfo(140520"Nick Xu",   
  2. new Date(Timestamp.valueOf("1990-11-11 00:00:00").getTime()));  

      使用Jedis操作:key、value都需要转成byte[]字节数组。

Java代码   Redis入门很简单之五【Jedis和Spring的整合】
  1. String key = "user.userid." + actual.getUserId();  
  2. jedis.set(key.getBytes(), SerializingUtil.serialize(actual));  
  3. Userinfo expected = (Userinfo) SerializingUtil.deserialize(jedis.get(key.getBytes()));  

        对象的比较:需要覆写equals和hashCode方法。   

Java代码   Redis入门很简单之五【Jedis和Spring的整合】
  1. assertEquals(expected, actual);