spring Cache的基本使用

news2024/12/25 0:07:08

一、spring Cache基本介绍（其实是通过代理对象来进行操作的）

  1. Spring Cache 是 Spring 框架提供的一个缓存抽象，它能够轻松地集成到 Spring 应用程序中，为方法调用的结果提供缓存支持，从而提高应用程序的性能和响应速度。Spring Cache 提供了一种声明式的缓存机制，可以在方法上使用注解来指定需要进行缓存的方法，而无需编写繁琐的缓存代码。
  2. Spring Cache 的基本介绍：
      1. 声明式缓存支持：Spring Cache 提供了一种声明式的缓存机制，通过在方法上使用注解来声明需要进行缓存的方法，如 @Cacheable、@CachePut、@CacheEvict 等。
      1. 灵活的缓存策略：Spring Cache 提供了多种灵活的缓存策略，可以根据具体需求选择合适的缓存方案，如基于内存的缓存、基于 Redis、Ehcache 等第三方缓存框架的集成。
      1. 支持缓存管理器：Spring Cache 支持多种缓存管理器，可以根据需要选择适合的缓存管理器，如 ConcurrentMapCacheManager、EhCacheCacheManager、RedisCacheManager 等。
      1. 缓存注解：
      • @Cacheable：用于声明方法的返回值可以被缓存，当下次使用相同的参数调用该方法时，直接从缓存中获取结果，而不会执行方法体。
      • @CachePut：用于声明方法的结果应该被更新到缓存中，即使缓存中已经存在相同键的条目。
      • @CacheEvict：用于声明方法执行后将缓存中的某些条目清除。
      1. 缓存注解的属性：缓存注解支持一系列属性，例如 value、key、condition、unless 等，用于配置缓存的键、条件判断等。
      1. 适用于各种应用场景：Spring Cache 适用于各种应用场景，可以用于缓存方法的返回值、类级别的缓存、缓存的条件判断等。

通过使用 Spring Cache，可以轻松地为应用程序中的方法调用提供缓存支持，从而提高应用程序的性能和响应速度，减少对数据库或其他资源的频繁访问。

在这里插入图片描述
在这里插入图片描述

二、基本使用1

  1. Spring Cache 的基本使用通常涉及以下几个步骤：
      1. 添加依赖：首先，需要在项目中添加 Spring Cache 的依赖。如果使用 Spring Boot，则无需额外添加依赖，因为 Spring Boot 已经自动集成了 Spring Cache。如果使用的是普通的 Spring 项目，则需要手动添加依赖。
      1. 配置缓存管理器：在 Spring 配置文件中配置缓存管理器，以便选择和配置合适的缓存提供者。常见的缓存管理器有 ConcurrentMapCacheManager、EhCacheCacheManager、RedisCacheManager 等。
      1. 在方法上使用缓存注解：在需要进行缓存的方法上使用 Spring Cache 提供的缓存注解，如 @Cacheable、@CachePut、@CacheEvict 等。根据方法的功能需求选择合适的注解。
      1. 触发缓存操作：调用被缓存注解修饰的方法，触发缓存操作。根据缓存注解的配置，方法的返回值将被缓存起来，以便后续使用。

下面是一个简单的示例，演示了如何在 Spring Boot 中使用 Spring Cache：

  1. 添加 Spring Boot Starter Cache 依赖。在 pom.xml 中添加以下依赖：
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
  1. 配置缓存管理器。在 application.properties 文件中配置缓存管理器，例如使用 ConcurrentMapCacheManager：
spring.cache.type=simple
  1. 在服务类中添加缓存注解。在需要进行缓存的方法上添加 @Cacheable 注解：
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    @Cacheable("myCache")
    public String cachedMethod(String param) {
        // Simulate time-consuming operation
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "Cached result for " + param;
    }
}
  1. 调用缓存方法。在其他类中调用被缓存注解修饰的方法：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

    @Autowired
    private MyService myService;

    @GetMapping("/getData")
    public String getData() {
        // Calling cached method
        return myService.cachedMethod("param");
    }
}

这样，在第一次调用 getData() 方法时，cachedMethod() 方法将被执行，并将返回值缓存起来。在后续调用 getData() 方法时，将直接从缓存中获取结果，而不会再执行方法体。

