利用Spring-Data-Redis和Jedis操作Redis缓存

只需简单几步，就可以利用Spring-Data-Redis和Jedis操作Redis缓存。步骤如下：

第一步：依赖包

		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redis</artifactId>
			<version>1.4.2.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.6.0</version>
		</dependency>

第二步：封装自己的Redis操作类

/**
 * 封装对Redis的常用操作，尽量与Redis原始命令一致。Redis命令参考：http://redisdoc.com/
 * @author Xu
 *
 */
public class XjjStringRedisOps extends StringRedisTemplate {

	
	//Key（键），简单的key-value操作
	
	/**
	 * 实现命令：TTL key，以秒为单位，返回给定 key的剩余生存时间(TTL, time to live)。
	 * @param key
	 * @return
	 */
	public long TTL(String key) {
		return getExpire(key);
	}
	
	/**
	 * 实现命令：KEYS pattern，查找所有符合给定模式 pattern的 key
	 */
	public Set<String> KEYS(String pattern){
		return super.keys(pattern);
	}
	
	/**
	 * 实现命令：DEL key，删除一个key
	 * @param key
	 */
	public void DEL(String key){
		delete(key);
	}
	
	//String（字符串）
	
	/**
	 * 实现命令：SET key value，设置一个key-value（将字符串值 value关联到 key）
	 * @param key
	 * @param value
	 */
	public void SET(String key, String value) {
		opsForValue().set(key, value);
	}
	
	/**
	 * 实现命令：SET key value EX seconds，设置key-value和超时时间（秒）
	 * @param key
	 * @param value
	 * @param timeout （以秒为单位）
	 */
	public void SET(String key, String value, long timeout) {
		opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
	}
	
	/**
	 * 实现命令：GET key，返回 key所关联的字符串值。
	 * @param key
	 * @return value
	 */
	public String GET(String key) {
		return opsForValue().get(key);
	}
	
	//Hash（哈希表）
	
	/**
	 * 实现命令：HSET key field value，将哈希表 key中的域 field的值设为 value
	 * @param key
	 * @param field
	 * @param value
	 */
	public void HSET(String key, String field, Object value) {
		opsForHash().put(key, field, value);
	}
	
	/**
	 * 实现命令：HGET key field，返回哈希表 key中给定域 field的值
	 * @param key
	 * @param field
	 * @return
	 */
	public String HGET(String key, String field) {
		return (String) opsForHash().get(key, field);
	}
	
	/**
	 * 实现命令：HDEL key field [field ...]，删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
	 * @param key
	 * @param fields
	 */
	public void HDEL(String key, Object... fields) {
		opsForHash().delete(key, fields);
	}
	
	/**
	 * 实现命令：HGETALL key，返回哈希表 key中，所有的域和值。
	 * @param key
	 * @return
	 */
	public Map<Object, Object> HGETALL(String key) {
		return opsForHash().entries(key);
	}
	
	//List（列表）
	
	/**
	 * 实现命令：LPUSH key value，将一个值 value插入到列表 key的表头
	 * @param key
	 * @param value
	 * @return 执行 LPUSH命令后，列表的长度。
	 */
	public long LPUSH(String key, String value) {
		return opsForList().leftPush(key, value);
	}
	
	/**
	 * 实现命令：LPOP key，移除并返回列表 key的头元素。
	 * @param key
	 * @return 列表key的头元素。
	 */
	public String LPOP(String key) {
		return opsForList().leftPop(key);
	}
	
	/**
	 * 实现命令：RPUSH key value，将一个值 value插入到列表 key的表尾(最右边)。
	 * @param key
	 * @param value
	 * @return 执行 LPUSH命令后，列表的长度。
	 */
	public long RPUSH(String key, String value) {
		return opsForList().rightPush(key, value);
	}
	
	/**
	 * 实现命令：RPOP key，移除并返回列表 key的尾元素。
	 * @param key
	 * @return 列表key的头元素。
	 */
	public String RPOP(String key) {
		return opsForList().rightPop(key);
	}
	
	//Set（集合）
	/**
	 * 实现命令：SADD key member，将一个 member元素加入到集合 key当中，已经存在于集合的 member元素将被忽略。
	 * @param key
	 * @param member
	 */
	public void SADD(String key, String member) {
		opsForSet().add(key, member);
	}
	
	/**
	 * 实现命令：SMEMBERS key，返回集合 key 中的所有成员。 
	 * @param key
	 * @return
	 */
	public Set<String> SMEMEBERS(String key) {
		return opsForSet().members(key);
	}
	
