SSM集成Redis

1.导入pom文件

		 <dependency>
           <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.8.4.RELEASE</version>
        </dependency>


        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>

2.编写redis.properties文件

#redis配置
redis.ip=localhost
redis.port=6379
redis.password=123456
redis.maxTotal=1000
redis.maxactive=64
redis.maxIdle=20
redis.maxWaitMillis=3000
redis.timeout=3000
redis.testOnBorrow=true
redis.testOnReturn=true
redis.blockWhenExhausted=true

3.spring配置文件中添加容器

 <!-- jedis连接池配置 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <!-- 最小空闲连接数 -->
        <!-- <property name="minIdle" value="${redis.minIdle}" /> -->
        <!-- 最大空闲连接数 -->
        <property name="maxIdle" value="${redis.maxIdle}" />
        <!-- 最大连接数 -->
        <property name="maxTotal" value="${redis.maxTotal}" />
        <!-- 获取连接时的最大等待毫秒数,小于零:阻塞不确定的时间,默认-1 -->
        <property name="maxWaitMillis" value="${redis.maxWaitMillis}" />
        <!-- 在获取连接的时候检查有效性, 默认false -->
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />
        <!-- 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true -->
        <property name="blockWhenExhausted"
                  value="${redis.blockWhenExhausted}" />
    </bean>
	
	 <!-- jedis工厂类 -->
    <bean id="jedisConnFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="poolConfig" ref="poolConfig" />
        <property name="hostName" value="${redis.ip}" />
        <property name="port" value="${redis.port}" />
        <property name="password" value="${redis.password}" />
        <property name="timeout" value="${redis.timeout}" />
    </bean>

    <!--redis操作模版,使用该对象可以操作redis  -->
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" >
        <property name="connectionFactory" ref="jedisConnFactory" />
        <!--如果不配置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.GenericJackson2JsonRedisSerializer" />
        </property>
        <property name="hashKeySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="hashValueSerializer">
            <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>
        </property>
        <!--开启事务  -->
        <!--  <property name="enableTransactionSupport" value="false"></property> -->
    </bean >


 <!--导入redis.properties文件  -->
 <bean id="propertyConfigurer"
          class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:redis.properties</value>
            </list>
        </property>
    </bean>

4.基本使用

1.通用操作

@Autowired
private RedisTemplate redisTemplate;

//删除key
redisTemplate.delete(key);

//设置过期时间
Boolean  redisTemplate.expire(key, timeout, unit); // 多久以后过期
Boolean  redisTemplate.expireAt(key, date);        // Date date 具体过期时间

//返回key类型
DataType redisTemplate.type(key);

//返回key过期时间
Long redisTemplate.getExpire(key); 
Long redisTemplate.getExpire(key, unit);// TimeUnit unit 指定返回的时间的单位  

//判断是否存在key
redisTemplate.hasKey(key);

//查找匹配的key值，返回一个Set集合类型（ * 代表查询所有）
Set<String> redisTemplate.keys(pattern); // pattern为正则表达式

//修改redis中key的名称；
void redisTemplate.rename(oldKey, newKey);
Boolean redisTemplate.renameIfAbsent(oldKey, newKey);// 如果旧值存在时，将旧值改为新值

2.String类型操作

// 设置key-value
redisTemplate.opsForValue().set("key", "value");

// 获取value
String value = redisTemplate.opsForValue().get("key");

3.Hash类型操作

// 设置hash值
redisTemplate.opsForHash().put("hash-key", "hash-field", "hash-value");

// 获取某个field的值
Object value = redisTemplate.opsForHash().get("hash-key", "hash-field");

// 获取hash所有值
Map<Object, Object> hash = redisTemplate.opsForHash().entries("hash-key");

//以map集合的形式添加键值对；
redisTemplate.opsForHash().putAll(key, maps); // Map<String, String> maps

// 查看hash表中指定字段是否存在
Boolean redisTemplate.opsForHash().hasKey(key, field);

4.List类型操作

// 从左边添加元素
redisTemplate.opsForList().leftPush("list-key", "value1");

//通过索引获取列表中的元素
redisTemplate.opsForList().index(key, index);

// 获取list范围内的元素
List<Object> list = redisTemplate.opsForList().range("list-key", 0, -1);

//把多个值存入List中(value可以是多个值，也可以是一个Collection value);
redisTemplate.opsForList().leftPushAll(key, value);

//设置指定索引处元素的值设置指定索引处元素的值
redisTemplate.opsForList().set(key, index, value);

//获取当前key的List列表长度
redisTemplate.opsForList().size(key);

5.Set类型操作

// 添加元素
redisTemplate.opsForSet().add("set-key", "value1");

// 获取set中所有元素
Set<Object> set = redisTemplate.opsForSet().members("set-key");

//移除元素(单个值、多个值)
redisTemplate.opsForSet().remove(key, values);

//获取集合的大小
redisTemplate.opsForSet().size(key);

// 判断集合是否包含value
redisTemplate.opsForSet().isMember(key, value);

//获取集合中的所有元素
redisTemplate.opsForSet().members(key);

6.ZSet类型操作

// 添加元素
redisTemplate.opsForZSet().add("zset-key", "value1", 10);

// 获取排名区间内的元素
Set<Object> set = redisTemplate.opsForZSet().range("zset-key", 0, -1);

//删除对应的value,value可以为多个值；
redisTemplate.opsForZSet().remove(key, values);

//获取集合中key、value元素对应的score值
redisTemplate.opsForZSet().score(key, value);

//增加元素的score值，并返回增加后的值
redisTemplate.opsForZSet().incrementScore(key, value, delta);

//返回元素在集合的排名,有序集合是按照元素的score值由小到大排列
redisTemplate.opsForZSet().rank(key, value);

//返回元素在集合的排名,按元素的score值由大到小排列
redisTemplate.opsForZSet().reverseRank(key, value);