三、基本使用2

Spring Cache 的基本使用可以通过以下步骤完成：

  1. 添加依赖：首先，在项目的依赖管理文件（如 Maven 的 pom.xml）中添加 Spring Cache 相关的依赖。
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
  1. 启用缓存：在 Spring Boot 的主类上添加 @EnableCaching 注解，以启用 Spring Cache 功能。
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

@SpringBootApplication
@EnableCaching
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
  1. 声明需要缓存的方法：在需要进行缓存的方法上使用 @Cacheable、@CachePut 或 @CacheEvict 等注解，以实现缓存的功能。
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    @Cacheable("myCache") // 声明方法的返回值可以被缓存，缓存名称为 "myCache"
    public String getCachedData(String key) {
        // 此处通常为从数据库或其他数据源获取数据的逻辑
        return "Data for key: " + key;
    }
}
  1. 配置缓存管理器（可选）：Spring Cache 默认使用 ConcurrentMapCacheManager 作为缓存管理器，但你也可以根据需求配置其他缓存管理器，如 EhCache、Redis 等。
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;

@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        RedisCacheManager cacheManager = RedisCacheManager.create(connectionFactory);
        return cacheManager;
    }

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, String> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        return template;
    }
}
  1. 使用缓存：调用声明了 @Cacheable、@CachePut 或 @CacheEvict 注解的方法时，Spring Cache 将会自动根据缓存的配置情况来处理缓存。
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

    @Autowired
    private MyService myService;

    @GetMapping("/data/{key}")
    public String getData(@PathVariable String key) {
        return myService.getCachedData(key);
    }
}

以上就是 Spring Cache 的基本使用步骤。通过上述配置，你就可以在 Spring Boot 应用程序中使用缓存来提高方法调用的性能和响应速度。

1、@CachePut注解

  1. @CachePut 是 Spring Cache 中的一个注解，用于更新缓存中的数据。与 @Cacheable 不同，@CachePut 不会检查缓存中是否已经存在相同键的条目，而是直接将方法的返回值更新到缓存中。

  2. @CachePut 注解有以下几个属性：

      1. value：与cacheNames相同，用于指定要操作的缓存名称或缓存管理器的名称。可以是一个字符串，也可以是一个字符串数组，用于指定多个缓存名称。
      1. key：指定缓存条目的键，用于唯一标识缓存中的条目。SpEL 表达式可以用于动态地生成键值。如果不指定 key，Spring Cache 将会使用默认的键生成策略来生成键值。
      1. condition：指定一个 SpEL 表达式，用于判断是否执行缓存操作。只有当表达式的值为 true 时，才会执行缓存操作。默认为空，表示始终执行缓存操作。
      1. unless：指定一个 SpEL 表达式，用于判断是否不执行缓存操作。只有当表达式的值为 false 时，才会执行缓存操作。默认为空，表示始终执行缓存操作。
      1. keyGenerator：指定一个自定义的键生成器，用于生成缓存条目的键值。默认为空，表示使用默认的键生成策略。
      1. cacheManager：指定一个自定义的缓存管理器，用于指定缓存的实现。默认为空，表示使用默认的缓存管理器。
      1. cacheResolver：指定一个自定义的缓存解析器，用于解析缓存的实现。默认为空，表示使用默认的缓存解析器。
      1. condition：指定一个 SpEL 表达式，用于判断是否执行缓存操作。只有当表达式的值为 true 时，才会执行缓存操作。默认为空，表示始终执行缓存操作。

  3. @CachePut 注解通常用于更新缓存中的数据，例如在更新数据库中的数据后，同时更新缓存中的数据。因此，@CachePut 注解常常与 @Cacheable 注解一起使用，前者用于更新缓存，后者用于读取缓存。

  4. 以下是 @CachePut 的一些使用示例：

使用 SpEL 表达式作为缓存键：

import org.springframework.cache.annotation.CachePut;

@Service
public class MyService {

    @CachePut(cacheNames = "userCache_", key = "#user.id")
    public User updateUser(User user) {
        // update user in the database
        return user;
    }
}

