多级缓存架构开发 六 ( 测试开发的框架 )

最新推荐文章于 2023-10-28 09:21:14 发布
最新推荐文章于 2023-10-28 09:21:14 发布
阅读量278 收藏 1
点赞数
分类专栏： 缓存 文章标签： serializer

0.导入pom文件

  父级模块的pom文件添加

 <dependencyManagement>
        <dependencies>

            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <version>${spring.boot.version}</version>
                <scope>test</scope>
            </dependency>

        </dependencies>
    </dependencyManagement>

子级模块的pom文件添加

 <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

    </dependencies>

 

1.注册RedisTemplate客户端

         1.1)配置文件

spring.redis.pool.max-idle=200
spring.redis.pool.min-idle=10
spring.redis.pool.max-active=80
spring.redis.pool.max-wait=-1

spring.redis.database=0
#server host
spring.redis.host=127.0.0.1
#server password
spring.redis.password=
#connection port
spring.redis.port=6379

    1.2) 把redisTemplate客户端交给spring容器管理

package org.github.roger.cache.config;

import io.lettuce.core.resource.ClientResources;
import io.lettuce.core.resource.DefaultClientResources;
import org.github.roger.serializer.FastJsonRedisSerializer;
import org.github.roger.serializer.KryoRedisSerializer;
import org.github.roger.serializer.StringRedisSerializer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration.LettuceClientConfigurationBuilder;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;

@Configuration
@PropertySource({"classpath:application.properties"})
public class RedisConfig {

    @Value("${spring.redis.database:0}")
    private int database;

    @Value("${spring.redis.host:127.0.0.1}")
    private String host;

    @Value("${spring.redis.password:}")
    private String password;

    @Value("${spring.redis.port:6379}")
    private int port;

    @Value("${spring.redis.pool.max-idle:200}")
    private int maxIdle;

    @Value("${spring.redis.pool.min-idle:10}")
    private int minIdle;

    @Value("${spring.redis.pool.max-active:80}")
    private int maxActive;

    @Value("${spring.redis.pool.max-wait:-1}")
    private int maxWait;


//    @Bean
//    public JedisConnectionFactory redisConnectionFactory() {
//        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
//        jedisPoolConfig.setMinIdle(minIdle);
//        jedisPoolConfig.setMaxIdle(maxIdle);
//        jedisPoolConfig.setMaxTotal(maxActive);
//        jedisPoolConfig.setMaxWaitMillis(maxWait);
//
//        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(jedisPoolConfig);
//        jedisConnectionFactory.setDatabase(database);
//        jedisConnectionFactory.setHostName(host);
//        jedisConnectionFactory.setPassword(password);
//        jedisConnectionFactory.setPort(port);
//        jedisConnectionFactory.setUsePool(true);
//        return jedisConnectionFactory;
//    }

    @Bean
    public LettuceConnectionFactory redisConnectionFactory() {
        ClientResources clientResources = DefaultClientResources.create();
        LettuceClientConfigurationBuilder builder = LettuceClientConfiguration.builder();
        builder.clientResources(clientResources);
        LettuceClientConfiguration configuration = builder.build();

        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
        config.setHostName(host);
        config.setPort(port);
        config.setPassword(RedisPassword.of(password));
        config.setDatabase(database);
        return new LettuceConnectionFactory(config, configuration);
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        FastJsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJsonRedisSerializer<Object>(Object.class, "com.xxx.");
        KryoRedisSerializer<Object> kryoRedisSerializer = new KryoRedisSerializer<Object>(Object.class);

        // 设置值（value）的序列化采用FastJsonRedisSerializer。
        redisTemplate.setValueSerializer(kryoRedisSerializer);
        redisTemplate.setHashValueSerializer(kryoRedisSerializer);
        // 设置键（key）的序列化采用StringRedisSerializer。
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

2.利用1注册的RedisTemplate客户端构造多级缓存管理器，并交给Spring容器管理

package org.github.roger.cache.config;

import org.github.roger.MultiLayeringCacheManager;
import org.github.roger.manager.ICacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.redis.core.RedisTemplate;

@Configuration
@Import({RedisConfig.class})
public class ICacheManagerConfig {


    @Bean
    public ICacheManager cacheManager(RedisTemplate<String, Object> redisTemplate) {
        MultiLayeringCacheManager layeringCacheManager = new MultiLayeringCacheManager(redisTemplate);

        return layeringCacheManager;
    }
}

3.创建多级缓存测试类

        3.1) 测试 org.github.roger.manager.ICacheManager#getCache(java.lang.String, org.github.roger.settings.MultiLayeringCacheSetting)

