SpringBoot25-spingboot数据访问-数据缓存Cache

最新推荐文章于 2024-07-16 17:55:05 发布
最新推荐文章于 2024-07-16 17:55:05 发布
阅读量742 收藏
点赞数
分类专栏： spring boot springboot和springcloud 文章标签： spring boot java spring cache 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/j903829182/article/details/78177962
版权

    我们知道一个程序的瓶颈在于数据库，我们也知道内存的速度是大大快于硬盘的速度的。当我们需要重复地获取相同的数据的时候，我们一次又一次的请求数据库或者远程服务，导致大量的时间耗费在数据库查询或者远程方法调用上，导致程序性能的恶化，这便是数据缓存要解决的问题。

一，Spring 缓存支持

     Spring定义了org.springframework.cache.CacheManager和org.springframework.cache.Cache接口用来统一不同的缓存技术。其中CacheManager是Spring提供的各种缓存技术抽象接口，Cache接口包含缓存的各种操作（增加，删除，获得缓存，我们一般不会直接和此接口打交道）

1，Spring支持的CacheManager

      针对不同的缓存技术，需要实现不同的CacheManager，Spring定义了如下所示的CacheManager实现：

SimpleCacheManager：使用简单的Collection来存储缓存，主要用来测试用途。

ConcurrentMapCacheManager：使用ConcurrentMap来存储缓存。

NoOpCacheManager：仅测试用途，不会实际存储缓存。

EhCacheCacheManager：使用EhCache作为缓存技术。

GuavaCacheManager：使用Google Guava的GuavaCache作为缓存技术。

HazelcastCacheManager：使用Hazelcast作为缓存技术。

JCacheCacheManager：支持JCache标准的实现作为缓存技术，如Apache Commons JCS


RedisCacheManager：使用Redis作为缓存技术。


     在我们使用任意一个实现的CacheManager的时候，需要注册实现CacheManager的Bean，例如：

@Bean
    public EhCacheCacheManager cacheManager(CacheManager ehCacheCacheManager){
        return new EhCacheCacheManager(ehCacheCacheManager);
    }

     当然，每种缓存技术都有很多的额外配置，但配置cacheManager是必不可少的


2，声名式缓存注解

      Spring提供了4个注解来声明缓存规则（又是使用注解式的AOP的一个生动例子）。这四个注解如下：


@Cacheable：在方法执行前spring先查看缓存中是否有数据，如果有数据，则直接返回缓存数据；若没有数据，调用方法并将方法返回值放进缓存。

@CachePut：无论怎样，都会将方法的返回值放到缓存中。@CachePut的属性与@Cacheable保持一致。

@CacheEvict：将一条或多条数据从缓存中删除。

@Caching：可以通过@Caching注解组合多个注解策略在一个方法上。


     @Cacheable，@Cacheable，@CacheEvict都有value属性，指定的是要使用的缓存名称；key属性指定的是数据在缓存中的存储的键。


3，开启声名式缓存支持

     开启声名式缓存支持十分简单，只需在配置类上使用@EnableCaching注解即可，如下：

package com.jack.springboot8cache.config;

import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Configuration;

/**
 * create by jack 2017/10/9
 */
@Configuration
@EnableCaching
public class AppConfig {
}


二，Spring Boot的支持

      在spring中使用缓存技术的关键是配置CacheManager，而Spring Boot为我们自动配置了多个CacheManager的实现。

      Spring Boot的CacheManager的自动配置放置在org.springframework.boot.autoconfigure.cache包中，如下所示：



       通过上图我们可以看出，Spring Boot为我们自动配置了EhCacheCacheConfiguration（使用EhCache），GenericCacheConfiguration（使用Collection），GuavaCacheConfiguration（使用Guava），HazelcastCacheConfiguration（使用Hazelcast），InfinispanCacheConfiguration（使用Infinispan），JCacheCacheConfiguration（使用JCache），NoOpCacheConfiguration（不使用存储），RedisCacheConfiguration（使用Redis），SimpleCacheConfiguration（使用ConcurrentMap）。在不做任何额外配置的情况下，默认使用的是SimpleCacheConfiguration，即使用ConcurrentMapCacheManager。Spring boot支持以“spring.cache”为前缀的属性来配置缓存：

