spring缓存机制-入门实例(一)

最新推荐文章于 2025-01-08 16:34:57 发布

原创最新推荐文章于 2025-01-08 16:34:57 发布 · 6.2k 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#spring #cache #缓存 #方法

------spring 专栏收录该内容

18 篇文章

订阅专栏

本文详细介绍了Spring框架中的缓存模块，包括其核心组件和使用方式。通过Maven构建项目，创建服务、DAO、模型层，并实现注解驱动的缓存功能，展示了如何在服务层使用@Cacheable和@CacheEvict进行缓存操作。

spring是一个轻量级开源框架,以IoC(Inverse of Control:控制反转)和AOP(Aspect Oriented Programming:面向切面编程)为内核,
兼具功能强大的的原生展现层spring mvc,原生持久层spring jdbc和原生业务层等技术,并且以海纳百川的胸怀整合了开源世界里众多
著名的第三方框架和类库,已经逐渐成为世界上使用最多的JavaEE企业级应用开源框架.
spring3.2.3中负责cache的模块是org.spring.framework.context-3.2.3.RELEASE.jar.
@Cacheable支持如下参数:负责将方法的返回值加入到缓存中
value:缓存位置名称,不能为空.
key:缓存的key,默认为空,支持springEL表达式.
condition:触发条件,只有满足条件的情况下才会加入缓存,默认为空,表示全部加入缓存,支持springEL表达式.
@CachEvict支持如下参数:负责清除缓存.
value:缓存位置名称,不能为空.
key:缓存的key,默认为空,支持springEL表达式.
condition:触发条件,只有满足条件的情况下才会清除缓存,默认为空,支持springEL表达式.
allEntries:ture表示清除value中的全部缓存,默认为false.
下面通过一个实例简单介绍一下spring缓存的使用.

1.通过maven构建项目,直接看pom.xml文件.

<span style="font-size:12px;"><?xml version="1.0" encoding="UTF-8" ?> 
- <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.ilucky.spring</groupId> 
  <artifactId>spring-cache</artifactId> 
  <version>1.0.0</version> 
  <packaging>jar</packaging> 
- <dependencies>
- <dependency>
  <groupId>org.springframework</groupId> 
  <artifactId>spring-core</artifactId> 
  <version>3.2.3.RELEASE</version> 
  </dependency>
- <dependency>
  <groupId>org.springframework</groupId> 
  <artifactId>spring-context</artifactId> 
  <version>3.2.3.RELEASE</version> 
  </dependency>
  </dependencies>
  </project></span>

2.创建service,dao和model,并将spring缓存加在service层,直接看代码UserService,UserServiceImpl,UserDao,UserDaoImpl和User.

<span style="font-size:12px;">package com.ilucky.spring.cache.service;

import java.util.Map;

import com.ilucky.spring.cache.model.User;

/**
 * @author IluckySi
 * @date 20140612
 */
public interface UserService {

	public abstract void add(User user);
	
	public abstract void delete(String id);
	
	public abstract void update(User user);
	
	public abstract User find(String id);
	
	public abstract Map<String, User> getAll();
}
</span>

<span style="font-size:12px;">package com.ilucky.spring.cache.service.impl;

import java.util.Map;

import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;

import com.ilucky.spring.cache.dao.UserDao;
import com.ilucky.spring.cache.model.User;
import com.ilucky.spring.cache.service.UserService;

/**
 * @author IluckySi
 * @date 20140612
 */
public class UserServiceImpl implements UserService {

	private UserDao userDao;
	
	/**
	 * JVM加载spring配置文件时, 通过set方法注入本类的依赖.
	 * @param userDao
	 */
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}

	/**
	 * 对数据进行增删改时清空缓存, 查询时使用缓存, 其中value为缓存区,
	 * allEntries表示清空缓存中所有的数据.
	 */
	@Override
    @CacheEvict(value = "data", allEntries = true)  
	public void add(User user) {
		System.out.println("UserService: method- add(User user)" );
		userDao.add(user);
	}

	@Override
	@CacheEvict(value = "data", allEntries = true)  
	public void delete(String id) {
		System.out.println("UserService: method-delete(String id)" );
		userDao.delete(id);
	}

	@Override
	@CacheEvict(value = "data", allEntries = true)  
	public void update(User user) {
		System.out.println("UserService: method-update(User user)" );
		userDao.update(user);
	}

	@Override
	@Cacheable(value = "data")   
	public User find(String id) {
		System.out.println("UserService: method-find(String id)" );
		return userDao.find(id);
	}

	@Override
	@Cacheable(value = "data")  
	public Map<String, User> getAll() {
		System.out.println("UserService: method-getAll()" );
		return userDao.getAll();
	}
}
</span>

<span style="font-size:12px;">package com.ilucky.spring.cache.dao;

import java.util.Map;

import com.ilucky.spring.cache.model.User;

/**
 * @author IluckySi
 * @date 20140612
 */
public interface UserDao {