	//SortedSet（有序集合）
	/**
	 * 实现命令：ZADD key score member，将一个 member元素及其 score值加入到有序集 key当中。
	 * @param key
	 * @param score
	 * @param member
	 */
	public void ZADD(String key, double score, String member) {
		opsForZSet().add(key, member, score);
	}
	
	/**
	 * 实现命令：ZRANGE key start stop，返回有序集 key中，指定区间内的成员。
	 * @param key
	 * @param start
	 * @param stop
	 * @return
	 */
	public Set<String> ZRANGE(String key, double start, double stop) {
		return opsForZSet().rangeByScore(key, start, stop);
	}
}

第三步：Spring配置

	<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
		<property name="hostName" value="${redis1.host}" />
		<property name="port" value="${redis1.port}" />
	</bean>
	
	<!-- <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
		<property name="connectionFactory" ref="jedisConnectionFactory" />
	</bean> -->
	
	<bean id="redisOps" class="com.xjj.spring.data.XjjStringRedisOps">
		<property name="connectionFactory" ref="jedisConnectionFactory" />
	</bean>

第四步：测试

@RunWith(SpringJUnit4ClassRunner.class)  //使用Spring Junit4进行测试  
@ContextConfiguration ({"classpath:spring/applicationContext.xml"}) //加载配置文件
public abstract class BaseJunit4Test {

}

public class RedisTest extends BaseJunit4Test {
	@Autowired
	XjjStringRedisOps redisOps;

	@Test
	public void deleteTestKeys(){
		redisOps.DEL("xjj.v1");
		redisOps.DEL("xjj.v2");
		redisOps.DEL("xjj.h1");
		redisOps.DEL("xjj.11");
		redisOps.DEL("xjj.z1");
		HashSet<String> keySet = (HashSet<String>) redisOps.keys("xjj*");
		System.out.println(keySet);
		Assert.assertEquals("keys删除不成功！", new HashSet<String>(), keySet);
	}

	//String类型测试
	@Test
	public void setStringValue(){
		String key = "xjj.v1";
		String value = "Hello World!";
		
		redisOps.SET(key, value);
		System.out.println("value of xjj: " + redisOps.GET(key));
		Assert.assertEquals(value, redisOps.GET(key));
	}
	
	@Test
	public void setStringValueWithTimeout(){
		String key = "xjj.v2";
		String value = "Hello World, xjj1!";
		long timeout = 100;
		
		redisOps.SET(key, value, timeout);
		System.out.println("ttl of xjj1: " + redisOps.TTL(key));
		Assert.assertEquals(timeout, redisOps.TTL(key));
	}
	
	//Hash类型测试
	
	@Test
	public void setHashValue(){
		String key = "xjj.h1";
		String field1 = "f1";
		String value1 = "123";
		
		redisOps.HSET(key, field1, value1);
		System.out.println(redisOps.HGET(key, field1));
		
		String field2 = "f2";
		String value2 = String.valueOf(888);
		redisOps.HSET(key, field2, value2);
		System.out.println(redisOps.HGET(key, field2));
		
		System.out.println(redisOps.HGETALL(key));
	}
	
	@Test
	public void delHashKeys(){
		redisOps.HDEL("xjj.h1", "f1", "f2"); //删除xjj.h1中的f1和f2
	}
	
	//List类型测试
	@Test
	public void ListOps(){
		String key = "xjj.l1";
		String value1 = "Java";
		
		redisOps.LPUSH(key, value1);
		
		String value2 = "php";
		redisOps.RPUSH(key, value2);
		
		System.out.println(redisOps.RPOP(key));
		System.out.println(redisOps.LPOP(key));
	}
	
	//Set类型测试
	@Test
	public void SetOps(){
		String key = "xjj.s1";
		String member1 = "Java";
		String member2 = "Python";
		String member3 = "PHP";
		
		redisOps.SADD(key, member1);
		redisOps.SADD(key, member2);
		redisOps.SADD(key, member3);
		
		System.out.println(redisOps.SMEMEBERS(key));
	}
	
	//SortedSet类型测试
	@Test
	public void ZSetOps(){
		String key = "xjj.z1";
		String member1 = "Java";
		String member2 = "Python";
		String member3 = "PHP";
		double score1 = 1.2;
		double score2 = 100.5;
		double score3 = 188;
		
		redisOps.ZADD(key, score1, member1);
		redisOps.ZADD(key, score2, member2);
		redisOps.ZADD(key, score3, member3);
		
		System.out.println(redisOps.ZRANGE(key, 1, 150));
	}
	
}