          该方法的功能: 根据缓存名称获取缓存API操作接口，获取到直接返回，如果获取不到，就创建一个，使用

org.github.roger.manager.AbstractCacheManager#getMissingCache方法指定一级缓存和二级缓存分别是什么。

 

package org.github.roger.cache.core;

import org.github.roger.cache.ICache;
import org.github.roger.cache.config.ICacheManagerConfig;
import org.github.roger.enumeration.ExpireMode;
import org.github.roger.manager.ICacheManager;
import org.github.roger.settings.FirstCacheSetting;
import org.github.roger.settings.MultiLayeringCacheSetting;
import org.github.roger.settings.SecondaryCacheSetting;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.Collection;
import java.util.concurrent.TimeUnit;

// SpringJUnit4ClassRunner再Junit环境下提供Spring TestContext Framework的功能。
@RunWith(SpringJUnit4ClassRunner.class)
// @ContextConfiguration用来加载配置ApplicationContext，其中classes用来加载配置类
@ContextConfiguration(classes = {ICacheManagerConfig.class})
public class CacheCoreTest {
    private Logger logger = LoggerFactory.getLogger(CacheCoreTest.class);

    @Autowired
    private ICacheManager cacheManager;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private MultiLayeringCacheSetting layeringCacheSetting1;
    private MultiLayeringCacheSetting layeringCacheSetting2;
    private MultiLayeringCacheSetting layeringCacheSetting4;
    private MultiLayeringCacheSetting layeringCacheSetting5;

    @Before
    public void before() {
        // 测试 CacheManager getCache方法
        FirstCacheSetting firstCacheSetting1 = new FirstCacheSetting(10, 1000, 4, TimeUnit.SECONDS, ExpireMode.WRITE);
        SecondaryCacheSetting secondaryCacheSetting1 = new SecondaryCacheSetting(10, 4, TimeUnit.SECONDS, true, true, true,1);
        layeringCacheSetting1 = new MultiLayeringCacheSetting(firstCacheSetting1, secondaryCacheSetting1);

        // 二级缓存可以缓存null,时间倍率是1
        FirstCacheSetting firstCacheSetting2 = new FirstCacheSetting(10, 1000, 5, TimeUnit.SECONDS, ExpireMode.WRITE);
        SecondaryCacheSetting secondaryCacheSetting2 = new SecondaryCacheSetting(3000, 14, TimeUnit.SECONDS, true, true,true, 1);
        layeringCacheSetting2 = new MultiLayeringCacheSetting(firstCacheSetting2, secondaryCacheSetting2);

        // 二级缓存可以缓存null,时间倍率是10
        FirstCacheSetting firstCacheSetting4 = new FirstCacheSetting(10, 1000, 5, TimeUnit.SECONDS, ExpireMode.WRITE);
        SecondaryCacheSetting secondaryCacheSetting4 = new SecondaryCacheSetting(100, 70, TimeUnit.SECONDS, true, true, true,10);
        layeringCacheSetting4 = new MultiLayeringCacheSetting(firstCacheSetting4, secondaryCacheSetting4);


        // 二级缓存不可以缓存null
        FirstCacheSetting firstCacheSetting5 = new FirstCacheSetting(10, 1000, 5, TimeUnit.SECONDS, ExpireMode.WRITE);
        SecondaryCacheSetting secondaryCacheSetting5 = new SecondaryCacheSetting(10, 7, TimeUnit.SECONDS, true, false,true, 1);
        layeringCacheSetting5 = new MultiLayeringCacheSetting(firstCacheSetting5, secondaryCacheSetting5);

    }

