【原】Spring整合Redis(第二篇)—SDR环境搭建具体步骤

【环境参数】

Spring版本：4.2.6.RELEASE
Spring-Data-Redis版本：1.7.2.RELEASE

Redis版本：redis-2.4.5-win32-win64

【简要说明】

搭建Spring与Reids的环境时，重点在于在Spring容器中配置RedisTemplate和ConnectionFactory，以及封装RedisTemplate组件。

【具体步骤】

0、配置pom.xml文件

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.zjrodger</groupId>
    <artifactId>Spring-Redis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
  
    <!-- 定义依赖的版本 -->
    <properties>
        <spring.version>4.2.6.RELEASE</spring.version>
    </properties>
  
    <dependencies>
        <!-- Spring Core -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>    
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>    
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>            
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>${spring.version}</version>
        </dependency>
        
        <!-- Spring Transaction -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- Spring AOP -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>                        
                
        <!-- JUnit相关jar包 -->        
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- Spring-Date-Redis相关 -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.7.2.RELEASE</version>
        </dependency>                
         <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.7.3</version>
        </dependency>
                              
    </dependencies>
  
</project>

1、配置redis.properties属性文件

# 连接redis服务的ip
redis.host=127.0.0.1
# 连接redis服务的端口
redis.port=6379
# 连接redis服务的超时时间（单位：秒）
redis.timeout=10
# 连接redis服务的密码
#redis.password=zjrodger
# 连接redis服务的数据库
redis.database=2

# 最大连接数
redis.maxTotal=5000
# 最大空闲连接数
redis.maxIdle=100
# 最大等待时间：单位（毫秒）
redis.maxWait=10000
# 最小空闲连接数
redis.minIdle=10
# 在borrow一个jedis实例时，是否提前进行alidate操作；如果为true，则得到的jedis实例均是可用的。
redis.testOnBorrow=true
# 在return给pool时，是否提前进行validate操作。
redis.testOnReturn=true
# 如果为true，表示有一个idle object evitor线程对idle object进行扫描，如果validate失败，此object会被从pool中drop掉；这一项只有在timeBetweenEvictionRunsMillis大于0时才有意义。
redis.testWhileIdle=false

2、在Spring容器中配置RedisTemplate和ConnectionFactory

在Spring容器中配置RedisTemplate和RedisConnectionFactory的实现类，即JedisConnectionFactory

<?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:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:p="http://www.springframework.org/schema/p" xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:task="http://www.springframework.org/schema/task"
    xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- Spring 扫包 -->
    <context:component-scan base-package="com.zjrodger"/>

    <!-- 读取配置文件 -->    
    <context:property-placeholder location="classpath:properties/*.properties"/>
        
    <!-- jedis 配置 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig" >
          <property name="maxIdle" value="${redis.maxIdle}" />
          <property name="maxWaitMillis" value="${redis.maxWait}" />
          <property name="testOnBorrow" value="${redis.testOnBorrow}" />
    </bean >
    
    <!-- redis服务器中心 -->
    <bean id="jedisConnectionFactory"  class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" >
          <property name="poolConfig" ref="poolConfig" />
          <property name="port" value="${redis.port}" />
          <property name="hostName" value="${redis.host}" />
          <property name="timeout" value="${redis.timeout}" />
          <property name="database" value="${redis.database}" />
          <!-- <property name="password" value="${redis.password}"></property> -->
    </bean >
    
    <!-- redisTemplate配置 -->
     <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" >
          <property name="connectionFactory" ref="jedisConnectionFactory" />
    </bean>     
</beans>

3、封装RedisTemplate组件。

@Component( value ="redisTemplateFactory" )
public class RedisTemplateFactory {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @SuppressWarnings("rawtypes")
    public RedisTemplate getLocalRedisTemplate(){
        redisTemplate.setKeySerializer(redisTemplate.getStringSerializer());
        return this.redisTemplate;
    }
}

4、准备测试数据：实体类、Dao接口和其实现类。

(1)封装User实体类

public class User implements Serializable {    
    private String userId;    
    private String username;    
    private String password;
    ... 省略 setter()和getter()方法..
}

(2)封装IUserDao接口