spring.cache.type=#可选generic，ehcache，hazelcast，infinispan，jcache，redis，guava，simple，none

spring.cache.cache-names=#程序启动时创建缓存名称

spring.cache.ehcache.config=#ehcache配置文件地址

spring.cache.hazelcast.config=#hazelcast配置文件地址

spring.cache.infinispan.config=#infinispan配置文件地址

spring.cache.jcache.config=#jcache配置文件地址

spring.cache.jcache.provider=#当多个jcache实现在类路径中的时候，指定jcache实现

spring.cache.guava.spec=#guava specs


       在Spring Boot环境下，使用缓存技术只需在项目中导入相关缓存技术的依赖包，并在配置类上使用@EnableCaching开启缓存即可。


三，实战

      下面将以Spring Boot默认的ConcurrentMapCacheManager作为缓存技术，演示@Cacheable，@CachePut，@CacheEvit，最后使用EhCache，Guava来替换缓存技术。


1，新建Spring Boot项目

      新建Spring Boot项目依赖为Cache，JPA,WEB，添加mysql驱动，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: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.jack</groupId>
	<artifactId>springboot8cache</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>springboot8cache</name>
	<description>Demo project for Spring Boot</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.7.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<!--mysql连接驱动-->
		<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
		</dependency>

		<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.39</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-cache -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-cache</artifactId>
		</dependency>


		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>


</project>

2，实体类 

package com.jack.springboot8cache.entity;

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

/**
 * create by jack 2017/10/3
 */
//@Entity注解指明这是一个和数据库表映射的实体类
@Entity
public class Person {
    /**
     * 主键id
     * @Id注解指明这个属性映射为数据库的主键
     * @GeneratedValue定义主键生成的方式，下面采用的是mysql的自增属性
     */
    @Id
    @GeneratedValue(strategy= GenerationType.AUTO)
    private Integer id;
    /**
     * 姓名
     */
    private String name;
    /**
     * 年龄
     */
    private Integer age;
    /**
     * 地址
     */
    private String address;

    public Person() {
        super();
    }

    public Person(Integer id, String name, Integer age, String address) {
        super();
        this.id = id;
        this.name = name;
        this.age = age;
        this.address = 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;
    }
}

3，实体类Repository 

package com.jack.springboot8cache.dao;


import com.jack.springboot8cache.entity.Person;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 * create by jack 2017/10/8
 * 实体类
 */
public interface PersonRepository extends JpaRepository<Person,Integer> {
}

4，业务服务

1）接口：

package com.jack.springboot8cache.service;

import com.jack.springboot8cache.entity.Person;

/**
 * create by jack 2017/10/9
 */
public interface DemoService {
    Person save(Person person);

    void remove(Integer id);

    Person findOne(Person person);
}

2）实现类 

package com.jack.springboot8cache.impl;


import com.jack.springboot8cache.dao.PersonRepository;
import com.jack.springboot8cache.entity.Person;
import com.jack.springboot8cache.service.DemoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

/**
 * create by jack 2017/10/9
 */
@Service
public class DemoServiceImpl implements DemoService {
    @Autowired
    private PersonRepository personRepository;
    /**
     * 注意：如果没有指定key，则方法参数作为key保存到缓存中
     */
    /**
     *@CachePut缓存新增的或更新的数据到缓存，其中缓存的名称为people，数据的key是person的id
     * @param person
     * @return
     */
    @CachePut(value = "people",key="person.id")
    @Override
    public Person save(Person person) {
        Person p = personRepository.save(person);
        System.out.println("为id，key为："+p.getId()+"数据做了缓存");
        return p;
    }

    /**
     * @CacheEvict从缓存people中删除key为id的数据
     * @param id
     */
    @CacheEvict(value = "people")
    @Override
    public void remove(Integer id) {
        System.out.println("删除了id，key为"+id+"的数据缓存");
        personRepository.delete(id);
    }