    @Test
    public void testGetCache(){
        String cacheName = "cache:name";
        ICache cache1 = cacheManager.getCache(cacheName, layeringCacheSetting1);
        ICache cache2 = cacheManager.getCache(cacheName, layeringCacheSetting1);
        Assert.assertEquals(cache1, cache2);

        ICache cache3 = cacheManager.getCache(cacheName, layeringCacheSetting2);
        Collection<ICache> caches = cacheManager.getCache(cacheName);
        Assert.assertTrue(caches.size() == 2);
        Assert.assertNotEquals(cache1, cache3);
    }
}

   3.2)测试缓存的过期时间

package org.github.roger.cache.core;

import lombok.extern.slf4j.Slf4j;
import org.github.roger.MultiLayeringCache;
import org.github.roger.cache.ICache;
import org.github.roger.cache.config.ICacheManagerConfig;
import org.github.roger.cache.redis.RedisCache;
import org.github.roger.enumeration.ExpireMode;
import org.github.roger.manager.ICacheManager;
import org.github.roger.settings.FirstCacheSetting;
import org.github.roger.settings.MultiLayeringCacheSetting;
import org.github.roger.settings.SecondaryCacheSetting;
import org.github.roger.utils.RedisCacheKey;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.Collection;
import java.util.concurrent.TimeUnit;

// SpringJUnit4ClassRunner再Junit环境下提供Spring TestContext Framework的功能。
@RunWith(SpringJUnit4ClassRunner.class)
// @ContextConfiguration用来加载配置ApplicationContext，其中classes用来加载配置类
@ContextConfiguration(classes = {ICacheManagerConfig.class})
@Slf4j
public class CacheCoreTest {

    @Autowired
    private ICacheManager cacheManager;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private MultiLayeringCacheSetting layeringCacheSetting1;
    private MultiLayeringCacheSetting layeringCacheSetting2;
    private MultiLayeringCacheSetting layeringCacheSetting4;
    private MultiLayeringCacheSetting layeringCacheSetting5;

    @Before
    public void before() {
        // 测试 CacheManager getCache方法
        FirstCacheSetting firstCacheSetting1 = new FirstCacheSetting(10, 1000, 4, TimeUnit.SECONDS, ExpireMode.WRITE);
        SecondaryCacheSetting secondaryCacheSetting1 = new SecondaryCacheSetting(10, 4, TimeUnit.SECONDS, true, true, true, 1);
        layeringCacheSetting1 = new MultiLayeringCacheSetting(firstCacheSetting1, secondaryCacheSetting1);

        // 二级缓存可以缓存null,时间倍率是1
        FirstCacheSetting firstCacheSetting2 = new FirstCacheSetting(10, 1000, 5, TimeUnit.SECONDS, ExpireMode.WRITE);
        SecondaryCacheSetting secondaryCacheSetting2 = new SecondaryCacheSetting(3000, 14, TimeUnit.SECONDS, true, true, true, 1);
        layeringCacheSetting2 = new MultiLayeringCacheSetting(firstCacheSetting2, secondaryCacheSetting2);

        // 二级缓存可以缓存null,时间倍率是10
        FirstCacheSetting firstCacheSetting4 = new FirstCacheSetting(10, 1000, 5, TimeUnit.SECONDS, ExpireMode.WRITE);
        SecondaryCacheSetting secondaryCacheSetting4 = new SecondaryCacheSetting(100, 70, TimeUnit.SECONDS, true, true, true, 10);
        layeringCacheSetting4 = new MultiLayeringCacheSetting(firstCacheSetting4, secondaryCacheSetting4);


        // 二级缓存不可以缓存null
        FirstCacheSetting firstCacheSetting5 = new FirstCacheSetting(10, 1000, 5, TimeUnit.SECONDS, ExpireMode.WRITE);
        SecondaryCacheSetting secondaryCacheSetting5 = new SecondaryCacheSetting(10, 7, TimeUnit.SECONDS, true, false, true, 1);
        layeringCacheSetting5 = new MultiLayeringCacheSetting(firstCacheSetting5, secondaryCacheSetting5);

    }

