redission续锁逻辑 redission续期

转载

梦里忧郁 2024-03-11 23:44:37

文章标签 redission续锁逻辑 redission redis 缓存本地缓存 文章分类 Redis 数据库

Redission - 第三方框架整合

14.2.1. Spring Cache - 本地缓存和数据分片
14.2.2. Spring Cache - JSON和YAML配置文件格式：
14.3. Hibernate整合

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

hibernate-redis.properties文件范例:

14.4. Java缓存标准规范JCache API (JSR-107)
14.5. Tomcat会话管理器（Tomcat Session Manager）
14.6. Spring会话管理器（Spring Session Manager）
14.7. Spring事务管理器（Spring Transaction Manager）
14.8. Spring Data Redis集成
14.9. Spring Boot Starter集成
14.10. 统计与监控 (JMX和其它监控系统)

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

客户端配置相关指标
每个Redis节点的指标
每个分布式远程服务（RRemoteService）对象的指标
每个分布式执行服务（RExecutorService）对象的指标
每个分布式映射（RMap）对象的指标
每个分布式映射缓存（RMapCache）对象的指标
每个集群分布式映射缓存（RClusteredMapCache）对象的指标
每个分布式本地缓存映射（RLocalCachedMap）对象的指标
每个集群分布式本地缓存映射（RClusteredLocalCachedMap）对象的指标
每个分布式本地缓存映射缓存（RLocalCachedMapCache）对象的指标
每个集群分布式本地缓存映射缓存（RClusteredLocalCachedMapCache）对象的指标
每个分布式话题（RTopic）对象的指标
每个分布式通用对象桶（RBucket）对象的指标

14.1. Spring框架整合

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);
        }

    }

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");
        }

    }

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的名称及其特性：

类名	本地缓存功能 Local Cache	数据分片功能Sharding
RedissonSpringCacheManager	No	No
RedissonClusteredSpringLocalCachedCacheManager 仅限于Redisson PRO版本	Yes	No
RedissonClusteredSpringCacheManager 仅限于Redisson PRO版本	No	Yes
RedissonSpringClusteredLocalCachedCacheManager 仅限于Redisson PRO版本	Yes	Yes

在初始化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);
     ```
Redisson为每个Spring缓存实例都提供了两个很重要的参数：`ttl`和`maxIdleTime`，当两个参数设为0或为指定值时，缓存数据将永久保留。

完整的使用范例如下：
```java
    @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);
        }

    }

也可以通过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");
        }

    }

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
    }
  }
}

YAML:

---
testMap:
  ttl: 1440000
  maxIdleTime: 720000
  localCacheOptions:
    invalidationPolicy: "ON_CHANGE"
    evictionPolicy: "NONE"
    cacheSize: 0
    timeToLiveInMillis: 0
    maxIdleInMillis: 0

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

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

14.3. Hibernate整合

hibernate-redis(https://github.com/debop/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的名称及其特性：

类名	本地缓存功能Local Cache	数据分片功能Sharding
SingletonRedisRegionFactory	No	No
LocalCachedRedisRegionFactory仅限于Redisson PRO版本	Yes	No
ClusteredRedisRegionFactory 仅限于Redisson PRO版本	No	Yes
ClusteredLocalCachedRedisRegionFactory仅限于Redisson PRO版本	Yes	Yes

配置范例如下：

// 二级缓存
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");

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

需要注意的是: 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);

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

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);

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

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);

甚至可以用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);

关于配置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集群提供高效的非黏性会话管理的同时，避免了同一客户端的多个并发请求造成业务逻辑混乱。

使用方法：

首先将RedissonSessionManager添加到相关的context.xml（求中文文档连接）里：

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

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

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

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

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

configPath - 是指的Redisson的JSON或YAML格式的配置文件路径。配置文件详见这里。

拷贝相应的两个 JAR包到指定的TOMCAT_BASE/lib目录下：
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

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这三个字符。

使用方法:

首先请确保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>

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'

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

@EnableRedissonHttpSession 
public class Config {

   @Bean
   public RedissonClient redisson() {
       return Redisson.create();
   }
}

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

public class Initializer extends AbstractHttpSessionApplicationInitializer { 

     public Initializer() {
             super(Config.class); 
     }
}

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");
    }
 }

14.8. Spring Data Redis集成

本章节相关信息请查阅此处。

14.9. Spring Boot Starter集成

本章节相关信息请查阅此处。

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

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

监控系统	适配类从属于’org.redisson.config.metrics’包	参数	依赖包的artifactId *
AppOptics	AppOpticsMeterRegistryProvider	uri, hostTag, apiToken	micrometer-registry-appoptics
Atlas	AtlasMeterRegistryProvider	uri, configUri, evalUri	micrometer-registry-atlas
Azure	AzureMonitorMeterRegistryProvider	instrumentationKey	micrometer-registry-azure-monitor
CloudWatch	CloudWatchMeterRegistryProvider	accessKey, secretKey, namespace	micrometer-registry-cloudwatch
Datadog	DatadogMeterRegistryProvider	uri, hostTag, apiKey	micrometer-registry-datadog
Dropwizard	DropwizardMeterRegistryProvider	sharedRegistryName	-
Dynatrace	DynatraceMeterRegistryProvider	apiToken, uri, deviceId	micrometer-registry-dynatrace
Elastic	ElasticMeterRegistryProvider	host, userName, password	micrometer-registry-elastic
Ganglia	GangliaMeterRegistryProvider	host, port	micrometer-registry-ganglia
Graphite	GraphiteMeterRegistryProvider	host, port	micrometer-registry-graphite
Humio	HumioMeterRegistryProvider	uri, repository, apiToken	micrometer-registry-humio
Influx	InfluxMeterRegistryProvider	uri, db, userName, password	micrometer-registry-influx
JMX	JmxMeterRegistryProvider	domain, sharedRegistryName	micrometer-registry-jmx
Kairos	KairosMeterRegistryProvider	uri, userName, password	micrometer-registry-kairos
NewRelic	NewRelicMeterRegistryProvider	uri, apiKey, accountId	micrometer-registry-new-relic
Prometheus	PrometheusMeterRegistryProvider	-	micrometer-registry-prometheus
SingnalFx	SingnalFxMeterRegistryProvider	accessToken, apiHost, source	micrometer-registry-signalfx
Stackdriver	StackdriverMeterRegistryProvider	projectId	micrometer-registry-stackdriver
Statsd	StatsdMeterRegistryProvider	flavor, host, port	micrometer-registry-statsd
Wavefront	WavefrontMeterRegistryProvider	uri, source, apiToken	micrometer-registry-wavefront

groupId统一为 ‘io.micrometer’

配置方法

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

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

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

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]

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] 用于统计擦除操作次数

每个分布式映射缓存（RMapCache）对象的指标

名称前缀：redisson.map-cache.<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.<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] 用于统计本地缓存的容量大小

每个集群分布式本地缓存映射缓存（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版本

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：ugreen串行链路测试仪PL2303 链路连通性检测

下一篇：android开发 app进行系统级签名 android 系统签名作用

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