【Redis】redisson框架使用与spring框架整合测试

redisson框架

1.地址： https://github.com/redisson/redisson

2.maven配置：

<!-- JDK 1.8+ compatible  新框架-->
<dependency>
   <groupId>org.redisson</groupId>
   <artifactId>redisson</artifactId>
   <version>3.5.7</version>
</dependency>

3.说明

版本情况： 3.5.7 2017年12月25日1.8+是 3.1.X

Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。 它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。其中包括 (BitSet, Set, Multimap, SortedSet, Map, List, Queue, BlockingQueue, Deque, BlockingDeque, Semaphore, Lock, AtomicLong, CountDownLatch, Publish / Subscribe, Bloom filter, Remote service, Spring cache, Executor service, Live Object service, Scheduler service) Redisson提供了使用Redis的最简单和最便捷的方法。Redisson的宗旨是促 进使用者对Redis的关注分离（Separation of Concern），从而让使用者能够将精力更集中地放在处理业务逻辑上。

每个Redis服务实例都能管理多达1TB的内存。

能够完美的在云计算环境里使用，并且支持AWS ElastiCache主备版，AWS ElastiCache集群版， Azure Redis Cache和阿里云（Aliyun）的云数据库Redis版

Redisson底层采用的是Netty 框架。支持Redis 2.8以上版本，支持Java1.6+以上版本。

4.使用方法 官网介绍

// 1. Create config object
Config = ...


// 2. Create Redisson instance
RedissonClient redisson = Redisson.create(config);


// 3. Get object you need
RMap<MyKey, MyValue> map = redisson.getMap("myMap");


RLock lock = redisson.getLock("myLock");


RExecutorService executor = redisson.getExecutorService("myExecutorService");


// over 30 different objects and services ...

5.wiki目录

https://github.com/redisson/redisson/wiki/目录

6.官网案例：

https://github.com/redisson/redisson-examples

Redisson管道


RBatch batch = redisson.createBatch();
batch.getMap("test").fastPutAsync("1", "2");
batch.getMap("test").fastPutAsync("2", "3");
batch.getMap("test").putAsync("2", "5");
batch.getAtomicLongAsync("counter").incrementAndGetAsync();
batch.getAtomicLongAsync("counter").incrementAndGetAsync();


List<?> res = batch.execute();
// 或
Future<List<?>> asyncRes = batch.executeAsync();


// 发送指令并等待执行，但是跳过结果
batch.executeSkipResult();
// 或
batch.executeSkipResultAsync();

7.第三方框架整合

Redisson不仅完美地支持运行在Spring框架下，还提供了和Spring框架的各项特性类似的，以Spring XML的命名空间的方式配置RedissonClient实例和它所支持的所有对象和服务。

首先需要做的是向你的Spring XML文件增加一个Redisson的引用描述：

<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:redisson="http://redisson.org/schema/redisson"
       xsi:schemaLocation="
       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://redisson.org/schema/redisson
       http://redisson.org/schema/redisson/redisson.xsd
">
...
</beans>

然后按照配置方法文档中介绍的方法配置需要的Redisson实例类型。比如一个单Redis节点模式的配置方法如下：

<!-- 最基本配置 -->
<redisson:client>
    <!-- 默认地址是 127.0.0.1:6379 -->
    <redisson:single-server/>
</redisson:client>
<!-- 或者 -->
<redisson:client>
    <redisson:single-server address="${redisAddress}"/>
</redisson:client>

其它连接类型的使用范例以及所有的可变参数均可在配置方法文档中找到。

通常情况下在一个应用程序里创建一个Redisson实例就已经能够满足正常的使用了，但是在个别的情况下， 一个应用程序可能会遇到需要同时连接多个不同的Redis环境，这就需要多个Redisson实例同时并存。你可以通过定义多个<redisson:client/>元素标签来实现这个要求：

<redisson:client id="myRedisson1" name="redisson1,redisson2" >
    <redisson:single-server address="127.0.0.1:6379" client-name="1"/>
</redisson:client>


<redisson:client id="myRedisson2" name="redisson3,redisson4">
    <redisson:single-server address="127.0.0.1:6380" client-name="2"/>
</redisson:client>

Redisson实例之间是通过它们的id属性值来区分的，这个值也同时被用来在自动依赖注入时作为qualifier的备选值使用。在name属性中 出现的多个由英文逗号分开的值是作为这个bean的化名的方式来解析的，它们在自动依赖注入时也会被用来作为qualifier的备选值使用。

