Redission - 第三方框架整合（14）

沐淼

已于 2022-04-07 18:29:12 修改

阅读量953

点赞数

分类专栏： redis 文章标签： redission redis

于 2022-04-04 20:49:04 首次发布

原文链接：https://github.com/redisson/redisson/wiki/14.-第三方框架整合#1431-hibernate二级缓存---本地缓存和数据分片

版权

redis 专栏收录该内容

9 篇文章 1 订阅

订阅专栏

Redission - 第三方框架整合

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版本

沐淼

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Redission - 第三方框架整合（14）

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

扫一扫

专栏目录