一、Spring Cache整合分布式缓存redis（Lettuce）

已于 2024-11-12 16:41:36 修改
阅读量309 收藏 2
点赞数 5
分类专栏： Spring Cache 文章标签： 缓存 spring
于 2024-11-12 16:38:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_44012070/article/details/143715188
版权

1、依赖包

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>        
    <version>2.2.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>io.lettuce</groupId>
  <artifactId>lettuce-core</artifactId>
  <version>5.2.1.RELEASE</version>
</dependency>

2、redis配置

方式一：

连接工厂

//@EnableCaching
@Configuration
public class CacheConfig extends CachingConfigurerSupport {

    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        // RedisStandaloneConfiguration这个配置类是Spring Data Redis2.0后才有的~~~
        RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();
        configuration.setHostName("10.102.132.150");
        //configuration.setPassword(RedisPassword.of("123456"));
        configuration.setPort(6379);
        configuration.setDatabase(0);


        LettuceConnectionFactory factory = new LettuceConnectionFactory(configuration);
        // Spring Data Redis1.x这么来设置  2.0后建议使用RedisStandaloneConfiguration来取代
        //factory.setHostName("10.102.132.150");
        //factory.setPassword("123456");
        //factory.setPort(6379);
        //factory.setDatabase(0);
        return factory;
    }

    @Bean
    public RedisTemplate<String, String> stringRedisTemplate() {
        RedisTemplate<String, String> redisTemplate = new StringRedisTemplate();
        redisTemplate.setConnectionFactory(redisConnectionFactory());
        return redisTemplate;
    }

}

方式二：采用自动配置，yml文件配置连接信息

spring:
  redis:
    #    cluster:
    # Comma-separated list of "host:port" pairs to bootstrap from.
    #      nodes:
    #      max-redirects:
    database: 0
    host: 127.0.0.1
    #Connection URL. Overrides host, port, and password. User is ignored. Example: redis://user:password@example.com:6379
    #    url:
    port: 6379
    password:
    timeout:
    ssl: false
    lettuce:
      pool:
        max-active: 1000
        max-idle: 8
        max-wait: -1ms
        min-idle: 0

3、cacheManager、ttl、异常配置

@Slf4j
@Configuration
public class UspCacheAutoConfiguration extends CachingConfigurerSupport {

    @Autowired
    private ApplicationContext applicationContext;

    /**
     * 键默有效时间
     */
    private static final Duration TTL = Duration.ofMinutes(30);

    @Bean
    @Override
    public CacheErrorHandler errorHandler() {
        return new CacheErrorHandler() {

            @Override
            public void handleCacheGetError(RuntimeException exception, Cache cache, Object key) {
                log.error("redis异常: key=[{}]", key, exception);
            }

            @Override
            public void handleCachePutError(RuntimeException exception, Cache cache, Object key, Object value) {
                log.error("redis异常: key=[{}]", key, exception);
            }

            @Override
            public void handleCacheEvictError(RuntimeException exception, Cache cache, Object key) {
                log.error("redis异常: key=[{}]", key, exception);
            }

            @Override
            public void handleCacheClearError(RuntimeException exception, Cache cache) {
                log.error("redis异常:", exception);
            }
        };
    }

    @Bean
    public RedisCacheManager redisCacheManager(RedisConnectionFactory redisConnectionFactory) {
        return RedisCacheManager.builder(redisConnectionFactory)
                .initialCacheNames(cacheNames())
                .withInitialCacheConfigurations(redisCacheConfigurationMap())
                .build();
    }

    private Set<String> cacheNames() {
        Set<String> cacheSet = new HashSet<>();
        // 此处UspCacheDefinition为cache配置接口，包含擦车Name，TTL,prefix，序列化反序列化等
        applicationContext.getBeansOfType(UspCacheDefinition.class).forEach((key, uspCacheDefinition) -> cacheSet.add(uspCacheDefinition.getKey()));
        return cacheSet;
    }

