redisson使用全解——redisson官方文档+注释（上篇）
redisson使用全解——redisson官方文档+注释（中篇）
redisson使用全解——redisson官方文档+注释（下篇）

十二、独立节点模式

12.1. 概述

Redisson Node指的是Redisson在分布式运算环境中作为独立节点运行的一种模式。Redisson Node的功能可以用来执行通过分布式执行服务或分布式调度执行服务发送的远程任务，也可以用来为分布式远程服务提供远端服务。 所有这些功能全部包含在一个JAR包里，您可以从这里下载。

12.2. 配置方法

12.2.1. 配置参数

Redisson Node采用的是与Redisson框架同样的配置方法，并同时还增加了以下几个专用参数。值得注意的是ExecutorService使用的线程数量可以通过threads参数来设定。

mapReduceWorkers （MapReduce的工作者数量）
默认值：0 用来指定执行MapReduce任务的工作者的数量 0 代表当前CPU核的数量

executorServiceWorkers（执行服务的工作者数量）
默认值：null 用一个Map结构来指定某个服务的工作者数量，Map的Key是服务名称，用value指定数量。

redissonNodeInitializer（初始化监听器）
默认值：null

Redisson Node启动完成后调用的初始化监听器。

12.2.2. 通过JSON和YAML配置文件配置独立节点

以下是JSON格式的配置文件范例，该范例是在集群模式配置方法基础上，增加了Redisson Node的配置参数。