    @Test
    public void testGetCache() {
        String cacheName = "cache:name";
        ICache cache1 = cacheManager.getCache(cacheName, layeringCacheSetting1);
        ICache cache2 = cacheManager.getCache(cacheName, layeringCacheSetting1);
        Assert.assertEquals(cache1, cache2);

        ICache cache3 = cacheManager.getCache(cacheName, layeringCacheSetting2);
        Collection<ICache> caches = cacheManager.getCache(cacheName);
        Assert.assertTrue(caches.size() == 2);
        Assert.assertNotEquals(cache1, cache3);
    }

    @Test
    public void testCacheExpiration() {
        //一级缓存的有效时间是在写入之后，4秒
        String cacheName = "cache:name";
        String cacheKey1 = "cache:key1";
        MultiLayeringCache cache1 = (MultiLayeringCache) cacheManager.getCache(cacheName, layeringCacheSetting1);
        cache1.get(cacheKey1, () -> initCache(String.class));
        // 测试一级缓存值及过期时间
        String str1 = cache1.getFirstCache().get(cacheKey1, String.class);
        String st2 = cache1.getFirstCache().get(cacheKey1, () -> initCache(String.class));
        log.debug("========================:{}", str1);
        Assert.assertTrue(str1.equals(st2));
        Assert.assertTrue(str1.equals(initCache(String.class)));
        sleep(5);
        Assert.assertNull(cache1.getFirstCache().get(cacheKey1, String.class));
        // 看日志是不是走了二级缓存
        cache1.get(cacheKey1, () -> initCache(String.class));
        log.debug("***********************");
        log.debug("***********************");
        log.debug("***********************");
        //二级缓存的有效时间是10秒，在失效前 4秒强制刷新缓存
        str1 = cache1.getSecondCache().get(cacheKey1, String.class);
        st2 = cache1.getSecondCache().get(cacheKey1, () -> initCache(String.class));
        Assert.assertTrue(st2.equals(str1));
        Assert.assertTrue(str1.equals(initCache(String.class)));
        sleep(5);
        // 看日志是不是走了自动刷新
        RedisCacheKey redisCacheKey = ((RedisCache) cache1.getSecondCache()).getRedisCacheKey(cacheKey1);
        cache1.get(cacheKey1, () -> initCache(String.class));
        sleep(6);
        Long ttl = redisTemplate.getExpire(redisCacheKey.getKey());
        log.debug("========================ttl 1:{}", ttl);
        Assert.assertNotNull(cache1.getSecondCache().get(cacheKey1));
        sleep(5);
        ttl = redisTemplate.getExpire(redisCacheKey.getKey());
        log.debug("========================ttl 2:{}", ttl);
        Assert.assertNull(cache1.getSecondCache().get(cacheKey1));
    }

    private <T> T initCache(Class<T> t) {
        log.debug("加载缓存");
        return (T) "test";
    }

    private void sleep(int time) {
        try {
            Thread.sleep(time * 1000);
        } catch (InterruptedException e) {
            log.error(e.getMessage(), e);
        }
    }
}

    3.测试删除某个缓存key

	13:54:50.799 [main] INFO org.github.roger.cache.redis.RedisCache 
		- 清除redis缓存 key= cache:name:cache:key2 
	13:55:16.762 [main] DEBUG org.github.roger.listener.RedisPublisher 
		- redis消息发布者向频道【cache:name】发布了【RedisPubSubMessage(cacheName=cache:name, key=cache:key2, messageType=EVICT)】消息

	13:57:06.707 [RedisMessageListenerContainer-3] DEBUG org.github.roger.listener.RedisMessageListener 
		- redis消息订阅者接收到频道【cache:name】发布的消息。消息内容：{"cacheName":"cache:name","key":"cache:key2","messageType":"EVICT"}

 