在这个示例中，Spring 表达式语言 (SpEL) #user.id 将作为缓存键，表示使用cacheNames的属性值 +::+ User 对象的 id 属性值作为缓存键。（这里的user对象是值updateUser方法的参数）
加入user的id=1，那么这里缓存键的值=userCache::1
在这里插入图片描述
还有其他方式：
在这里插入图片描述

  1. 总之，@CachePut 注解用于指示 Spring 在方法执行后将结果放入缓存中，并始终执行方法以确保缓存中的数据是最新的。

2、@Cacheable注解

  1. @Cacheable 是 Spring Cache 中的一个注解，用于声明方法的返回值可以被缓存。当调用被 @Cacheable 注解修饰的方法时，Spring Cache 会首先检查缓存中是否已经存在相同键的条目，如果存在，则直接从缓存中获取结果，而不会执行方法体；如果不存在，则执行方法体，并将方法的返回值缓存起来，以便下次使用相同参数调用时直接从缓存中获取结果。

  2. @Cacheable 注解有以下几个属性：

      1. value：与cacheNames相同，用于指定要操作的缓存名称或缓存管理器的名称。可以是一个字符串，也可以是一个字符串数组，用于指定多个缓存名称。
      1. key：指定缓存条目的键，用于唯一标识缓存中的条目。SpEL 表达式可以用于动态地生成键值。如果不指定 key，Spring Cache 将会使用默认的键生成策略来生成键值。
      1. condition：指定一个 SpEL 表达式，用于判断是否执行缓存操作。只有当表达式的值为 true 时，才会执行缓存操作。默认为空，表示始终执行缓存操作。
      1. unless：指定一个 SpEL 表达式，用于判断是否不执行缓存操作。只有当表达式的值为 false 时，才会执行缓存操作。默认为空，表示始终执行缓存操作。
      1. keyGenerator：指定一个自定义的键生成器，用于生成缓存条目的键值。默认为空，表示使用默认的键生成策略。
      1. cacheManager：指定一个自定义的缓存管理器，用于指定缓存的实现。默认为空，表示使用默认的缓存管理器。
      1. cacheResolver：指定一个自定义的缓存解析器，用于解析缓存的实现。默认为空，表示使用默认的缓存解析器。
      1. sync：指定是否启用同步模式。如果设置为 true，那么缓存操作将在调用方法的同一线程中执行，否则将在后台线程中异步执行。默认为 false。

  3. @Cacheable 注解可以应用于类或方法上。当应用于类上时，表示该类的所有方法的返回值都可以被缓存；当应用于方法上时，表示特定方法的返回值可以被缓存。

  4. @Cacheable的使用

下面是一个示例：

@Service
public class MyService {

    @Cacheable(value = "myCache", key = "#key")
    public String getCachedData(String key) {
        // 此处通常为从数据库或其他数据源获取数据的逻辑
        return "Data for key: " + key;
    }
}

在这个示例中，getCachedData 方法使用 @Cacheable 注解，将方法的返回值缓存到名为 “myCache” 的缓存中，并使用参数 key 作为缓存条目的键。每次调用 getCachedData 方法时，Spring Cache 会首先检查缓存中是否存在相同键的条目，如果存在，则直接从缓存中获取结果，而不会执行方法体；如果不存在，则执行方法体，并将方法的返回值缓存起来，以便下次使用相同参数调用时直接从缓存中获取结果。

