Spring中使用Redis之集合类型

一、Redis集合简介
Redis的集合不是严格线性结构，而是严格哈希表结构，它的内部会根据hash分子来存储和查找数据，理论上严格集合可以存储42亿个元素，因为采用哈希表结构，所以对于Redis集合的插入，删除，和查找的复杂度都是O(1)，只是我们需要注意三点：

• 对于集合而言，它的每一个元素都是不能重复的，当插入相同记录的时候会失败。
• 集合是无序的。
• 集合的每一个元素都是String数据类型。

Redis集合可以对于不同的集合进行操作，比如求出两个或者两个以上的集合的交集、差集和并集。

二、集合的基本命令
【1】sadd key number1 [number2 …] ，功能：给键为key的集合添加成员，可以同时添加多个。
【2】scard key，功能：统计键为key的集合的成员数。
【3】sdiff key1 [key2]，功能：找出两个集合的差集，参数如果是单个key，那么就返回这个key的所有元素。
【4】sdiffstore desKey key1 [key2]，功能：先按照sdiff命令的规则，找出key1和key2两个集合的差集，然后保存在desKey集合中，参数如果是单个key，那么就返回这个key的所有元素。
【5】sinter key1 [key2]，功能：求key1和key2两个集合的交集，参数如果是单个key，那么就返回这个key的所有元素。
【6】sinterstore key1 [key2]，功能：先按照sinter 命令的规则，找出key1和key2两个集合的交集，然后保存在desKey集合中，参数如果是单个key，那么就返回这个key的所有元素。
【7】sismember key member，功能：判断member是否为key键的集合的成员，如果是返回1，不是则返回0。
【8】smembers key，功能：返回集合所有成员。
【9】smove src des member，功能：键成员member从集合src中迁移到集合des中。
【10】spop key，功能：随机弹出集合的严格元素。
【11】srandmember key [count]，功能：随机返回集合中严格或者多个元素，如果count为负数，则先取绝对值，count默认值为1，若count大于等于集合总数，则返回整个集合。
【12】srem key member1 [member2]，移除集合中的指定元素，可以移除多个。
【13】sunion key1 [key2]，功能：求两个集合的并集，参数如果是单个key，那么就返回这个key的所有元素。
【14】sunionstore des key1 key2，功能：先执行sunion命令求出并集，然后保存到集合des中。

三、Spring中使用Redis操作集合类型

步骤一：创建Maven项目，在pom.xml文件中导入一下三个依赖。

     <dependencies>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-nop</artifactId>
            <version>1.7.2</version>
        </dependency>
        <!-- 导入Spring中的redis依赖 -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>2.1.6.RELEASE</version>
        </dependency>
        <!-- 导入jedis依赖 -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.1</version>
        </dependency>
    </dependencies>

步骤二：在applicationContext.xml文件中配置Redis。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- Jedis 的连接池配置 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <!-- 最大空闲连接数量-->
        <property name="maxIdle" value="50"/>
        <!-- 最大连接数量-->
        <property name="maxTotal" value="100"/>
        <!-- 最大等待时间-->
        <property name="maxWaitMillis" value="20000"/>
    </bean>

    <bean id="stringRedisSerializer" class="org.springframework.data.redis.serializer.StringRedisSerializer"/>

    <!-- Redis服务中心-->
    <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="hostName" value="localhost"/>
        <property name="port" value="6379"/>
        <property name="poolConfig" ref="poolConfig"/>
    </bean>

    <!-- Redis模板类-->
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="connectionFactory"/>
        <property name="defaultSerializer" ref="stringRedisSerializer"/>
        <property name="valueSerializer" ref="stringRedisSerializer"/>
    </bean>
</beans>

步骤三：创建一个RedisSetDemo类，使用Spring测试Redis链表操作，如下所示：

package demo;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.redis.core.RedisTemplate;

import java.util.List;
import java.util.Set;

/**
 * @author czd
 */
public class RedisSetDemo {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        RedisTemplate redisTemplate = applicationContext.getBean(RedisTemplate.class);

        Set<String> set = null;
        //将元素加入链表中，相当于sadd key number1 [number2 …]
        redisTemplate.boundSetOps("set1").add("value1", "value2", "value3");
        redisTemplate.boundSetOps("set2").add("value0", "value1", "value2");

        //求集合的长度，相当于scard key
        long size = redisTemplate.opsForSet().size("set1");
        System.out.println("set1集合的长度为：" + size);

        //求两个集合的差集，相当于sdiff key1 [key2]
        set = redisTemplate.opsForSet().difference("set1", "set2");
        for (String value : set) {
            System.out.println("set集合中的值：" + value);
        }

        //求两个集合的交集，相当于sinter key1 [key2]
        set = redisTemplate.opsForSet().intersect("set1", "set2");
        for (String value : set) {
            System.out.println("set集合中的值：" + value);
        }

        //判断某个元素是否为集合中的元素，相当于sismember key member
        boolean exist = redisTemplate.opsForSet().isMember("set1", "value1");
        System.out.println("value1是否存在集合set1中：" + exist);

        //获取集合中所有的元素，相当于smembers key
        set = redisTemplate.opsForSet().members("set1");
        for (String value : set) {
            System.out.println("set集合中的值：" + value);
        }

        //从集合中随机弹出一个数，相当于spop key
        String value = (String) redisTemplate.opsForSet().pop("set1");
        System.out.println("从集合中随机弹出一个数的值为：" + value);

        //随机获取一个集合的元素，相当于srandmember key
        value = (String) redisTemplate.opsForSet().randomMember("set1");
        System.out.println("随机获取一个集合的元素的值为：" + value);

        //随机获取一个集合的元素，相当于srandmember key [count]
//        List list =redisTemplate.opsForSet().randomMembers("sete1",2L);
//        for(int i = 0; i < list.size(); i++){
//            System.out.println("值为：" + list.get(i));
//        }

        //删除集合一个元素，也可以删除多个，相当于srem key member1 [member2]
        redisTemplate.opsForSet().remove("set1", "value1", "value2");

        //求两个集合的并集，相当于sunion key1 [key2]
        set = redisTemplate.opsForSet().union("set1","set2");
        for (String value1 : set) {
            System.out.println("set集合中的值：" + value1);
        }

        //求两个集合的差集，并且保存到diff_set中，相当于sdiffstore desKey key1 [key2]
        redisTemplate.opsForSet().differenceAndStore("set1","set2","diff_set");

        //求两个集合的交集，并且保存到inter_set中，相当于sinterstore key1 [key2]
        redisTemplate.opsForSet().intersectAndStore("set1","set2","inter_set");

        //求两个集合的并集，并且保存到union_set中，相当于sunionstore des key1 key2
        redisTemplate.opsForSet().unionAndStore("set1","set2","union_set");
    }
}

运行效果如下图所示：