《Spring 高手系列》（40）（Spring Cache）笔记

已于 2023-02-17 13:42:45 修改
阅读量427 收藏 1
点赞数
分类专栏： 笔记 文章标签： spring java 缓存
于 2022-10-31 16:17:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37151886/article/details/127616408
版权

前言

参考链接1

https://docs.spring.io/spring-framework/docs/5.3.3/reference/html/integration.html#cache-annotations

https://docs.spring.io/spring-data/redis/docs/current/reference/html

涉及知识点

spring cache

@EnableCaching

在这里插入图片描述

源码

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(CachingConfigurationSelector.class)
public @interface EnableCaching {

	boolean proxyTargetClass() default false;
	
	AdviceMode mode() default AdviceMode.PROXY;
	
	int order() default Ordered.LOWEST_PRECEDENCE;
}

public enum AdviceMode {	
	PROXY,
	ASPECTJ
}

注解的主要作用是引入一个选择器 CachingConfigurationSelector ，选择器会根据注解的 mode 参数使用不同的方法，默认为 PROXY ，执行 getProxyImports 方法。

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

	private String[] getAspectJImports() {
		List<String> result = new ArrayList<>(2);
		result.add(CACHE_ASPECT_CONFIGURATION_CLASS_NAME);
		if (jsr107Present && jcacheImplPresent) {
			result.add(JCACHE_ASPECT_CONFIGURATION_CLASS_NAME);
		}
		return StringUtils.toStringArray(result);
	}

getProxyImports 方法导入的三个类名如图所示
在这里插入图片描述

@Cacheable

在这里插入图片描述

源码

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Cacheable {
	//value 和 cacheNames 互为别名
	@AliasFor("cacheNames")
	String[] value() default {};

	@AliasFor("value")
	String[] cacheNames() default {};
	
	String key() default "";
	
	String keyGenerator() default "";
	
	String cacheManager() default "";
	
	String cacheResolver() default "";
	
	String condition() default "";
	
	String unless() default "";
	
	boolean sync() default false;
}

在这里插入图片描述

案例1 缓存list

@Component
public class ArticleService {

    @Cacheable(cacheNames = {"cache1"})
    public List<String> list() {
        System.out.println("获取文章列表!");
        return Arrays.asList("spring", "mysql", "java高并发", "maven");
    }
}

在这里插入图片描述

@EnableCaching
@ComponentScan
@Configuration
public class Client {

    @Bean
    public CacheManager cacheManager() {
        ConcurrentMapCacheManager cacheManager = new ConcurrentMapCacheManager("cache1");
        return cacheManager;
    }

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(Client.class);
        context.refresh();
        ArticleService articleService = context.getBean(ArticleService.class);
        System.out.println(articleService.list());
        System.out.println(articleService.list());
    }

}

获取文章列表!
[spring, mysql, java高并发, maven]
[spring, mysql, java高并发, maven]

在这里插入图片描述

key属性：自定义key

在这里插入图片描述

案例2 自定义key

    @Cacheable(cacheNames = {"cache1"}, key = "#root.target.class.name+'-'+#page+'-'+#pageSize")
    public String getPage(int page, int pageSize) {
        String msg = String.format("page-%s-pageSize-%s", page, pageSize);
        System.out.println("从db中获取数据：" + msg);
        return msg;
    }

@EnableCaching
@ComponentScan
@Configuration
public class Client2 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(Client2.class);
        context.refresh();
        ArticleService articleService = context.getBean(ArticleService.class);

        //page=1,pageSize=10调用2次
        System.out.println(articleService.getPage(1, 10));
        System.out.println(articleService.getPage(1, 10));

        //page=2,pageSize=10调用2次
        System.out.println(articleService.getPage(2, 10));
        System.out.println(articleService.getPage(2, 10));

        {
            System.out.println("下面打印出cache1缓存中的key列表");
            ConcurrentMapCacheManager cacheManager = context.getBean(ConcurrentMapCacheManager.class);
            ConcurrentMapCache cache1 = (ConcurrentMapCache) cacheManager.getCache("cache1");
            cache1.getNativeCache().keySet().stream().forEach(System.out::println);
        }
    }
}

从db中获取数据：page-1-pageSize-10
page-1-pageSize-10
page-1-pageSize-10
从db中获取数据：page-2-pageSize-10
page-2-pageSize-10
page-2-pageSize-10
下面打印出cache1缓存中的key列表
com.example.lurenjia.spring.c40.cacheable.d1.ArticleService-1-10
com.example.lurenjia.spring.c40.cacheable.d1.ArticleService-2-10