3、@CacheEvict注解

  1. @CacheEvict 是 Spring Cache 中的一个注解，用于从缓存中移除指定的条目。当调用被 @CacheEvict 注解修饰的方法时，Spring Cache 会从指定的缓存中移除与方法参数匹配的条目。

  2. @CacheEvict 注解有以下几个属性：

      1. value：与cacheNames相同，用于指定要操作的缓存名称或缓存管理器的名称。可以是一个字符串，也可以是一个字符串数组，用于指定多个缓存名称。
      1. key：指定缓存条目的键，用于唯一标识缓存中的条目。SpEL 表达式可以用于动态地生成键值。如果不指定 key，Spring Cache 将会使用默认的键生成策略来生成键值。
      1. condition：指定一个 SpEL 表达式，用于判断是否执行缓存操作。只有当表达式的值为 true 时，才会执行缓存操作。默认为空，表示始终执行缓存操作。
      1. keyGenerator：指定一个自定义的键生成器，用于生成缓存条目的键值。默认为空，表示使用默认的键生成策略。
      1. cacheManager：指定一个自定义的缓存管理器，用于指定缓存的实现。默认为空，表示使用默认的缓存管理器。
      1. cacheResolver：指定一个自定义的缓存解析器，用于解析缓存的实现。默认为空，表示使用默认的缓存解析器。
      1. beforeInvocation：指定是否在方法调用之前或之后执行缓存操作。如果设置为 true，则在方法调用之前执行缓存操作；如果设置为 false（默认值），则在方法调用之后执行缓存操作。

  3. @CacheEvict 注解通常用于清除缓存中的数据，例如在更新数据库中的数据后，需要清除缓存中相应的数据以保持一致性。因此，@CacheEvict 注解常常与 @Cacheable 或 @CachePut 注解一起使用，前者用于清除缓存，后者用于更新缓存或执行其他操作。

  4. @CacheEvict 是 Spring Cache 中的一个注解，用于从缓存中移除指定的条目。基本使用步骤如下：

      1. 在需要清除缓存的方法上添加 @CacheEvict 注解。
      1. 配置 @CacheEvict 注解的属性，指定要操作的缓存名称、缓存条目的键等信息。

下面是一个基本使用示例：

@Service
public class MyService {

    @CacheEvict(value = "myCache", key = "#key")
    public void clearCache(String key) {
        // 此处通常为清除缓存的逻辑
    }
}

在这个示例中，clearCache 方法使用 @CacheEvict 注解，指定了要清除的缓存名称为 “myCache”，并使用参数 key 作为缓存条目的键。每次调用 clearCache 方法时，Spring Cache 会从名为 “myCache” 的缓存中移除与参数 key 匹配的条目。

需要注意的是，@CacheEvict 注解默认是在方法调用之后执行缓存操作的。如果想在方法调用之前执行缓存操作，可以设置 beforeInvocation 属性为 true。例如：

@CacheEvict(value = "myCache", key = "#key", beforeInvocation = true)

这样配置之后，@CacheEvict 注解会在方法调用之前先清除缓存，然后再执行方法体。

在这里插入图片描述

四、使用spring Cache

  1. 使用springCache其实就是使用它的注解

四、1、项目起始状态

项目结构：
在这里插入图片描述

数据库：

DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `name` varchar(45) DEFAULT NULL,
  `age` int DEFAULT NULL,
  PRIMARY KEY (`id`)
);

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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.3</version>
        <relativePath/>
    </parent>
    <groupId>com.itheima</groupId>
    <artifactId>springcache-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

    <dependencies>
<!--        web依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <scope>compile</scope>
        </dependency>
<!--        lombok依赖-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.76</version>
        </dependency>

        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>
<!--        缓存依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>

<!--        redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

<!--        mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

<!--        mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.0</version>
        </dependency>

<!--        druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.1</version>
        </dependency>

<!--        knife4j（swagger）-->
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>knife4j-spring-boot-starter</artifactId>
            <version>3.0.2</version>
        </dependency>

<!--        测试依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.7.3</version>
            </plugin>
        </plugins>
    </build>
</project>

application.yml

server:
  port: 6688
spring:
  datasource:
    druid:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/spring_cache?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowPublicKeyRetrieval=true
      username: root
      password: dadao
  redis:
    host: localhost
    port: 6379
    password: 123456
    database: 1
logging:
  level:
    com:
      itheima:
        mapper: debug
        service: info
        controller: info

config

@Configuration
@Slf4j
public class WebMvcConfiguration extends WebMvcConfigurationSupport {

    /**
     * 生成接口文档配置
     * @return
     */
    @Bean
    public Docket docket(){
        log.info("准备生成接口文档...");

        ApiInfo apiInfo = new ApiInfoBuilder()
                .title("接口文档")
                .version("2.0")
                .description("接口文档")
                .build();

        Docket docket = new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo)
                .select()
                //指定生成接口需要扫描的包
                .apis(RequestHandlerSelectors.basePackage("com.itheima.controller"))
                .paths(PathSelectors.any())
                .build();

