Spring Cache常用注解

最新推荐文章于 2024-08-21 17:36:40 发布

筱顾大men

最新推荐文章于 2024-08-21 17:36:40 发布

阅读量1k

点赞数 13

文章标签： spring sql 数据库

本文链接：https://blog.csdn.net/2301_79693537/article/details/140774709

版权

依赖代码如下：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>

常用注解详解

1. @Cacheable

作用：主要用于配置方法，使其能够根据方法的请求参数对其结果进行缓存。在查询时，会先从缓存中取，若不存在才会再发起对数据库的访问。

主要参数：

value/cacheNames：指定缓存的名称，用于区分不同的缓存集合。

key：缓存对象存储在Map集合中的key值，非必需，缺省按照函数的所有参数组合作为key值。

condition：缓存对象的条件，非必需，需使用SpEL表达式，只有满足表达式条件的内容才会被缓存。

unless：另一个缓存条件参数，非必需，也需使用SpEL表达式，在函数被调用之后才做判断，可以通过对result进行判断。

keyGenerator：用于指定key生成器，非必需。

cacheManager：用于指定使用哪个缓存管理器，非必需。

cacheResolver：用于指定使用哪个缓存解析器，非必需。

2. @CachePut

作用：配置于函数上，能够根据方法的请求参数对其结果进行缓存。与@Cacheable不同的是，@CachePut每次都会真实调用函数，所以主要用于数据新增和修改操作上。

主要参数：与@Cacheable类似，包括value/cacheNames、key、keyGenerator、cacheManager、cacheResolver等。

3. @CacheEvict

作用：配置于函数上，通常用在删除方法上，用来从缓存中移除对应数据。

主要参数：

value/cacheNames：指定要清空的缓存名称。

key：指定要删除的缓存项的key，可以使用SpEL表达式。

allEntries：是否清空指定缓存中的所有缓存项，默认为false。

beforeInvocation：是否在方法执行之前就清空缓存，默认为false，即在方法执行之后清空。

4. @Caching

作用：配置于函数上，组合多个Cache注解使用，以便在一个方法上同时使用@Cacheable、@CachePut、@CacheEvict等注解。

这里用案例讲解一下，

首先创建一个新的项目这里取名为SpringCache-demo

导入依赖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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <scope>compile</scope>
        </dependency>
        <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>

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

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

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

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

        <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>

启动类加入@EnableCaching注解

@Slf4j
@SpringBootApplication
@EnableCaching
public class CacheDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(CacheDemoApplication.class,args);
        log.info("项目启动成功...");
    }
}

这里提前准备好数据库，spring_cache_demo，创建user表

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

UserController代码

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

    @Autowired
    private UserMapper userMapper;

    @PostMapping
    @CachePut(cacheNames = "userCache",key = "#user.id")  // 如果使用Spring Cache缓存数据，key的生成：userCache::2
//    @CachePut(cacheNames = "userCache",key = "#result.id")  // 对象导航
//    @CachePut(cacheNames = "userCache",key = "#p0.id")
//    @CachePut(cacheNames = "userCache",key = "#a0.id")
//    @CachePut(cacheNames = "userCache",key = "#root.args[0].id")
    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;
    }

}

@CachePut：这是Spring Cache框架提供的注解，用于在方法执行后更新缓存。它在这个例子中被用来在插入或更新用户后，将用户数据放入名为userCache的缓存中。key属性指定了缓存的键，这里使用了#user.id，意味着缓存的键是用户ID。这允许你根据用户ID快速地从缓存中获取用户数据。

注释中的其他@CachePut用法示例展示了不同的键生成方式。例如，#result.id会在方法执行完成后使用返回值（在这个场景中是User对象）的ID作为键；#p0.id、#a0.id和#root.args[0].id都是访问方法参数（在这个例子中是User对象）的ID的不同方式。

这里启动看一下

这里存到redis就成功了，至于userCache：：id，就是分目录保存

@Cacheable注解的使用

    @GetMapping
    @Cacheable(cacheNames = "userCache", key = "#id") //key 的生成 userCache::2
    public User getById(Long id){
        User user = userMapper.getById(id);
        return user;
    }

断点并没有触发，就直接输出了，这里是因为SpringCache使用了动态代理对象，先访问redis缓存，如果有则直接使用redis里的缓存，如果没有，则需要进行正常查询，并把数据存储到redis缓存中。

@CacheEvict注解使用（单条删除）

    @DeleteMapping
    @CacheEvict(cacheNames = "userCache",key = "#id") //key 的生成 userCache::2
    public void deleteById(Long id){
        userMapper.deleteById(id);
    }

@CacheEvict注解使用（多条删除，全部删除）

	@DeleteMapping("/delAll")
    @CacheEvict(cacheNames = "userCache",allEntries = true)
    public void deleteAll(){
        userMapper.deleteAll();
    }