condition属性：控制缓存的使用条件

在这里插入图片描述

案例3 condition

    @Cacheable(cacheNames = "cache1", key = "'getById'+#id", condition = "#cache")
    public String getById(Long id, boolean cache) {
        System.out.println("获取数据!");
        return "spring缓存:" + UUID.randomUUID().toString();
    }

@EnableCaching
@ComponentScan
@Configuration
public class Client3 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(Client3.class);
        context.refresh();
        ArticleService articleService = context.getBean(ArticleService.class);

        System.out.println(articleService.getById(1L, true));
        System.out.println(articleService.getById(1L, true));
        System.out.println(articleService.getById(1L, false));
        System.out.println(articleService.getById(1L, true));
    }
}

获取数据!
spring缓存:0320318f-7cff-4efb-91ac-e7ed2da8eadb
spring缓存:0320318f-7cff-4efb-91ac-e7ed2da8eadb
获取数据!
spring缓存:04ffafe0-fc36-43a3-b400-2243dca2c545
spring缓存:0320318f-7cff-4efb-91ac-e7ed2da8eadb

在这里插入图片描述

unless属性：控制是否需要将结果丢到缓存中

在这里插入图片描述

案例4 unless 当返回结果为null的时候，不要将结果进行缓存

    java.util.Map<Long, String> articleMap = new HashMap<>();

    @Cacheable(cacheNames = "cache1", key = "'findById'+#id", unless = "#result==null")
    public String findById(Long id) {
        this.articleMap.put(1L, "spring系列");
        System.out.println("----获取文章:" + id);
        return articleMap.get(id);
    }

@EnableCaching
@ComponentScan
@Configuration
public class Client4 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(Client4.class);
        context.refresh();
        ArticleService articleService = context.getBean(ArticleService.class);

        System.out.println(articleService.findById(1L));
        System.out.println(articleService.findById(1L));
        System.out.println(articleService.findById(3L));
        System.out.println(articleService.findById(3L));

        {
            System.out.println("下面打印出缓cache1缓存中的key列表");
            ConcurrentMapCacheManager cacheManager = context.getBean(ConcurrentMapCacheManager.class);
            ConcurrentMapCache cache1 = (ConcurrentMapCache) cacheManager.getCache("cache1");
            cache1.getNativeCache().keySet().stream().forEach(System.out::println);
        }
    }
}

----获取文章:1
spring系列
spring系列
----获取文章:3
null
----获取文章:3
null
下面打印出缓cache1缓存中的key列表
findById1

condition和unless对比

在这里插入图片描述

@CachePut：将结果放入缓存

在这里插入图片描述

源码

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface CachePut {

	@AliasFor("cacheNames")
	String[] value() default {};

	@AliasFor("value")
	String[] cacheNames() default {};
		
	String key() default "";
	
	String keyGenerator() default "";
	
	String cacheManager() default "";
	
	String cacheResolver() default "";
	
	String condition() default "";

	String unless() default "";
}

案例1

    @CachePut(cacheNames = "cache1", key = "'findById'+#id")
    public String add(Long id, String content) {
        System.out.println("新增文章:" + id);
        this.articleMap.put(id, content);
        return content;
    }

@EnableCaching
@ComponentScan
@Configuration
public class Client6 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(Client6.class);
        context.refresh();
        ArticleService articleService = context.getBean(ArticleService.class);

        //新增3个文章，由于add方法上面有@CachePut注解，所以新增之后会自动丢到缓存中
        articleService.add(1L, "java高并发系列");
        articleService.add(2L, "Maven高手系列");
        articleService.add(3L, "MySQL高手系列");

        //然后调用findById获取，看看是否会走缓存
        System.out.println("调用findById方法，会尝试从缓存中获取");
        System.out.println(articleService.findById(1L));
        System.out.println(articleService.findById(2L));
        System.out.println(articleService.findById(3L));

        {
            System.out.println("下面打印出cache1缓存中的key列表");
            ConcurrentMapCacheManager cacheManager = context.getBean(ConcurrentMapCacheManager.class);
            ConcurrentMapCache cache1 = (ConcurrentMapCache) cacheManager.getCache("cache1");
            cache1.getNativeCache().keySet().stream().forEach(System.out::println);
        }
    }
}

