赞
踩
使用SpringBoot提供的统一缓存接口spring-boot-starter-cache, 以下的几个例子都是spring-boot-starter-cache的具体底层实现,但是不推荐使用这些,功能不灵活。只是介绍
提前准备的类
- import lombok.Builder;
- import lombok.Data;
-
- @Data
- @Builder
- public class Book {
- private Integer id;
- private String name;
- private String description;
-
- public Book(Integer id, String name, String description) {
- this.id = id;
- this.name = name;
- this.description = description;
- System.out.println("Book 创建完成"+ this.id);
- }
- }
springboot技术提供有内置的缓存解决方案,可以帮助开发者快速开启缓存技术,并使用缓存技术进行数据的快速操作
步骤①:导入springboot提供的缓存技术对应的starter
- <dependency>
- <groupId>org.springframework.boot</groupId>
- <artifactId>spring-boot-starter-cache</artifactId>
- </dependency>
步骤②:启用缓存,在引导类上方标注注解@EnableCaching配置springboot程序中可以使用缓存
- @SpringBootApplication
- //开启缓存功能
- @EnableCaching
- public class Springboot19CacheApplication {
- public static void main(String[] args) {
- SpringApplication.run(Springboot19CacheApplication.class, args);
- }
- }
步骤③:设置获得的数据是否来自于缓存
- @Service
- public class BookService {
-
- @Cacheable(value = "cache_namespace",key = "#id")
- public Book getById(Integer id) {
- return Book.builder()
- .id(id)
- .name("book_name" + id)
- .description("book_desc" + id)
- .build();
- }
- }
在业务方法上面使用注解@Cacheable声明当前方法的返回值放入缓存中,其中要指定缓存的存储位置,以及缓存中保存当前方法返回值对应的名称。上例中value属性描述缓存的存储位置,可以理解为是一个存储空间名,key属性描述了缓存中保存数据的名称,使用#id读取形参中的id值作为缓存名称。
使用@Cacheable注解后,执行当前操作,如果发现对应名称在缓存中没有数据,就正常Build数据,然后放入缓存;如果对应名称在缓存中有数据,就终止当前业务方法执行,直接返回缓存中的数据。
缺点: 无法设置过期时间等,灵活性差
步骤①:导入Ehcache的坐标
- <dependency>
- <groupId>org.springframework.boot</groupId>
- <artifactId>spring-boot-starter-cache</artifactId>
- </dependency>
- <dependency>
- <groupId>net.sf.ehcache</groupId>
- <artifactId>ehcache</artifactId>
- </dependency>
此处为什么不是导入Ehcache的starter,而是导入技术坐标呢?其实springboot整合缓存技术做的是通用格式,不管你整合哪种缓存技术,只是实现变化了,操作方式一样。
步骤②:配置缓存技术实现使用Ehcache
- spring:
- cache:
- type: ehcache
- ehcache:
- config: classpath:ehcache.xml
ehcache.xml配置如下
- <?xml version="1.0" encoding="UTF-8"?>
- <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
- updateCheck="false">
- <diskStore path="D:\ehcache" />
-
- <!--默认缓存策略 -->
- <!-- external:是否永久存在,设置为true则不会被清除,此时与timeout冲突,通常设置为false-->
- <!-- diskPersistent:是否启用磁盘持久化-->
- <!-- maxElementsInMemory:最大缓存数量-->
- <!-- overflowToDisk:超过最大缓存数量是否持久化到磁盘-->
- <!-- timeToIdleSeconds:最大不活动间隔,设置过长缓存容易溢出,设置过短无效果,可用于记录时效性数据,例如验证码-->
- <!-- timeToLiveSeconds:最大存活时间-->
- <!-- memoryStoreEvictionPolicy:缓存清除策略-->
- <defaultCache
- eternal="false"
- diskPersistent="false"
- maxElementsInMemory="1000"
- overflowToDisk="false"
- timeToIdleSeconds="60"
- timeToLiveSeconds="60"
- memoryStoreEvictionPolicy="LRU" />
-
- <cache
- name="myNameSpace"
- eternal="false"
- diskPersistent="false"
- maxElementsInMemory="1000"
- overflowToDisk="false"
- timeToIdleSeconds="10"
- timeToLiveSeconds="10"
- memoryStoreEvictionPolicy="LRU" />
- </ehcache>
注意前面的案例中,设置了数据保存的位置是myNameSpace
- @Service
- public class BookService {
-
- @Cacheable(value = "myNameSpace",key = "#id")
- public Book getById(Integer id) {
- return Book.builder()
- .id(id)
- .name("book_name" + id)
- .description("book_desc" + id)
- .build();
- }
- }
到这里springboot整合Ehcache就做完了,可以发现一点,原始代码没有任何修改,仅仅是加了一组配置就可以变更缓存供应商了,这也是springboot提供了统一的缓存操作接口的优势,变更实现并不影响原始代码的书写。
推荐使用jetcache或者Redis本身的API进行缓存操作
步骤①:导入redis的坐标
- <dependency>
- <groupId>org.springframework.boot</groupId>
- <artifactId>spring-boot-starter-cache</artifactId>
- </dependency>
- <dependency>
- <groupId>org.springframework.boot</groupId>
- <artifactId>spring-boot-starter-data-redis</artifactId>
- </dependency>
步骤②:配置缓存技术实现使用redis
- spring:
- redis:
- host: localhost
- port: 6379
- cache:
- type: redis
如果需要对redis作为缓存进行配置,注意不是对原始的redis进行配置,而是配置redis作为缓存使用相关的配置,隶属于spring.cache.redis节点下,注意不要写错位置了。
- spring:
- redis:
- host: localhost
- port: 6379
- cache:
- type: redis
- redis:
- use-key-prefix: false
- key-prefix: sms_
- cache-null-values: false
- time-to-live: 10s
目前我们已经掌握了3种缓存解决方案的配置形式,分别是springboot内置缓存,ehcache和redis,这里研究一下国内比较流行的一款缓存memcached。
提前安装,启动Memecached。
memcached目前提供有三种客户端技术,分别是Memcached Client for Java、SpyMemcached和Xmemcached,其中性能指标各方面最好的客户端是Xmemcached,本次整合就使用这个作为客户端实现技术了。下面开始使用Xmemcached
步骤①:导入xmemcached的坐标
- <dependency>
- <groupId>com.googlecode.xmemcached</groupId>
- <artifactId>xmemcached</artifactId>
- <version>2.4.7</version>
- </dependency>
步骤②:配置memcached,制作memcached的配置类
- memcached:
- servers: localhost:11211
- poolSize: 10
- opTimeout: 3000
- @Component
- @ConfigurationProperties(prefix = "memcached")
- @Data
- public class XMemcachedProperties {
- private String servers;
- private int poolSize;
- private long opTimeout;
- }
- @Configuration
- public class XMemcachedConfig {
- @Autowired
- private XMemcachedProperties props;
- @Bean
- public MemcachedClient getMemcachedClient() throws IOException {
- MemcachedClientBuilder memcachedClientBuilder = new XMemcachedClientBuilder(props.getServers());
- memcachedClientBuilder.setConnectionPoolSize(props.getPoolSize());
- memcachedClientBuilder.setOpTimeout(props.getOpTimeout());
- MemcachedClient memcachedClient = memcachedClientBuilder.build();
- return memcachedClient;
- }
- }
步骤③:使用xmemcached客户端操作缓存,注入MemcachedClient对象
- @Service
- public class SMSCodeServiceImpl implements SMSCodeService {
- @Autowired
- private CodeUtils codeUtils;
- @Autowired
- private MemcachedClient memcachedClient;
-
- public String sendCodeToSMS(String tele) {
- String code = codeUtils.generator(tele);
- try {
- memcachedClient.set(tele,10,code);
- } catch (Exception e) {
- e.printStackTrace();
- }
- return code;
- }
-
- public boolean checkCode(SMSCode smsCode) {
- String code = null;
- try {
- code = memcachedClient.get(smsCode.getTele()).toString();
- } catch (Exception e) {
- e.printStackTrace();
- }
- return smsCode.getCode().equals(code);
- }
- }
目前我们使用的缓存都是要么A要么B, springboot针对缓存的整合仅仅停留在用缓存上面,如果缓存自身不支持同时支持AB一起用,springboot也没办法,所以要想解决AB缓存一起用的问题,就必须找一款缓存能够支持AB两种缓存一起用,有这种缓存吗?还真有,阿里出品,jetcache。
jetcache并不是随便拿两个缓存都能拼到一起去的。目前jetcache支持的缓存方案本地缓存支持两种,远程缓存支持两种,分别如下:
本地缓存(Local)
LinkedHashMap
Caffeine
远程缓存(Remote)
Redis
Tair
纯远程方案
步骤①:导入springboot整合jetcache对应的坐标starter,当前坐标默认使用的远程方案是redis
- <dependency>
- <groupId>com.alicp.jetcache</groupId>
- <artifactId>jetcache-starter-redis</artifactId>
- <version>2.6.2</version>
- </dependency>
步骤②:远程方案基本配置
- jetcache:
- remote:
- default:
- type: redis
- host: localhost
- port: 6379
- poolConfig:
- maxTotal: 50
其中poolConfig是必配项,否则会报错
步骤③:启用缓存,在引导类上方标注注解@EnableCreateCacheAnnotation配置springboot程序中可以使用注解的形式创建缓存
- @SpringBootApplication
- //jetcache启用缓存的主开关
- @EnableCreateCacheAnnotation
- public class Springboot20JetCacheApplication {
- public static void main(String[] args) {
- SpringApplication.run(Springboot20JetCacheApplication.class, args);
- }
- }
步骤④:创建缓存对象Cache,并使用注解@CreateCache标记当前缓存的信息,然后使用Cache对象的API操作缓存,put写缓存,get读缓存。
- @Service
- public class SMSCodeServiceImpl implements SMSCodeService {
- @Autowired
- private CodeUtils codeUtils;
-
- @CreateCache(name="jetCache_",expire = 10,timeUnit = TimeUnit.SECONDS)
- private Cache<String ,String> jetCache;
-
- public String sendCodeToSMS(String tele) {
- String code = codeUtils.generator(tele);
- jetCache.put(tele,code);
- return code;
- }
-
- public boolean checkCode(SMSCode smsCode) {
- String code = jetCache.get(smsCode.getTele());
- return smsCode.getCode().equals(code);
- }
- }
纯本地方案
远程方案中,配置中使用remote表示远程,换成local就是本地,只不过类型不一样而已。
步骤①:导入springboot整合jetcache对应的坐标starter
- <dependency>
- <groupId>com.alicp.jetcache</groupId>
- <artifactId>jetcache-starter-redis</artifactId>
- <version>2.6.2</version>
- </dependency>
步骤②:本地缓存基本配置
- jetcache:
- local:
- default:
- type: linkedhashmap
- keyConvertor: fastjson
为了加速数据获取时key的匹配速度,jetcache要求指定key的类型转换器。简单说就是,如果你给了一个Object作为key的话,我先用key的类型转换器给转换成字符串,然后再保存。等到获取数据时,仍然是先使用给定的Object转换成字符串,然后根据字符串匹配。由于jetcache是阿里的技术,这里推荐key的类型转换器使用阿里的fastjson。
步骤③:启用缓存
- @SpringBootApplication
- //jetcache启用缓存的主开关
- @EnableCreateCacheAnnotation
- public class Springboot20JetCacheApplication {
- public static void main(String[] args) {
- SpringApplication.run(Springboot20JetCacheApplication.class, args);
- }
- }
步骤④:创建缓存对象Cache时,标注当前使用本地缓存
- @Service
- public class SMSCodeServiceImpl implements SMSCodeService {
- @CreateCache(name="jetCache_",expire = 1000,timeUnit = TimeUnit.SECONDS,cacheType = CacheType.LOCAL)
- private Cache<String ,String> jetCache;
-
- public String sendCodeToSMS(String tele) {
- String code = codeUtils.generator(tele);
- jetCache.put(tele,code);
- return code;
- }
-
- public boolean checkCode(SMSCode smsCode) {
- String code = jetCache.get(smsCode.getTele());
- return smsCode.getCode().equals(code);
- }
- }
cacheType控制当前缓存使用本地缓存还是远程缓存,配置cacheType=CacheType.LOCAL即使用本地缓存。
本地+远程方案
本地和远程方法都有了,两种方案一起使用如何配置呢?其实就是将两种配置合并到一起就可以了。
- jetcache:
- local:
- default:
- type: linkedhashmap
- keyConvertor: fastjson
- remote:
- default:
- type: redis
- host: localhost
- port: 6379
- poolConfig:
- maxTotal: 50
- sms:
- type: redis
- host: localhost
- port: 6379
- poolConfig:
- maxTotal: 50
在创建缓存的时候,配置cacheType为BOTH即则同时到本地缓存与远程缓存。
- @Service
- public class SMSCodeServiceImpl implements SMSCodeService {
- @CreateCache(name="jetCache_",expire = 1000,timeUnit = TimeUnit.SECONDS,cacheType = CacheType.BOTH)
- private Cache<String ,String> jetCache;
- }
cacheType如果不进行配置,默认值是REMOTE,即仅使用远程缓存方案。关于jetcache的配置,参考以下信息
属性 | 默认值 | 说明 |
---|---|---|
jetcache.statIntervalMinutes | 0 | 统计间隔,0表示不统计 |
jetcache.hiddenPackages | 无 | 自动生成name时,隐藏指定的包名前缀 |
jetcache.[local|remote].${area}.type | 无 | 缓存类型,本地支持linkedhashmap、caffeine,远程支持redis、tair |
jetcache.[local|remote].${area}.keyConvertor | 无 | key转换器,当前仅支持fastjson |
jetcache.[local|remote].${area}.valueEncoder | java | 仅remote类型的缓存需要指定,可选java和kryo |
jetcache.[local|remote].${area}.valueDecoder | java | 仅remote类型的缓存需要指定,可选java和kryo |
jetcache.[local|remote].${area}.limit | 100 | 仅local类型的缓存需要指定,缓存实例最大元素数 |
jetcache.[local|remote].${area}.expireAfterWriteInMillis | 无穷大 | 默认过期时间,毫秒单位 |
jetcache.local.${area}.expireAfterAccessInMillis | 0 | 仅local类型的缓存有效,毫秒单位,最大不活动间隔 |
jetcache提供了方法缓存方案,只不过名称变更了而已。在对应的操作接口上方使用注解@Cached即可
步骤①:导入springboot整合jetcache对应的坐标starte
- <dependency>
- <groupId>com.alicp.jetcache</groupId>
- <artifactId>jetcache-starter-redis</artifactId>
- <version>2.6.2</version>
- </dependency>
步骤②:配置缓存
jetcache: local: default: type: linkedhashmap keyConvertor: fastjson remote: default: type: redis host: localhost port: 6379 keyConvertor: fastjson valueEncode: java valueDecode: java poolConfig: maxTotal: 50 sms: type: redis host: localhost port: 6379 poolConfig: maxTotal: 50
由于redis缓存中不支持保存对象,因此需要对redis设置当Object类型数据进入到redis中时如何进行类型转换。需要配置keyConvertor表示key的类型转换方式,同时标注value的转换类型方式,值进入redis时是java类型,标注valueEncode为java,值从redis中读取时转换成java,标注valueDecode为java。
注意,为了实现Object类型的值进出redis,需要保障进出redis的Object类型的数据必须实现序列化接口。
- @Data
- public class Book implements Serializable {
- private Integer id;
- private String type;
- private String name;
- private String description;
- }
步骤③:启用缓存时开启方法缓存功能,并配置basePackages,说明在哪些包中开启方法缓存
- @SpringBootApplication
- //jetcache启用缓存的主开关
- @EnableCreateCacheAnnotation
- //开启方法注解缓存
- @EnableMethodCache(basePackages = "com.itheima")
- public class Springboot20JetCacheApplication {
- public static void main(String[] args) {
- SpringApplication.run(Springboot20JetCacheApplication.class, args);
- }
- }
步骤④:使用注解@Cached标注当前方法使用缓存
- @Service
- public class BookServiceImpl implements BookService {
- @Autowired
- private BookDao bookDao;
-
- @Override
- @Cached(name="book_",key="#id",expire = 3600,cacheType = CacheType.REMOTE)
- public Book getById(Integer id) {
- return bookDao.selectById(id);
- }
- }
远程方案的数据同步
由于远程方案中redis保存的数据可以被多个客户端共享,这就存在了数据同步问题。jetcache提供了3个注解解决此问题,分别在更新、删除操作时同步缓存数据,和读取缓存时定时刷新数据
更新缓存
- @CacheUpdate(name="book_",key="#book.id",value="#book")
- public boolean update(Book book) {
- return bookDao.updateById(book) > 0;
- }
删除缓存
- @CacheInvalidate(name="book_",key = "#id")
- public boolean delete(Integer id) {
- return bookDao.deleteById(id) > 0;
- }
定时刷新缓存
refresh如果时间太短,会对数据库性能有很大影响
- @Cached(name="book_",key="#id",expire = 3600,cacheType = CacheType.REMOTE)
- @CacheRefresh(refresh = 5)
- public Book getById(Integer id) {
- return bookDao.selectById(id);
- }
数据报表
jetcache还提供有简单的数据报表功能,帮助开发者快速查看缓存命中信息,只需要添加一个配置即可
- jetcache:
- statIntervalMinutes: 1
设置后,每1分钟在控制台输出缓存数据命中信息
- [DefaultExecutor] c.alicp.jetcache.support.StatInfoLogger : jetcache stat from 2022-02-28 09:32:15,892 to 2022-02-28 09:33:00,003
- cache | qps| rate| get| hit| fail| expire| avgLoadTime| maxLoadTime
- ---------+-------+-------+------+-------+-------+---------+--------------+--------------
- book_ | 0.66| 75.86%| 29| 22| 0| 0| 28.0| 188
- ---------+-------+-------+------+-------+-------+---------+--------------+--------------
总结
jetcache是一个类似于springcache的缓存解决方案,自身不具有缓存功能,它提供有本地缓存与远程缓存多级共同使用的缓存解决方案
jetcache提供的缓存解决方案受限于目前支持的方案,本地缓存支持两种,远程缓存支持两种
注意数据进入远程缓存时的类型转换问题
jetcache提供方法缓存,并提供了对应的缓存更新与刷新功能
jetcache提供有简单的缓存信息命中报表方便开发者即时监控缓存数据命中情况
jetcache可以在限定范围内构建多级缓存,但是灵活性不足,不能随意搭配缓存,本节介绍一种可以随意搭配缓存解决方案的缓存整合框架,j2cache。下面就来讲解如何使用这种缓存框架,以Ehcache与redis整合为例:
步骤①:导入j2cache、redis、ehcache坐标
- <dependency>
- <groupId>net.oschina.j2cache</groupId>
- <artifactId>j2cache-core</artifactId>
- <version>2.8.4-release</version>
- </dependency>
- <dependency>
- <groupId>net.oschina.j2cache</groupId>
- <artifactId>j2cache-spring-boot2-starter</artifactId>
- <version>2.8.0-release</version>
- </dependency>
- <dependency>
- <groupId>net.sf.ehcache</groupId>
- <artifactId>ehcache</artifactId>
- </dependency>
j2cache的starter中默认包含了redis坐标,官方推荐使用redis作为二级缓存,因此此处无需导入redis坐标
步骤②:配置一级与二级缓存,并配置一二级缓存间数据传递方式,配置书写在名称为j2cache.properties的文件中。如果使用ehcache还需要单独添加ehcache的配置文件
- # 1级缓存
- j2cache.L1.provider_class = ehcache
- ehcache.configXml = ehcache.xml
-
- # 2级缓存
- j2cache.L2.provider_class = net.oschina.j2cache.cache.support.redis.SpringRedisProvider
- j2cache.L2.config_section = redis
- redis.hosts = localhost:6379
-
- # 1级缓存中的数据如何到达二级缓存
- j2cache.broadcast = net.oschina.j2cache.cache.support.redis.SpringRedisPubSubPolicy
此处配置不能乱配置,需要参照官方给出的配置说明进行。例如1级供应商选择ehcache,供应商名称仅仅是一个ehcache,但是2级供应商选择redis时要写专用的Spring整合Redis的供应商类名SpringRedisProvider,而且这个名称并不是所有的redis包中能提供的,也不是spring包中提供的。因此配置j2cache必须参照官方文档配置,而且还要去找专用的整合包,导入对应坐标才可以使用。
一级与二级缓存最重要的一个配置就是两者之间的数据沟通方式,此类配置也不是随意配置的,并且不同的缓存解决方案提供的数据沟通方式差异化很大,需要查询官方文档进行设置。
步骤③:使用缓存
- @Service
- public class SMSCodeServiceImpl implements SMSCodeService {
- @Autowired
- private CodeUtils codeUtils;
-
- @Autowired
- private CacheChannel cacheChannel;
-
- public String sendCodeToSMS(String tele) {
- String code = codeUtils.generator(tele);
- cacheChannel.set("sms",tele,code);
- return code;
- }
-
- public boolean checkCode(SMSCode smsCode) {
- String code = cacheChannel.get("sms",smsCode.getTele()).asString();
- return smsCode.getCode().equals(code);
- }
- }
j2cache的使用和jetcache比较类似,但是无需开启使用的开关,直接定义缓存对象即可使用,缓存对象名CacheChannel。
j2cache的使用不复杂,配置是j2cache的核心,毕竟是一个整合型的缓存框架。缓存相关的配置过多,可以查阅j2cache-core核心包中的j2cache.properties文件中的说明。如下:
- #J2Cache configuration
- #########################################
- # Cache Broadcast Method
- # values:
- # jgroups -> use jgroups's multicast
- # redis -> use redis publish/subscribe mechanism (using jedis)
- # lettuce -> use redis publish/subscribe mechanism (using lettuce, Recommend)
- # rabbitmq -> use RabbitMQ publisher/consumer mechanism
- # rocketmq -> use RocketMQ publisher/consumer mechanism
- # none -> don't notify the other nodes in cluster
- # xx.xxxx.xxxx.Xxxxx your own cache broadcast policy classname that implement net.oschina.j2cache.cluster.ClusterPolicy
- #########################################
- j2cache.broadcast = redis
-
- # jgroups properties
- jgroups.channel.name = j2cache
- jgroups.configXml = /network.xml
-
- # RabbitMQ properties
- rabbitmq.exchange = j2cache
- rabbitmq.host = localhost
- rabbitmq.port = 5672
- rabbitmq.username = guest
- rabbitmq.password = guest
-
- # RocketMQ properties
- rocketmq.name = j2cache
- rocketmq.topic = j2cache
- # use ; to split multi hosts
- rocketmq.hosts = 127.0.0.1:9876
-
- #########################################
- # Level 1&2 provider
- # values:
- # none -> disable this level cache
- # ehcache -> use ehcache2 as level 1 cache
- # ehcache3 -> use ehcache3 as level 1 cache
- # caffeine -> use caffeine as level 1 cache(only in memory)
- # redis -> use redis as level 2 cache (using jedis)
- # lettuce -> use redis as level 2 cache (using lettuce)
- # readonly-redis -> use redis as level 2 cache ,but never write data to it. if use this provider, you must uncomment `j2cache.L2.config_section` to make the redis configurations available.
- # memcached -> use memcached as level 2 cache (xmemcached),
- # [classname] -> use custom provider
- #########################################
-
- j2cache.L1.provider_class = caffeine
- j2cache.L2.provider_class = redis
-
- # When L2 provider isn't `redis`, using `L2.config_section = redis` to read redis configurations
- # j2cache.L2.config_section = redis
- # Enable/Disable ttl in redis cache data (if disabled, the object in redis will never expire, default:true)
- # NOTICE: redis hash mode (redis.storage = hash) do not support this feature)
- j2cache.sync_ttl_to_redis = true
- # Whether to cache null objects by default (default false)
- j2cache.default_cache_null_object = true
- #########################################
- # Cache Serialization Provider
- # values:
- # fst -> using fast-serialization (recommend)
- # kryo -> using kryo serialization
- # json -> using fst's json serialization (testing)
- # fastjson -> using fastjson serialization (embed non-static class not support)
- # java -> java standard
- # fse -> using fse serialization
- # [classname implements Serializer]
- #########################################
-
- j2cache.serialization = json
- #json.map.person = net.oschina.j2cache.demo.Person
-
- #########################################
- # Ehcache configuration
- #########################################
-
- # ehcache.configXml = /ehcache.xml
-
- # ehcache3.configXml = /ehcache3.xml
- # ehcache3.defaultHeapSize = 1000
-
- #########################################
- # Caffeine configuration
- # caffeine.region.[name] = size, xxxx[s|m|h|d]
- #
- #########################################
- caffeine.properties = /caffeine.properties
-
- #########################################
- # Redis connection configuration
- #########################################
-
- #########################################
- # Redis Cluster Mode
- #
- # single -> single redis server
- # sentinel -> master-slaves servers
- # cluster -> cluster servers (数据库配置无效,使用 database = 0)
- # sharded -> sharded servers (密码、数据库必须在 hosts 中指定,且连接池配置无效 ; redis://user:password@127.0.0.1:6379/0)
- #
- #########################################
- redis.mode = single
- #redis storage mode (generic|hash)
- redis.storage = generic
-
- ## redis pub/sub channel name
- redis.channel = j2cache
- ## redis pub/sub server (using redis.hosts when empty)
- redis.channel.host =
-
- #cluster name just for sharded
- redis.cluster_name = j2cache
-
- ## redis cache namespace optional, default[empty]
- redis.namespace =
-
- ## redis command scan parameter count, default[1000]
- #redis.scanCount = 1000
-
- ## connection
- # Separate multiple redis nodes with commas, such as 192.168.0.10:6379,192.168.0.11:6379,192.168.0.12:6379
-
- redis.hosts = 127.0.0.1:6379
- redis.timeout = 2000
- redis.password =
- redis.database = 0
- redis.ssl = false
-
- ## redis pool properties
- redis.maxTotal = 100
- redis.maxIdle = 10
- redis.maxWaitMillis = 5000
- redis.minEvictableIdleTimeMillis = 60000
- redis.minIdle = 1
- redis.numTestsPerEvictionRun = 10
- redis.lifo = false
- redis.softMinEvictableIdleTimeMillis = 10
- redis.testOnBorrow = true
- redis.testOnReturn = false
- redis.testWhileIdle = true
- redis.timeBetweenEvictionRunsMillis = 300000
- redis.blockWhenExhausted = false
- redis.jmxEnabled = false
-
- #########################################
- # Lettuce scheme
- #
- # redis -> single redis server
- # rediss -> single redis server with ssl
- # redis-sentinel -> redis sentinel
- # redis-cluster -> cluster servers
- #
- #########################################
-
- #########################################
- # Lettuce Mode
- #
- # single -> single redis server
- # sentinel -> master-slaves servers
- # cluster -> cluster servers (数据库配置无效,使用 database = 0)
- # sharded -> sharded servers (密码、数据库必须在 hosts 中指定,且连接池配置无效 ; redis://user:password@127.0.0.1:6379/0)
- #
- #########################################
- ## redis command scan parameter count, default[1000]
- #lettuce.scanCount = 1000
- lettuce.mode = single
- lettuce.namespace =
- lettuce.storage = hash
- lettuce.channel = j2cache
- lettuce.scheme = redis
- lettuce.hosts = 127.0.0.1:6379
- lettuce.password =
- lettuce.database = 0
- lettuce.sentinelMasterId =
- lettuce.maxTotal = 100
- lettuce.maxIdle = 10
- lettuce.minIdle = 10
- # timeout in milliseconds
- lettuce.timeout = 10000
- # redis cluster topology refresh interval in milliseconds
- lettuce.clusterTopologyRefresh = 3000
- #########################################
- # memcached server configurations
- # refer to https://gitee.com/mirrors/XMemcached
- #########################################
- memcached.servers = 127.0.0.1:11211
- memcached.username =
- memcached.password =
- memcached.connectionPoolSize = 10
- memcached.connectTimeout = 1000
- memcached.failureMode = false
- memcached.healSessionInterval = 1000
- memcached.maxQueuedNoReplyOperations = 100
- memcached.opTimeout = 100
- memcached.sanitizeKeys = false
总结
j2cache是一个缓存框架,自身不具有缓存功能,它提供多种缓存整合在一起使用的方案
j2cache需要通过复杂的配置设置各级缓存,以及缓存之间数据交换的方式
j2cache操作接口通过CacheChannel实现
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。