        return docket;
    }

    /**
     * 设置静态资源映射
     * @param registry
     */
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        log.info("开始设置静态资源映射...");
        registry.addResourceHandler("/doc.html").addResourceLocations("classpath:/META-INF/resources/");
        registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
    }
}

controller

@RestController
@RequestMapping("/user")
@Slf4j
public class UserController {

    @Autowired
    private UserMapper userMapper;

    @PostMapping
    public User save(@RequestBody User user){
        userMapper.insert(user);
        return user;
    }

    @DeleteMapping
    public void deleteById(Long id){
        userMapper.deleteById(id);
    }

	@DeleteMapping("/delAll")
    public void deleteAll(){
        userMapper.deleteAll();
    }

    @GetMapping
    public User getById(Long id){
        User user = userMapper.getById(id);
        return user;
    }

}

entity

@Data
public class User implements Serializable {

    private static final long serialVersionUID = 1L;

    private Long id;

    private String name;

    private int age;

}

mapper

@Mapper
public interface UserMapper{

    @Insert("insert into user(name,age) values (#{name},#{age})")
    @Options(useGeneratedKeys = true,keyProperty = "id")
    void insert(User user);

    @Delete("delete from user where id = #{id}")
    void deleteById(Long id);

    @Delete("delete from user")
    void deleteAll();

    @Select("select * from user where id = #{id}")
    User getById(Long id);
}

引导类

@Slf4j
@SpringBootApplication
@EnableCaching //第一步：开启缓存注解
public class CacheDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(CacheDemoApplication.class,args);
        log.info("项目启动成功...");
    }
}

四、2、修改后的controller（其实就加了几个注解）

@RestController
@RequestMapping("/user")
@Slf4j
public class UserController {

    @Autowired
    private UserMapper userMapper;

    @PostMapping
    //使用spEl表达式生成key，这里的user表示参数的user，假设user的id是1，key的生成是userCache::1,
//    @CachePut(cacheNames = "userCache",key = "#user.id")
    @CachePut(value = "userCache",key = "#user.id")
//    @CachePut(cacheNames = "userCache",key = "#result.id") //result表示最后return的User对象
//    @CachePut(cacheNames = "userCache",key = "#p0.id") // p0表示第一个参数
//    @CachePut(cacheNames = "userCache",key = "#a0.id")// a0表示第一个参数
//    @CachePut(cacheNames = "userCache",key = "#root.args[0].id") //root.args[0]表示第一个参数，即user
    public User save(@RequestBody User user){
        userMapper.insert(user);
        return user;
    }

    @DeleteMapping
    @CacheEvict(cacheNames = "userCache",key = "#id") // 根据id进行删除缓存
    public void deleteById(Long id){
        userMapper.deleteById(id);
    }

	@DeleteMapping("/delAll")
    @CacheEvict(cacheNames = "userCache",allEntries = true) //删除缓存名称为userCache缓存的所有缓存键
    public void deleteAll(){
        userMapper.deleteAll();
    }

    @GetMapping
    @Cacheable(cacheNames = "userCache",key = "#id") // key对应形参的名称
    public User getById(Long id){
        User user = userMapper.getById(id);
        return user;
    }

}