Roger6650
关注
专栏目录
软件架构设计与模式之：敏捷架构与敏捷开发
程序员光剑
09-24 1768
软件架构设计是一个非常重要的环节。过去几年，软件架构已经成为企业创新驱动力的源泉。为提升软件质量、降低成本、提升效率、满足客户需求等目的，企业不得不面对庞大的软件系统，需要采取架构设计方法。企业采用什么样的软件架构，会影响到企业的成功运营。架构设计应该做到以下几个方面：1、架构易于理解架构易于理解意味着架构师要在一个抽象层次上搭建起系统，让各个部门可以轻松地了解系统结构及其关系。不管是内部架构还是外部架构，都应该把系统的主要功能模块、数据流向和关键技术点都列出来。
Hibernate4二级缓存Ehcache案例
10-25
Hibernate4二级缓存Ehcache案例，可参考博客：http://blog.csdn.net/coco2d_x2014/article/details/52927638
Mybatis 一级缓存与二级缓存（用例测试）
ZZBoss
09-14 797
一级缓存： Mybatis 一级缓存作用域是一个sqlsession（缓存属于当前会话独享），即一次sqlsession从打开到关闭，这个过程中，重复的查询语句只执行一次，第一次查询会将结果放入一级缓存，sqlsession关闭之前，重复的查询语句将直接读取缓存。 当发生增删改操作时，在事务commit前会先清空sqlsession的缓存数据（此时清空的只是当前sqlsession的缓存，其他...
分布式多级缓存
dark159735的博客
01-04 2649
来自itheima
缓存怎么测试？
weixin_60664821的博客
08-31 2760
部分场景可能存在查询缓存时，如缓存无数据，可能会直接返回空数据给客户端，不再去查询。数据库，是高并发场景常用一款存储中间件，其主要用于：缓存热点数据，减少。验证缓存查询达到超时后，未返回指定的数据，对系统的影响；并发请求缓存中的有的数据，验证返回数据是否正确，性能指标是否正常。中也没有的数据，验证返回数据是否为空，性能指标是否正常；有的数据，验证返回数据是否正确，性能指标是否正常。和缓存中一定不存在的数据，验证返回数据为空；，数据返回是否正确，且缓存淘汰是否正确。，计数器，限流，消息队列，购物车等。...
多级缓存的原理和实现
qq_46624276的博客
09-02 2292
对于请求，进来会通过nginx转发到另一个缓存nginx，缓存nginx查询后端，如果配置集群，只有访问到的那一台服务器有数据，所以不使用轮询，使用hash $request_uri;OpenResty为Nginx提供了shard dict的功能，可以在nginx的多个worker之间共享数据，实现缓存功能。:服务刚刚启动时，Redis中并没有缓存，如果所有商品数据都在第一次查询时添加缓存，可能会给数据库带来较大压力。设置缓存为软引用或者弱引用，利用GC来回收，性能差，不建议使用。
设计高并发架构与系统多级缓存架构如何设计？
m0_67322837的博客
04-10 1153
高并发经常会发生在有大活跃用户量，用户高聚集的业务场景中，如：秒杀活动，定时领取红包等。 为了让业务可以流畅的运行并且给用户一个好的交互体验，我们需要根据业务场景预估达到的并发量等因素，来设计适合自己业务场景的高并发处理方案。 在电商相关产品开发的这些年，我有幸的遇到了并发下的各种坑，这一路摸爬滚打过来有着不少的血泪史，这里进行的总结，作为自己的归档记录，同时分享给大家。 服务器架构 业务从发展的初期到逐渐成熟，服务器架构也是从相对单一到集群，再到分布式服务。 一个可以支持高并发的服务少不了好的服
双11期间系统并发上10w，我用多级缓存架构直接撑住
石杉的架构笔记
11-10 641
今天给大家分享一个话题，就是如果要是你老板突然要求你把你负责的系统，要接入到双十一中去抗下双十一带来的超大流量，你会感到心里特别慌，然后特别没底吗？
八(4)多级缓存
sweetcuter的博客
10-10 212
八(4)多级缓存
Java编程代码-多级缓存-源代码+讲义+资料
10-26
3. **多级缓存架构**：阐述多级缓存如何降低延迟，提升系统性能，以及如何设计合理的缓存层次。 4. **缓存实战**：提供实际案例分析，展示如何在项目中部署和调优多级缓存。 资料部分可能包含： 1. **缓存最佳实践*...
高并发 -- 多级缓存
qq_33753147的博客
08-27 815
高并发，多级缓存
多级缓存架构开发 一 (创建一个通用的缓存顶级接口)
lihongtai的专栏
05-13 893
实现思路： 1) 采用caffeine作为一级缓存，caffeine是一个高性能的Java缓存库，采用的是Window TinyLfu回收策略， 提供了一个近乎最佳的缓存命中率；优点是数据就在应用内存中所以速度块；缺点是1)受应用内存限制，容量有限, 2)没有持久化，重启服务后缓存数据会丢失3)分布式式环境下，缓存数据无法同步 ...
SpringBoot整合redis(StringRedisTemplate)，操作一个redis服务器的多个库
热门推荐
lixianhe的博客
04-14 2万+
SpringBoot整合redis(StringRedisTemplate)，操作一个redis服务器的多个库
Springboot 中 Redis 自动配置源码分析
donkeyboy001的博客
11-24 1946
Springboot 中 Redis 自动配置源码分析
【java笔记】记一次线上redis之lettuce客户端创建异常问题
欢迎光临
08-04 4579
导读 目前线上报错如下： ERROR [io.netty.util.ResourceLeakDetector 317] - LEAK: HashedWheelTimer.release() was not called before it's garbage-collected. See http://netty.io/wiki/reference-counted-objects.html for more information. Recent access records: Created at:
Redis学习笔记6：基于springboot的Lettuce redis客户端ConnectionWatchdog断线重连时间ExponentialDelay延迟策略
最新发布
OceanSky的专栏
10-28 1060
lettuce断线重连监视器ConnectionWatchdog#scheduleReconnect方法中的延迟重连时间是根据io.lettuce.core.resource.Delay策略来决定，默认是采用ExponentialDelay延迟策略，即2的幂次方，即时间是PT0.001S、PT0.002S、PT0.004S一直到最大PT30S。一个对springboot redis框架进行重写，支持lettuce、jedis、连接池、同时连接多个集群、多个redis数据库、开发自定义属性配置的开源SDK。
redis Lettuce客户端
qq_37436172的博客
09-17 1138
与Jedis相比，Lettuce则完全克服了其线程不安全的缺点：Lettuce是一个可伸缩的线程安全的Redis客户端，支持同步、异步和响应式模式。 多个线程可以共享一个连接实例，而不必担心多线程并发问题。 它基于优秀Netty NIO框架构建，支持Redis的高级功能，如Sentinel，集群，流水线，自动重新连接和Redis数据模型。 Jedis在实现上是直接连接的redis server，如果在多线程环境下是非线程安全的，这个时候只有使用jedis pool连接池，为每个Jedis实例增加物理连接。
springboot 高级教程 jetcache 二级缓存用法
qq_34874784的博客
06-07 1396
nullable表示是否缓存null值。name即为缓存的名称，key为缓存的键值，expire为缓存过期的时间，cacheType即为缓存类型。Spring Boot是Spring Framework的增强版本，可以快速开发基于Spring的应用程序。在Spring Boot中使用Jetcache的二级缓存也是极为简单的。使用Junit等测试框架编写测试用例，测试Spring Boot应用程序中的JetCache二级缓存是否成功启用，缓存是否生效。在需要缓存处理的方法上使用JetCache提供的注解。
Springboot 项目中Redis用lettuce连接池经常断连的问题解决
迷宫的博客
11-24 9765
Springboot 项目中Redis用lettuce连接池，如果长时间不用redis的话，就会断连。可以通过用netty的心跳机制来维持连接。 心跳机制 心跳是在TCP长连接中，客户端和服务端定时向对方发送数据包通知对方自己还在线，保证连接的有效性的一种机制 在服务器和客户端之间一定时间内没有数据交互时, 即处于 idle 状态时, 客户端或服务器会发送一个特殊的数据包给对方, 当接收方收到这个数据报文后, 也立即发送一个特殊的数据报文, 回应发送方, 此即一个 PING-PONG 交...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值