Spring Boot缓存技术（ehcache、SpringData Redis）

最新推荐文章于 2024-05-13 19:34:12 发布
最新推荐文章于 2024-05-13 19:34:12 发布
阅读量450 收藏
点赞数
分类专栏： SpringBoot SpringData Redis 文章标签： SpringBoot缓存技术
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39086296/article/details/90521469
版权
  • SpringBoot 整合 Ehcache
  • SpringBoot 整合 SpringDataRedis

 
 
一、SpringBoot 整合 Ehcache
 
1、导入相关maven依赖

<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>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.10.RELEASE</version>
	</parent>
	<groupId>com.bjsxt</groupId>
	<artifactId>23-spring-boot-ehcache</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>
		<!-- springBoot的启动器 -->
		<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 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 data 正向工程
spring.jpa.hibernate.ddl-auto=update
#显示sql
spring.jpa.show-sql=true

#配置ehcache
spring.cache.ehcache.cofnig=ehcache.xml

 
4、修改启动类，在启动类上面添加@EnableCaching

package com.bjsxt;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;


@SpringBootApplication
@EnableCaching
public class App {

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

 
5、创建业务层

package com.bjsxt.service;

import java.util.List;

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;

import com.bjsxt.pojo.Users;

public interface UsersService {
	
	List<Users> findUserAll();
	Users findUserById(Integer id);
	Page<Users> findUserByPage(Pageable pageable);
	void saveUsers(Users users);
}


package com.bjsxt.service.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;

import com.bjsxt.dao.UsersRepository;
import com.bjsxt.pojo.Users;
import com.bjsxt.service.UsersService;
/**
 * UsersService接口实现类
 *
 *
 */
@Service
public class UsersServiceImpl implements UsersService {

	@Autowired
	private UsersRepository usersRepository;
	
	@Override
	@Cacheable(value = "users")
	public List<Users> findUserAll() {
		return this.usersRepository.findAll();
	}

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

}

 
6、修改实体类

package com.bjsxt.pojo;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@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、测试

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

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

<!-- 自定义缓存策略 -->
    <cache name="users"
            maxElementsInMemory="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            maxElementsOnDisk="10000000"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
        <persistence strategy="localTempSwap"/>
    </cache>

  Key 属性：给存储的值起个名称。在查询时如果有名称相同的，那么则知己从缓存中将 数据返回
 
1.1、业务层

@Override
	@Cacheable(value = "users",key = "#pageable.pageSize")
	public Page<Users> findUserByPage(Pageable pageable) {
		return this.usersRepository.findAll(pageable);
	}

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

 
2、@CacheEvict
 
@CacheEvict 作用：清除缓存
 
2.1、业务层

package com.bjsxt.service.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;

import com.bjsxt.dao.UsersRepository;
import com.bjsxt.pojo.Users;
import com.bjsxt.service.UsersService;
/**
 * UsersService接口实现类
 *
 *
 */
@Service
public class UsersServiceImpl implements UsersService {

	@Autowired
	private UsersRepository usersRepository;
	
	@Override
	@Cacheable(value = "users")
	public List<Users> findUserAll() {
		return this.usersRepository.findAll();
	}

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

	@Override
	@Cacheable(value = "users",key = "#pageable.pageSize")
	public Page<Users> findUserByPage(Pageable pageable) {
		return this.usersRepository.findAll(pageable);
	}

	@Override
	@CacheEvict(value = "users",allEntries = true)//清除缓存中以users缓存策略缓存的对象
	public void saveUsers(Users users) {
		this.usersRepository.save(users);
	}

}

 
2.2、测试代码

@Test
	public void testFindAll(){
		//第一次查询
		System.out.println(usersService.findUserAll().size());
		Users users=new Users();
		users.setAddress("南京");
		users.setAge(43);
		users.setName("朱七");
		this.usersService.saveUsers(users);
		//第二次查询
		System.out.println(usersService.findUserAll().size());

	}

 
 
三、SpringBoot 整合 SpringDataRedis
 
Redis 版本：3.2.1
运行环境：windows
 
1、SpringBoot 整合 SpringDataRedis
 
  SpringDataRedis 是属于 SpringData 下的一个模块。作用就是简化对于 redis 的操作
 
1.1、修改 pom 文件添加 SpringDataRedis 的坐标

<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>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.10.RELEASE</version>
  </parent>
  <groupId>com.bjsxt</groupId>
  <artifactId>24-spring-boot-redis</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>
    
    <!-- Spring Data Redis的启动器 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

      <!-- 测试工具的启动器 -->
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-test</artifactId>
      </dependency>


  </dependencies>
</project>

 
1.2、编写 SpringDataRedis 的配置类（重点）

package com.bjsxt.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import redis.clients.jedis.JedisPoolConfig;

/**
 * 完成对Redis的整合的一些配置
 *
 *
 */
@Configuration
public class RedisConfig {

