SpringData Redis的简单使用

SpringDate Redis是在Jedis框架的基础之上对Redis进行了高度封装，通过简单的属性配置就可以通过调用方法完成对Redis数据库的操作，而且SpringData Redis使用了连接工厂（JedisConnectionFactory），相比于Jedis框架性能更好。

Spring集成Jedis要使用的jar包

<!-- Jedis 与spring整合 -->
<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.5.1</version>
</dependency>

在xml中的配置

<!-- Redis 连接池 -->
<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
　　 <!-- 最小保持idle状态的对象数 -->
    <property name="minIdle" value="20"/>
    <!-- 最大能够保持idel状态的对象数-->
    <property name="maxIdle" value="50"/>
    <!-- 最大分配的对象数 -->
    <property name="maxTotal" value="2048"/>
    <!-- 当池内没有返回对象时，最大等待时间 -->
    <property name="maxWaitMillis" value="3000"/>
    <!-- 当调用borrow Object方法时，是否进行有效性检查 -->
    <property name="testOnBorrow" value="true"/>
</bean>
<!-- business Redis 连接工厂 -->
<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
     destroy-method="destroy">
    <!-- Redis地址 -->
    <property name="hostName" value="127.0.0.1"/>
    <!-- Redis端口 -->
    <property name="port" value="6379"/>
    <!-- Redis库索引 -->
    <property name="database" value="0"/>
    <!-- Redis连接池 -->
    <property name="poolConfig" ref="poolConfig"/>
    <property name="usePool" value="true"/>
　　 <!-- 连接redis的密码 -->　　　
    <property name="password" value="123456"/>
</bean>
<!--针对String的序列化工具-->
<bean id="stringRedisSerializer" name="stringRedisSerializer"
     class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
<!-- SpringData Redis默认使用的序列化工具 -->
<bean id="jdkSerializationRedisSerializer" name="jdkSerializationRedisSerializer"
     class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
<!-- RedisTemplate类配置 -->
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
    <property name="connectionFactory" ref="jedisConnectionFactory"/>
    <property name="keySerializer" ref="stringRedisSerializer"/>
    <property name="hashKeySerializer" ref="stringRedisSerializer"/>
    <property name="hashValueSerializer" ref="jdkSerializationRedisSerializer"/>
    <property name="valueSerializer" ref="jdkSerializationRedisSerializer"/>
</bean>    

通过使用RedisTemplate类的opsForValue()方法获取封装操作value为字符串的各种命令的方法的操作对象、opsForList()方法获取封装操作value为列表的各种命令的方法的操作对象、opsForSet()方法获取封装操作value为集合的各种命令的方法的操作对象、opsForHash()方法获取封装操作value为字符串的各种命令的方法的操作对象、opsForZSet()方法获取封装操作value为有序集合的各种命令的方法的操作对象、opsForHyperLogLog()方法获取封装操作基数统计的各种命令的方法的操作对象。通过获取的操作对象，直接调用封装的方法对Redis数据库进行操作。

备注：Redis是String类型的key-value类型的nosql数据库，对于对象，我们可以将在value里存储的对象进行json序列化，然后储存在Redis中，其中要使用到json序列化工具，SpringData Redis提供了json序列化工具类（JacksonJsonRedisSerializer<T>），使用过程中遇到了一点麻烦，参考网上的事例自己写了一个json序列化工具类，代码如下

import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;

import com.fasterxml.jackson.annotation.JsonTypeInfo.As;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectMapper.DefaultTyping;

public class MyJacksonJsonRedisSerializer implements RedisSerializer<Object> {

    private final ObjectMapper mapper;

    public MyJacksonJsonRedisSerializer() {
        this((String) null);
    }

    public MyJacksonJsonRedisSerializer(String classPropertyTypeName) {

        this(new ObjectMapper());

        if (StringUtils.hasText(classPropertyTypeName)) {
            mapper.enableDefaultTypingAsProperty(DefaultTyping.NON_FINAL,
                    classPropertyTypeName);
        } else {
            mapper.enableDefaultTyping(DefaultTyping.NON_FINAL, As.PROPERTY);
        }
    }

    public MyJacksonJsonRedisSerializer(ObjectMapper mapper) {

        Assert.notNull(mapper, "ObjectMapper must not be null!");
        this.mapper = mapper;
    }

    @Override
    public byte[] serialize(Object source) throws SerializationException {

        if (source == null) {
            return new byte[0];
        }

        try {
            return mapper.writeValueAsBytes(source);
        } catch (JsonProcessingException e) {
            throw new SerializationException("Could not write JSON: "
                    + e.getMessage(), e);
        }
    }

    @Override
    public Object deserialize(byte[] source) throws SerializationException {
        return deserialize(source, Object.class);
    }

    public <T> T deserialize(byte[] source, Class<T> type)
            throws SerializationException {

        Assert.notNull(
                type,
                "Deserialization type must not be null! Pleaes provide Object.class to make use of Jackson2 default typing.");

        if (source == null || source.length == 0) {
            return null;
        }

        try {
            return mapper.readValue(source, type);
        } catch (Exception ex) {
            throw new SerializationException("Could not read JSON: "
                    + ex.getMessage(), ex);
        }
    }
}