    // TODO 待优化
    private Map<String, RedisCacheConfiguration> redisCacheConfigurationMap() {
        Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();

        applicationContext.getBeansOfType(UspCacheDefinition.class).forEach((key, uspCacheDefinition) -> {
            RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                    .entryTtl(uspCacheDefinition.getTimeToLive())
                    .disableCachingNullValues();

            if (uspCacheDefinition.getTimeToLive() != null) {
                redisCacheConfiguration = redisCacheConfiguration.entryTtl(uspCacheDefinition.getTimeToLive());
            }

            if (!"".equals(uspCacheDefinition.getPrefix()) && uspCacheDefinition.getPrefix() != null) {
                redisCacheConfiguration.usePrefix();
                redisCacheConfiguration = redisCacheConfiguration.prefixKeysWith(uspCacheDefinition.getPrefix());
            }

            if (uspCacheDefinition.getSerializeKey() != null) {
                redisCacheConfiguration = redisCacheConfiguration.serializeKeysWith(uspCacheDefinition.getSerializeKey());
            }

            if (uspCacheDefinition.getSerializeValue() != null) {
                redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(uspCacheDefinition.getSerializeValue());
            }

            redisCacheConfigurationMap.put(uspCacheDefinition.getKey(), redisCacheConfiguration);
        });

        return redisCacheConfigurationMap;
    }
}

4、配置类上开启缓存注解支持：@EnableCaching

5、RedisCacheManager中注意RedisCacheWriter和RedisCacheConfiguration

public class RedisCacheManager extends AbstractTransactionSupportingCacheManager {

	private final RedisCacheWriter cacheWriter;
    // 这个配置类非常重要。能配置ttl、CacheKeyPrefix、ConversionService等等
	private final RedisCacheConfiguration defaultCacheConfig;
	private final Map<String, RedisCacheConfiguration> initialCacheConfiguration;
	private final boolean allowInFlightCacheCreation;

	private RedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration,
			boolean allowInFlightCacheCreation) {

		Assert.notNull(cacheWriter, "CacheWriter must not be null!");
		Assert.notNull(defaultCacheConfiguration, "DefaultCacheConfiguration must not be null!");

		this.cacheWriter = cacheWriter;
		this.defaultCacheConfig = defaultCacheConfiguration;
		this.initialCacheConfiguration = new LinkedHashMap<>();
		this.allowInFlightCacheCreation = allowInFlightCacheCreation;
	}

	
	public RedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration) {
		this(cacheWriter, defaultCacheConfiguration, true);
	}

	
	public RedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration,
			String... initialCacheNames) {

		this(cacheWriter, defaultCacheConfiguration, true, initialCacheNames);
	}

	
	public RedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration,
			boolean allowInFlightCacheCreation, String... initialCacheNames) {

		this(cacheWriter, defaultCacheConfiguration, allowInFlightCacheCreation);
        // 给每个Cache都放一个配置，默认都使用全局的defaultCacheConfiguration
		// 可见：它是支持给不同的Cache，给出不同的配置的（比如过期时间，，，等等等）
		for (String cacheName : initialCacheNames) {
			this.initialCacheConfiguration.put(cacheName, defaultCacheConfiguration);
		}
	}
    // 这里也可以自己把initialCacheConfigurations这个Map传进来（完成完全个性化）
	public RedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration,
			Map<String, RedisCacheConfiguration> initialCacheConfigurations) {

		this(cacheWriter, defaultCacheConfiguration, initialCacheConfigurations, true);
	}

	
	public RedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration,
			Map<String, RedisCacheConfiguration> initialCacheConfigurations, boolean allowInFlightCacheCreation) {

		this(cacheWriter, defaultCacheConfiguration, allowInFlightCacheCreation);

		Assert.notNull(initialCacheConfigurations, "InitialCacheConfigurations must not be null!");

		this.initialCacheConfiguration.putAll(initialCacheConfigurations);
	}

	
	public static RedisCacheManager create(RedisConnectionFactory connectionFactory) {

		Assert.notNull(connectionFactory, "ConnectionFactory must not be null!");

		return new RedisCacheManager(new DefaultRedisCacheWriter(connectionFactory),
				RedisCacheConfiguration.defaultCacheConfig());
	}

	...

	/**
	 * Configurator for creating {@link RedisCacheManager}.
	 */
	public static class RedisCacheManagerBuilder {

		...
		public RedisCacheManager build() {

			RedisCacheManager cm = new RedisCacheManager(cacheWriter, defaultCacheConfiguration, initialCaches,
					allowInFlightCacheCreation);

			cm.setTransactionAware(enableTransactions);

			return cm;
		}
	}
}

6、RedisCache是对Cache的实现
 

// @since 2.0   请注意：这里也是以2.0版本的为准的
public class RedisCache extends AbstractValueAdaptingCache {

	private static final byte[] BINARY_NULL_VALUE = RedisSerializer.java().serialize(NullValue.INSTANCE);

	private final String name; // 缓存的名字
	private final RedisCacheWriter cacheWriter; //最终操作是委托给它的
	private final RedisCacheConfiguration cacheConfig; // cache的配置（因为每个Cache的配置可能不一样，即使来自于同一个CacheManager）
	private final ConversionService conversionService; // 数据转换
	
	// 唯一构造函数，并且还是protected 的。可见我们自己并不能操控它
	protected RedisCache(String name, RedisCacheWriter cacheWriter, RedisCacheConfiguration cacheConfig) {

		super(cacheConfig.getAllowCacheNullValues());

		Assert.notNull(name, "Name must not be null!");
		Assert.notNull(cacheWriter, "CacheWriter must not be null!");
		Assert.notNull(cacheConfig, "CacheConfig must not be null!");

		this.name = name;
		this.cacheWriter = cacheWriter;
		this.cacheConfig = cacheConfig;
		this.conversionService = cacheConfig.getConversionService();
	}

	@Override
	public String getName() {
		return name;
	}
	@Override
	public RedisCacheWriter getNativeCache() {
		return this.cacheWriter;
	}

	// cacheWriter会有网络访问请求~~~去访问服务器
	@Override
	protected Object lookup(Object key) {
		byte[] value = cacheWriter.get(name, createAndConvertCacheKey(key));
		if (value == null) {
			return null;
		}
		return deserializeCacheValue(value);
	}

	@Override
	@Nullable
	public ValueWrapper get(Object key) {
		Object value = lookup(key);
		return toValueWrapper(value);
	}

	// 请注意：这个方法因为它要保证同步性，所以使用了synchronized 
	// 还记得我说过的sync=true这个属性吗，靠的就是它来保证的（当然在分布式情况下 不能百分百保证）
	@Override
	@SuppressWarnings("unchecked")
	public synchronized <T> T get(Object key, Callable<T> valueLoader) {
		ValueWrapper result = get(key);
		if (result != null) { // 缓存里有，就直接返回吧
			return (T) result.get();
		}
	
		// 缓存里没有，那就从valueLoader里拿值，拿到后马上put进去
		T value = valueFromLoader(key, valueLoader);
		put(key, value); 
		return value;
	}


	@Override
	public void put(Object key, @Nullable Object value) {
		Object cacheValue = preProcessCacheValue(value);

		// 对null值的判断，看看是否允许存储它呢~~~
		if (!isAllowNullValues() && cacheValue == null) {
			throw new IllegalArgumentException(String.format("Cache '%s' does not allow 'null' values. Avoid storing null via '@Cacheable(unless=\"#result == null\")' or configure RedisCache to allow 'null' via RedisCacheConfiguration.", name));
		}
		cacheWriter.put(name, createAndConvertCacheKey(key), serializeCacheValue(cacheValue), cacheConfig.getTtl());
	}

	// @since 4.1
	@Override
	public ValueWrapper putIfAbsent(Object key, @Nullable Object value) {
	...
	}

	@Override
	public void evict(Object key) {
		cacheWriter.remove(name, createAndConvertCacheKey(key));
	}

	// 清空：在redis中慎用。因为它是传一个*去  进行全部删除的。
	@Override
	public void clear() {
		byte[] pattern = conversionService.convert(createCacheKey("*"), byte[].class);
		cacheWriter.clean(name, pattern);
	}

	public RedisCacheConfiguration getCacheConfiguration() {
		return cacheConfig;
	}
	// 序列化key、value   ByteUtils为redis包的工具类，Data Redis 1.7
	protected byte[] serializeCacheKey(String cacheKey) {
		return ByteUtils.getBytes(cacheConfig.getKeySerializationPair().write(cacheKey));
	}
	protected byte[] serializeCacheValue(Object value) {
		if (isAllowNullValues() && value instanceof NullValue) {
			return BINARY_NULL_VALUE;
		}
		return ByteUtils.getBytes(cacheConfig.getValueSerializationPair().write(value));
	}

	protected String createCacheKey(Object key) {

		String convertedKey = convertKey(key);

		if (!cacheConfig.usePrefix()) {
			return convertedKey;
		}

		return prefixCacheKey(convertedKey);
	}
	... 
}

RedisCache持有RedisCacheWriter的引用，所有的对Redis服务的操作都是委托给了它，同时它还持有RedisCacheConfiguration和ConversionService

Spring Cloud Alibaba微服务架构实战教程—17分布式缓存下Redis设计
空空说技术的博客
06-15 913
前言 大多数的文章，开头就是告诉你使用redis做缓存，怎么怎么样，而本系列，不打算采用这样无趣的写法，这和直接搬运有什么区别？笔者力求读者能得到更大程度的系统学习，会从为什么使用缓存来给大家进行学习。 问问大家，当系统的执行速度慢怎么办？ 对于更新速度不是很快的站点，可以采用静态化来避免过多的数据查询。通常前端使用Freemaker或Velocity、thymeleaf等模板引擎来实现 页面的静态化。 对于更新数据频繁的站点，可通过 分布式缓存 来解决快速获取的查询，结合如Redis、MemCa
SpringBoot 使用 Cache 集成 Redis做缓存保姆教程
笑小枫
01-08 1710
Spring Cache是Spring框架提供的一种缓存解决方案，基于AOP原理，实现了基于注解的缓存功能，只需要简单地加一个注解就能实现缓存功能，对业务代码的侵入性很小。使用Spring Cache的方法很简单，只需要在方法上添加注解即可实现将方法返回数据存入缓存，以及清理缓存等注解的使用。SpEL是Spring框架提供的一种功能强大的表达式语言，它能够在运行时查询和操作对象图。
Springboot 2.X中Spring-cache与redis整合
04-02
Springboot中Spring-cache与redis整合。这也是一个不错的框架，与spring的事务使用类似，只要添加一些注解方法，就可以动态的去操作缓存了，减少代码的操作。
redis+springcache
最新发布
qq_50372901的博客
04-21 398
通过结合 Redis 和 Spring Cache，可以快速实现基于 Redis 的分布式缓存功能。Spring Cache 提供了简洁的注解方式，降低了缓存管理的复杂性。根据实际需求，还可以进一步优化 Redis 的配置，例如设置不同的缓存过期时间、序列化方式等。
spring cache 与redis缓存整合
热门推荐
yang7678287的专栏
03-10 1万+
spring cache，基本能够满足一般应用对缓存的需求，但现实总是很复杂，当你的用户量上去或者性能跟不上，总需要进行扩展，这个时候你或许对其提供的内存缓存不满意了，因为其不支持高可用性，也不具备持久化数据能力，这个时候，你就需要自定义你的缓存方案了，还好，spring 也想到了这一点。 本篇文章采用spring cache与redis进行整合，实现自己想要的缓存。 我们先配置redis：
Spring Cache集成 redis
菜鸟日记
07-22 361
spring cache默认是将数据缓存到内存当中，当系统体量较大，架构复杂时明显不适用，幸好它支持将缓存存入redis或者MongoDB等nosql中，下面记录一下它对redis的集成。 先上配置类 @Configuration @EnableCaching // 开启缓存支持 public class RedisConfig extends CachingConfigurerSupport { @Resource private LettuceConnectionFactory lettuceCo
Spring-Cache整合Redis
qq_27579471的博客
10-08 1128
配置类 使用 从数据库中查到数据后，序列化到缓存时报错： 将改为： 从缓存中查到数据后，反序列化时报错： 原来是因为实体类中有方法，在序列化时会调用该方法，然后缓存的json中会有字段。后来反序列化时，在实体类中找不到属性，所以就报错了！实体类
SpringCache整合redis
weixin_46972981的博客
04-27 734
SpringCache整合redis
springcache的使用详解（使用redis做分布式缓存）
秃了也弱了
07-03 6254
使用springcache做缓存，需要首先明白几个概念：缓存穿透、缓存击穿、缓存雪崩，以及缓存一致性。 缓存一致性解决方案——改数据时如何保证缓存和数据库中数据的一致性 从查询数据库性能优化谈到redis缓存-谈一谈缓存的穿透、雪崩、击穿Spring 从 3.1 开始定义了 org.springframework.cache.Cache 和 org.springframework.cache.CacheManager 接口来统一不同的缓存技术； 并支持使用 JCache（JSR-107）注解简化我们开发；C
spring redis 分布式缓存整合详细的注释说明
07-29
在现代的Web应用程序开发中，...总结，Spring Redis的整合使得我们可以充分利用Redis的特性，实现高效的分布式缓存。通过详细注释的工具类，可以帮助团队更好地理解和使用这一功能，提升项目的开发效率和运行性能。
SpringBoot快速上手——《四》：SpringBoot 集成Redis +SpringCache做缓存
rita_0567的博客
08-25 527
操作Redis不依赖SpringCache，实现SpringCache也不止Redis，也可以用ehCache做缓存！只是现在主流还是用Redis做缓存。©著作权归作者所有,转载或内容合作请联系作者。
springboot整合redis-lettuce
端点星
10-17 492
0、前言 redis客户端采用lettuce 1、先上代码目录 2、pom文件 1）父pom <dependency> <groupId>com.alicp.jetcache</groupId> <artifactId>jetcache-starter-redis-lettuce</artifactId> <version
扩展spring boot cache实现redis一二级分布式缓存
05-01
NULL 博文链接：https://sundoctor.iteye.com/blog/2409237
SpringCache整合Redis
antiling9663的博客
08-28 333
　　之前一篇文章 SpringBoot整合Redis 已经介绍了在SpringBoot中使用redisTemplate手动 操作redis数据库的方法了。其实这个时候我们就已经可以拿redis来做项目了，需要缓存服务的地方 就引入redisTemplate就行啦。 　　但是这里有个问题，缓存归根结底不是业务的核心，只是作为功能和效率上的辅助，如果我现在在某个 项目中用到缓存的地方...
Spring Cache整合Redis
zhang19903848257的博客
03-24 4179
文章介绍 继myabtis二级缓存整合redis之后，利用课余时间又研究了一下Spring Cache整合redis。原本是计划将这两篇文章和redis的介绍整合成一篇文章，但是。。。手贱的我在整合过程中不小心点击了刷新，导致新写的内容被清空了。花了我两天的宝贵时间啊。。。。。。 额额额，这一篇是继删除之后，根据回忆，又重写了一篇。虽然原文档丢了，但是还好，参考的blog，笔记浏览器里面还保存着，不至于让我太过难受，好了。拿重点。 本篇主要从原生spring cache实现缓存操作，背后源码浅析，再到re
Spring Cache 整合 Redis
g124486的博客
03-18 226
Cacheable：使用缓存。在方法执行前Spring先查看缓存中是否有数据，如果有数据，则直接返回缓存数据；可以指定一个特定的缓存管理器来管理缓存操作，用于在多个缓存管理器存在的情况下，选择使用哪个缓存管理器。@EnableCaching：开启缓存功能，一般使用在springboot的启动类或配置类上。用于指定一个 SpEL 表达式，当表达式的结果为 true 时，才会进行缓存操作。可以指定一个特定的缓存解析器，用于更灵活地解析缓存操作的存储位置，用于指定缓存存储和检索的键。
spring cache整合redis
huan的学习记录
06-26 483
，方便我们实际的开发。我们可以扩展spring的cache接口以达到使用redis来做缓存的效果。   步骤: 1.编写一个类用于实现   org.springframework.cache.Cache  这个接口 2.编写一个类实现  org.springframework.cache.CacheManager 这个接口或继承 org.springframework.cache.support.AbstractCacheManager这个类 3.在配置文件中进行配置。   代码: 1.使用
【spring cache整合redis】
workhard2的博客
09-11 668
spring cache整合redis，并给key设置过期时间
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值