{
   "clusterServersConfig":{
      "nodeAddresses":[
         "//127.0.0.1:7004",
         "//127.0.0.1:7001",
         "//127.0.0.1:7000"
      ],
   },
   "threads":0,

   "executorServiceThreads": 0,
   "executorServiceWorkers": {"myExecutor1":3, "myExecutor2":5},
   "redissonNodeInitializer": {"class":"org.mycompany.MyRedissonNodeInitializer"}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

以下是YAML格式的配置文件范例，该范例是在集群模式配置方法基础上，增加了Redisson Node的配置参数。

---
clusterServersConfig:
  nodeAddresses:
  - "//127.0.0.1:7004"
  - "//127.0.0.1:7001"
  - "//127.0.0.1:7000"
  scanInterval: 1000
threads: 0

executorServiceThreads: 0
executorServiceWorkers:
  myService1: 123
  myService2: 421
redissonNodeInitializer: !<org.mycompany.MyRedissonNodeInitializer> {}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

12.3. 初始化监听器

Redisson Node提供了在启动完成后，执行RedissonNodeInitializer指定的初始化监听器的机制。这个机制可以用在启动完成时执行注册在类路径（classpath）中分布式远程服务的实现，或其他必要业务逻辑。比如，通知其他订阅者关于一个新节点上线的通知：

public class MyRedissonNodeInitializer implements RedissonNodeInitializer {

    @Override
    public void onStartup(RedissonNode redissonNode) {
        RMap<String, Integer> map = redissonNode.getRedisson().getMap("myMap");
        // ...
        // 或
        redisson.getRemoteService("myRemoteService").register(MyRemoteService.class, new MyRemoteServiceImpl(...));
        // 或
        reidsson.getTopic("myNotificationTopic").publish("New node has joined. id:" + redissonNode.getId() + " remote-server:" + redissonNode.getRemoteAddress());
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13

12.4. 嵌入式运行方法

Redisson Node也可以以嵌入式方式运行在其他应用当中。

// Redisson程序化配置代码
Config config = ...
// Redisson Node 程序化配置方法
RedissonNodeConfig nodeConfig = new RedissonNodeConfig(config);
Map<String, Integer> workers = new HashMap<String, Integer>();
workers.put("test", 1);
nodeConfig.setExecutorServiceWorkers(workers);

// 创建一个Redisson Node实例
RedissonNode node = RedissonNode.create(nodeConfig);
// 或者通过指定的Redisson实例创建Redisson Node实例
RedissonNode node = RedissonNode.create(nodeConfig, redisson);

node.start();

//...

node.shutdown();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

12.5. 命令行运行方法

下载Redisson Node的JAR包。
编写一个JSON或YAML格式的配置文件。
通过以下方式之一运行Redisson Node： java -jar redisson-all.jar config.json 或 java -jar redisson-all.jar config.yaml
另外不要忘记添加-Xmx或-Xms之类的参数。

12.6. Docker方式运行方法

无现有Redis环境：
首先运行Redis： docker run -d --name redis-node redis

再运行Redisson Node： docker run -d --network container:redis-node -e JAVA_OPTS=“” -v :/opt/redisson-node/redisson.conf redisson/redisson-node

- Redisson Node的JSON或YAML配置文件路径 - JAVA虚拟机的运行参数

有现有Redis环境：
运行Redisson Node： docker run -d -e JAVA_OPTS=“” -v :/opt/redisson-node/redisson.conf redisson/redisson-node

- Redisson Node的JSON或YAML配置文件路径 - JAVA虚拟机的运行参数

十三、工具

13.1. 集群管理工具

Redisson集群管理工具提供了通过程序化的方式，像redis-trib.rb脚本一样方便地管理Redis集群的工具。

13.1.1 创建集群

以下范例展示了如何创建三主三从的Redis集群。

ClusterNodes clusterNodes = ClusterNodes.create()
.master("127.0.0.1:7000").withSlaves("127.0.0.1:7001", "127.0.0.1:7002")
.master("127.0.0.1:7003").withSlaves("127.0.0.1:7004")
.master("127.0.0.1:7005");
ClusterManagementTool.createCluster(clusterNodes);
1
2
3
4
5

主节点127.0.0.1:7000的从节点有127.0.0.1:7001和127.0.0.1:7002。

主节点127.0.0.1:7003的从节点是127.0.0.1:7004。

主节点127.0.0.1:7005没有从节点。

13.1.2 踢出节点

以下范例展示了如何将一个节点踢出集群。

ClusterManagementTool.removeNode("127.0.0.1:7000", "127.0.0.1:7002");
// 或
redisson.getClusterNodesGroup().removeNode("127.0.0.1:7002");
1
2
3

将从节点127.0.0.1:7002从其主节点127.0.0.1:7000里踢出。

13.1.3 数据槽迁移

以下范例展示了如何将数据槽在集群的主节点之间迁移。

ClusterManagementTool.moveSlots("127.0.0.1:7000", "127.0.0.1:7002", 23, 419, 4712, 8490);
// 或
redisson.getClusterNodesGroup().moveSlots("127.0.0.1:7000", "127.0.0.1:7002", 23, 419, 4712, 8490);
1
2
3

将番号为23，419，4712和8490的数据槽从127.0.0.1:7002节点迁移至127.0.0.1:7000节点。

以下范例展示了如何将一个范围的数据槽在集群的主节点之间迁移。

ClusterManagementTool.moveSlotsRange("127.0.0.1:7000", "127.0.0.1:7002", 51, 9811);
// 或
redisson.getClusterNodesGroup().moveSlotsRange("127.0.0.1:7000", "127.0.0.1:7002", 51, 9811);
1
2
3

将番号范围在[51, 9811]（含）之间的数据槽从127.0.0.1:7002节点移动到127.0.0.1:7000节点。

13.1.4 添加从节点

以下范例展示了如何向集群中添加从节点。

ClusterManagementTool.addSlaveNode("127.0.0.1:7000", "127.0.0.1:7003");
// 或
redisson.getClusterNodesGroup().addSlaveNode("127.0.0.1:7003");
1
2
3

将127.0.0.1:7003作为从节点添加至127.0.0.1:7000所在的集群里。

13.2.5 添加主节点

以下范例展示了如何向集群中添加主节点。

ClusterManagementTool.addMasterNode("127.0.0.1:7000", "127.0.0.1:7004");
// 或
redisson.getClusterNodesGroup().addMasterNode("127.0.0.1:7004");
1
2
3

将127.0.0.1:7004作为主节点添加至127.0.0.1:7000所在的集群里。 Adds master node 127.0.0.1:7004 to cluster where 127.0.0.1:7000 participate in

该功能仅限于Redisson PRO版本。

十四、第三方框架整合

14.1. Spring框架整合

（1）引入pom

<!-- 以后使用Redisson作为所有分布式锁 -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.12.0</version>
</dependency>
1
2
3
4
5
6

（2）配置类

/**
* 所有对Redisson的使用都是通过RedissonClient
*/
@Bean(destroyMethod="shutdown")
public RedissonClient redisson() throws IOException {
    //1、创建单节点配置
    Config config = new Config();
    config.useSingleServer().setAddress("redis://192.168.56.10:6379");

    //2、根据Config创建出RedissonClient实例
    //Redis url should start with redis:// or rediss://
    //可以用"rediss://"来启用SSL连接
    RedissonClient redissonClient = Redisson.create(config);
    return redissonClient;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

注意：此处为单机实例，集群、哨兵等实例请查看二、配置方法
（3）使用
直接@Autoware注入RedissonClient 即可使用。

14.2. Spring Cache整合

Redisson提供了将Redis无缝整合到Spring框架的能力。Redisson依照Spring Cache标准提供了基于Redis的Spring缓存实现。 每个缓存（Cache）实例都提供了了两个重要的可配置参数：过期时间（ttl）和最长空闲时间（maxIdleTime），如果这两个参数都未指定或值为0，那么实例管理的数据将永久保存。 配置范例:

    @Configuration
    @ComponentScan
    @EnableCaching
    public static class Application {

        @Bean(destroyMethod="shutdown")
        RedissonClient redisson() throws IOException {
            Config config = new Config();
            config.useClusterServers()
                  .addNodeAddress("127.0.0.1:7004", "127.0.0.1:7001");
            return Redisson.create(config);
        }

        @Bean
        CacheManager cacheManager(RedissonClient redissonClient) {
            Map<String, CacheConfig> config = new HashMap<String, CacheConfig>();
            // 创建一个名称为"testMap"的缓存，过期时间ttl为24分钟，同时最长空闲时maxIdleTime为12分钟。
            config.put("testMap", new CacheConfig(24*60*1000, 12*60*1000));
            return new RedissonSpringCacheManager(redissonClient, config);
        }

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Spring Cache也可以通过JSON或YAML配置文件来配置：

    @Configuration
    @ComponentScan
    @EnableCaching
    public static class Application {

        @Bean(destroyMethod="shutdown")
        RedissonClient redisson(@Value("classpath:/redisson.json") Resource configFile) throws IOException {
            Config config = Config.fromJSON(configFile.getInputStream());
            return Redisson.create(config);
        }

        @Bean
        CacheManager cacheManager(RedissonClient redissonClient) throws IOException {
            return new RedissonSpringCacheManager(redissonClient, "classpath:/cache-config.json");
        }

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

14.2.1. Spring Cache - 本地缓存和数据分片

Redisson提供了几种不同的Spring Cache Manager，按功能可以分为以下两大类：

• 本地缓存（Local Cache） 类 – 本地缓存（Local Cache）也叫就近缓存（Near Cache）。这类Spring Cache的使用主要用于在特定的场景下，映射缓存（MapCache）上的高度频繁的读取操作，使网络通信都被视为瓶颈的情况。Redisson与Redis通信的同时，还将部分数据保存在本地内存里。这样的设计的好处是它能将读取速度提高最多 45倍 。

• 数据分片（Sharding） 类 – 数据分片（Sharding）类仅适用于Redis集群环境下，因此带有数据分片（Sharding）功能的Spring Cache也叫集群分布式Spring缓存。它利用分库的原理，将单一一个缓存结构切分为若干个小的缓存，并均匀的分布在集群中的各个槽里。这样的设计能使Spring缓存突破Redis自身的容量限制，让其容量随集群的扩大而增长。在扩容的同时，还能够使读写性能和元素淘汰处理能力随之成线性增长。

以下列表是Redisson提供的所有Spring Cache Manager的名称及其特性：

在初始化org.redisson.spring.cache.RedissonSpringLocalCachedCacheManager对象和org.redisson.spring.cache.RedissonSpringClusteredLocalCachedCacheManager对象的时候可以通过LocalCachedMapOptions对象来配置选项。

LocalCachedMapOptions options = LocalCachedMapOptions.defaults()
      // 淘汰机制有LFU, LRU和NONE这几种算法策略可供选择
     .evictionPolicy(EvictionPolicy.LFU)
     .cacheSize(1000)
      // 如果该值是`真(true)`时，在该实例执行更新和删除操作的同时，将向其他所有的相同实例发
      // 送针对该元素的淘汰消息。其他相同实例在收到该消息以后，会同时删除自身的缓存。下次读取
      // 该元素时会从Redis服务器获取。
     .invalidateEntryOnChange(false)
      // 每个Map本地缓存里元素的有效时间，默认毫秒为单位
     .timeToLive(10000)
      // 或者
     .timeToLive(10, TimeUnit.SECONDS)
      // 每个Map本地缓存里元素的最长闲置时间，默认毫秒为单位
     .maxIdle(10000)
      // 或者
     .maxIdle(10, TimeUnit.SECONDS);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Redisson为每个Spring缓存实例都提供了两个很重要的参数：ttl和maxIdleTime，当两个参数设为0或为指定值时，缓存数据将永久保留。

完整的使用范例如下：

    @Configuration
    @ComponentScan
    @EnableCaching
    public static class Application {

        @Bean(destroyMethod="shutdown")
        RedissonClient redisson() throws IOException {
            Config config = new Config();
            config.useClusterServers()
                  .addNodeAddress("127.0.0.1:7004", "127.0.0.1:7001");
            return Redisson.create(config);
        }

        @Bean
        CacheManager cacheManager(RedissonClient redissonClient) {
            Map<String, CacheConfig> config = new HashMap<String, CacheConfig>();

            LocalCachedMapOptions options = LocalCachedMapOptions.defaults()
                   .evictionPolicy(EvictionPolicy.LFU)
                   .cacheSize(1000);
            // 创建一个名称为"testMap"的缓存，过期时间ttl为24分钟，同时最长空闲时maxIdleTime为12分钟。
            config.put("testMap", new LocalCachedCacheConfig(24*60*1000, 12*60*1000, options));
            return new RedissonSpringLocalCachedCacheManager(redissonClient, config);
        }

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

也可以通过JSON或YAML配置文件来设置相关缓存参数：

    @Configuration
    @ComponentScan
    @EnableCaching
    public static class Application {

        @Bean(destroyMethod="shutdown")
        RedissonClient redisson(@Value("classpath:/redisson.yaml") Resource configFile) throws IOException {
            Config config = Config.fromYAML(configFile.getInputStream());
            return Redisson.create(config);
        }

        @Bean
        CacheManager cacheManager(RedissonClient redissonClient) throws IOException {
            return new RedissonSpringLocalCachedCacheManager(redissonClient, "classpath:/cache-config.yaml");
        }

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

14.2.2. Spring Cache - JSON和YAML配置文件格式：

JSON:

{
  "testMap": {
    "ttl": 1440000,
    "maxIdleTime": 720000,
    "localCacheOptions": {
      "invalidationPolicy": "ON_CHANGE",
      "evictionPolicy": "NONE",
      "cacheSize": 0,
      "timeToLiveInMillis": 0,
      "maxIdleInMillis": 0
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

YAML:

---
testMap:
  ttl: 1440000
  maxIdleTime: 720000
  localCacheOptions:
    invalidationPolicy: "ON_CHANGE"
    evictionPolicy: "NONE"
    cacheSize: 0
    timeToLiveInMillis: 0
    maxIdleInMillis: 0
1
2
3
4
5
6
7
8
9
10

以上内容是名叫testMap的Spring缓存实例的配置方式。

需要注意的是：localCacheOptions配置实例仅适用于org.redisson.spring.cache.RedissonSpringLocalCachedCacheManager类和org.redisson.spring.cache.RedissonSpringClusteredLocalCachedCacheManager类。

14.3. Hibernate整合

hibernate-redis项目实现了Redisson与Hibernate的完美整合。

14.3.1. Hibernate二级缓存 - 本地缓存和数据分片

Redisson提供了几种不同的Hibernate Cache Factory，按功能主要分为两大类：

• 本地缓存 类 – 本地缓存（Local Cache）也叫就近缓存（Near Cache）。这类Hibernate Cache的使用主要用于在特定的场景下，映射缓存（MapCache）上的高度频繁的读取操作，使网络通信都被视为瓶颈的情况。Redisson与Redis通信的同时，还将部分数据保存在本地内存里。这样的设计的好处是它能将读取速度提高最多 5倍 。

• 数据分片 类 – 数据分片（Sharding）类仅适用于Redis集群环境下，因此带有数据分片（Sharding）功能的Hibernate Cache也叫集群分布式Hibernate二级缓存。它利用分库的原理，将单一一个缓存结构切分为若干个小的缓存，并均匀的分布在集群中的各个槽里。这样的设计能使Hibernate缓存突破Redis自身的容量限制，让其容量随集群的扩大而增长。在扩容的同时，还能够使读写性能和元素淘汰处理能力随之成线性增长。

以下列表是Redisson提供的所有Hibernate Cache Factory的名称及其特性：

配置范例如下：

// 二级缓存
props.put(Environment.USE_SECOND_LEVEL_CACHE, true);
props.put(Environment.USE_QUERY_CACHE, true);
props.put(Environment.CACHE_REGION_FACTORY, org.redisson.hibernate.v52.LocalCachedRedisRegionFactory.class.getName());
props.put(Environment.CACHE_REGION_PREFIX, "hibernate");

// 为Hibernate提供Redis相关的配置
props.put(Environment.CACHE_PROVIDER_CONFIG, "hibernate-redis.properties");
1
2
3
4
5
6
7
8

hibernate-redis.properties文件范例:

hibernate-redis.properties文件

# redisson配置文件地址
redisson-config=conf/redisson.yaml

# 为缓存指定默认过期时间
redis.expiryInSeconds.default=120

# 为缓存指定默认过期策略

# 如果过期策略采用了`ON_CHANGE`、`ON_CHANGE_WITH_CLEAR_ON_RECONNECT`或是`ON_CHANGE_WITH_LOAD_ON_RECONNECT` 
# 那么在修改或删除映射元素的时候，相应的映射元素将被从所有掌握该缓存的Hibernate本地缓存实例中驱除
redis.localCache.invalidationPolicy.default=ON_CHANGE_WITH_CLEAR_ON_RECONNECT

# 如果本地缓存最大数量设定为`0`则表示默认缓存的元素数量不受限制
redis.localCache.cacheSize.default=10000

# 有`LFU`、`LRU`、`SOFT`、`WEAK`以及`NONE`这几种默认驱逐策略可供选择
redis.localCache.evictionPolicy.default=LFU

# 默认每个本地缓存中的元素过期时间
redis.localCache.timeToLiveInMillis.default=1000000

# 默认每个本地缓存中的元素最大闲置时间
redis.localCache.maxIdleInMillis.default=1000000

# 指定`player`区域的过期时间
redis.expiryInSeconds.hibernate.player=900

# `player`区域的本地缓存相关设定
redis.localCache.invalidationPolicy.hibernate.player=ON_CHANGE_WITH_CLEAR_ON_RECONNECT
redis.localCache.cacheSize.hibernate.player=10000
redis.localCache.evictionPolicy.hibernate.player=LFU
redis.localCache.timeToLiveInMillis.hibernate.player=1000000
redis.localCache.maxIdleInMillis.hibernate.player=1000000
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

需要注意的是: redis.localCache.*配置参数仅适用于ClusteredLocalCachedRedisRegionFactory类和LocalCachedRedisRegionFactory类。

14.4. Java缓存标准规范JCache API (JSR-107)

Redisson在Redis的基础上实现了Java缓存标准规范（JCache API JSR-107）

以下范例展示了使用Java缓存标准的用法。范例采用了保存在默认路径/redisson-jcache.json或/redisson-jcache.yaml下的配置文件构造实例。

MutableConfiguration<String, String> config = new MutableConfiguration<>();
        
CacheManager manager = Caching.getCachingProvider().getCacheManager();
Cache<String, String> cache = manager.createCache("namedCache", config);
1
2
3
4

也可以采用指定配置文件路径的方式构造实例：

MutableConfiguration<String, String> config = new MutableConfiguration<>();

// JSON格式的配置文件
URI redissonConfigUri = getClass().getResource("redisson-jcache.json").toURI();
// YAML格式的配置文件
URI redissonConfigUri = getClass().getResource("redisson-jcache.yaml").toURI();
CacheManager manager = Caching.getCachingProvider().getCacheManager(redissonConfigUri, null);
Cache<String, String> cache = manager.createCache("namedCache", config);
1
2
3
4
5
6
7
8

还可以通过程序化的方式来构造：

MutableConfiguration<String, String> jcacheConfig = new MutableConfiguration<>();

Config redissonCfg = ...
Configuration<String, String> config = RedissonConfiguration.fromConfig(redissonCfg, jcacheConfig);

CacheManager manager = Caching.getCachingProvider().getCacheManager();
Cache<String, String> cache = manager.createCache("namedCache", config);
1
2
3
4
5
6
7

甚至可以用Redisson实例来构造：

MutableConfiguration<String, String> jcacheConfig = new MutableConfiguration<>();

RedissonClient redisson = ...
Configuration<String, String> config = RedissonConfiguration.fromInstance(redisson, jcacheConfig);

CacheManager manager = Caching.getCachingProvider().getCacheManager();
Cache<String, String> cache = manager.createCache("namedCache", config);
1
2
3
4
5
6
7

关于配置Redisson的方式详见二、配置方法。

由Redisson提供的JCache(JSR-107)完全符合标准要求并全部通过TCK标准检测。标准检验代码在这里。

14.5. Tomcat会话管理器（Tomcat Session Manager）

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

Redisson实现的方式有别于现有的其他的Tomcat会话管理器（Tomcat Session Manager）。在每次调用HttpSession.setAttribute接口方法时，以每一条会话的字段属性（Attribute）为单位，将修改内容记录在Redis的一个Hash结构里。相比之下，其他的现有解决方案都普遍采用的是：在任何一个字段属性更改时，将整个会话序列化后保存。Redisson的实现方式产生的优势显而易见：在为Tomcat集群提供高效的非黏性会话管理的同时，避免了同一客户端的多个并发请求造成业务逻辑混乱。

使用方法：

（1）首先将RedissonSessionManager添加到相关的context.xml里：

<Manager className="org.redisson.tomcat.RedissonSessionManager"
	         configPath="${catalina.base}/redisson.conf" updateMode="DEFAULT" />
1
2

readMode - 用来设定读取会话里各个属性的方式。主要分为以下两种：

• MEMORY - 内存读取模式。直接从本地Tomcat中的会话里读取。这是默认情况。
• REDIS - Redis读取模式。绕过本地会话信息，直接从Redis里读取。

updateMode - 用来设定更新会话属性的方式。主要有以下两种：

• DEFAULT - 会话的属性只能通过setAttribute方法来储存到Redis里。这是默认请况。
• AFTER_REQUEST - 再每次请求结束以后进行一次所有属性全量写入Redis。

configPath - 是指的Redisson的JSON或YAML格式的配置文件路径。配置文件详见这里。
（2）拷贝相应的 两个 JAR包到指定的TOMCAT_BASE/lib目录下：

（3）JDK 1.8+适用

redisson-all-3.6.4.jar
Tomcat 6.x适用 redisson-tomcat-6-3.6.4.jar
Tomcat 7.x适用 redisson-tomcat-7-3.6.4.jar
Tomcat 8.x适用 redisson-tomcat-8-3.6.4.jar
Tomcat 9.x适用 redisson-tomcat-9-3.6.4.jar

（4）JDK 1.6+适用
redisson-all-2.11.4.jar

Tomcat 6.x适用 redisson-tomcat-6-2.11.4.jar
Tomcat 7.x适用 redisson-tomcat-7-2.11.4.jar
Tomcat 8.x适用 redisson-tomcat-8-2.11.4.jar

14.6. Spring会话管理器（Spring Session Manager）

Redisson提供的Spring会话管理器（Spring Session Manager）实现了跨机Web会话共享的功能。

在每次调用HttpSession.setAttribute接口方法时，以每一条会话的字段属性（Attribute）为单位，将修改内容记录在Redis的一个Hash结构里。需要注意的是Redis服务端的notify-keyspace-events参数设置中需要包含Exg这三个字符。

使用方法:

（1）首先请确保Spring Session library版本号为1.2.2+的依赖已经添加到了您的项目中:
Maven：

<!-- for Redisson 2.x -->
<dependency>
    <groupId>org.springframework.session</groupId>
    <artifactId>spring-session</artifactId>
    <version>1.3.2.RELEASE</version>
</dependency>

<!-- for Redisson 3.x -->
<dependency>
    <groupId>org.springframework.session</groupId>
    <artifactId>spring-session-core</artifactId>
    <version>2.1.2.RELEASE</version>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13

Gradle：

// for Redisson 2.x
compile 'org.springframework.session:spring-session:1.3.2.RELEASE'  

// for Redisson 3.x
compile 'org.springframework.session:spring-session-core:2.1.2.RELEASE'  
1
2
3
4
5

（2）然后将@EnableRedissonHttpSession注释和Redisson实例添加到Spring的配置里：

@EnableRedissonHttpSession 
public class Config {

   @Bean
   public RedissonClient redisson() {
       return Redisson.create();
   }
}
1
2
3
4
5
6
7
8

（3）然后提供一个启动器AbstractHttpSessionApplicationInitializer的扩展就行了：

public class Initializer extends AbstractHttpSessionApplicationInitializer { 

     public Initializer() {
             super(Config.class); 
     }
}
1
2
3
4
5
6

14.7. Spring事务管理器（Spring Transaction Manager）

Redisson为Spring事务（Spring Transaction）提供了基于org.springframework.transaction.PlatformTransactionManager 接口的功能实现。另请查阅事务（Transaction） 章节。

代码范例:

@Configuration
@EnableTransactionManagement
public class RedissonTransactionContextConfig {
    
    @Bean
    public TransactionalBean transactionBean() {
        return new TransactionalBean();
    }
    
    @Bean
    public RedissonTransactionManager transactionManager(RedissonClient redisson) {
        return new RedissonTransactionManager(redisson);
    }
    
    @Bean
    public RedissonClient redisson() {
        return BaseTest.createInstance();
    }
    
    @PreDestroy
    public void destroy() {
        redisson().shutdown();
    }
}

public class TransactionalBean {
    @Autowired
    private RedissonTransactionManager transactionManager;
    @Transactional
    public void commitData() {
        RTransaction transaction = transactionManager.getCurrentTransaction();
        RMap<String, String> map = transaction.getMap("test1");
        map.put("1", "2");
    }
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

14.8. Spring Data Redis集成

（1）添加redisson-spring-data依赖
Maven：

     <dependency>
         <groupId>org.redisson</groupId>
         <!-- for Spring Data Redis v.1.6.x -->
         <artifactId>redisson-spring-data-16</artifactId>
         <!-- for Spring Data Redis v.1.7.x -->
         <artifactId>redisson-spring-data-17</artifactId>
         <!-- for Spring Data Redis v.1.8.x -->
         <artifactId>redisson-spring-data-18</artifactId>
         <!-- for Spring Data Redis v.2.0.x -->
         <artifactId>redisson-spring-data-20</artifactId>
         <!-- for Spring Data Redis v.2.1.x -->
         <artifactId>redisson-spring-data-21</artifactId>
         <!-- for Spring Data Redis v.2.2.x -->
         <artifactId>redisson-spring-data-22</artifactId>
         <!-- for Spring Data Redis v.2.3.x -->
         <artifactId>redisson-spring-data-23</artifactId>
         <!-- for Spring Data Redis v.2.4.x -->
         <artifactId>redisson-spring-data-24</artifactId>
         <!-- for Spring Data Redis v.2.5.x -->
         <artifactId>redisson-spring-data-25</artifactId>
         <!-- for Spring Data Redis v.2.6.x -->
         <artifactId>redisson-spring-data-26</artifactId>
         <!-- for Spring Data Redis v.2.7.x -->
         <artifactId>redisson-spring-data-27</artifactId>
         <version>3.17.4</version>
     </dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

Gradle：

     // for Spring Data Redis v.1.6.x
     compile 'org.redisson:redisson-spring-data-16:3.17.4'
     // for Spring Data Redis v.1.7.x
     compile 'org.redisson:redisson-spring-data-17:3.17.4'
     // for Spring Data Redis v.1.8.x
     compile 'org.redisson:redisson-spring-data-18:3.17.4'
     // for Spring Data Redis v.2.0.x
     compile 'org.redisson:redisson-spring-data-20:3.17.4'
     // for Spring Data Redis v.2.1.x
     compile 'org.redisson:redisson-spring-data-21:3.17.4'
     // for Spring Data Redis v.2.2.x
     compile 'org.redisson:redisson-spring-data-22:3.17.4'
     // for Spring Data Redis v.2.3.x
     compile 'org.redisson:redisson-spring-data-23:3.17.4'
     // for Spring Data Redis v.2.4.x
     compile 'org.redisson:redisson-spring-data-24:3.17.4'
     // for Spring Data Redis v.2.5.x
     compile 'org.redisson:redisson-spring-data-25:3.17.4'
     // for Spring Data Redis v.2.6.x
     compile 'org.redisson:redisson-spring-data-26:3.17.4'
     // for Spring Data Redis v.2.7.x
     compile 'org.redisson:redisson-spring-data-27:3.17.4'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

（2）在spring容器中注册RedissonConnectionFactory

 @Configuration
 public class RedissonSpringDataConfig {

    @Bean
    public RedissonConnectionFactory redissonConnectionFactory(RedissonClient redisson) {
        return new RedissonConnectionFactory(redisson);
    }

    @Bean(destroyMethod = "shutdown")
    public RedissonClient redisson(@Value("classpath:/redisson.yaml") Resource configFile) throws IOException {
        Config config = Config.fromYAML(configFile.getInputStream());
        return Redisson.create(config);
    }

 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

14.9. Spring Boot Starter集成

支持Spring Boot 1.3.x - 2.7.x
（1）将redisson-spring-boot-starter依赖添加到项目中
Maven：

     <dependency>
         <groupId>org.redisson</groupId>
         <artifactId>redisson-spring-boot-starter</artifactId>
         <version>3.17.4</version>
     </dependency>
1
2
3
4
5

Gradle：

     compile 'org.redisson:redisson-spring-boot-starter:3.17.4'
1

如果需要的话，降级redisson-spring-data模块以支持所需的Spring Boot版本：

（2）添加配置文件application.settings
使用通用的springboot配置：

spring:
  redis:
    database: 
    host:
    port:
    password:
    ssl: 
    timeout:
    cluster:
      nodes:
    sentinel:
      master:
      nodes:
1
2
3
4
5
6
7
8
9
10
11
12
13

使用Redisson的配置：

spring:
  redis:
   redisson: 
      file: classpath:redisson.yaml
      config: |
        clusterServersConfig:
          idleConnectionTimeout: 10000
          connectTimeout: 10000
          timeout: 3000
          retryAttempts: 3
          retryInterval: 1500
          failedSlaveReconnectionInterval: 3000
          failedSlaveCheckInterval: 60000
          password: null
          subscriptionsPerConnection: 5
          clientName: null
          loadBalancer: !<org.redisson.connection.balancer.RoundRobinLoadBalancer> {}
          subscriptionConnectionMinimumIdleSize: 1
          subscriptionConnectionPoolSize: 50
          slaveConnectionMinimumIdleSize: 24
          slaveConnectionPoolSize: 64
          masterConnectionMinimumIdleSize: 24
          masterConnectionPoolSize: 64
          readMode: "SLAVE"
          subscriptionMode: "SLAVE"
          nodeAddresses:
          - "redis://127.0.0.1:7004"
          - "redis://127.0.0.1:7001"
          - "redis://127.0.0.1:7000"
          scanInterval: 1000
          pingConnectionInterval: 0
          keepAlive: false
          tcpNoDelay: false
        threads: 16
        nettyThreads: 32
        codec: !<org.redisson.codec.MarshallingCodec> {}
        transportMode: "NIO"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

可用的spring 的beans：
RedissonClient
RedissonRxClient
RedissonReactiveClient
RedisTemplate
ReactiveRedisTemplate

14.10. 统计与监控 (JMX和其它监控系统)

该功能仅适用于Redisson PRO版本 Redisson为各大知名监控系统提供了集成：

• groupId统一为 ‘io.micrometer’

配置方法

Config config = ... // Redisson的Config对象
DropwizardMeterRegistryProvider provider = new DropwizardMeterRegistryProvider();
provider.setSharedRegistryName("mySharedRegistry");
config.setMeterRegistryProvider(provider);
1
2
3
4

也可以在YAML格式的配置文件中添加以下配置参数：

 meterRegistryProvider: !<org.redisson.config.metrics.DropwizardMeterRegistryProvider>
   sharedRegistryName: "mySharedRegistry"
1
2

Redisson提供了以下这些性能监控指标

客户端配置相关指标

• redisson.executor-pool-size - [Gauge] 用于展示Executor线程池大小的度量值
• redisson.netty-pool-size - [Gauge] 用于展示Netty线程池大小的度量值

每个Redis节点的指标
名称前缀格式：redisson.redis.< host>:< port>

• status - [Gauge] 用于展示连接状态，连接 和 断开 状态的值分别为：[connected, disconnected]

• type - [Gauge] 用于展示节点类型，主节点 和 从节点 的状态值分别为：[MASTER, SLAVE]

• total-response-bytes - [Meter] 用于统计从该节点收到的总字节量

• response-bytes - [Histogram] 用于统计从该节点收到的字节量

• total-request-bytes - [Meter] 用于统计写入到该节点的总字节量

• request-bytes - [Histogram] 用于统计写入到该节点的字节量

• connections.active - [Counter] 用于显示客户端到该Redis节点的连接池当前 正在使用 的连接数量

• connections.free - [Counter] 用于显示客户端到该Redis节点的连接池当前 空闲 的连接数量

• connections.max-pool-size - [Counter] 用于显示客户端到该Redis节点的连接池大小

• connections.total - [Counter] 用于显示客户端到该Redis节点的连接池当前 所有 的连接数量

• operations.total - [Meter] 用于统计客户端到该Redis节点所有 已发送 的指令数量

• operations.total-failed - [Meter] 用于统计客户端到该Redis节点所有 发送失败 的指令数量

• operations.total-successful - [Meter] 用于统计客户端到该Redis节点所有 发送成功 的指令数量

• publish-subscribe-connections.active - [Counter] 用于显示客户端到该Redis节点用于订阅发布的连接池 正在使用 的连接数量

• publish-subscribe-connections.free - [Counter] 用于显示客户端到该Redis节点用于订阅发布的连接池 空闲 的连接数量

• publish-subscribe-connections.max-pool-size - [Counter] 用于显示客户端到该Redis节点用于订阅发布的连接池大小

• publish-subscribe-connections.total - [Counter] 用于显示客户端到该Redis节点用于订阅发布的连接池 所有 的连接数量

每个分布式远程服务（RRemoteService）对象的指标
名称前缀格式：redisson.remote-service.< name>

• invocations.total - [Meter] 用于统计该远程服务对象所有 已执行 的请求数量
• invocations.total-failed - [Meter] 用于统计该远程服务对象 执行失败 的请求数量
• invocations.total-successful - [Meter] 用于统计该远程服务对象 执行成功 的请求数量

每个分布式执行服务（RExecutorService）对象的指标
名称前缀格式：redisson.executor-service.< name>

• tasks.submitted - [Meter] 用于统计 已提交 的任务数量

• tasks.executed - [Meter] 用于统计 已执行 的任务数量

• workers.active - [Gauge] 用于统计 工作中 的任务线程（Workers）数量

• workers.free - [Gauge] 用于统计 空闲 的任务线程（Workers）数量

• workers.total - [Gauge] 用于统计 所有 的任务线程（Workers）数量

• workers.tasks-executed.total - [Meter] 用于统计任务线程（Workers） 已执行 的任务数量

• workers.tasks-executed.total-failed - [Meter] 用于统计任务线程（Workers） 执行失败 的任务数量

• workers.tasks-executed.total-successful - [Meter] 用于统计任务线程（Workers） 执行成功 的任务数量

每个分布式映射（RMap）对象的指标
名称前缀：redisson.map.< name>

• hits - [Meter] 用于统计 Redis命中（Redis内 有 需要的数据）的次数
• misses - [Meter] 用于统计 Redis未命中（Redis内 没有 需要的数据）的次数
• puts - [Meter] 用于统计 写入 操作次数
• removals - [Meter] 用于统计 擦除 操作次数

每个集群分布式映射缓存（RClusteredMapCache）对象的指标
名称前缀：redisson.clustered-map-cache.< name>

• hits - [Meter] 用于统计 Redis命中（Redis内 有 需要的数据）的次数
• misses - [Meter] 用于统计 Redis命中（Redis内 没有 需要的数据）的次数
• puts - [Meter] 用于统计 写入 操作次数
• removals - [Meter] 用于统计 擦除 操作次数

每个分布式本地缓存映射（RLocalCachedMap）对象的指标
名称前缀：redisson.local-cached-map.< name>

• hits - [Meter] 用于统计 Redis命中（Redis内 有 需要的数据）的次数

• misses - [Meter] 用于统计 Redis未命中（Redis内 没有 需要的数据）的次数

• puts - [Meter] 用于统计 写入 操作次数

• removals - [Meter] 用于统计 擦除 操作次数

• local-cache.hits - [Meter] 用于统计 本地命中（JVM内 有 需要的数据）的次数

• local-cache.misses - [Meter] 用于统计 本地未命中（Redis内 没有 需要的数据）的次数

• local-cache.evictions - [Meter] 用于统计 驱逐 发生次数

• local-cache.size - [Gauge] 用于统计 本地缓存 的容量大小

每个集群分布式本地缓存映射（RClusteredLocalCachedMap）对象的指标
名称前缀：redisson.clustered-local-cached-map.< name>

• hits - [Meter] 用于统计 Redis命中（Redis内 有 需要的数据）的次数

• misses - [Meter] 用于统计 Redis未命中（Redis内 没有 需要的数据）的次数

• puts - [Meter] 用于统计 写入 操作次数

• removals - [Meter] 用于统计 擦除 操作次数

• local-cache.hits - [Meter] 用于统计 本地命中（JVM内 有 需要的数据）的次数

• local-cache.misses - [Meter] 用于统计 本地未命中（Redis内 没有 需要的数据）的次数

• local-cache.evictions - [Meter] 用于统计 驱逐 发生次数

• local-cache.size - [Gauge] 用于统计 本地缓存 的容量大小

每个分布式本地缓存映射缓存（RLocalCachedMapCache）对象的指标
名称前缀：redisson.local-cached-map-cache.

• hits - [Meter] 用于统计 Redis命中（Redis内 有 需要的数据）的次数

• misses - [Meter] 用于统计 Redis未命中（Redis内 没有 需要的数据）的次数

• puts - [Meter] 用于统计 写入 操作次数

• removals - [Meter] 用于统计 擦除 操作次数

• local-cache.hits - [Meter] 用于统计 本地命中（JVM内 有 需要的数据）的次数

• local-cache.misses - [Meter] 用于统计 本地未命中（Redis内 没有 需要的数据）的次数

• local-cache.evictions - [Meter] 用于统计 驱逐 发生次数

• local-cache.size - [Gauge] 用于统计 本地缓存 的容量大小

每个集群分布式本地缓存映射缓存（RClusteredLocalCachedMapCache）对象的指标
名称前缀：redisson.clustered-local-cached-map-cache.

• hits - [Meter] 用于统计 Redis命中（Redis内 有 需要的数据）的次数

• misses - [Meter] 用于统计 Redis未命中（Redis内 没有 需要的数据）的次数

• puts - [Meter] 用于统计 写入 操作次数

• removals - [Meter] 用于统计 擦除 操作次数

• local-cache.hits - [Meter] 用于统计 本地命中（JVM内 有 需要的数据）的次数

• local-cache.misses - [Meter] 用于统计 本地未命中（Redis内 没有 需要的数据）的次数

• local-cache.evictions - [Meter] 用于统计 驱逐 发生次数

• local-cache.size - [Gauge] 用于统计 本地缓存 的容量大小

每个分布式话题（RTopic）对象的指标
名称前缀：redisson.topic.

• messages-sent - [Meter] 用于统计向该话题 发送 出的消息数量
• messages-received - [Meter] 用于统计从该话题 接收 到的消息数量

每个分布式通用对象桶（RBucket）对象的指标
名称前缀：redisson.bucket.

• gets - [Meter] 用于该统计分布式通用对象桶 读取 操作的次数
• sets - [Meter] 用于该统计分布式通用对象桶 写入 操作的次数
  该功能仅适用于Redisson PRO版本

十五、项目依赖列表

以下是所有被Redisson使用到的依赖：