@CacheEvict：缓存清理

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface CacheEvict {
	
	@AliasFor("cacheNames")
	String[] value() default {};
	
	@AliasFor("value")
	String[] cacheNames() default {};
	
	String key() default "";
	
	String keyGenerator() default "";
	
	String cacheManager() default "";
	
	String cacheResolver() default "";
	
	String condition() default "";

	boolean allEntries() default false;
	
	boolean beforeInvocation() default false;
}

修饰范围：类型、方法，修饰类子类继承，value和cacheNames互为别名。

案例1

    @CacheEvict(cacheNames = "cache1", key = "'findById'+#id") //@1
    public void delete(Long id) {
        System.out.println("删除文章：" + id);
        this.articleMap.remove(id);
    }

@EnableCaching
@ComponentScan
@Configuration
public class Client7 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(Client7.class);
        context.refresh();
        ArticleService articleService = context.getBean(ArticleService.class);

        //第1次调用findById，缓存中没有，则调用方法，将结果丢到缓存中
        System.out.println(articleService.findById(1L));
        //第2次调用findById，缓存中存在，直接从缓存中获取
        System.out.println(articleService.findById(1L));

        //执行删除操作，delete方法上面有@CacheEvict方法，会清除缓存
        articleService.delete(1L);

        //再次调用findById方法，发现缓存中没有了，则会调用目标方法
        System.out.println(articleService.findById(1L));
    }
}

----获取文章:1
spring系列
spring系列
删除文章：1
----获取文章:1
spring系列

@Caching：缓存注解组

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Caching {

	Cacheable[] cacheable() default {};

	CachePut[] put() default {};

	CacheEvict[] evict() default {};

}

修饰范围：类型、方法，修饰类子类继承。

Cacheable、CachePut、CacheEvict不支持重复使用，所以定义该注解存放。

@CacheConfig

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface CacheConfig {

	String[] cacheNames() default {};
	
	String keyGenerator() default "";
	
	String cacheManager() default "";
	
	String cacheResolver() default "";
}

修饰范围：类型，用于统一设置一些属性。

Redis整合Spring Cache

yml添加注解

spring:
  cache:
    type: redis

测试方法

    @GetMapping("cache1")
    @Cacheable(cacheNames = "cache1")
    public List<String> list() {
        System.out.println("---模拟从db中获取数据---");
        return Arrays.asList("java高并发", "springboot", "springcloud");
    }

效果
在这里插入图片描述

不足

      time-to-live: 3600000

Redisson整合Spring Cache

参考链接2

        <!-- https://mvnrepository.com/artifact/org.redisson/redisson -->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.17.7</version>
        </dependency>

@Configuration
public class RedissonConfig {

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

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

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

    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        if (org.springframework.util.ObjectUtils.isEmpty(password)) {
            config.useSingleServer().setAddress("redis://" + host + ":" + port);
        } else {
            config.useSingleServer().setAddress("redis://" + host + ":" + port).setPassword(password);
        }

        config.setCodec(new org.redisson.codec.JsonJacksonCodec());
        return Redisson.create(config);
    }

    @ConditionalOnBean(value = RedissonClient.class)
    @Bean
    public RedissonSpringCacheManager manager(@Autowired RedissonClient client) {
        RedissonSpringCacheManager manager = new RedissonSpringCacheManager(client);
        return new RedissonSpringCacheManager(client);
    }

}


    @GetMapping("cache1")
    @Cacheable(cacheNames = "cache1", key = "#root.targetClass.name+'-'+#root.method.name")
    public List<String> list() {
        System.out.println("---模拟从db中获取数据---");
        return Arrays.asList("java高并发", "springboot", "springcloud");
    }

编码问题 codec

        if (oldConf.getCodec() == null) {
            // use it by default
            oldConf.setCodec(new MarshallingCodec());
        }

默认情况下会使用 MarshallingCodec

在这里插入图片描述

在配置文件中修改为jackson

        config.setCodec(new org.redisson.codec.JsonJacksonCodec());

在这里插入图片描述

原理

CacheAutoConfiguration

源码如下，重点是导入了 CacheConfigurationImportSelector.class这一个类

@EnableConfigurationProperties(CacheProperties.class)
@AutoConfigureAfter({ CouchbaseDataAutoConfiguration.class, HazelcastAutoConfiguration.class,
		HibernateJpaAutoConfiguration.class, RedisAutoConfiguration.class })