	public abstract void add(User user);
	
	public abstract void delete(String id);
	
	public abstract void update(User user);
	
	public abstract User find(String id);
	
	public abstract Map<String, User> getAll();
}
</span>

<span style="font-size:12px;">package com.ilucky.spring.cache.dao.impl;

import java.util.HashMap;
import java.util.Map;

import com.ilucky.spring.cache.dao.UserDao;
import com.ilucky.spring.cache.model.User;

/**
 * @author IluckySi
 * @date 20140612
 */
public class UserDaoImpl implements UserDao {

	//使用Map模拟数据表.
	private Map<String, User> users = new HashMap<String, User>();
	
	@Override
	public void add(User user) {
		System.out.println("UserDao method- add(User user)" );
		users.put(user.getId(), user);
	}

	@Override
	public void delete(String id) {
		System.out.println("UserDao method- delete(String id)" );
		users.remove(id);
	}

	@Override
	public void update(User user) {
		System.out.println("UserDao method- update(User user)" );
		users.put(user.getId(), user);
	}

	@Override
	public User find(String id) {
		System.out.println("UserDao method- find(String id)" );
		return users.get(id);
	}

	@Override
	public Map<String, User> getAll() {
		System.out.println("UserDao method- getAll()" );
		return users;
	}
}
</span>

<span style="font-size:12px;">package com.ilucky.spring.cache.model;

/**
 * @author IluckySi
 * @date 20140612
 */
public class User {

	private String id;
	
	private String username;
	
	private String password;

	public User(String id, String username, String password) {
		this.id = id;
		this.username = username;
		this.password = password;
	}

	public String getUsername() {
		return username;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}
	
	public String toString() {
		return this.id + "-" + this.username + "-" + this.password;
	}
}
</span>

3.创建spring配置文件,配置spring自己的缓存管理器和bean之间的依赖关系,直接看代码spring-cahce.xml.

<span style="font-size:12px;"><?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:p="http://www.springframework.org/schema/p"
	xmlns:cache="http://www.springframework.org/schema/cache"
	xsi:schemaLocation="   
                http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd   
                http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-3.1.xsd">


	<!-- 应用spring cache注解功能  -->
	<cache:annotation-driven />

 	<!-- 创建spring cache bean -->
	<bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
		<property name="caches">
			<set>
				<bean
					class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean"
					p:name="default" />
				<bean
					class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean"
					p:name="data" />
			</set>
		</property>
	</bean>

	<!-- 创建User Dao bean -->
	<bean id="userDao" class="com.ilucky.spring.cache.dao.impl.UserDaoImpl" ></bean>

	<!-- 创建User Service bean -->
	<bean id="userService" class="com.ilucky.spring.cache.service.impl.UserServiceImpl" >
		<property name="userDao" >
			<ref bean="userDao"></ref>
		 </property>
	</bean> 
</beans>  </span>

4.最后通过测试类测试spring缓存机制是否生效,直接看代码MainTest.

<span style="font-size:12px;">package com.ilucky.spring.cache;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ilucky.spring.cache.model.User;
import com.ilucky.spring.cache.service.UserService;

/**
 * @author IluckySi
 * @date 20140613
 * 测试spring缓存机制是否生效.
 */
public class MainTest {

	public static void main(String[] args) {
		
		//加载ClassPath路径下的spring配置文件, 并获取service bean.
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-cache.xml");  
		UserService userService = context.getBean("userService", UserService.class); 
		System.out.println("service bean: " + userService);
		
		//添加一个用户, 然后查询并输出.
		userService.add(new User("1", "Ilucky1", "pwd1"));
		User user = userService.find("1");
		System.out.println(user);
		
		//紧接着再次查询刚刚添加的用户并输出, 从输出结果看, 数据是从缓存中获取的.
		User userFromCache = userService.find("1");
		System.out.println(userFromCache);
		
		//更新用户数据, 同时清空缓存.
		userService.update(new User("1", "Ilucky_new", "pwd_new"));
		
		//重新获取数据, 因为缓存已被清空, 所以需要从数据库重新获取数据, 同时将从数据库获取的新数据再次放到缓存中供下次查询.
		User userFromCache2 = userService.find("1");
		System.out.println(userFromCache2);
	}
}
/**
 输出结果:
service bean: com.ilucky.spring.cache.service.impl.UserServiceImpl@fd918a
UserService: method- add(User user)
UserDao method- add(User user)
UserService: method-find(String id)
UserDao method- find(String id)
1-Ilucky1-pwd1
1-Ilucky1-pwd1
UserService: method-update(User user)
UserDao method- update(User user)
UserService: method-find(String id)
UserDao method- find(String id)
1-Ilucky_new-pwd_new
*/</span>

在测试代码中通过ClassPathXmlApplicationContext类加载spring配置文件,因为此maven项目是jar项目,且在maven中默认约定资源
放在src/main/resources目录,所以spring配置文件要放在src/main/resources目录下.
点击链接下载源码