    /**
     * @Cacheable缓存key为person的id数据到缓存people中
     * @param person
     * @return
     */
    @Cacheable(value = "people",key = "person.id")
    @Override
    public Person findOne(Person person) {
        Person p = personRepository.findOne(person.getId());
        System.out.println("为id，key为："+p.getId()+"数据做了缓存");
        return p;
    }
}

    注意：如果没有指定key，则方法参数作为key保存到缓存中


5，控制器

package com.jack.springboot8cache.controller;

import com.jack.springboot8cache.entity.Person;
import com.jack.springboot8cache.service.DemoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * create by jack 2017/10/9
 */
@RestController
@RequestMapping("cache")
public class CacheController {
    @Autowired
    private DemoService demoService;

    @RequestMapping("/put")
    public Person put(Person person){
        return demoService.save(person);
    }

    @RequestMapping("/evit")
    public String evit(Integer id){
        demoService.remove(id);
        return "ok";
    }

    @RequestMapping("/cacheable")
    public Person cacheable(Person person){
        return demoService.findOne(person);
    }

}

6，开启缓存支持 

package com.jack.springboot8cache;

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

@SpringBootApplication
@EnableCaching
public class Springboot8cacheApplication {

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

7，运行


     当我们对数据库做了缓存以后，数据的获得将从缓存中得到，而不是从数据库中得到。当前的数据库的数据情况如下所示：



    我们在每次运行测试情况下，都重启了应用程序。

1）测试@Cacheable