@Import({ CacheConfigurationImportSelector.class, CacheManagerEntityManagerFactoryDependsOnPostProcessor.class })
public class CacheAutoConfiguration {}

CacheConfigurationImportSelector

	static class CacheConfigurationImportSelector implements ImportSelector {

		@Override
		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;
		}

	}

通过这个选择器来获取导入内容。 imports[i] = CacheConfigurations.getConfigurationClass(types[i]);

CacheConfigurations

final class CacheConfigurations {

	private static final Map<CacheType, Class<?>> MAPPINGS;

	static {
		Map<CacheType, Class<?>> mappings = new EnumMap<>(CacheType.class);
		mappings.put(CacheType.GENERIC, GenericCacheConfiguration.class);
		mappings.put(CacheType.EHCACHE, EhCacheCacheConfiguration.class);
		mappings.put(CacheType.HAZELCAST, HazelcastCacheConfiguration.class);
		mappings.put(CacheType.INFINISPAN, InfinispanCacheConfiguration.class);
		mappings.put(CacheType.JCACHE, JCacheCacheConfiguration.class);
		mappings.put(CacheType.COUCHBASE, CouchbaseCacheConfiguration.class);
		mappings.put(CacheType.REDIS, RedisCacheConfiguration.class);
		mappings.put(CacheType.CAFFEINE, CaffeineCacheConfiguration.class);
		mappings.put(CacheType.SIMPLE, SimpleCacheConfiguration.class);
		mappings.put(CacheType.NONE, NoOpCacheConfiguration.class);
		MAPPINGS = Collections.unmodifiableMap(mappings);
	}

	private CacheConfigurations() {
	}
	//如果在MAPPINGS中找到了，返回class的名字
	static String getConfigurationClass(CacheType cacheType) {
		Class<?> configurationClass = MAPPINGS.get(cacheType);
		Assert.state(configurationClass != null, () -> "Unknown cache type " + cacheType);
		return configurationClass.getName();
	}

	static CacheType getType(String configurationClassName) {
		for (Map.Entry<CacheType, Class<?>> entry : MAPPINGS.entrySet()) {
			if (entry.getValue().getName().equals(configurationClassName)) {
				return entry.getKey();
			}
		}
		throw new IllegalStateException("Unknown configuration class " + configurationClassName);
	}

}

CacheConfigurations会帮我们导入 mappings.put(CacheType.REDIS, RedisCacheConfiguration.class);

RedisCacheConfiguration

最重要的就是 RedisCacheConfiguration 中的这个bean，RedisCacheManager

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

	@Bean
	RedisCacheManager cacheManager(CacheProperties cacheProperties, CacheManagerCustomizers cacheManagerCustomizers,
			ObjectProvider<org.springframework.data.redis.cache.RedisCacheConfiguration> redisCacheConfiguration,
			ObjectProvider<RedisCacheManagerBuilderCustomizer> redisCacheManagerBuilderCustomizers,
			RedisConnectionFactory redisConnectionFactory, ResourceLoader resourceLoader) {}
}

这个类里面有一个比较重要的bean RedisCacheManager ，下面我们重点看一下这一个类。

RedisCacheManager

	@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(
				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 cacheManagerCustomizers.customize(builder.build());
	}

在这个bean上定义的参数首先会去容器中查找。

	private org.springframework.data.redis.cache.RedisCacheConfiguration determineConfiguration(
			CacheProperties cacheProperties,
			ObjectProvider<org.springframework.data.redis.cache.RedisCacheConfiguration> redisCacheConfiguration,
			ClassLoader classLoader) {
		//如果没有默认创建一个新的redisCacheConfiguration
		return redisCacheConfiguration.getIfAvailable(() -> createConfiguration(cacheProperties, classLoader));
	}

createConfiguration这一个类就是创建配置的核心类

	private org.springframework.data.redis.cache.RedisCacheConfiguration createConfiguration(
			CacheProperties cacheProperties, ClassLoader classLoader) {
		Redis redisProperties = cacheProperties.getRedis();
		org.springframework.data.redis.cache.RedisCacheConfiguration config = org.springframework.data.redis.cache.RedisCacheConfiguration
				.defaultCacheConfig();
		config = config.serializeValuesWith(
				SerializationPair.fromSerializer(new JdkSerializationRedisSerializer(classLoader)));
		if (redisProperties.getTimeToLive() != null) {
			config = config.entryTtl(redisProperties.getTimeToLive());
		}
		if (redisProperties.getKeyPrefix() != null) {
			config = config.prefixCacheNameWith(redisProperties.getKeyPrefix());
		}
		if (!redisProperties.isCacheNullValues()) {
			config = config.disableCachingNullValues();
		}
		if (!redisProperties.isUseKeyPrefix()) {
			config = config.disableKeyPrefix();
		}
		return config;
	}