五、spring Cache的实现原理

  1. Spring Cache 的实现原理基本上遵循了标准的缓存机制。它的核心思想是在方法执行时，首先检查缓存中是否存在与方法调用相关联的结果，如果存在，则直接返回缓存中的结果，避免重复执行方法体；如果缓存中不存在相关结果，则执行方法体，并将结果存储到缓存中。

  2. 具体来说，Spring Cache 的实现原理如下：

      1. 缓存管理器（Cache Manager）：Spring Cache 提供了一个抽象的缓存管理器接口，用于管理缓存的创建、查询和更新等操作。缓存管理器负责与实际的缓存实现（如 ConcurrentMap、EhCache、Redis 等）进行交互，将缓存操作委托给具体的缓存实现来处理。
      1. 缓存注解：Spring Cache 提供了一系列的缓存注解，如 @Cacheable、@CachePut、@CacheEvict 等，用于声明方法的缓存行为。通过在方法上添加这些注解，可以指定方法的返回值可以被缓存、更新缓存或清除缓存等操作。
      1. 缓存操作拦截器（Cache Operation Interceptor）：Spring Cache 使用 AOP（Aspect-Oriented Programming）技术，通过代理模式在方法调用前后执行缓存操作。在方法调用前，缓存操作拦截器会检查缓存中是否存在与方法调用相关联的结果，如果存在则直接返回缓存中的结果；在方法调用后，缓存操作拦截器会将方法的返回值存储到缓存中，以便下次使用相同参数调用时直接从缓存中获取结果。
      1. 缓存键生成器（Cache Key Generator）：Spring Cache 使用缓存键来唯一标识缓存中的条目。缓存键通常由方法的参数、类名、方法名等信息组成。Spring Cache 提供了灵活的缓存键生成器接口，允许开发者根据需求自定义缓存键的生成策略。
      1. 缓存适配器（Cache Adapter）：Spring Cache 提供了一个抽象的缓存适配器接口，用于封装不同缓存实现之间的差异，使得缓存操作可以统一处理。通过缓存适配器，Spring Cache 可以与不同的缓存实现（如 ConcurrentMap、EhCache、Redis 等）进行无缝集成。

  3. 总之，Spring Cache 的实现原理是基于缓存管理器、缓存注解、缓存操作拦截器、缓存键生成器和缓存适配器等组件共同协作，实现了对方法调用结果的缓存管理。通过合理配置这些组件，可以实现灵活、高效的缓存功能，提升系统的性能和响应速度。

六、spring Cache通过代理对象实现的

  1. Spring Cache 通过代理对象来实现缓存功能。Spring Cache 使用了 AOP（Aspect-Oriented Programming）技术，利用动态代理机制在运行时生成代理对象，从而在方法调用前后执行缓存操作。

  2. 具体来说，当一个 Bean 中的方法被 @Cacheable、@CachePut 或 @CacheEvict 等注解修饰时，Spring Cache 会在运行时生成一个代理对象来包装这个 Bean，使得方法调用时可以被代理对象拦截。当方法被调用时，代理对象会首先检查缓存中是否存在与方法调用相关联的结果，如果存在，则直接返回缓存中的结果；如果不存在，则执行原始方法体，并将方法的返回值存储到缓存中，以便下次使用相同参数调用时直接从缓存中获取结果。

  3. 这种基于代理对象的缓存机制有以下几个优点：

      1. 透明性：开发者无需手动编写缓存逻辑，只需在方法上添加相应的缓存注解即可。代理对象会自动处理缓存操作，使得缓存逻辑与业务逻辑分离，提高了代码的清晰度和可维护性。
      1. 灵活性：代理对象可以根据配置动态生成，支持在方法调用前后执行不同的缓存操作。通过合理配置缓存注解的属性，可以实现灵活的缓存策略，满足不同场景下的需求。
      1. 扩展性：Spring Cache 提供了丰富的缓存注解和缓存管理器等组件，支持与各种缓存实现（如 ConcurrentMap、EhCache、Redis 等）无缝集成。开发者可以根据需求自定义缓存键生成器、缓存解析器等组件，实现更灵活、更高效的缓存功能。

  4. 总之，Spring Cache 通过代理对象实现了对方法调用结果的缓存管理，提供了一种简单、灵活、高效的缓存解决方案，帮助开发者提升系统性能和响应速度。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1581481.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

基于拉格朗日分布算法的电动汽车充放电调度MATLAB程序

基于拉格朗日分布算法的电动汽车充放电调度MATLAB程序

微❤关注“电气仔推送”获得资料&#xff08;专享优惠&#xff09; 程序简介 该模型主要做的是基于拉格朗日分布算法的电动汽车充放电调度模型。利用蒙特卡洛模拟法模拟出电动汽车负荷曲线&#xff0c;并求解出无序充电功率曲线和有序充电曲线&#xff0c;该模型在电动汽车个…
阅读更多...
合并单元格的excel文件转换成json数据格式

合并单元格的excel文件转换成json数据格式

github地址: https://github.com/CodeWang-Ay/DataProcess 类型1 需求1: 类似于数据格式: https://blog.csdn.net/qq_44072222/article/details/120884158 目标json格式 {"位置": 1, "名称": "nba球员", "国家": "美国"…
阅读更多...
C++设计模式：原型模式（八）

