Spring Cache 使用

最新推荐文章于 2025-09-09 09:10:31 发布
转载 最新推荐文章于 2025-09-09 09:10:31 发布 · 54 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/whzhaochao/p/5023405.html
文章标签：

#java #测试

本文介绍如何使用Maven管理项目的依赖，并结合Spring框架实现缓存管理。具体包括Maven配置文件详解、Spring配置说明、自定义缓存实现等。通过示例展示了缓存查询、更新和删除的操作。

1.Maven配置项目所需要的JAR包

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.zhaochao</groupId>
	<artifactId>Demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>Demo</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<org.springframework.version>4.1.6.RELEASE</org.springframework.version>
		<project.version>1.0.0-SNAPSHOT</project.version>
		<junit.version>4.12</junit.version>

	</properties>

	<dependencies>
		<!-- junit 测试包 -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>${junit.version}</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>
		<!-- Bean Factory and JavaBeans utilities (depends on spring-core) Define this if you use Spring Bean APIs (org.springframework.beans.*) -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>

		<!-- Aspect Oriented Programming (AOP) Framework (depends on spring-core, spring-beans) Define this if you use Spring AOP APIs (org.springframework.aop.*) -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>

		<!-- Application Context (depends on spring-core, spring-expression, spring-aop, spring-beans) This is the central artifact for Spring's Dependency Injection Container and is generally always defined -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>


		<!-- Support for testing Spring applications with tools such as JUnit and TestNG This artifact is generally always defined with a 'test' scope for the integration testing framework and unit testing stubs -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>${org.springframework.version}</version>
			<scope>test</scope>
		</dependency>





	</dependencies>
</project>

2.Spring配置


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:p="http://www.springframework.org/schema/p" xmlns:cache="http://www.springframework.org/schema/cache"
	xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
		http://www.springframework.org/schema/cache
        http://www.springframework.org/schema/cache/spring-cache.xsd"
	default-autowire="byType">

	<context:annotation-config />
	<context:component-scan base-package="com.zhaochao.service" />
	<cache:annotation-driven cache-manager="cacheManager" />
	<!--spring 自带CachedManager    -->
	<bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
		<property name="caches">
			<set>
				<bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean">
					<property name="name" value="userCache" />
				</bean>
			</set>
		</property>
	</bean>


</beans>

3.定义用户类


package com.zhaochao.service;

public class User {
	private Integer id;
	private String  name;
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	private Integer age;
}

4.用户服务类

package com.zhaochao.service;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service("userService")
public class UserService {

	// 查询缓存
	@Cacheable(value = "userCache", key = "#userId")
	public User getUserById(Integer userId) {
		System.err.println("===queryUserById from db======");
		User u=new User();
		u.setId(userId);
		u.setName("赵云");
		u.setAge(20);
		return u;
	}
	// 删除缓存
	@CacheEvict(value = "userCache", condition ="#userId <=2 ")
	public String deleteUserById(int userId) {
	
		System.err.println("===deleteUserById===="+userId+"===");
		return String.valueOf(userId);
	}
	// 更新缓存
	@CachePut(value = "userCache", key = "#userId")
	public User updateUserById(Integer userId) {
		System.err.println("updateUserById ======== in DB =========");
		User u=new User();
		u.setId(userId);
		u.setName("马超");
		u.setAge(20);
		return u;
	}

}

5.测试类

package com.zhaochao.service.test;

import org.junit.Test;


import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.zhaochao.service.UserService;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring-common.xml")
public class UserServiceTest {
	@Autowired
	private UserService userService;

	@Test
	public void testCache(){
		//首次查询
		System.err.println(userService.getUserById(1));
		System.err.println(userService.getUserById(2));
		System.err.println(userService.getUserById(3));
		System.err.println(userService.getUserById(4));
		System.err.println();
		//缓存查询
		System.err.println(userService.getUserById(1));
		System.err.println(userService.getUserById(2));
		System.err.println();
		//更新缓存
		System.err.println(userService.updateUserById(1));
		System.err.println(userService.getUserById(1));
		System.err.println();
		//删除缓存中userId<2
		System.err.println(userService.deleteUserById(1));
		System.err.println(userService.deleteUserById(4));
		System.err.println(userService.getUserById(1));
		System.err.println(userService.getUserById(4));
		
		
	}
}