public interface IUserDao {
    /** 新增 */  
    boolean add(User user);  
      
    /** 批量新增 使用pipeline方式 */  
    boolean add(List<User> list);     
      
    /**删除*/  
    void delete(String key);  
      
    /**删除多个*/  
    void delete(List<String> keys);  
      
    /**修改*/  
    boolean update(User user) throws Exception;  
  
    /**通过key获取*/  
    User get(String keyId);

    boolean opsForList(String key, User user);

    boolean getListValueByIndex(String key, int index);
}

(3)实现IUserDao接口

@Component( value = "userDao")
public class UserDaoImpl implements IUserDao {
    
    @Autowired
    public RedisTemplateFactory redisTemplateFactory;

    @SuppressWarnings("unchecked")
    @Override
    public boolean add(User user) {        
        RedisTemplate<String, Object> localRedisTemplate = redisTemplateFactory.getLocalRedisTemplate();        
        ValueOperations<String, Object> opsForValue = localRedisTemplate.opsForValue();        
        opsForValue.set(user.getUserId(), user);        
        return true;
    }

    @SuppressWarnings("unchecked")
    @Override
    public boolean add(List<User> list) {        
        RedisTemplate<String, Object> localRedisTemplate = redisTemplateFactory.getLocalRedisTemplate();
        ValueOperations<String, Object> opsForValue = localRedisTemplate.opsForValue();
        for(User user: list){
            opsForValue.set(user.getUserId(), user);
        }                
        return true;
    }

    @SuppressWarnings("unchecked")
    @Override
    public void delete(String key) {
        RedisTemplate<String, Object> localRedisTemplate = redisTemplateFactory.getLocalRedisTemplate();
        ValueOperations<String, Object> opsForValue = localRedisTemplate.opsForValue();
        opsForValue.getOperations().delete(key);
    }

    @SuppressWarnings("unused")
    @Override
    public void delete(List<String> keys) {
        RedisTemplate<String, Object> localRedisTemplate = redisTemplateFactory.getLocalRedisTemplate();
        ValueOperations<String, Object> opsForValue = localRedisTemplate.opsForValue();
        RedisOperations<String, Object> operations = opsForValue.getOperations();
        for(String key : keys){
            operations.delete(key);
        }
    }

    @Override
    public boolean update(User user) throws Exception {        
        if( null == user.getUserId()){
            throw new Exception("该用户的Key不存在");
        }
        RedisTemplate<String, Object> localRedisTemplate = redisTemplateFactory.getLocalRedisTemplate();
        ValueOperations<String, Object> opsForValue = localRedisTemplate.opsForValue();
        opsForValue.set(user.getUserId(), user);                
        return true;
    }

    @Override
    public User get(String keyId) {
        RedisTemplate<String, Object> localRedisTemplate = redisTemplateFactory.getLocalRedisTemplate();
        ValueOperations<String, Object> opsForValue = localRedisTemplate.opsForValue();
        return (User)opsForValue.get(keyId);
    }

    @Override
    public boolean opsForList(String key, User user) {        
        RedisTemplate<String, Object> localRedisTemplate = redisTemplateFactory.getLocalRedisTemplate();
        ListOperations<String, Object> opsForList = localRedisTemplate.opsForList();
        opsForList.rightPush(key, user);                
        return true;
    }

    @Override
    public boolean getListValueByIndex(String key, int index) {                
        RedisTemplate<String, Object> localRedisTemplate = redisTemplateFactory.getLocalRedisTemplate();
        ListOperations<String, Object> opsForList = localRedisTemplate.opsForList();
        User user = (User) opsForList.index(key, index);
        System.out.println(user);
        return true;
    }    
}

5、测试：以OpsForXX()方式，对User的增删改查操作（推荐）。

此种方式是推荐的操作Redis的方式。

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:applicationContext.xml" })
public class SpringTestCase {
    
    @Autowired
    private IUserDao userDao;
    
    private static final Integer COUNTER = 10;
    
    // 测试添加单个User
    @Test
    public void testAddUser(){
        for(int i=1; i<=COUNTER; i++){
            User user = new User("mykey000"+i, "zjroger000"+i, "password000"+i);
            if( userDao.add(user) ){
                System.out.println("用户zjrodger"+i+"添加成功。");
            }else{
                System.out.println("用户zjrodger"+i+"添加失败。");                
            }            
        }
    }
        