当没有 org.springframework.data.redis.cache.RedisCacheConfiguration 这个bean的时候会使用这个方法默认创建一个新的配置类。

当我们

ObjectProvider的用法

ObjectProvider<org.springframework.data.redis.cache.RedisCacheConfiguration> redisCacheConfiguration

newProxyInstance
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springcache笔记
shuangmu9768的博客
09-05 1万+
【1】概述 【2】@EnableCaching的使用 【3】@Cacheable的使用 【4】@CachePut的使用 【5】@CacheEvict的使用 【6】@CacheConfig的使用 【1】概述 #Spring 3.1引入了激动人心的基于注释（annotation）的缓存（cache）技术，它本质上不是一个具体的缓存实现方案（例如 EHCache 或者 OSCache），而是一个对缓存使用的抽象，通过在既有代码中添加少量它定义的各种 annotation，即能够达到缓存方法的返回对象的效果。 #
第七章 Spring cache与异步调用笔记
hankin的博客
01-16 970
一、Spring cache缓存 1、缓存配置 1.1、xml文件配置 <!-- 配置文件加载 --><bean id="propertyConfigurerForCache" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property...
spring学习--12 @Enable*注解工作原理
xiewz1112的博客
05-29 425
所有@Enable*已经注解的元注解中均包含@Import注解，@Import用于导入配置类，因此@Enable*注解通过导入配置类实现*所标注功能的使能。如@EnableAsync、@EnableScheduling、@EnableAspectJAutoProxy等等。 导入配置类方式分为三种： 1、直接导入配置类，如@EnableScheduling导入SchedulingConfigur...
spring注解驱动系列--声明式事务
最新发布
weixin_42972832的博客
04-06 1003
- 数据源、数据库驱动、spring-jdbc模块-->
设计模式之代理设计模式(Proxy)之 (3)动态代理(CGLIB)
MrLiar的博客
03-28 610
cglib代理 前提条件： 需要引入cglib的jar文件，由于Spring的核心包中已经包括了Cglib功能，所以也可以直接引入spring-core-xxx.jar 目标类不能为final 目标对象的方法如果为final/static，那么就不会被拦截，即不会执行目标对象额外的业务方法 /* * 接口 */ public interface ISinger { void si...
Spring注解驱动开发第35讲——声明式事务原理的源码分析
李阿昀的博客
12-28 3242
写在前面 上一讲，我向大家简单介绍了一下注解版的声明式事务，相信大家已经会初步使用了。这一讲，咱们就从源码的角度分析一下声明式事务的原理，让大家对声明式事务的原理有一个更加深入的认识。 声明式事务的原理 其实，要想知道声明式事务的原理，只需要搞清楚@EnableTransactionManagement注解给容器中注册了什么组件，以及这些组件工作时候的功能是什么就行了，一旦把这个研究透了，那么声明式事务的原理我们就清楚了。 你有没有发现，咱们之前研究AOP的原理时，是从@EnableAspectJAutoP
缓存初见——EhCache
IT小小鸟
10-29 397
Ehcache简介 Ehcache简单使用 首先需要一个配置文件 <?xml version="1.0" encoding="UTF-8"?> <ehcache> <!-- 指定一个文件目录，当EhCache把数据写到硬盘上时，将把数据写到这个文件目录下 --> <diskStore path="java.io.tmpdir"/> <!-- cache元素的属性： name：缓存名称
spring-ehcache-redis两级缓存
11-13
两级缓存在redis的方案上做一步优化，在缓存到远程redis的同时，缓存一份到本地进程ehcache（此处的ehcache不用做集群，避免组播带来的开销），取缓存的时候会先取本地，没有会向redis请求，这样会减少应用服务器<–>缓存服务器redis之间的网络开销。（见下图，为了减少get这几条网络传输，我们会在每个应用服务器上增加本地的ehcache缓存作为二级缓存，即第一次get到的数据存入ehcache，后面output输出即可从本地ehcache中获取，不用再访问redis了，所以就减少了以后get的网络开销。get开销只要一次，后续不需要了，除非本地缓存过期需要再get。）
spring cache基础篇
weixin_43679491的博客
11-16 1996
Spring从3.1开始定义了org.springframework.cache.Cache和org.springframework.cache.CacheManager接口来统一不同的缓存技术；并支持使用JSR-107注解简化我们开发； 提供支持多种缓存的实现。 主要接口有两个: org.springframework.cache.Cache：用于定义缓存的各种操作 org.springframework.cache.CacheManager：用于管理各个cache缓存组件 常...
spring cache
qq_35653822的博客
03-12 548
1.想用redistemplate作为缓存，被领导制止了，指定用spring cache 2.自我理解：spring cache也是一个缓存，方便存储对象，但是缓存底层可以选择redis 3.spring cache+redis的好处 解决缓存不同步的情况 解决springcache占用内存的情况 集群环境下，每台服务器的spring cache是不同步的，这样会出问题的， spring cache只适合单机环境 redis是设置单独的缓存服务器，所有集群服务器统一访问redis，不会出现...
Spring Boot 学习笔记完整教程.docx
12-29
这个学习笔记的完整教程将涵盖多个关键领域，帮助开发者深入理解和使用 Spring Boot。 1. **Spring Boot 教程** - **基础入门**：了解 Spring Boot 的核心理念，包括自动配置、起步依赖和独立运行的特性。 - **...
完整版缓存CacheManagerDemo+通过反射获取对象
07-29
本Demo是Servlet 拿过去既可以导入运行，主要知识点是缓存管理，通过反射机制获取对象,有一种工厂设计模式在里面，缓存工具类采用的是单例模式.
Spring源码refresh方法调试笔记
11-01
### Spring源码refresh方法调试笔记 #### 一、概述 `refresh` 方法是Spring框架中的一个核心方法，它主要用于初始化整个应用上下文（ApplicationContext），包括加载配置文件、创建Bean实例等重要步骤。本文将深入...
SpringBoot系列：Spring Boot集成Spring Cache，使用EhCache
m0_63176399的博客
11-06 214
org.springframework.boot spring-boot-starter-cache 然后创建EhCache的配置文件ehcache.xml。 <?xml version="1.0" encoding="UTF-8"?> <ehcache 【一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义】 浏览器打开：qq.cn.hn/FTf 免费领取 xmlns:xsi=“http://www.w3.org/2001/XMLSchema-insta
Spring Cache源码分析
moranshouwang的博客
05-05 3636
Spring Cache源码分析 2018-05-05 10:55:20 星期六 1. @EnableCaching 我们通过在配置类中使用@EnableCaching开启Spring的缓存功能。 @EnableCaching 源码如下： @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Document...
Redisson的配置
qq_44861126的博客
04-23 4692
【代码】Redisson的配置。
Spring : @EnableCaching 的工作原理
Details Inside Spring
07-23 3583
开发人员使用注解@EnableCaching； 注解@EnableCaching导入CachingConfigurationSelector; CachingConfigurationSelector根据注解@EnableCaching 属性AdviceMode mode决定引入哪些配置类; 1.PROXY : AutoProxyRegistrar,ProxyCachingConfigurat...
Spring源码分析之@EnableAspectJAutoProxy注解分析
cherry93925的博客
05-09 952
纵观整个Spring的发展历史，注解的配置正逐步替代xml的配置，到SpringBoot时代，完全可以用注解的配置替换繁杂的xml配置，例如我们需要开启AOP功能只要在代码上配置上@EnableAspectJAutoProxy。废话不多说，我们这节来分析下@EnableAspectJAutoP...
Java for Web学习笔记（一零二）：Spring框架中使用JPA（2）Transaction（下）
愷风（Wei）的专栏
12-30 1427
上下文的配置 /* 【3】设置事务管理 * 3.1】允许@Transactional标记有效 * 使得@Transactional有效，可以被动态截获bean中被标识的方法，对其进行Spring framework method Advice，类似@EnableAsync，需要设置@EnableTransactionManagement。但需要注意：对于方法增强，我们应使用同一方式，如果配置
Spring框架配置与缓存实战笔记
"这篇资料是关于Spring框架的学习笔记，涵盖了Spring与Struts集成、缓存配置以及Hibernate中缓存的使用。" 在Spring框架的学习中，我们常常会遇到与其它框架如Struts的集成。在Struts-config.xml文件中添加Spring的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值