6.结果




7.自定义缓存将spring 配置改成

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:p="http://www.springframework.org/schema/p" xmlns:cache="http://www.springframework.org/schema/cache"
	xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
		http://www.springframework.org/schema/cache
        http://www.springframework.org/schema/cache/spring-cache.xsd"
	default-autowire="byType">

	<context:annotation-config />
	<context:component-scan base-package="com.zhaochao.service" />
	<cache:annotation-driven cache-manager="cacheManager" />

  <!-- 自定义CachedManager  -->
	<bean id="cacheManager" class="com.zhaochao.service.MyCacheManager">
		<property name="caches">
			<set>
				<bean class="com.zhaochao.service.MyCache" p:name="userCache" />
			</set>
		</property>
	</bean>

</beans>

8.MyCache


package com.zhaochao.service;

import java.util.HashMap;
import java.util.Map;
import org.springframework.cache.Cache;
import org.springframework.cache.support.SimpleValueWrapper;

public class MyCache implements Cache {
	private String name;

	public void setName(String name) {
		this.name = name;
	}
	private Map<Integer, User> store = new HashMap<Integer, User>();
	public MyCache() {

	}
	public MyCache(String name) {
		this.name = name;
	}
	public String getName() {
		return this.name;
	}

	public Object getNativeCache() {
		return null;
	}
	public ValueWrapper get(Object key) {
		ValueWrapper result = null;
		User thevalue = store.get(key);
		if (thevalue != null) {
			result = new SimpleValueWrapper(thevalue);
		}
		return result;
	}
	public <User> User get(Object key, Class<User> type) {
		return (User) store.get(key);
	}
	public void put(Object key, Object value) {
		store.put((Integer) key, (User) value);
	}
	public ValueWrapper putIfAbsent(Object key, Object value) {
		return null;
	}

	public void evict(Object key) {
		store.remove((String) key);
	}
	public void clear() {
		store.clear();
	}

}

9.MyCacheManager

package com.zhaochao.service;

import java.util.Collection;

import org.springframework.cache.support.AbstractCacheManager;

public class MyCacheManager extends AbstractCacheManager {
	private Collection<? extends MyCache> caches;

	public void setCaches(Collection<? extends MyCache> caches) {
		this.caches = caches;
	}
	@Override
	protected Collection<? extends MyCache> loadCaches() {
		return this.caches;
	}

}



转载于:https://www.cnblogs.com/whzhaochao/p/5023405.html