C++设计模式：原型模式（八）

1、定义与动机 定义&#xff1a;使用原型实例指定创建对象的种类&#xff0c;然后通过拷贝这些原型来创建新的对象。 动机&#xff1a; 在软件系统中&#xff0c;经常面临着“某些结构复杂的对象”的创建工作&#xff1b;由于需求的变化&#xff0c;这些对象经常面临着剧烈的变…
阅读更多...
登录压力测试

登录压力测试

目录 一、准备测试数据 1.1数据库存储过程添加数据 1.2导出为csv作为测试数据&#xff08;账号、密码&#xff09; 二、使用fiddler抓包查看接口 2.1.抓到相关接口信息 2.2添加线程组和http请求 2.3将前面接口需要的参数去json格式化 ​2.4填写相关信息 ​ 2.5添加http…
阅读更多...
顺序表（C语言实现）

顺序表（C语言实现）

什么是顺序表 顺序表和数组的区别 顺序表本质就是数组 结构体初阶进阶 系统化的学习-CSDN博客 简单解释一下&#xff0c;就像大家去吃饭&#xff0c;然后左边是苍蝇馆子&#xff0c;右边是修饰过的苍蝇馆子&#xff0c;但是那个好看的苍蝇馆子一看&#xff0c;这不行啊&a…
阅读更多...
Web前端-Ajax

Web前端-Ajax

Ajax 概念:Asynchronous JavaScript And XML,异步的JavaScript和XML。 作用: 1.数据交换:通过Ajax可以给服务器发送请求,并获取服务器响应的数据。 2.异步交互:可以在不重新加载整个页面的情况下,与服务器交换数据并更新部分网页的技术,如:搜索联想、用户名是否可用的校验等等…
阅读更多...
「44」直播间换脸，揭开神秘的面纱……

「44」直播间换脸，揭开神秘的面纱……

「44」换脸神器 让你瞬间秒变「明星脸」带货 DeepFace是Facebook的人脸识别系统之一&#xff0c;旨在在照片和视频中准确识别和标识人脸。它使用深度学习和神经网络技术来进行高度精确的人脸匹配和验证。 DeepFace利用了大量的训练数据和先进的人脸识别算法&#xff0c;能够…
阅读更多...
Redis中的集群(二)

Redis中的集群(二)

节点 集群数据结构 redisClient结构和clusterLink结构的相同和不同之处 redisClient结构和clusterLink结构都有自己的套接字描述符和输入、输出缓冲区&#xff0c;这两个结构的区别在于&#xff0c;redisClient结构中的套接字和缓冲区是用于连接客户端的&#xff0c;而clust…
阅读更多...
使用Vivado Design Suite进行功率优化

使用Vivado Design Suite进行功率优化

功率优化是一个可选步骤&#xff0c;它通过使用时钟门控来优化动态功率。它既可以在Project模式下使用&#xff0c;也可以在Non-Project模式下使用&#xff0c;并且可以在逻辑优化之后或布局之后运行&#xff0c;以减少设计中的功率需求。功率优化包括Xilinx的智能时钟门控解决…
阅读更多...
git分支-分支工作流

git分支-分支工作流

分支工作流 现在已经掌握了分支和合并的基础知识&#xff0c;可以或应该如何使用它们&#xff1f;在本节中&#xff0c;我们将介绍一些常见的工作流程&#xff0c;这种轻量级的分支使得这些工作流程成为可能&#xff0c;因此我们可以决定是否要将它们纳入到自己的开发周期中。…
阅读更多...
每天五分钟深度学习：如何理解逻辑回归算法的假设函数？

每天五分钟深度学习：如何理解逻辑回归算法的假设函数？

本文重点 我们在机器学习专栏中已经学习了逻辑回归算法，本次课程我们将重温逻辑回归算法，该算法适用于二分类的问题，本文主要介绍逻辑回归的假设函数。我们在学习线性回归算法的时候，我们已经知道了线性回归算法的假设hθ(x)=θTX（参数θ的转置*X），但是对于逻辑回归而言…
阅读更多...
使用wget下载Github代码文件

使用wget下载Github代码文件

