redis+spring 整合

最近在研究redis也结合了许多网上的资料分享给大家，有些不足的还望大家多补充提点，下面直接进入主题。

结构图：

几个redis的核心jar，spring的一些jar自行导入

接下来开始配置项目：

1、配置文件

redis.properties

redis.host = 192.168.76.76
redis.port = 6379
redis.pass = admin
redis.maxIdle = 200
redis.maxActive = 1024
redis.maxWait = 10000
redis.testOnBorrow = true

spring-redis.xml

<?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:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xmlns:cache="http://www.springframework.org/schema/cache"
    xmlns:jaxws="http://cxf.apache.org/jaxws"
    xmlns:jaxrs="http://cxf.apache.org/jaxrs"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
                     http://www.springframework.org/schema/beans/spring-beans.xsd
                     http://www.springframework.org/schema/tx
                     http://www.springframework.org/schema/tx/spring-tx.xsd
                     http://www.springframework.org/schema/context
                     http://www.springframework.org/schema/context/spring-context.xsd
                     http://www.springframework.org/schema/aop
                     http://www.springframework.org/schema/aop/spring-aop.xsd
                     http://www.springframework.org/schema/jee
                     http://www.springframework.org/schema/jee/spring-jee-3.1.xsd
                     http://www.springframework.org/schema/jdbc
                     http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd
                     http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-3.2.xsd
                     http://cxf.apache.org/jaxws
                     http://cxf.apache.org/schemas/jaxws.xsd
                     http://cxf.apache.org/jaxrs
                     http://cxf.apache.org/schemas/jaxrs.xsd"  default-autowire="byName" >

    <!-- 引入配置文件 -->
    <context:property-placeholder location="classpath:/resource/redis.properties"/>

    <!-- 连接池基本参数配置，类似数据库连接池 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="${redis.maxIdle}" />
        <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
    </bean>

    <!-- 连接池配置，类似数据库连接池 -->
    <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" >
        <property name="hostName" value="${redis.host}"></property>
        <property name="port" value="${redis.port}"></property>
        <property name="password" value="${redis.pass}"></property>
        <property name="poolConfig"  ref="poolConfig"></property>
    </bean>

    <!-- 调用连接池工厂配置 -->
    <bean id="redisTemplate" class=" org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="connectionFactory"></property>
        <!-- 自定义json序列化存储 -->
        <!--  <property name="defaultSerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>   -->

        <!-- 如果不配置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.JdkSerializationRedisSerializer" />
        </property>
    </bean>
</beans>

spring-source.xml

<?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:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xmlns:cache="http://www.springframework.org/schema/cache"
    xmlns:jaxws="http://cxf.apache.org/jaxws"
    xmlns:jaxrs="http://cxf.apache.org/jaxrs"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
                     http://www.springframework.org/schema/beans/spring-beans.xsd
                     http://www.springframework.org/schema/tx
                     http://www.springframework.org/schema/tx/spring-tx.xsd
                     http://www.springframework.org/schema/context
                     http://www.springframework.org/schema/context/spring-context.xsd
                     http://www.springframework.org/schema/aop
                     http://www.springframework.org/schema/aop/spring-aop.xsd
                     http://www.springframework.org/schema/jee
                     http://www.springframework.org/schema/jee/spring-jee-3.1.xsd
                     http://www.springframework.org/schema/jdbc
                     http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd
                     http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-3.2.xsd
                     http://cxf.apache.org/jaxws
                     http://cxf.apache.org/schemas/jaxws.xsd
                     http://cxf.apache.org/jaxrs
                     http://cxf.apache.org/schemas/jaxrs.xsd"  default-autowire="byName" >

    <context:annotation-config />
    <!-- 扫描注解web整合时用 -->
    <context:component-scan base-package="com.tp.soft.*" />

    <bean id="jsonSerializer" class="com.tp.soft.base.redis.JsonRedisSeriaziler"/>
    <bean id="userDao" class="com.tp.soft.dao.impl.UserDaoImpl" />
</beans>

2、配置公用Dao

AbstractBaseRedisDao.java

package com.tp.soft.base.dao;

import java.io.Serializable;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;

import com.tp.soft.base.redis.JsonRedisSeriaziler;

/**
 * @author taop
 *
 * @param <K>
 * @param <V>
 */

public abstract class AbstractBaseRedisDao<K extends Serializable, V extends Serializable> {

    @Autowired
    protected RedisTemplate<K, V> redisTemplate;

    //json转换时用 若用系统自带序列对象可不写
    @Autowired
    private JsonRedisSeriaziler jsonSerializer;

    /**
     * 注入
     * 设置redisTemplate
     * @param redisTemplate
     */
    public void setRedisTemplate(RedisTemplate<K, V> redisTemplate){
        this.redisTemplate = redisTemplate;
    }

    //json转换时用 若用系统自带序列对象可不写
    public void setJsonRedisSeriaziler(JsonRedisSeriaziler jsonSerializer) {
        this.jsonSerializer = jsonSerializer;
    }

    //json转换时用 若用系统自带序列对象可不写
    protected String getRedisSerializer(Object obj){
        return jsonSerializer.seriazileAsString(obj);
    }

    //json转换时用 若用系统自带序列对象可不写
    protected <T> T deserRedisSerializer(String str, Class<T> clazz){
        return jsonSerializer.deserializeAsObject(str, clazz);
    }

     /**
      * 方法一
       * 获取 RedisSerializer
       * <br>------------------------------<br>
       */
      protected RedisSerializer<String> getRedisSerializer() {
        return redisTemplate.getStringSerializer();
      }
}

3、若调用jackson 序列化对象 则新建, 若默认序列化对象可不创建