springcache使用详解
congge
11-14 8874
springcache 使用详解
Spring Cache使用Redis自定义缓存key
bird_tp的博客
09-06 3386
本篇博客，简单的介绍了sprig cache，spring cache如何使用redis作为缓存，已经自定义缓存key策略，以及通过配置缓存过期时间
Spring Cache使用
2303_80195175的博客
05-03 1457
Spring Cache 是 Spring Framework 提供的一种缓存抽象，旨在简化缓存的使用和集成。它使得开发者可以通过注解方式轻松地对方法的返回结果进行缓存，从而提升应用程序的性能，尤其是在访问频繁但计算开销较大的操作时。Spring Cache 提供了一个一致的缓存抽象，支持多种缓存技术，比如：EhcacheRedisGuavaCaffeine它提供了注解式的缓存配置，并且能够与现有的缓存解决方案无缝集成。
Spring Cache基本使用
Charge8的博客
05-24 2056
Spring Cache基本使用
Spring Cache使用指南
m0_64972409的博客
01-07 1223
文章介绍了Spring Cache的基本使用，包括如何配置和使用不同的缓存管理器、缓存注解和缓存策略。同时，还提供了一些实际的使用示例和最佳实践，以帮助读者更好地理解和应用Spring Cache。
Spring cache的使用
cyt涛的博客
09-08 1184
Spring Cache是Spring提供的一个缓存框架，基于AOP原理，实现了基于注解的缓存功能，只需要简单地加一个注解就能实现缓存功能，对业务代码的侵入性很小。
Spring Cache的详细使用
weixin_52580607的博客
05-12 1059
Spring Cache 是 Spring 框架提供的缓存抽象层，它通过注解的方式简化缓存的使用，允许开发者在不修改业务逻辑的情况下，轻松地为方法添加缓存功能。它支持多种缓存实现（如 Redis、Ehcache、Caffeine 等），并提供统一的 API 进行管理。
Spring Cache的基本使用
学习记录和总结
11-18 4803
Spring Cache的基本使用：环境搭建、@Cacheable、@CachePut、@CacheEvict等注解的使用......
Spring Cache 使用详解及原理 ----非关系型数据库缓存框架
Yluciud的博客
09-09 1237
提供了一个强大的缓存抽象层，称为 Spring Cache，它可以帮助开发者轻松地集成各种缓存解决方案，如 Ehcache、Caffeine、Guava Cache、Redis 等。Spring Cache 的目标是提供一个统一的API来管理缓存，使得开发者无需关心底层缓存实现的具体细节。Spring Cache 通过提供一个抽象层，简化了缓存的使用，使得开发者可以专注于业务逻辑而不用担心缓存的细节。通过使用适当的注解和配置，您可以很容易地在应用程序中实现缓存机制，从而提高应用程序的性能和响应速度。
Spring Cache结合redis使用
weixin_43811057的博客
12-09 1427
Spring Cache 整合 Redis 做缓存使用~ 快速上手~Spring源码解析-Spring Cache
Spring Cache使用RedisCache案例解析
08-25
Spring Cache使用RedisCache案例解析 Spring Cache是Spring框架中的一种缓存机制，主要用于优化应用程序的性能和响应速度。通过使用缓存，可以减少对数据库的访问次数，降低系统的负载，提高系统的整体性能。在...
Spring Cache的基本使用与实现原理详解
08-27
2. **开启Spring的缓存功能**：在配置文件中使用`<cache:annotation-driven />`或通过`@EnableCaching`注解开启缓存支持。 3. **配置缓存后端**：配置CacheManager，指定缓存的存储实现，例如使用Ehcache、Guava或...
spring boot+spring cache实现两级缓存(redis+caffeine)
08-27
Spring Cache的实现是使用Spring AOP中的MethodInterceptor封装的扩展，当然Spring AOP也是基于Aspect来实现的。Spring Cache的实现机制是将缓存操作与业务逻辑分离，避免缓存代码与业务处理耦合在一起的问题。 ...
二叉树的前中后序遍历(迭代法)
mrjieke6的博客
09-07 1283
本文系统介绍了二叉树前序、中序和后序遍历的迭代实现方法。前序遍历采用栈结构，按;根→右→左 ;顺序入栈；中序遍历先全部左子树入栈再访问节点；后序遍历则通过修改前序遍历顺序为"根→右→左 ;后反转结果。三种遍历时间复杂度均为O(n)，空间复杂度最坏O(n)。与递归实现相比，迭代方法避免了栈溢出风险，处理大型树更稳定。每种遍历方式都配有详细代码解析、执行示例和复杂度分析，并讨论了实际应用场景，为掌握树结构操作提供了系统指导。
基于SpringBoot和uni-app开发的陪诊陪护软件系统源码
程序员创业中
09-06 1486
中国60岁以上人口已突破3.1亿，独居老人超1.3亿，而一线城市三甲医院日均门诊量超万人次。在这组数据背后，是无数家庭面临的困境：子女异地工作无法陪同父母就医，独居老人因不会操作智能设备在挂号机前徘徊，异地患者因不熟悉流程在医院迷路……当“就医”从个人事务演变为社会难题，陪诊陪护系统正以“专业服务+技术赋能”的双重模式，成为破解这一困局的关键。
大数据毕业设计选题推荐-基于大数据的贵州茅台股票数据分析系统-Spark-Hadoop-Bigdata
IT研究室的博客
09-07 1003
本文介绍了基于Hadoop+Spark的贵州茅台股票数据分析系统，采用Python/Java语言开发，集成Django/Spring Boot后端与Vue前端，实现多维金融数据分析。系统核心功能包括价格趋势分析、成交量跟踪、波动性评估及技术指标验证，通过Spark SQL和Pandas处理海量交易数据，支持日均价格走势、价量相关性、MACD/RSI指标等深度挖掘。界面展示包含Echarts动态可视化图表，代码示例演示了Spark计算日均均价、20日均线及价格区间统计逻辑。
从Java全栈开发到微服务架构的实战经验分享
CatchLight的博客
09-09 768
应聘者：我认为最重要的是能够理解业务需求，并将其转化为技术方案。同时，持续学习新技术，保持对行业趋势的关注也很关键。毕竟，技术更新很快，只有不断学习才能跟上节奏。通过这次面试，我们可以看到一位资深Java全栈开发者的专业能力和实践经验。他不仅掌握了多种技术栈，还能在实际业务场景中灵活运用，解决实际问题。同时，他也展现了良好的沟通能力和学习能力，这些都是成为一名优秀工程师的关键素质。
Java内存区域与内存溢出
DKPT的博客
09-07 625
Java内存溢出的核心在于内存分配与回收失衡，需结合区域特性针对性解决。堆溢出最常见，需重点排查泄漏；方法区溢出多因动态类加载失控；直接内存溢出则需关注NIO使用。通过工具分析+代码优化+参数调优的组合策略，可显著降低OOM风险。二、内存溢出（OOM）类型与触发场景。三、内存溢出诊断与解决策略。一、Java内存区域划分。
【lucene】bitsetiterator
最新发布
risc123456的博客
09-09 375
某些自定义 `FieldCache` 或 `DocValues` 去重逻辑，会先把出现过的 docID 记到 `BitSet`，再用 `BitSetIterator` 一次性吐出。`BitSet` 本身只有 `get()/set()/nextSetBit(int)`，没有标准的迭代器语义，于是就有了 `BitSetIterator` 做适配。- `cost()` 直接返回 `cardinality()`，方便上层 `ConjunctionDISI/DisjunctionDISI` 做排序、选 lead。
spring cache使用
07-27
Spring Cache是Spring框架提供的一种缓存机制，用于提高应用程序的性能和响应速度。通过使用Spring Cache，可以将方法的返回值缓存起来，当下次调用相同的方法时，可以直接从缓存中获取结果，而不需要再执行方法的逻辑。 在使用Spring Cache时，需要进行一些配置。首先，需要添加Redis的配置信息，包括缓存类型、缓存过期时间、缓存键的前缀等。可以通过设置`spring.cache.type`为`redis`来指定使用Redis作为缓存类型。可以使用`spring.cache.redis.time-to-live`设置缓存的过期时间，单位为毫秒。可以使用`spring.cache.redis.key-prefix`设置缓存键的前缀，如果不指定前缀，则默认使用缓存的名字作为前缀。可以使用`spring.cache.redis.use-key-prefix`设置是否使用前缀，默认为true。可以使用`spring.cache.redis.cache-null-values`设置是否缓存空值，以防止缓存穿透。 另外，Spring Cache还支持使用JCache（JSR-107）注解来简化开发。从Spring 3.1开始，定义了`org.springframework.cache.Cache`和`org.springframework.cache.CacheManager`接口来统一不同的缓存技术。 在使用Spring Cache时，可以通过在方法上添加`@Cacheable`注解来启用缓存功能。当调用带有`@Cacheable`注解的方法时，Spring会首先检查缓存中是否存在相应的结果，如果存在，则直接返回缓存中的结果，如果不存在，则执行方法的逻辑，并将结果存入缓存中。 总结起来，使用Spring Cache可以通过配置Redis等缓存信息，并在方法上添加`@Cacheable`注解来实现缓存功能，提高应用程序的性能和响应速度。 #### 引用[.reference_title] - *1* [SpringCache的使用](https://blog.youkuaiyun.com/ABestRookie/article/details/121297482)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^koosearch_v1,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* *3* [springcache的使用详解（使用redis做分布式缓存）](https://blog.youkuaiyun.com/A_art_xiang/article/details/125580962)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^koosearch_v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值