前言 使用wget无法直接从Github链接直接下载代码文件&#xff0c;下文介绍解决方案。 解决方案 确保要下载的代码文件是公开文件&#xff0c;否则无法通过wget下载。 进入Github并找到要下载的代码文件&#xff0c;例如&#xff1a; 进入文件后&#xff0c;点击文件右侧的…
阅读更多...
Windows完全卸载MySQL后再下载安装（附安装包）

Windows完全卸载MySQL后再下载安装（附安装包）

目录 友情提醒第一章&#xff1a;如何完全卸载干净mysql教程&#xff08;三个步骤完全卸载&#xff09;1&#xff09;步骤一&#xff1a;卸载程序2&#xff09;步骤二&#xff1a;删除文件3&#xff09;步骤三&#xff1a;删除注册表信息 第二章&#xff1a;下载软件两种方式1&…
阅读更多...
R语言数据可视化：ggplot2绘图系统

R语言数据可视化：ggplot2绘图系统

ggpolt2绘图系统被称为R语言中最高大上的绘图系统&#xff0c;使用ggplot2绘图系统绘图就像是在使用语法创造句子一样&#xff0c;把数据映射到几何客体的美学属性上。因此使用ggplot2绘图系统的核心函数ggplot来绘图必须具备三个条件&#xff0c;数据data&#xff0c;美学属性…
阅读更多...
视频插针调研

视频插针调研

视频插针 1、评估指标2、准确度3、实时4、视频流处理3、实时RIFE视频插帧测试 1、评估指标 参考&#xff1a;https://blog.csdn.net/weixin_43478836/article/details/104159648 https://blog.csdn.net/weixin_43605641/article/details/118088814 PSNR和SSIM PSNR数值越大表…
阅读更多...
【CSS】MDN

【CSS】MDN

一、CSS构建 1.1 CSS选择器 1.1.1 元素选择器 标签不区分大小写 示例&#xff1a; span {background-color: yellow; }1.1.2 通用选择器 选择文档中所有内容&#xff0c;重置样式表中使用较多 鉴于div:first-child&#xff08;代表所有的div元素&#xff0c;并且是第一个…
阅读更多...
IT行业网络安全守护者-行云管家云堡垒机

IT行业网络安全守护者-行云管家云堡垒机

IT行业即信息技术行业&#xff0c;是一个涵盖广泛的行业领域&#xff0c;主要涉及与信息的处理、存储、传输和应用相关的技术。对于IT行业而言&#xff0c;保障数据安全以及网络安全至关重要&#xff0c;一不小心就容易造成数据泄露事件。今天我们小编就给大家介绍一下IT行业网…
阅读更多...
Docker 搭建私有镜像仓库

Docker 搭建私有镜像仓库

一、镜像仓库简介 Docker的镜像仓库是一个用于存储和管理Docker镜像的中央位置。镜像仓库的主要作用是提供一个集中的地方&#xff0c;让用户可以上传、下载、删除和共享Docker镜像。镜像仓库又可以分为公共镜像仓库和私有仓库镜像仓库&#xff1a; 公共镜像仓库 Docker Hub 是…
阅读更多...
ZStack Cloud 5.0.0正式发布——Vhost主存储、隔离PVLAN网络、云平台报警优化、灰度升级增强四大亮点简析

ZStack Cloud 5.0.0正式发布——Vhost主存储、隔离PVLAN网络、云平台报警优化、灰度升级增强四大亮点简析

近日&#xff0c;ZStack Cloud 5.0.0正式发布&#xff0c;推出了包含Vhost主存储、隔离PVLAN网络、云平台报警优化、灰度升级增强在内的一系列重要功能。云主机管理、物理机运维、密评合规、灾备服务等诸多使用场景和功能模块均有更新&#xff0c;为您带来更完善的平台服务、更…
阅读更多...
OJ 进制转换 判断进制【C】

OJ 进制转换 判断进制【C】

进制转换 好久没写C&#xff0c;太生疏了&#xff0c;记一下我卡住的几个点 1.C没有字符串这种数据类型&#xff0c;要实现读入一个未知长度的字符串比较简单的方法 建立一个一定比这个字符串长的数组&#xff0c;而字符串在数组中的存储是会自动以\0结尾的&#xff0c;所以遍…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023