Spring Boot 缓存Ehcache、Redis（六）

最新推荐文章于 2023-02-13 14:08:40 发布
最新推荐文章于 2023-02-13 14:08:40 发布
阅读量148 收藏
点赞数 1
分类专栏： spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_38075227/article/details/108269880
版权

Spring Boot 缓存技术

一、Spring Boot整合Ehcache

如果对Ehcache不了解可以查看一下文档，进行了解

1 修改 pom 文件

<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>

		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.10.RELEASE</version>
	</parent>
	<groupId>com.xk</groupId>
	<artifactId>spring-boot-demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<properties>
		<java.version>1.7</java.version>
		<thymeleaf.version>3.0.2.RELEASE</thymeleaf.version>
		<thymeleaf-layout-dialect.version>2.0.4</thymeleaf-layout-dialect.version>
	</properties>

	<dependencies>
		<!-- springBoot 的启动器 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<!-- thymeleaf 的启动器 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-thymeleaf</artifactId>
		</dependency>
		<!-- springBoot 的启动器 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<!-- 测试工具的启动器 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
		</dependency>
		<!-- mysql -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
		</dependency>
		<!-- druid 连接池 -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.0.9</version>
		</dependency>
		<!-- Spring Boot 缓存支持启动器 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-cache</artifactId>
		</dependency>
		<!-- Ehcache  -->
		<dependency>
			<groupId>net.sf.ehcache</groupId>
			<artifactId>ehcache</artifactId>
		</dependency>
	</dependencies>

</project>

2、创建 Ehcache 的配置文件

文件名:ehcache.xml
位置:src/main/resources/ehcache.xml

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
	<diskStore path="java.io.tmpdir" />
	<!--defaultCache:echcache的默认缓存策略 -->
	<defaultCache maxElementsInMemory="10000" eternal="false"
		timeToIdleSeconds="120" timeToLiveSeconds="120"
		maxElementsOnDisk="10000000" diskExpiryThreadIntervalSeconds="120"
		memoryStoreEvictionPolicy="LRU">
		<persistence strategy="localTempSwap" />
	</defaultCache>
	<!-- 自定义缓存策略 -->
	<cache name="users" maxElementsInMemory="10000" eternal="false"
		timeToIdleSeconds="120" timeToLiveSeconds="120"
		maxElementsOnDisk="10000000" diskExpiryThreadIntervalSeconds="120"
		memoryStoreEvictionPolicy="LRU">
		<persistence strategy="localTempSwap" />
	</cache>
</ehcache>

3、修改 application.properties 文件

spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/ssm
spring.datasource.username=root
spring.datasource.password=root

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

spring.cache.ehcache.cofnig=ehcache.xml

4 修改启动类

@EnableCaching
@SpringBootApplication
public class App {

	public static void main(String[] args) {
		SpringApplication.run(App.class, args);
	}

}

5、创建业务层

/**
 * UsersService 接口实现类 *
 *
 */
@Service
public class UsersServiceImpl implements UsersService {
	@Autowired
	private UsersRepository usersRepository;

	@Override
	public List<Users> findUserAll() {
		return this.usersRepository.findAll();
	}

	@Override	
	//@Cacheable:对当前查询的对象做缓存处理
	@Cacheable(value = "users")
	public Users findUserById(Integer id) {
		return this.usersRepository.findOne(id);
	}

	@Override
	public Page<Users> findUserByPage(Pageable pageable) {
		return this.usersRepository.findAll(pageable);
	}

	@Override
	public void saveUsers(Users users) {
		this.usersRepository.save(users);
	}
}

6 修改实体类 Users

@Entity
@Table(name = "t_users")
public class Users implements Serializable {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name = "id")
	private Integer id;
	@Column(name = "name")
	private String name;
	@Column(name = "age")
	private Integer age;
	@Column(name = "address")
	private String address;

	public Integer getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	@Override
	public String toString() {
		return "Users [id=" + id + ", name=" + name + ", age=" + age + ", address=" + address + "]";
	}
}

7 测试

/**
 * UsersService 测试 *
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = App.class)
public class UsersServiceTest {
	@Autowiredprivate
	UsersService usersService;

	@Test
	public void testFindUserById() { 
		// 第一次查询
		System.out.println(this.usersService.findUserById(1));
		//第二次查询
		System.out.println(this.usersService.findUserById(1));
	}
}

结果就是应该执行两次sql的查询语句，但是第二查询并没有执行，原因是因为从缓存里面取出类第一次查询的结果。

二、 @Cacheable 与@CacheEvict

1 @Cacheable

@Cacheable 作用:把方法的返回值添加到 Ehcache 中做缓存
Value 属性:指定一个 Ehcache 配置文件中的缓存策略，如果么有给定 value，name 	则 表示使用默认的缓存策略。

Key 属性:给存储的值起个名称。在查询时如果有名称相同的，那么则知己从缓存中将 	数据返回
1、业务层
    @Override
	@Cacheable(value = "users", key = "#pageable.pageSize")
	public Page<Users> findUserByPage(Pageable pageable) {
		return this.usersRepository.findAll(pageable);
	}
2、测试代码
    @Test
	public void testFindUserByPage() {
		Pageable pageable = new PageRequest(0, 2); // 第一次查询
		System.out.println(this.usersService.findUserByPage(pageable).getTotalElements());
		// 第二次查询
		System.out.println(this.usersService.findUserByPage(pageable).getTotalElements());
		// 第三次查询
		pageable = new PageRequest(1, 2);
		System.out.println(this.usersService.findUserByPage(pageable).getTotalElements());
	}

这里结果就是第一次查询，第二次没有sql语句查询，直接从缓存里面取，第三次执行类sql查询。

2 @CacheEvict

@CacheEvict 作用:清除缓存

@CacheEvict(value="users",allEntries=true)
public void saveUsers(Users users) {
	this.usersRepository.save(users); 
}

使用场景，比喻说，我们第一次查询数据库前两条数据添加类缓存，在我们将数据添加到数据库后，数据库对应前两条数据和缓存里面到数据就不一样类，这时我们要清除缓存，查询时重新添加缓存。

三、 Spring Boot 整合 Spring Data Redis

1、Linux安装 Redis

可以下载一个虚拟机进行测试
安装步骤省略，可以在网上找教程，写几个命令，面试用

1、安装 gcc

Yum install gcc-c++

2、解压 redis 压缩包

tar -zxvf redis-3.0.0.tar.gz

3、进入解压后的目录进行编译

cd redis-3.0.0
make

4、将 Redis 安装到指定目录

make PREFIX=/usr/local/redis install

5、启动 Redis

./redis-server

2、Spring Boot 整合 Spring Data Redis

Spring Data Redis 是属于 Spring Data 下的一个模块。作用就是简化对于 redis 的操做

1、修改 pom 文件添加 Spring Data Redis 的坐标
<!-- Spring Data Redis 的启动器 --> 
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId> 
</dependency>
<!-- Test 的启动器 --> 
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId> 
</dependency>
2、编写 Spring Data Redis 的配置类
/**
 * 完成对 Redis 的整合的一些配置 *
 */
@Configuration
public class RedisConfig {
	/**
	 * 1.创建 JedisPoolConfig 对象。在该对象中完成一些链接池配置 *
	 */
	@Bean
	public JedisPoolConfig jedisPoolConfig() {
		JedisPoolConfig config = new JedisPoolConfig();
		// 最大空闲数
		config.setMaxIdle(10);
		// 最小空闲数
		config.setMinIdle(5);
		// 最大链接数
		config.setMaxTotal(20);
		return config;
	}

	/**
	 * 2.创建 JedisConnectionFactory:配置 redis 链接信息
	 */
	@Bean
	public JedisConnectionFactory jedisConnectionFactory(JedisPoolConfig config) {
		JedisConnectionFactory factory = new JedisConnectionFactory();
		// 关联链接池的配置对象
		factory.setPoolConfig(config);
		// 配置链接 Redis 的信息
		// 主机地址
		factory.setHostName("192.168.0.106"); 
		// 端口
		factory.setPort(6379);
		return factory;
	}

	/**
	* 3.创建 RedisTemplate:用于执行 Redis 操作的方法
	*/
	@Bean
	public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory factory) {
		RedisTemplate<String, Object> template = new RedisTemplate<>(); // 关联
		template.setConnectionFactory(factory);
		// 为 key 设置序列化器
		template.setKeySerializer(new StringRedisSerializer()); 
		// 为 value 设置序列化器
		template.setValueSerializer(new StringRedisSerializer());
		return template;
	}

}
3、编写测试代码，测试整合环境
/**
 * Spring Data Redis 测试 *
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = App.class)
public class RedisTest {
	@Autowired
	private RedisTemplate<String, Object> redisTemplate;

	/**
	 * 添加一个字符串
	 */
	@Test
	public void testSet() {
		this.redisTemplate.opsForValue().set("key", "北京尚学堂");
	}

	/**
	 * 获取一个字符串
	 */
	@Test
	public void testGet() {
		String value = (String) this.redisTemplate.opsForValue().get("key");
		System.out.println(value);
	}
}

3、提取 redis 的配置信息

1、在 src/main/resource/ 目录下新建一个配置文件:
application.properties
spring.redis.pool.max-idle=10
spring.redis.pool.min-idle=5
spring.redis.pool.max-total=20

spring.redis.hostName=192.168.0.106
spring.redis.port=6379
2、修改配置类
/**
 * 完成对 Redis 的整合的一些配置 *
 */
@Configuration
public class RedisConfig {
	/**
	 * 1.创建 JedisPoolConfig 对象。在该对象中完成一些链接池配置 *
	 */
	@Bean
	@ConfigurationProperties(prefix = "spring.redis.pool")
	public JedisPoolConfig jedisPoolConfig() {
		JedisPoolConfig config = new JedisPoolConfig();
		// 最大空闲数
		// config.setMaxIdle(10);
		// 最小空闲数
		// config.setMinIdle(5);
		// 最大链接数
		// config.setMaxTotal(20);
		System.out.println("默认值:" + config.getMaxIdle());
		System.out.println("默认值:" + config.getMinIdle());
		System.out.println("默认值:" + config.getMaxTotal());
		return config;
	}

	/**
	 * 2.创建 JedisConnectionFactory:配置 redis 链接信息
	 */
	@Bean
	@ConfigurationProperties(prefix = "spring.redis")
	public JedisConnectionFactory jedisConnectionFactory(JedisPoolConfig config) {
		System.out.println("配置完毕:" + config.getMaxIdle());
		System.out.println("配置完毕:" + config.getMinIdle());
		System.out.println("配置完毕:" + config.getMaxTotal());
		JedisConnectionFactory factory = new JedisConnectionFactory();
		// 关联链接池的配置对象
		factory.setPoolConfig(config);
		// 配置链接 Redis 的信息
		// 主机地址
		//factory.setHostName("192.168.0.106");
		// 端口
		//factory.setPort(6379);
		return factory;
	}

	/**
	 * 3.创建 RedisTemplate:用于执行 Redis 操作的方法
	 */
	@Bean
	public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory factory) {
		RedisTemplate<String, Object> template = new RedisTemplate<>(); // 关联
		template.setConnectionFactory(factory);
		// 为 key 设置序列化器
		template.setKeySerializer(new StringRedisSerializer());
		// 为 value 设置序列化器
		template.setValueSerializer(new StringRedisSerializer());
		return template;
	}

}

4 Spring Data Redis 操作实体对象

public class Users implements Serializable {
	private Integer id;
	private String name;
	private Integer age;
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "Users [id=" + id + ", name=" + name + ", age=" + age +"]";
	}
}

实现序列化接口Serializable

测试

@Test
	public void testSetUesrs() {
		Users users = new Users();
		users.setAge(20);
		users.setName("json");
		users.setId(1); // 重新设置序列化器
		this.redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());
		this.redisTemplate.opsForValue().set("users", users);
	}

	/**
	 * 取 Users 对象
	 */
	@Test
	public void testGetUsers() { // 重新设置序列化器
		this.redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());
		Users users = (Users) this.redisTemplate.opsForValue().get("users");
		System.out.println(users);
	}