	/**
	 * 1.创建JedisPoolConfig对象。在该对象中完成一些链接池配置
	 *	@ConfigurationProperties:会将前缀相同的内容创建一个实体
	 */
	@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("127.0.0.1");
		//端口
		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;
	}
}

 
1.3、编写测试代码，测试整合环境
 
  1.3.1、编写测试类

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

 
2、提取 redis 的配置信息
 
2.1、在 src/main/resource/ 目录下新建一个配置文件:application.properties

#最大空闲数
spring.redis.pool.max-idle=10
#最小空闲数
spring.redis.pool.min-idle=5
#最大链接数
spring.redis.pool.max-total=20
#主机ip
spring.redis.host=127.0.0.1
#redis端口
spring.redis.port=6379

 
2.2、修改redis配置类

package com.bjsxt.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import redis.clients.jedis.JedisPoolConfig;

/**
 * 完成对Redis的整合的一些配置
 *
 *
 */
@Configuration
public class RedisConfig {

	/**
	 * 1.创建JedisPoolConfig对象。在该对象中完成一些链接池配置
	 *	@ConfigurationProperties:会将前缀相同的内容创建一个实体
	 */
	@Bean
	@ConfigurationProperties(prefix = "spring.redis.pool")
	public JedisPoolConfig jedisPoolConfig(){
		JedisPoolConfig config = new JedisPoolConfig();
		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);
		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、SpringDataRedis 操作实体对象
 
  3.1.1、创建实体类

/**
 * Copyright (C), 2015-2019, XXX有限公司
 * FileName: Users
 * Author:   admin
 * Date:     2019/5/24 11:25
 * Description:
 * History:
 * <author>          <time>          <version>          <desc>
 * 作者姓名           修改时间           版本号              描述
 */
package com.bjsxt.pojo;

import java.io.Serializable;

/**
 * 〈一句话功能简述〉<br> 
 * 〈〉
 *
 * @author admin
 * @create 2019/5/24
 * @since 1.0.0
 */
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() {
        final StringBuffer sb = new StringBuffer("Users{");
        sb.append("id=").append(id);
        sb.append(", name='").append(name).append('\'');
        sb.append(", age=").append(age);
        sb.append('}');
        return sb.toString();
    }
}

 
3.1.2、测试代码

/**
     * 添加一个Users对象
     */
    @Test
    public void testSetUsers(){
        Users users=new Users();
        users.setAge(20);
        users.setName("张三丰");
        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);
    }

 
4、SpringDataRedis 以 JSON 格式存储实体对象
 
  4.1、测试代码

/**
     * 基于JSON格式存Users对象
     */
    @Test
    public void testSetUsersUseJSON(){
        Users users=new Users();
        users.setAge(20);
        users.setName("李四丰");
        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);
    }