    // 测试按照Key-Value方式添加User
    @Test
    public void testAddUserList(){        
        List<User> userList = new ArrayList<>();        
        for(int i=1; i<=COUNTER; i++){
            User user = new User("mykey000"+i, "zjroger000"+i, "password000"+i);
            userList.add(user);
        }
        if( userDao.add(userList) ){
            System.out.println("用户列表添加成功。");
        }else{
            System.out.println("用户列表添加成功。");
        }        
    }
    
    // 通过OpsForList方式添加User
    @Test
    public void testOpsForList(){
        String myListKey = "key:myListKey01";
        List<User> userList = new ArrayList<>();        
        for(int i=1; i<=COUNTER; i++){
            User user = new User("myUserList0"+i, "myUserList0"+i, "myUserList0"+i);
            userDao.opsForList(myListKey, user);
        }                    
    }
    
    @Test
    public void testgetListValueByIndex(){
        String myListKey = "key:myListKey01";
        int index = 0;
        userDao.getListValueByIndex(myListKey, index);
    }    
    
    // 测试删除User
    @Test
    public void testDelete(){
        // 单个删除
//        String key = "mykey0002";
//        userDao.delete(key);
        
        // 多个删除
        List<String> keys = new ArrayList<>();
        keys.add("mykey0001");
        keys.add("mykey0002");
        keys.add("mykey0003");
        userDao.delete(keys);
        
    }

    // 测试获取User
    @Test
    public void testGetUser(){        
        User user = userDao.get("mykey0001");
        System.out.println(user.toString());                        
        // 多条查询
//        for(int i=1; i<=COUNTER; i++){
//            User user = userDao.get("mykey0"+i);
//            System.out.println(user.toString());
//        }                        
    }
    
    // 测试更新User
    @Test
    public void testUpdateUser(){
        String mykey01 = "mykey0001";
        User user = userDao.get(mykey01);
        System.out.println("原来的用户："+user.toString());                
        user.setUsername("ttttt");
        
        try {
            boolean result = userDao.update(user);
            System.out.println("数据更新完毕。");
            System.out.println(user.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }        
    }

6、测试：以RedisCallback()方式，对User的增删改查操作。

public class UserDaoImpl implements IUserDao {
    
    @Autowired
    private RedisTemplateFactory redisTemplateFactory;    

    /**
     * 添加一个User对象
     */
    @SuppressWarnings("unchecked")
    @Override
    public boolean add(User user) {
        
        final RedisTemplate redisTemplate = redisTemplateFactory.getLocalRedisTemplate();
        
        boolean result = (boolean) redisTemplate.execute(new RedisCallback(){

            @SuppressWarnings("rawtypes")
            @Override
            public Boolean doInRedis(RedisConnection connection)
                    throws DataAccessException {
                
                RedisSerializer stringSerializer = redisTemplate.getStringSerializer();
                RedisSerializer<User> valueSerializer = redisTemplate.getValueSerializer();                
                byte[] key = stringSerializer.serialize(user.getUserId());
                byte[] value = valueSerializer.serialize(user);                
                return connection.setNX(key, value);
            }            
        });        
        return result;
    }

    /** 添加一个User的List对象*/
    @SuppressWarnings("unchecked")
    @Override
    public boolean add(List<User> list) {
        
        final RedisTemplate redisTemplate = redisTemplateFactory.getLocalRedisTemplate();
        
        return (boolean) redisTemplate.execute(new RedisCallback(){

            @SuppressWarnings("rawtypes")
            @Override
            public Boolean doInRedis(RedisConnection connection)
                    throws DataAccessException {
            
                RedisSerializer keySerializer = redisTemplate.getKeySerializer();
                RedisSerializer<User> valueSerializer = redisTemplate.getValueSerializer();
                for(User user : list){
                    byte[] key = keySerializer.serialize(user.getUserId());
                    byte[] value = valueSerializer.serialize(user);
                    connection.setNX(key, value);
                }
                return true;
            }
        }, 
        false,  
        true);        
    }
}