JsonRedisSeriaziler.java

package com.tp.soft.base.redis;

import java.nio.charset.Charset;

import org.apache.commons.lang.SerializationException;
import org.codehaus.jackson.map.ObjectMapper;

public class JsonRedisSeriaziler {
    public static final String EMPTY_JSON = "{}";  

    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");  

    protected ObjectMapper objectMapper = new ObjectMapper();
    public JsonRedisSeriaziler(){}  

    /**
     * java-object as json-string
     * @param object
     * @return
     */
    public String seriazileAsString(Object object){
        if (object== null) {
            return EMPTY_JSON;
        }
        try {
            return this.objectMapper.writeValueAsString(object);
        } catch (Exception ex) {
            throw new SerializationException("Could not write JSON: " + ex.getMessage(), ex);
        }
    }  

    /**
     * json-string to java-object
     * @param str
     * @return
     */
    public <T> T deserializeAsObject(String str,Class<T> clazz){
        if(str == null || clazz == null){
            return null;
        }
        try{
            return this.objectMapper.readValue(str, clazz);
        }catch (Exception ex) {
            throw new SerializationException("Could not write JSON: " + ex.getMessage(), ex);
        }
    }
}

4、实体类

AuUser.java

package com.tp.soft.entity;

import java.io.Serializable;

public class AuUser implements Serializable{

    /**
     *
     */
    private static final long serialVersionUID = -1695973853274402680L;

    private String id;

    private String username;

    private String password;

    public AuUser() {

    }

    public AuUser(String id, String username, String password) {
        super();
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

}

5、接口

UserDao.java

package com.tp.soft.dao;

import java.util.List;

import com.tp.soft.entity.AuUser;

public interface UserDao {
    boolean add(AuUser auUser) ;
    boolean add(List<AuUser> list);
    void delete(String key);
    void delete(List<String> keys);
    boolean update(AuUser auUser);
    AuUser get(String keyId);
}

6、接口实现类

UserDaoImpl.java

package com.tp.soft.dao.impl;

import java.io.Serializable;
import java.util.List;

import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.BoundValueOperations;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.RedisSerializer;

import com.tp.soft.base.dao.AbstractBaseRedisDao;
import com.tp.soft.dao.UserDao;
import com.tp.soft.entity.AuUser;

public class UserDaoImpl extends AbstractBaseRedisDao<String, AuUser> implements UserDao{

    @Override
    public boolean add(final AuUser auUser) {
//         this.redisTemplate.opsForValue().set("pwd", "123456");
//         ValueOperations<String, String> operations = redisTemplate
//                .opsForValue();
//         String redisSerializer = getRedisSerializer(auUser);
//         operations.set("user:"+auUser.getId(), redisSerializer);
//         return true;

        //方法一
//        redisTemplate.execute(new RedisCallback<Object>() {
//            public Object doInRedis(RedisConnection connection)
//                    throws DataAccessException {
//                RedisSerializer<String> serializer = getRedisSerializer();
//                byte[] key  = serializer.serialize(auUser.getId());
//                byte[] name = serializer.serialize(auUser.getUsername());
//                connection.set(key, name);
//                return null;
//              }
//        }); 

        //方法二
         ValueOperations<String, AuUser> valueOps = redisTemplate.opsForValue();
         valueOps.set(auUser.getId(), auUser);

         return true;
    }

    @Override
    public AuUser get(final String keyId) {
        //System.out.println(this.redisTemplate.opsForValue().get("pwd"));
//        ValueOperations<String, String> operations = redisTemplate
//                .opsForValue();
//        String json = operations.get("user:"+keyId);
//        return deserRedisSerializer(json, AuUser.class);
        //return null;

        //方法一
        /*AuUser result = redisTemplate.execute(new RedisCallback<AuUser>() {
              public AuUser doInRedis(RedisConnection connection)
                  throws DataAccessException {
                RedisSerializer<String> serializer = getRedisSerializer();
                byte[] key = serializer.serialize(keyId);
                byte[] value = connection.get(key);
                if (value == null) {
                  return null;
                }
                String nickname = serializer.deserialize(value);
                return new AuUser(keyId, nickname, "1234");
              }
            });
            return result; */

        //方式2：不在redistemplate中配置Serializer，而是在Service的实现类中单独指定Serializer。
        BoundValueOperations<String, AuUser> boundValueOps = redisTemplate.boundValueOps(keyId);
        AuUser user = (AuUser) boundValueOps.get();
        return user;
    }

    @Override
    public boolean add(List<AuUser> list) {
        // TODO Auto-generated method stub
        return false;
    }

    @Override
    public void delete(String key) {
        // TODO Auto-generated method stub

    }

    @Override
    public void delete(List<String> keys) {
        // TODO Auto-generated method stub

    }

    @Override
    public boolean update(AuUser auUser) {
        // TODO Auto-generated method stub
        return false;
    }
}

6、junit测试类

RedisZhTest.java

package junit;

import junit.framework.Assert;

import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;

import com.tp.soft.dao.UserDao;
import com.tp.soft.entity.AuUser;

@ContextConfiguration(locations = {"classpath:/resource/spring-*.xml"})
public class RedisZhTest extends AbstractJUnit4SpringContextTests{
    @Autowired
    private UserDao userDao;

    @Test
    public void testAddUser(){
        AuUser user = new AuUser();
        user.setId("1");
        user.setUsername("taop");
        user.setPassword("12345");
        boolean result = userDao.add(user);
        //Assert.assertTrue(result);
        AuUser auUser = userDao.get("1");
        System.out.println(auUser.getUsername());
        System.out.println(auUser.getPassword());
    }
}

结果打印: