【源码解析】SpringBoot缓存之@Cacheable的快速入门和源码解析

最新推荐文章于 2024-07-07 14:58:25 发布
最新推荐文章于 2024-07-07 14:58:25 发布
阅读量1.2k 收藏 3
点赞数
分类专栏： 源码解析 spring boot 文章标签： spring boot 缓存 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42985872/article/details/129398859
版权

快速入门

  1. 启动类上添加注解@EnableCaching
  2. 在方法上添加注解@Cacheable。
    @Override
    @Cacheable(cacheNames = "value", key = "#code+'_'+#dictKey")
    public String getValue(String code, Integer dictKey) {
        return baseMapper.getValue(code, dictKey);
    }

    @Override
    @Cacheable(cacheNames = "list", key = "#code")
    public List<Dict> getList(String code) {
        return baseMapper.getList(code);
    }

    @Override
    @CacheEvict(cacheNames = {"list", "value"}, allEntries = true)
    public boolean submit(Dict dict) {
        LambdaQueryWrapper<Dict> lqw = Wrappers.<Dict>query().lambda().eq(Dict::getCode, dict.getCode()).eq(Dict::getDictKey, dict.getDictKey());
        Long cnt = baseMapper.selectCount(dict.getId() == null ? lqw : lqw.notIn(Dict::getId, dict.getId()));
        if (cnt > 0) {
            throw new RuntimeException("当前字典键值已存在!");
        }
        return saveOrUpdate(dict);
    }
  1. 当缓存中存在数据的时候，会优先走缓存，否则会执行接口。

源码解析

@EnableCaching

该类会注入@Import(CachingConfigurationSelector.class)，而CachingConfigurationSelector重写了selectImports方法。

	@Override
	public String[] selectImports(AdviceMode adviceMode) {
		switch (adviceMode) {
			case PROXY:
				return getProxyImports();
			case ASPECTJ:
				return getAspectJImports();
			default:
				return null;
		}
	}

	private String[] getProxyImports() {
		List<String> result = new ArrayList<>(3);
		result.add(AutoProxyRegistrar.class.getName());
		result.add(ProxyCachingConfiguration.class.getName());
		if (jsr107Present && jcacheImplPresent) {
			result.add(PROXY_JCACHE_CONFIGURATION_CLASS);
		}
		return StringUtils.toStringArray(result);
	}

ProxyCachingConfiguration

缓存代理配置类。拦截类CacheInterceptor，切面类CacheOperationSourcePointcut。

@Configuration(proxyBeanMethods = false)
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public class ProxyCachingConfiguration extends AbstractCachingConfiguration {

	@Bean(name = CacheManagementConfigUtils.CACHE_ADVISOR_BEAN_NAME)
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	public BeanFactoryCacheOperationSourceAdvisor cacheAdvisor(
			CacheOperationSource cacheOperationSource, CacheInterceptor cacheInterceptor) {

		BeanFactoryCacheOperationSourceAdvisor advisor = new BeanFactoryCacheOperationSourceAdvisor();
		advisor.setCacheOperationSource(cacheOperationSource);
		advisor.setAdvice(cacheInterceptor);
		if (this.enableCaching != null) {
			advisor.setOrder(this.enableCaching.<Integer>getNumber("order"));
		}
		return advisor;
	}

	@Bean
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	public CacheOperationSource cacheOperationSource() {
		return new AnnotationCacheOperationSource();
	}

	@Bean
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	public CacheInterceptor cacheInterceptor(CacheOperationSource cacheOperationSource) {
		CacheInterceptor interceptor = new CacheInterceptor();
		interceptor.configure(this.errorHandler, this.keyGenerator, this.cacheResolver, this.cacheManager);
		interceptor.setCacheOperationSource(cacheOperationSource);
		return interceptor;
	}

}

SpringCacheAnnotationParser#isCandidateClass，判断是否会被拦截。

public class SpringCacheAnnotationParser implements CacheAnnotationParser, Serializable {

	private static final Set<Class<? extends Annotation>> CACHE_OPERATION_ANNOTATIONS = new LinkedHashSet<>(8);

	static {
		CACHE_OPERATION_ANNOTATIONS.add(Cacheable.class);
		CACHE_OPERATION_ANNOTATIONS.add(CacheEvict.class);
		CACHE_OPERATION_ANNOTATIONS.add(CachePut.class);
		CACHE_OPERATION_ANNOTATIONS.add(Caching.class);
	}


	@Override
	public boolean isCandidateClass(Class<?> targetClass) {
		return AnnotationUtils.isCandidateClass(targetClass, CACHE_OPERATION_ANNOTATIONS);
	}
}

CacheAutoConfiguration

自动装配，在spring-boot-autoconfigure中的spring.factoires有引入CacheAutoConfiguration。该类会注入Spring的条件是CacheManger类存在，且Spring容器中存在CacheAspectSupport。因为@EnableCaching引入了CacheInterceptor，CacheInterceptor继承了CacheAspectSupport，所以CacheAutoConfiguration会被注入到Spring容器中。随着CacheAutoConfiguration的成功注入，会注入CacheConfigurationImportSelector和CacheManagerEntityManagerFactoryDependsOnPostProcessor。

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnClass({CacheManager.class})
@ConditionalOnBean({CacheAspectSupport.class})
@ConditionalOnMissingBean(
    value = {CacheManager.class},
    name = {"cacheResolver"}
)
@EnableConfigurationProperties({CacheProperties.class})
@AutoConfigureAfter({CouchbaseDataAutoConfiguration.class, HazelcastAutoConfiguration.class, HibernateJpaAutoConfiguration.class, RedisAutoConfiguration.class})
@Import({CacheAutoConfiguration.CacheConfigurationImportSelector.class, CacheAutoConfiguration.CacheManagerEntityManagerFactoryDependsOnPostProcessor.class})
public class CacheAutoConfiguration {
    public CacheAutoConfiguration() {
    }
}

CacheAutoConfiguration.CacheConfigurationImportSelector

CacheAutoConfiguration.CacheConfigurationImportSelector#selectImports，该类重写了selectImports方法，引入了RedisCacheConfiguration等缓存类。

        public String[] selectImports(AnnotationMetadata importingClassMetadata) {
            CacheType[] types = CacheType.values();
            String[] imports = new String[types.length];

            for(int i = 0; i < types.length; ++i) {
                imports[i] = CacheConfigurations.getConfigurationClass(types[i]);
            }

            return imports;
        }

CacheType

public enum CacheType {
    GENERIC,
    JCACHE,
    EHCACHE,
    HAZELCAST,
    INFINISPAN,
    COUCHBASE,
    REDIS,
    CAFFEINE,
    SIMPLE,
    NONE;
}

RedisCacheConfiguration

RedisCacheConfiguration会往spring中注入cacheManager的类。

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnClass({RedisConnectionFactory.class})
@AutoConfigureAfter({RedisAutoConfiguration.class})
@ConditionalOnBean({RedisConnectionFactory.class})
@ConditionalOnMissingBean({CacheManager.class})
@Conditional({CacheCondition.class})
class RedisCacheConfiguration {
    RedisCacheConfiguration() {
    }

    @Bean
    RedisCacheManager cacheManager(CacheProperties cacheProperties, CacheManagerCustomizers cacheManagerCustomizers, ObjectProvider<org.springframework.data.redis.cache.RedisCacheConfiguration> redisCacheConfiguration, ObjectProvider<RedisCacheManagerBuilderCustomizer> redisCacheManagerBuilderCustomizers, RedisConnectionFactory redisConnectionFactory, ResourceLoader resourceLoader) {
        RedisCacheManagerBuilder builder = RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(this.determineConfiguration(cacheProperties, redisCacheConfiguration, resourceLoader.getClassLoader()));
        List<String> cacheNames = cacheProperties.getCacheNames();
        if (!cacheNames.isEmpty()) {
            builder.initialCacheNames(new LinkedHashSet(cacheNames));
        }

        if (cacheProperties.getRedis().isEnableStatistics()) {
            builder.enableStatistics();
        }

        redisCacheManagerBuilderCustomizers.orderedStream().forEach((customizer) -> {
            customizer.customize(builder);
        });
        return (RedisCacheManager)cacheManagerCustomizers.customize(builder.build());
    }
}

RedisCacheManager

该类继承了AbstractCacheManager，AbstractCacheManager重写了接口InitializingBean的方法，loadCaches是模板方法，具体的业务由子类实现。

	@Override
	public void afterPropertiesSet() {
		initializeCaches();
	}

	public void initializeCaches() {
		Collection<? extends Cache> caches = loadCaches();

		synchronized (this.cacheMap) {
			this.cacheNames = Collections.emptySet();
			this.cacheMap.clear();
			Set<String> cacheNames = new LinkedHashSet<>(caches.size());
			for (Cache cache : caches) {
				String name = cache.getName();
				this.cacheMap.put(name, decorateCache(cache));
				cacheNames.add(name);
			}
			this.cacheNames = Collections.unmodifiableSet(cacheNames);
		}
	}

RedisCacheManager#loadCaches，会创建多个RedisCache的缓存。

	protected Collection<RedisCache> loadCaches() {

		List<RedisCache> caches = new LinkedList<>();

		for (Map.Entry<String, RedisCacheConfiguration> entry : initialCacheConfiguration.entrySet()) {
			caches.add(createRedisCache(entry.getKey(), entry.getValue()));
		}

		return caches;
	}

RedisCacheConfiguration#defaultCacheConfig()，加载默认配置，默认的缓存配置是0s，意味着没有缓存时间。

	public static RedisCacheConfiguration defaultCacheConfig() {
		return defaultCacheConfig(null);
	}

	public static RedisCacheConfiguration defaultCacheConfig(@Nullable ClassLoader classLoader) {

		DefaultFormattingConversionService conversionService = new DefaultFormattingConversionService();

		registerDefaultConverters(conversionService);

		return new RedisCacheConfiguration(Duration.ZERO, true, true, CacheKeyPrefix.simple(),
				SerializationPair.fromSerializer(RedisSerializer.string()),
				SerializationPair.fromSerializer(RedisSerializer.java(classLoader)), conversionService);
	}

CacheInterceptor

CacheInterceptor重写invoke方法。

public class CacheInterceptor extends CacheAspectSupport implements MethodInterceptor, Serializable {

	@Override
	@Nullable
	public Object invoke(final MethodInvocation invocation) throws Throwable {
		Method method = invocation.getMethod();

		CacheOperationInvoker aopAllianceInvoker = () -> {
			try {
				return invocation.proceed();
			}
			catch (Throwable ex) {
				throw new CacheOperationInvoker.ThrowableWrapper(ex);
			}
		};

		Object target = invocation.getThis();
		Assert.state(target != null, "Target must not be null");
		try {
			return execute(aopAllianceInvoker, target, method, invocation.getArguments());
		}
		catch (CacheOperationInvoker.ThrowableWrapper th) {
			throw th.getOriginal();
		}
	}

}

CacheAspectSupport#execute()，获取CacheOperation，执行缓存的相关逻辑。

	@Nullable
	protected Object execute(CacheOperationInvoker invoker, Object target, Method method, Object[] args) {
		// Check whether aspect is enabled (to cope with cases where the AJ is pulled in automatically)
		if (this.initialized) {
			Class<?> targetClass = getTargetClass(target);
			CacheOperationSource cacheOperationSource = getCacheOperationSource();
			if (cacheOperationSource != null) {
				Collection<CacheOperation> operations = cacheOperationSource.getCacheOperations(method, targetClass);
				if (!CollectionUtils.isEmpty(operations)) {
					return execute(invoker, method,
							new CacheOperationContexts(operations, method, args, target, targetClass));
				}
			}
		}

		return invoker.invoke();
	}

AbstractFallbackCacheOperationSource#getCacheOperations获取注解信息，为了避免重复解析，进行了缓存优化。已经解析过的方法直接从缓存中获取。

	public Collection<CacheOperation> getCacheOperations(Method method, @Nullable Class<?> targetClass) {
		if (method.getDeclaringClass() == Object.class) {
			return null;
		}

		Object cacheKey = getCacheKey(method, targetClass);
		Collection<CacheOperation> cached = this.attributeCache.get(cacheKey);

		if (cached != null) {
			return (cached != NULL_CACHING_ATTRIBUTE ? cached : null);
		}
		else {
			Collection<CacheOperation> cacheOps = computeCacheOperations(method, targetClass);
			if (cacheOps != null) {
				if (logger.isTraceEnabled()) {
					logger.trace("Adding cacheable method '" + method.getName() + "' with attribute: " + cacheOps);
				}
				this.attributeCache.put(cacheKey, cacheOps);
			}
			else {
				this.attributeCache.put(cacheKey, NULL_CACHING_ATTRIBUTE);
			}
			return cacheOps;
		}
	}

CacheAspectSupport#execute()，缓存中存在数据，则不会进行方法调用，缓存中不存在数据，进行缓存的更新。

	@Nullable
	private Object execute(final CacheOperationInvoker invoker, Method method, CacheOperationContexts contexts) {
		// Special handling of synchronized invocation
		if (contexts.isSynchronized()) {
			CacheOperationContext context = contexts.get(CacheableOperation.class).iterator().next();
			if (isConditionPassing(context, CacheOperationExpressionEvaluator.NO_RESULT)) {
				Object key = generateKey(context, CacheOperationExpressionEvaluator.NO_RESULT);
				Cache cache = context.getCaches().iterator().next();
				try {
					return wrapCacheValue(method, handleSynchronizedGet(invoker, key, cache));
				}
				catch (Cache.ValueRetrievalException ex) {
					// Directly propagate ThrowableWrapper from the invoker,
					// or potentially also an IllegalArgumentException etc.
					ReflectionUtils.rethrowRuntimeException(ex.getCause());
				}
			}
			else {
				// No caching required, only call the underlying method
				return invokeOperation(invoker);
			}
		}


		// Process any early evictions
		processCacheEvicts(contexts.get(CacheEvictOperation.class), true,
				CacheOperationExpressionEvaluator.NO_RESULT);

		// Check if we have a cached item matching the conditions
		Cache.ValueWrapper cacheHit = findCachedItem(contexts.get(CacheableOperation.class));

		// Collect puts from any @Cacheable miss, if no cached item is found
		List<CachePutRequest> cachePutRequests = new ArrayList<>();
		if (cacheHit == null) {
			collectPutRequests(contexts.get(CacheableOperation.class),
					CacheOperationExpressionEvaluator.NO_RESULT, cachePutRequests);
		}

		Object cacheValue;
		Object returnValue;

		if (cacheHit != null && !hasCachePut(contexts)) {
			// If there are no put requests, just use the cache hit
			cacheValue = cacheHit.get();
			returnValue = wrapCacheValue(method, cacheValue);
		}
		else {
			// Invoke the method if we don't have a cache hit
			returnValue = invokeOperation(invoker);
			cacheValue = unwrapReturnValue(returnValue);
		}

		// Collect any explicit @CachePuts
		collectPutRequests(contexts.get(CachePutOperation.class), cacheValue, cachePutRequests);

		// Process any collected put requests, either from @CachePut or a @Cacheable miss
		for (CachePutRequest cachePutRequest : cachePutRequests) {
			cachePutRequest.apply(cacheValue);
		}

		// Process any late evictions
		processCacheEvicts(contexts.get(CacheEvictOperation.class), false, cacheValue);

		return returnValue;
	}

CacheAspectSupport#findCachedItem，判断缓存中是否有数据。

	private Cache.ValueWrapper findCachedItem(Collection<CacheOperationContext> contexts) {
		Object result = CacheOperationExpressionEvaluator.NO_RESULT;
		for (CacheOperationContext context : contexts) {
			if (isConditionPassing(context, result)) {
				Object key = generateKey(context, result);
				Cache.ValueWrapper cached = findInCaches(context, key);
				if (cached != null) {
					return cached;
				}
				else {
					if (logger.isTraceEnabled()) {
						logger.trace("No cache entry for key '" + key + "' in cache(s) " + context.getCacheNames());
					}
				}
			}
		}
		return null;
	}

CacheAspectSupport.CacheOperationContext#generateKey，获取key，这里用到了Spring的表达式。

		protected Object generateKey(@Nullable Object result) {
			if (StringUtils.hasText(this.metadata.operation.getKey())) {
				EvaluationContext evaluationContext = createEvaluationContext(result);
				return evaluator.key(this.metadata.operation.getKey(), this.metadata.methodKey, evaluationContext);
			}
			return this.metadata.keyGenerator.generate(this.target, this.metadata.method, this.args);
		}

RedisCache

获取数据

根据key获取缓存数据，AbstractValueAdaptingCache#get(java.lang.Object)

	public ValueWrapper get(Object key) {
		return toValueWrapper(lookup(key));
	}

RedisCache#lookup，这里默认使用字符串序列化器对key进行序列化，用JDK序列器对value进行序列化。

	@Override
	protected Object lookup(Object key) {

		byte[] value = cacheWriter.get(name, createAndConvertCacheKey(key));

		if (value == null) {
			return null;
		}

		return deserializeCacheValue(value);
	}

RedisCache#prefixCacheKey，会将缓存的name和key拼接在一起。格式name::key。

	private String prefixCacheKey(String key) {

		// allow contextual cache names by computing the key prefix on every call.
		return cacheConfig.getKeyPrefixFor(name) + key;
	}

RedisCache#serializeCacheKey，根据生成的key进行序列化。这里有用到ByteBuff。

protected byte[] serializeCacheKey(String cacheKey) {
   return ByteUtils.getBytes(cacheConfig.getKeySerializationPair().write(cacheKey));
}

DefaultRedisCacheWriter#get，根据生成的key的字节数组来获取缓存中的数据。

	@Override
	public byte[] get(String name, byte[] key) {

		Assert.notNull(name, "Name must not be null!");
		Assert.notNull(key, "Key must not be null!");

		byte[] result = execute(name, connection -> connection.get(key));

		statistics.incGets(name);

		if (result != null) {
			statistics.incHits(name);
		} else {
			statistics.incMisses(name);
		}

		return result;
	}

RedisCache#deserializeCacheValue，反序列化转成对象。

	@Nullable
	protected Object deserializeCacheValue(byte[] value) {

		if (isAllowNullValues() && ObjectUtils.nullSafeEquals(value, BINARY_NULL_VALUE)) {
			return NullValue.INSTANCE;
		}

		return cacheConfig.getValueSerializationPair().read(ByteBuffer.wrap(value));
	}

存储数据

RedisCache#put

	@Override
	public void put(Object key, @Nullable Object value) {

		Object cacheValue = preProcessCacheValue(value);

		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());
	}

DefaultRedisCacheWriter#put，判断是否需要过期时间。RedisCache的缓存配置和CacheManager的缓存配置是一致的，默认的缓存配置ttl就是0s，所以没有过期时间。

	@Override
	public void put(String name, byte[] key, byte[] value, @Nullable Duration ttl) {

		Assert.notNull(name, "Name must not be null!");
		Assert.notNull(key, "Key must not be null!");
		Assert.notNull(value, "Value must not be null!");

		execute(name, connection -> {

			if (shouldExpireWithin(ttl)) {
				connection.set(key, value, Expiration.from(ttl.toMillis(), TimeUnit.MILLISECONDS), SetOption.upsert());
			} else {
				connection.set(key, value);
			}

			return "OK";
		});

		statistics.incPuts(name);
	}

	private static boolean shouldExpireWithin(@Nullable Duration ttl) {
		return ttl != null && !ttl.isZero() && !ttl.isNegative();
	}

设置过期时间

    @Bean
    public CacheManager cacheManager(@Autowired RedisConnectionFactory connectionFactory) {
        return RedisCacheManager
                .builder(connectionFactory)
                .cacheDefaults(RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofMinutes(5)))
                .transactionAware()
                .build();
    }

在这里插入图片描述

秋装什么
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot-Cache（缓存）
六道
05-12 395
JSR107 Java Caching定义了5个核心接口，分别是CachingProvider, CacheManager, Cache, Entry和 Expiry。 • CachingProvider定义了创建、配置、获取、管理和控制多个CacheManager。一个应用可以在运行期访问多个CachingProvider。 • CacheManager定义了创建、配置、获取、管理和控制多个唯一命名的Cache，这些Cache存在于CacheManager的上下文中。一个CacheManager仅被一个C
java之SpringCache之@Cacheable注解的说明使用
06-16
这里面说的“相同参数”一定要正确理解，也就是说同一个方法使用了@Cacheable注解，但是有不同的参数组合来调用这个方法，则会才产生你的组合数个key来存储缓存数据！ 好了，接下来我们看一下，这注解的每个参数...
springboot结合 @Cacheable和@CacheEvict拉起和清空缓存.zip
11-19
关于@Cacheable注解在方法上根据请求参数拉起缓存内容,同时@CacheEvict 注解在方法上清空指定key缓存的原理内容
Spring缓存注解--@Cacheable
llg___的博客
03-24 5474
@Cacheable注解失效的原因。缓存以键值对的形式，key用来指定键，String类型。在方法或者类上加了@Cacheable注解，但是数据并未被缓存到Redis。即缓存解析器，该属性与cacheManager 是互斥的，只能指定一个。源码中这个属性是String数组类型，即可以指定多个缓存位置。其中，#参数名和其他字符串使用+号拼接出一个key的做法很常见。指定是否使用异步模式，默认false，即同步模式。，和condition是条件满足时缓存，二者相反。条件，指定符合什么条件的时候，才进行缓存。
Spring Cache核心源码分析
最新发布
1点25的博客
07-07 902
Spring Cache整体而言，就是利用Spring AOP机制，利用代理对象在执行方法时对缓存进行操作，除开以上源码流程外，其实还有比如@EnableCaching的实现源码，以及RedisCache是怎么和Redis进行交互的实现源码，下次再分析吧，我是大都督周瑜，记得关注我，大家如果有收获，帮忙分享。
Spring 之 @Cacheable 源码解析（上）
龚小帅的博客
01-18 2416
当要使用 @Cacheable 注解时需要引入 @EnableCaching 注解开启缓存功能。为什么呢？现在就来看看为什么要加入 @EnableCaching 注解才能开启缓存切面呢？可以看出是通过 @Import 注解来导入一个类 CachingConfigurationSelector，猜测下，这个类肯定是一个入口类，也可以说是个触发类。注意此处 mode() 默认是。类、类。那么接下来就重点分析这两个类是用来干啥的？
Spring 之 @Cacheable 源码解析（下）
龚小帅的博客
01-18 2254
在 loadCaches() 方法中可以返回非常多 Cache 实例，那么这么多实例要怎么存呢，肯定需要有映射关系，那么必然采用 Map，那么 key 就是对应的 cacheName，value 就是对应的 Cache，Spring 就是这样设计的。：先去查对应缓存(Redis、LocalMap 等缓存)，缓存命中直接返回，未命中，先创建 CachePutRequest 请求头，在去调用目标方法获取数据(可能从数据库中查询数据等)，然后将查到的数据保存到对应缓存中，最后返回获取到的数据。
SpringBoot 整合缓存Cacheable实战详细使用
daTou
08-18 1973
前言 我知道在接口api项目中，频繁的调用接口获取数据，查询数据库是非常耗费资源的，于是就有了缓存技术，可以把一些不常更新，或者经常使用的数据，缓存起来，然后下次再请求时候，就直接从缓存中获取，不需要再去查询数据，这样可以提供程序性能，增加用户体验，也节省服务资源浪费开销， 在springboot帮你我们做好了整合，有对应的场景启动器start，我们之间引入使用就好了，帮我们整合了各种缓存 <dependencies> <dependency>
Spring boot cacheable源码及默认配置
淡然坊
11-20 4319
一. Spring boot cache原理 第一步. 自动配置类 ​自动启动类：CacheAutoConfiguration 属性配置：CacheProperties 主启动类添加：@EnableCaching注解 cache POM添加： <dependency> <groupId>org.springframework.boot</group...
详解Spring缓存注解@Cacheable,@CachePut , @CacheEvict使用
08-30
Spring 框架提供了三个缓存注解：@Cacheable、@CachePut 和 @CacheEvict，这三个注解可以帮助开发者简化缓存的使用，提高应用程序的性能。在本文中，我们将详细介绍这三个注解的使用方法和配置参数。 一、@...
SpringBoot缓存管理开源架构源码2021.pdf
04-27
虽然文档内容不全，但根据标题“SpringBoot缓存管理开源架构源码2021.pdf”，可以推断文档还可能介绍了Spring Boot缓存的高级特性。比如缓存的动态配置、缓存失效策略、缓存统计和监控等。这些高级特性可以帮助...
Springboot整合GuavaCache缓存过程解析
08-25
SpringBoot整合GuavaCache缓存过程解析是指使用SpringBoot框架将GuavaCache整合到应用程序中，以提高应用程序的性能和响应速度。 GuavaCache的优点是： * 简单：GuavaCache的使用非常简单，只需要在pom.xml文件中...
深入浅出@Cacheable
你就像甜甜的益达
10-20 367
它可以被用来缓存方法返回的结果。当使用@Cacheable注解时，Spring会在调用方法前检查缓存中是否已经存在该方法的结果，如果存在，则直接返回缓存中的结果，而不会执行方法体中的代码。如果缓存中不存在该方法的结果，则会执行方法体中的代码，并将结果存储到缓存中，以便下次调用该方法时可以直接返回缓存中的结果。当调用getUserById方法时，Spring会先检查名为“users”的缓存中是否已经存在键为userId的结果，如果存在，则直接返回缓存中的结果，否则执行方法体中的代码，并将结果存储到缓存中。
SpringBoot 缓存之 @Cacheable 详细介绍
热门推荐
勇往直前的专栏
12-10 13万+
一、简介 1、缓存介绍 Spring 从 3.1 开始就引入了对 Cache 的支持。定义了 org.springframework.cache.Cache 和 org.springframework.cache.CacheManager 接口来统一不同的缓存技术。并支持使用 JCache（JSR-107）注解简化我们的开发。 其使用方法和原理都类似于 Spring 对事务管理的支持。Spring Cache 是作用在方法上的，其核心思想是，当我们在调用一个缓存方法时会把该方法参数和返回结果作为一个
springboot-Cacheable
CentOS
04-10 2352
Spring为我们提供了几个注解来支持Spring Cache。其核心主要是@Cacheable和@CacheEvict。使用@Cacheable标记的方法在执行后Spring Cache将缓存其返回结果，而使用@CacheEvict标记的方法会在方法执行前或者执行后移除Spring Cache中的某些元素。下面我们将来详细介绍一下Spring基于注解对Cache的支持所提供的几个注解。 ...
spring缓存注解源码分析：@Cacheable @CacheEvict @CachePut
weixin_43866043的博客
12-07 1602
解决存入redis乱码 package com.example.demo.kang.config; import org.springframework.beans.factory.annotation.Value; import org.springframework.boot.autoconfigure.cache.CacheProperties; import org.springframework.context.annotation.Bean; import org.springframewor
Spring源码解析（一） 缓存——@Cacheable
方方园园的博客
07-27 1193
@Cacheable(value = "CACHE_BOOK",key = "#username", condition = "#language = 1") public List<Book> getBooksByUsernameAndLanguage(String username, int language) { // balabalabala...里面的代码不重要 return bookList; } value : 必须要的。就是个自己取的名字，通过它指明了第一次
springboot系列文章（十）springboot cache模块
kay三石
08-02 517
Spring Cache的使用方法和原理类似于Spring对事务管理的支持，都是AOP的方式。其核心思想是：当我们在调用一个缓存方法时会把该方法参数和返回结果作为一个键值对存放在缓存中，等到下次利用同样的参数来调用该方法时将不再执行该方法，而是直接从缓存中获取结果进行返回。 Spring Cache提供了@Cacheable、@CachePut、@CacheEvict等注解，在方法上使用。通过注...
spring boot中的@Cache
qq_24721713的博客
09-24 1131
#启用基于注解的缓存 使用@EnableCaching，在Application中声明Caching @EnableCaching @SpringBootApplication public class SpringbootApplication { } #在Server层的代码中使用@Cacheable Cacheable属性： cacheNames/value:缓存组名称 key:缓存数据...
SpringBoot 缓存 @Cacheable热加载
07-22
@Cacheable注解是Spring框架提供的缓存注解，用于标记方法的返回结果可被缓存。它可以应用在方法级别或类级别。当方法被调用时，Spring会首先从缓存中查找方法的返回结果，如果缓存中存在，则直接返回缓存值，不再执行方法体内的逻辑。如果缓存中不存在，则执行方法体内的逻辑，并将返回结果存入缓存中。 @Cacheable注解默认是使用方法的参数作为缓存的key，所以相同参数调用的方法返回结果会被缓存起来。但是默认情况下，如果在缓存中找不到对应的结果，Spring会执行方法体内的逻辑，并将返回结果存入缓存中。这样会导致并发调用时出现缓存穿透问题，即多个线程同时请求同一个参数值，导致每个线程都执行了方法体内的逻辑，没有从缓存中获取到结果。 为了解决缓存穿透问题，可以使用热加载机制。热加载是指在缓存失效期间，只有一个线程去执行方法体内的逻辑，其他线程等待该线程执行完毕后直接从缓存中获取结果。 实现热加载可以通过在@Cacheable注解中设置sync属性为true。这样在缓存失效期间，只有一个线程去执行方法体内的逻辑，其他线程等待该线程执行完毕后直接从缓存中获取结果。示例代码如下： ```java @Cacheable(value = "myCache", key = "#param", sync = true) public String getData(String param) { // 执行业务逻辑 } ``` 需要注意的是，设置sync属性为true会导致性能损失，因为其他线程在等待期间无法直接从缓存中获取结果。因此，只有在必要的情况下才应该使用热加载机制。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值