Skip to content

14. 第三方框架整合

Nikita Koksharov edited this page Jan 4, 2021 · 81 revisions

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缓存实例都提供了两个很重要的参数:ttlmaxIdleTime,当两个参数设为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);
        }

    }

也可以通过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项目实现了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集群提供高效的非黏性会话管理的同时,避免了同一客户端的多个并发请求造成业务逻辑混乱。

使用方法:

  1. 首先将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格式的配置文件路径。配置文件详见这里

  1. 拷贝相应的 两个 JAR包到指定的TOMCAT_BASE/lib目录下:

  2. 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

  3. 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>

    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'  
  2. 然后将@EnableRedissonHttpSession注释和Redisson实例添加到Spring的配置里:

    @EnableRedissonHttpSession 
    public class Config {
    
       @Bean
       public RedissonClient redisson() {
           return Redisson.create();
       }
    }
  3. 然后提供一个启动器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]

  • 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.<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] 用于统计 本地缓存 的容量大小

每个分布式话题(RTopic)对象的指标

名称前缀:redisson.topic.<name>

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

每个分布式通用对象桶(RBucket)对象的指标

名称前缀:redisson.bucket.<name>

  • gets - [Meter] 用于该统计分布式通用对象桶 读取 操作的次数
  • sets - [Meter] 用于该统计分布式通用对象桶 写入 操作的次数

该功能仅适用于Redisson PRO版本

6c188ff

Clone this wiki locally