      第一次访问http://localhost:9090/cache/cacheable?id=85，第一次将调用方法查询数据库，并将数据放到缓存people中。

此时控制台输出如下：

2017-10-09 23:29:05.877  INFO 2468 --- [nio-9090-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring FrameworkServlet 'dispatcherServlet'
2017-10-09 23:29:05.878  INFO 2468 --- [nio-9090-exec-1] o.s.web.servlet.DispatcherServlet        : FrameworkServlet 'dispatcherServlet': initialization started
2017-10-09 23:29:05.939  INFO 2468 --- [nio-9090-exec-1] o.s.web.servlet.DispatcherServlet        : FrameworkServlet 'dispatcherServlet': initialization completed in 61 ms
Hibernate: select person0_.id as id1_0_0_, person0_.address as address2_0_0_, person0_.age as age3_0_0_, person0_.name as name4_0_0_ from person person0_ where person0_.id=?
为id，key为：85数据做了缓存

页面输出如下：



      再次访问http://localhost:9090/cache/cacheable?id=85，此时控制台没有再次输出hibernate的查询语句，以及“为id，key为：85数据做了缓存”字样，表示没有调用这个方法，页面直接从数据缓存中获得数据，页面输出结果如下：



2）测试@CachePut

      访问http://localhost:9090/cache/put?name=jack8&age=99&address=深圳深圳，此时控制台输出如下：

2017-10-09 23:37:10.823  INFO 1212 --- [nio-9090-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring FrameworkServlet 'dispatcherServlet'
2017-10-09 23:37:10.824  INFO 1212 --- [nio-9090-exec-1] o.s.web.servlet.DispatcherServlet        : FrameworkServlet 'dispatcherServlet': initialization started
2017-10-09 23:37:10.893  INFO 1212 --- [nio-9090-exec-1] o.s.web.servlet.DispatcherServlet        : FrameworkServlet 'dispatcherServlet': initialization completed in 69 ms
Hibernate: insert into person (address, age, name) values (?, ?, ?)
为id，key为：86数据做了缓存

页面输出如下：



     我们再次访问：http://localhost:9090/cache/cacheable?id=87，控制台无输出，从缓存直接获得数据，页面显示如上。


3）测试@CacheEvit

       访问：http://localhost:9090/cache/cacheable?id=87，为id为87的数据做缓存，再次访问http://localhost:9090/cache/cacheable?id=87，确认数据已经从缓存中获取。

       访问：http://localhost:9090/cache/evit?id=87，从缓存中删除key为87的缓存数据：

删除了id，key为87的数据缓存
Hibernate: select person0_.id as id1_0_0_, person0_.address as address2_0_0_, person0_.age as age3_0_0_, person0_.name as name4_0_0_ from person person0_ where person0_.id=?
Hibernate: delete from person where id=?

     再次访问：http://localhost:9090/cache/cacheable?id=87，观察控制台，数据已经从数据库中删除了，查询缓存，发现空指针异常了，查询失败


四，切换缓存技术

      切换缓存技术除了移入相关依赖包或者配置以外，使用方式和上面的实战例子保存一致。下面讲解Spring Boot下EhCache和Guava作为缓存技术的方式，其余缓存技术也是类似的方式。

1，EhCahce

      当我们需要使用EhCache作为缓存技术的时候，我们只需要在pom.xml中添加EhCache的依赖即可：

<!-- https://mvnrepository.com/artifact/net.sf.ehcache/ehcache -->
<dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache</artifactId>
    <version>2.10.4</version>
</dependency>

     EhCache所需的配置文件ehcache.xml只需放在类路径下，Spring Boot会自动扫描，例如：

<?xml version="1.0" encoding="UTF-8">

<ehcache>

    <cache name="people" maxElementsInMemory="1000"/>

</ehcache>


Spring Boot会给我们自动配置EhcacheCacheManager的Bean。


2,Guava

     当我们需要使用Guava作为缓存技术的时候，我们只需要在pom.xml中增加Guava的依赖即可：

<!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>23.0</version>
</dependency>

Spring Boot会给我们自动配置GuavaCacheManager这个Bean。


3，Redis

       使用Redis，只需添加下面的依赖即可：

<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>1.5.7.RELEASE</version>
</dependency>

Spring Boot将会为我们自动配置RedisCacheManager以及RedisTemplate的Bean。


源码地址：https://github.com/wj903829182/SpringCloudTwo/tree/master/springboot8cache

















修炼中的菜鸟
关注
专栏目录
第九章 SpringBoot缓存-方法的缓存❤❤
与海
04-27 643
基于Ehcache或Redis通过注解Cacheable,CachePut及CacheEvict实现
Springboot集成Guava Cache
liuxw1的博客
07-13 2912
一、首先导入依赖 <dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> <version>23.6-jre</version> </dependency> 二、guava的配置，那个24指的是24小时
SpringBoot使用缓存
weixin_34056162的博客
05-29 148
前言 我们都知道，一个程序的瓶颈通常都在数据库，很多场景需要获取相同的数据。比如网站页面数据等，需要一次次的请求数据库，导致大部分时间都浪费在数据库查询和方法调用上，这时就可以利用到缓存来缓解这个问题。 简介 本文来介绍SpringBoot来简单整合缓存，使用SpringBoot+JPA+mysql来进行数据库操作。整合JPA的文章，具体可以参考 传送门。 新建项目 创建一个项目，pom文件中加入...
SpringBoot使用本地缓存——Caffeine
最新发布
pig_boss的博客
07-16 1900
Caffeine是一个高性能的Java本地缓存库，设计用于提供快速响应时间和高并发处理能力。它具有类似于Guava缓存的简单易用的API，同时也提供了许多额外的功能和性能优化。Caffeine支持缓存大小限制、缓存过期策略、异步加载数据等特性，可以帮助开发人员在应用程序中有效地管理和优化缓存。Caffeine还提供了可自定义的缓存策略和监听器，以帮助开发人员根据实际需求定制缓存行为。
Spring Boot数据缓存
G_Jansue的博客
10-31 963
缓存是分布式系统中的重要组件，主要解决数据库数据的高并发访问。在实际开发中，尤其是用户访问量较大的网站，用户对高频热点数据的访问非常频繁，为了提高服务器访问性能、减少数据库的压力、提高用户体验，使用缓存显得尤为重要。提示：以下是本篇文章正文内容，下面案例可供参考缓存是计算机已经接收并使⽤过⼀次，然后保存以备将来使⽤的数据。缓存的重点是下次不需要从远程的服务器中再次获取数据，⽽是从⾃⼰的快速缓存中获取数据。二、Spring boot默认缓存。
spring boot 缓存_Guava Cache本地缓存在 Spring Boot应用中的实践
weixin_39626586的博客
11-26 228
概述在如今高并发的互联网应用中，缓存的地位举足轻重，对提升程序性能帮助不小。而 3.x开始的 Spring也引入了对 Cache的支持，那对于如今发展得如火如荼的 Spring Boot来说自然也是支持缓存特性的。当然 Spring Boot默认使用的是 SimpleCacheConfiguration，即使用 ConcurrentMapCacheManager 来实现的缓存。但本文将讲述如何将 ...
Springboot缓存
AALouisaa的博客
08-21 1374
Springboot缓存
springboot笔记-集成Java本地缓存之王Caffeine Cache
06-25
springboot笔记-集成Java本地缓存之王Caffeine Cache
SpringBoot cache-control 配置静态资源缓存 （以及其中的思考经历）
weixin_30247159的博客
05-10 3445
　　昨天在部署项目时遇到一个问题，因为服务要部署到外网使用，中间经过了较多的网络传输限制，而且要加载arcgis等较大的文件，所以在部署后，发现页面loading需要很长时间，而且刷新也要重新从服务器下载文件。这当然是不能忍受的，即使在不考虑文件大小的情况下，我们也希望我们的静态文件如js， css， json， img等，可以在刷新的时候尽量不重新加载，这样我们的页面会变得更有效率即使在网络不好...
springboot 使用spring cache缓存 和 缓存数据落地到redis
09-13
【Spring Boot 使用 Spring Cache 缓存与数据落地到 Redis】\n\n在Spring Boot应用中，Spring Cache是一个强大的工具，可以极大地提升应用的性能，通过缓存非计算性或者昂贵的计算结果。Spring Cache抽象了缓存管理...
springboot-01-cache.rar_browndl4_goldk4u_mill18b_springboot
09-21
标题中的"springboot-01-cache.rar"表明这是一个关于Spring Boot缓存管理的项目压缩包。Spring Boot是Java开发的一款快速构建微服务的框架，它简化了Spring应用的初始搭建以及开发过程。"cache"部分则暗示我们这个...
Spring Boot 缓存
someday____的博客
08-30 1045
缓存相当于一个临时存储器，当我们想从数据库中拿取数据时，无需一直从数据库拿取，只需拿取一次之后把数据存入到缓存中，之后便可直接从缓存中拿数据，能大大提高数据的读取速度。Spring Boot 支持多种缓存实现方式，可以根据项目需求灵活选择。缓存数据量较小的项目，可以使用 Spring Boot 默认缓存。缓存数据量较大的项目，可以考虑使用 Ehcache 缓存框架。如果是大型系统，对缓存的依赖性比较高，还是建议采用独立的缓存组件 Redis ，通过主备、集群等形式提高缓存服务的性能和稳定性。...
SpringBoot缓存
Ledis的博客
04-27 210
缓存的简介 * 将方法的运行结果进行缓存；以后在要相同的数据，直接从缓存中获取，不用调用方法 * * CacheManager管理多个Cache组件，对缓存的真正CRUD操作在Cache组件中，每一个缓存组件有自己唯一的名字 * 几个属性： * cacheNames/value：制定缓存组件的名字 * key：缓存数据...
SpringBoot 缓存
dickysun1987的专栏
06-23 594
SpringBoot 缓存简单实用
springboot-3-整合ehcache缓存
05-17
其中，`spring.cache.type`属性指定使用的缓存类型为Ehcache，`ehcache.config`属性指定Ehcache配置文件的路径（在classpath下）。 3. 编写Ehcache配置文件 在classpath下创建`ehcache.xml`文件，配置Ehcache缓存...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值