我见青山多抚媚
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot整合ehcache+redis实现双缓存
congge
03-25 1万+
在一些对并发业务要求较高的场景下，对页面数据的响应是个急需解决的问题，对后端来说，ehcache+redis实现双缓存是解决这一问题的不错思路，而且在不少的电商项目中得到了很好的验证，但我在网上搜寻资料的时候总觉得一些材料不能很好的说明这个问题，要么太复杂，要么太简单，最近抽空思考了一下这一思路的简单实现，下面就用springboot整合ehcache和redis来说明一下实现的过程， 需求说明，...
【译】Spring的@EnableCaching注解
weixin_33725126的博客
09-08 1245
Spring的@EnableCaching注解 @EnableCaching注解是spring framework中的注解驱动的缓存管理功能。自spring版本3.1起加入了该注解。如果你使用了这个注解，那么你就不需要在XML文件中配置cache manager了。 当你在配置类(@Configuration)上使用@EnableCach...
【SpringBoot】 集成 Ehcache
Java_Wxlin的博客
02-10 1846
EhCache 是一个纯 Java 的进程内缓存框架，具有快速、精干等特点， 是 Hibernate 中默认CacheProvider。Ehcache 是一种广泛使用的开源 Java 分布式缓存。
springboot 开启缓存 @EnableCaching(使用redis)
最新发布
weixin_46591962的博客
05-13 624
启动类上 加 @EnableCaching 注解。
@EnableCaching,@Cacheable, @CachePut,@CacheEvict详解
Harry的博客
06-28 642
在@Cacheable注解中key的取值也可以使用SpringEL表达式来生成，内部可以嵌套方法的参数信息，例如，System . out . println("如果第二次没有走到这里说明缓存被添加了");
springboot整合redis 通过ehcache完成自动缓存 功能
IT 工农兵
03-05 879
pom文件 增加缓存依赖 &amp;lt;!-- redis --&amp;gt; &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.springframework.boot&amp;lt;/groupId&amp;gt; &amp;lt;artifactId&amp;gt;spring-boot-starter-data-redis&amp
浅谈Spring Boot中Redis缓存还能这么用
08-25
在Spring Boot中，Redis不仅可以作为一个简单的键值存储，还可以被用作高效的缓存系统。Spring Cache是Spring框架提供的一种统一的缓存抽象层，它允许开发者通过简单的注解方式实现缓存功能，而无需关心底层缓存的...
Spring Boot整合Redis做集中式缓存
05-09
在一些要求高一致性（任何数据变化都能及时的被查询到）的系统和应用中，就不能再使用EhCache来解决了，这个时候使用集中式缓存是个不错的选择，因此本文将介绍如何在Spring Boot的缓存支持中使用Redis进行数据缓存...
spring boot+spring cache实现两级缓存(redis+caffeine)
08-27
Spring Boot中集成了Spring Cache，并有多种缓存方式的实现，如：Redis、Caffeine、JCache、EhCache等等。如果只用一种缓存，要么会有较大的网络消耗（如Redis），要么就是内存占用太大（如Caffeine这种应用内存缓存...
09. Spring Boot缓存技术
03-20
在Spring Boot中，主要支持三种缓存管理机制： EhCache、Hazelcast 和 Redis。EhCache 是一个轻量级、分布式的内存缓存解决方案，适合于小型项目；Hazelcast 是一个开源的内存数据网格，可以提供分布式缓存服务；...
spring boot 集成activemq Datajpa Ehcache
05-17
在这个项目中，我们将探讨如何将Spring Boot与Apache ActiveMQ、DataJPA和Ehcache进行集成，以构建一个功能丰富的应用程序。 首先，ActiveMQ是Apache出品的一款开源消息中间件，它遵循Java Message Service (JMS) ...
在Springboot中整合Ehcache以及整合Redis
qq_35069673的博客
03-12 747
Spring Boot中的缓存支持（一）注解配置与EhCache使用 史上最全面的Spring Boot Cache使用与整合
spring-data-redis集成ehcache实现缓存
denghe4720的博客
07-11 93
1.结构 2.pom.xml <?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:sche...
spring同时整合redis和ehcache
caiwufei的博客
12-25 3157
spring同时整合redis和ehcache3，远程缓存和本地缓存同时使用，配置注解根据不同的使用场景和数据选择指定缓存。 1.maven依赖。注意版本兼容，开始就被版本问题坑了下。 org.springframework.data spring-data-redis 1.8.0.RELEASE
SpringBoot 2中使用redis用作缓存
entomb
05-11 4398
SpringBoot2.x.x版本+redis的缓存实现 前提条件:需要有redis数据库服务，本机位置或者远程服务器主机上 1.首先加入对应的jar包（主要的jar依赖如下）: &lt;!--开启 cache 缓存--&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/grou...
springboot springdata jpa 整合redis作为缓存使用
my的博客
08-30 5812
pom： &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-data-redis&lt;/artifactId&gt; &lt;/dependency&gt;   在你的应用启动类上边 添加如下注解...
Spring Data Redis 缓存的实现与使用
qq_42675905的博客
08-14 263
优势：Redis缓存是通过键值对存储的，很适合存储缓存。 实现思想：Spring Data Redis 提供了一个RedisCacheManager缓存管理器，这是CacheManager的一个实现，RedisCacheManager会与一个redis服务器写作，通过RedisTemplate 模板来实现缓存条目的存储。 配置流程：1 启用缓存（@EnableCaching）2 配置缓存管理器...
【spring-boot】spring-boot集成ehcache实现缓存机制
小告白
11-04 659
EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。 　　ehcache提供了多种缓存策略，主要分为内存和磁盘两级，所以无需担心容量问题。 　　spring-boot是一个快速的集成框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样
(十一)SpringBoot2.0整合Ehcache缓存技术
Autism、陌亡
04-09 3032
文章目录一. ehcache整合1. pom文件依赖2. 新增Ehcache.xml文件3. 启动类加上注解4. 在类或者方法上加入缓存二. 项目演示三. Ehcache缓存清除四. 源码下载 一. ehcache整合 1. pom文件依赖 默认情况下，Spring已经集成了cache的依赖，我亲自测试过，移除这个两个依赖，也可以整合cache。 <!-- caching --> ...
SpringBoot 学习笔记完整教程.pdf
12-12
说明了如何将Spring Boot与Redis集成，实现数据缓存，提高应用性能。 28. **Spring Cache与Spring Boot**： 介绍了Spring的缓存抽象层Spring Cache，并演示了如何在Spring Boot中使用它。 29. **集成EHCache**：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值