Spring Data Redis 以 JSON 格式存储实体对象

/**
	 * 基于 JSON 格式存 Users 对象
	 */
	@Test
	public void testSetUsersUseJSON() {
		Users users = new Users();
		users.setAge(20);
		users.setName("json");
		users.setId(1);
		this.redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer<>(Users.class));
		this.redisTemplate.opsForValue().set("users_json", users);
	}

	/**
	 * 基于 JSON 格式取 Users 对象
	 */
	@Test
	public void testGetUseJSON() {
		this.redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer<>(Users.class));
		Users users = (Users) this.redisTemplate.opsForValue().get("users_json");
		System.out.println(users);
	}

上一篇：Spring Boot 异常处理与单元测试（五）

老徐··
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
SpringBoot中Shiro缓存使用Redis、Ehcache的方法
08-25
主要介绍了SpringBoot中Shiro缓存使用Redis、Ehcache的方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Spring Boot：缓存-Ehcache和Redis
记录，记录，记录
07-03 311
一：前言 在我们编写的应用中，组件一般都是无状态的，一个请求过来，经过逻辑处理返回所需要的结果，但下一次再来的相同请求的时候，需要再走一边流程。对于所需求的结果，我们可能需要经过计算/访问数据库/远程服务调用来获取，但对于结果变更不频繁的，做相同的事就是资源浪费。 解决方案：缓存，现在主流的缓存是Encache和Redis，我就这两个为例。 二：缓存情况说明 下列是缓存使用的时候使用的注解 ...
SpringBoot整合(四)整合Ehcache、Redis、Memcached、jetcache、j2cache缓存
qq_44665283的博客
02-13 1273
SpringBoot整合Ehcache、Redis、Memcached、jetcache、j2cache缓存
springboot整合redis+ecache
03-25
这是一个完整的使用springboot整合redis和ecache的代码，数据库交互使用的是mybatis，欢迎下载
分分钟实践SpringBoot+Ehcache
HouXinLin_CSDN的博客
07-27 366
前言 以前一直用Redis做缓存，但后来慢慢了解到了Ehcache，貌似Redis的名声早就超越了Ehcache，就很少看到有人提起Ehcache以及文章，但是，还是有必要了解一下的，说不定以后会用的上。更何况Ehcache也是Java领域中比较优秀的缓存，不知道小伙伴发现没，Ehcache正着念反着念，都是 Ehcache。 Ehcache简介 Ehcache是一个用Java实现的使用简单、高速、线程安全的缓存管理类库，提供了用内存、磁盘文件存储，以及分布式存储等管理方案。同时Ehcache作为开放源代码
spring boot+spring cache实现两级缓存(redis+caffeine)
08-27
Spring Boot中集成了Spring Cache，并有多种缓存方式的实现，如：Redis、Caffeine、JCache、EhCache等等。如果只用一种缓存，要么会有较大的网络消耗（如Redis），要么就是内存占用太大（如Caffeine这种应用内存缓存...
Spring Boot整合Redis做集中式缓存
05-09
在一些要求高一致性（任何数据变化都能及时的被查询到）的系统和应用中，就不能再使用EhCache来解决了，这个时候使用集中式缓存是个不错的选择，因此本文将介绍如何在Spring Boot的缓存支持中使用Redis进行数据缓存...
浅谈Spring Boot中Redis缓存还能这么用
08-25
在Spring Boot中，Redis不仅可以作为一个...通过Spring Cache，我们可以利用统一的接口处理多种缓存实现，包括Redis、Ehcache等，极大地简化了开发过程。在实际项目中，合理地利用缓存策略可以显著提升系统的整体性能。
springboot 整合ehcache+redis 通过配置文件切换缓存类型
最新发布
09-14
1、springboot 整合ehcache+redis 通过配置文件application.yml切换缓存类型 2、ehcache 、redis 通过缓存管理器管理 3、可分别设置缓存的过期时间 ehcache ：添加依赖 pom.xml 2、添加配置文件ehcache.xml 3、添加...
09. Spring Boot缓存技术
03-20
当我们谈论"Spring Boot缓存技术"时，实际上是在讨论如何在Spring Boot应用中有效地管理和利用缓存，以提高系统的性能和响应速度。缓存技术是解决高并发场景下数据访问延迟的有效手段，它通过将常用数据存储在内存中...
Springboot搭建ehcache缓存&&redis缓存
qq_31564573的博客
08-03 691
Springboot搭建ehcache缓存 redis
SpringBoot集成Ehcache、Redis示例
DayDayUp的博客
12-12 593
一、摘要 1.1、Spring3.1开始内置了五个缓存管理器实现，如下所示： SimpleCacheManager NoOpCacheManager ConcurrentMapCacheManager CompositeCacheManager EhcacheCacheManager 1.2、Spring3.2又引入了 二、集成Ehcache 三、集成Redis 注意点：原生的spring cache不支持缓存过期，默认都是没有过期时间的，需要自定义...
SpringBoot+elasticsearch+JerseyRESTful +redis博客系统
09-11
包含技术Linux、Redis、spring boot、文件上传下载、FreeMarker、thymeleaf、spring jdbc、Spring Data JPA、 MyBatis、 Mybatis Generator逆向生成、CKEditor、AJAX异步上传文件、Jersey实现应用服务器和文件服务器分离、Elasticsearch
springboot整合ehcache+redis实现双缓存
热门推荐
congge
03-25 1万+
在一些对并发业务要求较高的场景下，对页面数据的响应是个急需解决的问题，对后端来说，ehcache+redis实现双缓存是解决这一问题的不错思路，而且在不少的电商项目中得到了很好的验证，但我在网上搜寻资料的时候总觉得一些材料不能很好的说明这个问题，要么太复杂，要么太简单，最近抽空思考了一下这一思路的简单实现，下面就用springboot整合ehcache和redis来说明一下实现的过程， 需求说明，...
springboot同时整合redis和ehcache
caiwufei的博客
12-21 7440
springboot同时整合redis和ehcache，redis和ehcache各种工作，互补干扰。 1.maven依赖 org.springframework.boot spring-boot-starter-cache org.ehcache ehcache javax.cache
Springboot同时集成ehcache 和 redis等等做缓存，支持切换
qq_43590771的博客
04-09 2327
文章目录1.导入相关依赖2.配置文件3.在初始化时指定cachemanager，根据配置文件中的redis/ehcache返回对应的cachemanager4.如何使用 支持多级缓存进入，这里以ehcache和redis作为例子 1.导入相关依赖 引入spring支持cache的依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-
SpringBoot使用注解方式同时集成Redis、Ehcache
会飞dē鱼
05-25 1万+
1、在开始之前先看下pom文件SpringBoot的版本我的是 2.0，现在网上很多资料用的都是1.5版本的，如果你使用2.0的版本就会报错，具体1.5-2.0升级了哪些内容在此就不多做阐述了，有兴趣的大家自己可以去了解一下。好了直接进入正题先看下我的pom文件：然后再看下Redis、Ehcache：以上pom文件就添加好了。2、使用SpringBoot注解方式集成Redis、Ehcache缓存，...
Spring Boot 使用Redis和Ehcache做拥有二级缓存的系统
小白杨
02-03 8658
上一张说到了Ehcache的简单使用，但是Ehcache一般作为本地缓存来使用，而在一个系统可能会根据服务的不用会部署在不同的机器上，那么在每一台机器都设置Ehcache，又要把一些公用的信息缓存一遍，这样不利于使用Ehcache。 而这时，我们可以再做一个缓存，这个缓存保存了一些经常使用，而且可以较大的数据。这个就是Redis。Redis已经成为了最常用的几种NoSql之一了，不仅开源，而且简单
Spring Boot集成EhCache：进程内缓存实战
在Spring Boot中，EhCache是一种常用的进程内缓存解决方案，它提供了丰富的缓存功能和管理。当Spring Boot的Cache模块没有明确指定其他第三方缓存实现时，默认会利用ConcurrentHashMap作为底层存储。然而，为了满足...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

老徐··

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值