也可以通过定义一个qualifier元素标签来明确的指定它的qualifier备选值，但是这个元素标签不能同时和name属性共存。

<redisson:client>
    <qualifier value="qualifiedName"/>
    <redisson:single-server address="127.0.0.1:6379"/>
</redisson:client>

网上可以参考文章： redisson整合spring：

http://blog.csdn.net/wang_keng/article/details/73549274

http://blog.csdn.net/zilong_zilong/article/details/78252037

8.依赖包：

io.netty netty-common4.1+必要
io.netty netty-codec4.1+必要
io.netty netty-buffer4.1+必要
io.netty netty-transport4.1+必要
io.netty netty-handler4.1+必要
net.openhft zero-allocation-hashing0.8+必要
com.fasterxml.jackson.dataformat jackson-core2.7+必要
com.fasterxml.jackson.dataformat jackson-databind2.7+必要
com.fasterxml.jackson.dataformat jackson-databind2.7+必要
com.fasterxml.jackson.dataformat jackson-dataformat-yaml2.7+可选（用于解析YAML配置文件）
net.bytebuddy byte-buddy1.6+可选 (实时对象服务需要）
org.jodd jodd-bean3.7+可选 (实时对象服务需要）
javax.cache cache-api1.0.0可选（JCache JSR107需要）
io.projectreactor reactor-stream2.0.8可选（使用2.x版本的RedissonReactiveClient的时候需要）
io.projectreactor reactor-core3.1.1可选（使用3.5+版本的RedissonReactiveClient的时候需要）

9.与Jedis对比

（https://www.cnblogs.com/mcbye/archive/2017/08/18/Jedis-VS-Redisson.html）

9.1. 概况对比

Jedis是Redis的Java实现的客户端，其API提供了比较全面的Redis命令的支持；Redisson实现了分布式和可扩展的Java数据结构，和Jedis相比， 功能较为简单，不支持字符串操作，不支持排序、事务、管道、分区等Redis特性。Redisson的宗旨是促进使用者对Redis的关注分离， 从而让使用者能够将精力更集中地放在处理业务逻辑上。

9.2. 编程模型

Jedis中的方法调用是比较底层的暴露的Redis的API，也即Jedis中的Java方法基本和Redis的API保持着一致，了解Redis的API， 也就能熟练的使用Jedis。而Redisson中的方法则是进行比较高的抽象，每个方法调用可能进行了一个或多个Redis方法调用。

如下分别为Jedis和Redisson操作的简单示例：

Jedis设置key-value与set操作：

Jedis jedis = …;


jedis.set("key", "value");


List<String> values = jedis.mget("key", "key2", "key3");


Redisson操作map：


Redisson redisson = …


RMap map = redisson.getMap("my-map"); 


map.put("key", "value");


map.containsKey("key");


map.get("key");

9.3. 可伸缩性

Jedis使用阻塞的I/O，且其方法调用都是同步的，程序流需要等到sockets处理完I/O才能执行，不支持异步。Jedis客户端实例不是线程安全的，所以需要通过连接池来使用Jedis。

Redisson使用非阻塞的I/O和基于Netty框架的事件驱动的通信层，其方法调用是异步的。Redisson的API是线程安全的，所以可以操作单个Redisson连接来完成各种操作。

9.4. 数据结构

Jedis仅支持基本的数据类型如：String、Hash、List、Set、Sorted Set。

Redisson不仅提供了一系列的分布式Java常用对象，基本可以与Java的基本数据结构通用，还提供了许多分布式服务， 其中包括（BitSet, Set, Multimap, SortedSet, Map, List, Queue, BlockingQueue, Deque, BlockingDeque, Semaphore, Lock, AtomicLong, CountDownLatch, Publish / Subscribe, Bloom filter, Remote service, Spring cache, Executor service, Live Object service, Scheduler service）。

在分布式开发中，Redisson可提供更便捷的方法。

9.5. 第三方框架整合

1 Redisson提供了和Spring框架的各项特性类似的，以Spring XML的命名空间的方式配置RedissonClient实例和它所支持的所有对象和服务；

2 Redisson完整的实现了Spring框架里的缓存机制；

3 Redisson在Redis的基础上实现了Java缓存标准规范；

4 Redisson为Apache Tomcat集群提供了基于Redis的非黏性会话管理功能。该功能支持Apache Tomcat的6、7和8版。

5 Redisson还提供了Spring Session会话管理器的实现。

10.工具类

import java.util.Map;  
  
import org.redisson.api.RAtomicLong;  
import org.redisson.api.RBucket;  
import org.redisson.api.RCountDownLatch;  
import org.redisson.api.RDeque;  
import org.redisson.api.RList;  
import org.redisson.api.RLock;  
import org.redisson.api.RMap;  
import org.redisson.api.RQueue;  
import org.redisson.api.RSet;  
import org.redisson.api.RSortedSet;  
import org.redisson.api.RTopic;  
import org.redisson.api.RedissonClient;  
import org.springframework.stereotype.Service;  
  
@Service  
public class RedissonUtils{  
      
      
    /**  
     * 获取字符串对象  
     * @param redisson  
     * @param t  
     * @param objectName  
     * @return  
     */    
    public static <T> RBucket<T> getRBucket(RedissonClient redissonClient,String objectName){    
        RBucket<T> bucket=redissonClient.getBucket(objectName);    
        return bucket;    
    }    
        
    /**  
     * 获取Map对象  
     * @param redisson  
     * @param objectName  
     * @return  
     */    
    public static <K,V> RMap<K, V> getRMap(RedissonClient redissonClient,String objectName){    
        RMap<K, V> map=redissonClient.getMap(objectName);    
        return map;    
    }    
        
    /**  
     * 获取有序集合  
     * @param redisson  
     * @param objectName  
     * @return  
     */    
    public static <V> RSortedSet<V> getRSortedSet(RedissonClient redissonClient,String objectName){    
        RSortedSet<V> sortedSet=redissonClient.getSortedSet(objectName);    
        return sortedSet;    
    }    
        
    /**  
     * 获取集合  
     * @param redisson  
     * @param objectName  
     * @return  
     */    
    public static <V> RSet<V> getRSet(RedissonClient redissonClient,String objectName){    
        RSet<V> rSet=redissonClient.getSet(objectName);    
        return rSet;    
    }    
        
    /**  
     * 获取列表  
     * @param redisson  
     * @param objectName  
     * @return  
     */    
    public static <V> RList<V> getRList(RedissonClient redissonClient,String objectName){    
        RList<V> rList=redissonClient.getList(objectName);    
        return rList;    
    }    
        
    /**  
     * 获取队列  
     * @param redisson  
     * @param objectName  
     * @return  
     */    
    public static <V> RQueue<V> getRQueue(RedissonClient redissonClient,String objectName){    
        RQueue<V> rQueue=redissonClient.getQueue(objectName);    
        return rQueue;    
    }    
        
    /**  
     * 获取双端队列  
     * @param redisson  
     * @param objectName  
     * @return  
     */    
    public static <V> RDeque<V> getRDeque(RedissonClient redissonClient,String objectName){    
        RDeque<V> rDeque=redissonClient.getDeque(objectName);    
        return rDeque;    
    }    
      
    /**  
     * 获取锁  
     * @param redisson  
     * @param objectName  
     * @return  
     */    
    public static RLock getRLock(RedissonClient redissonClient,String objectName){    
        RLock rLock=redissonClient.getLock(objectName);    
        return rLock;    
    }    
        
    /**  
     * 获取原子数  
     * @param redisson  
     * @param objectName  
     * @return  
     */    
    public static RAtomicLong getRAtomicLong(RedissonClient redissonClient,String objectName){    
        RAtomicLong rAtomicLong=redissonClient.getAtomicLong(objectName);    
        return rAtomicLong;    
    }    
        
    /**  
     * 获取记数锁  
     * @param redisson  
     * @param objectName  
     * @return  
     */    
    public static RCountDownLatch getRCountDownLatch(RedissonClient redissonClient,String objectName){    
        RCountDownLatch rCountDownLatch=redissonClient.getCountDownLatch(objectName);    
        return rCountDownLatch;    
    }    
        
    /**  
     * 获取消息的Topic  
     * @param redisson  
     * @param objectName  
     * @return  
     */    
    public static <M> RTopic<M> getRTopic(RedissonClient redissonClient,String objectName){    
         RTopic<M> rTopic=redissonClient.getTopic(objectName);    
         return rTopic;    
    }    
      
      
}  

然后我们需要在调用RedissonUtils的类中依赖进RedissonClient @Autowired
private RedissonClient redisson;

只后便可以对redis进行操作啦 RMap<String, Object> map = RedissonUtils.getRMap(redisson,key); map.put("key","value"); 调用到这个语句的同时就已经对redis中的数据进行了修改。

11.示例：

applicationContext.xml

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

	<context:property-placeholder location="classpath:application.properties" />

	<context:annotation-config />
	<!-- 使用annotation 自动注册bean,并保证@Required,@Autowired,@Resource的属性被注入 -->
	<context:component-scan base-package="com.naton" />

	 <import resource="application-spring-mongo.xml"/> 
	 <import resource="application-spring-jedis.xml"/>
	 <import resource="application-spring-redisson.xml"/>
	 


	<bean id="multipartResolver"
		class="org.springframework.web.multipart.commons.CommonsMultipartResolver" />
	<bean
		class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor" />

</beans>

application-spring-redisson.xml

<?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:redisson="http://redisson.org/schema/redisson"
       xsi:schemaLocation="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://redisson.org/schema/redisson
       http://redisson.org/schema/redisson/redisson.xsd">

   
    <!-- 单台redis机器配置   -->
	  <!-- 单台redis机器配置   -->
    <redisson:client id="redissonClient">
        <redisson:single-server address="redis://127.0.0.1:6379" connection-pool-size="30"/>
    </redisson:client>

     <!-- redis集群配置 -->
     <!-- <redisson:client id="redissonClient" >
     	
        <redisson:cluster-servers scan-interval="10000">   //scan-interval:集群状态扫描间隔时间，单位是毫秒
        	<redisson:node-address value="redis://192.168.2.100:7000"></redisson:node-address>
        	<redisson:node-address value="redis://192.168.2.100:7001"></redisson:node-address>
        	<redisson:node-address value="redis://192.168.2.100:7002"></redisson:node-address>
        	<redisson:node-address value="redis://192.168.2.100:7003"></redisson:node-address>
        	<redisson:node-address value="redis://192.168.2.100:7004"></redisson:node-address>
        	<redisson:node-address value="redis://192.168.2.100:7005"></redisson:node-address>
        </redisson:cluster-servers>
        
    </redisson:client> -->
</beans>

RedissonService 就用上面那个配置

调用方式：

package com.naton.test;

import java.io.IOException;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.redisson.api.RBucket;
import org.redisson.api.RMap;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.naton.service.RedissonService;

@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration({"classpath:applicationContext.xml"}) 
public class RedissonDemoTest {
	
	@Autowired  
	private RedissonClient redisson;
    
    @Test  
    public void testRedisson(){  
    	try {
			redisson.getConfig().toJSON().toString();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    	//调用到这个语句的同时就已经对redis中的数据进行了修改。 
    	RBucket<String> bucket = RedissonService.getRBucket(redisson, "test");
    	System.out.println(bucket.get());
    	RBucket<String> bucket2 = RedissonService.getRBucket(redisson, "test2");
    	System.out.println(bucket2.get());
    	
    }
}

11.编码

redisson默认编码方式为org.redisson.codec.JsonJacksonCodec，修改默认编码方式为：

<?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:redisson="http://redisson.org/schema/redisson"
       xsi:schemaLocation="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://redisson.org/schema/redisson
       http://redisson.org/schema/redisson/redisson.xsd">

    <!-- 修改默认编码 -->  
    <bean id="StringCodec" class="org.redisson.client.codec.StringCodec"></bean>  
    <!-- 单台redis机器配置   -->
	  <!-- 单台redis机器配置   -->
    <redisson:client 
        id="redissonClient"
        codec-ref="StringCodec"  >
        <redisson:single-server 
            address="redis://127.0.0.1:6379" 
            connection-pool-size="30"/>
    </redisson:client>

     <!-- redis集群配置 -->
     <!-- <redisson:client id="redissonClient" >
     	
        <redisson:cluster-servers scan-interval="10000">   //scan-interval:集群状态扫描间隔时间，单位是毫秒
        	<redisson:node-address value="redis://192.168.2.100:7000"></redisson:node-address>
        	<redisson:node-address value="redis://192.168.2.100:7001"></redisson:node-address>
        	<redisson:node-address value="redis://192.168.2.100:7002"></redisson:node-address>
        	<redisson:node-address value="redis://192.168.2.100:7003"></redisson:node-address>
        	<redisson:node-address value="redis://192.168.2.100:7004"></redisson:node-address>
        	<redisson:node-address value="redis://192.168.2.100:7005"></redisson:node-address>
        </redisson:cluster-servers>
        
    </redisson:client> -->
</beans>