@Cacheable, @CachePut, @CacheEvict注解的功能是什么？它们的执行过程是怎样的？

@Cacheable、@CachePut和@CacheEvict是Spring框架提供的缓存注解。它们的功能如下：

@Cacheable：该注解表示需要将方法返回结果缓存起来，以便后续使用相同的参数调用该方法时可以直接从缓存中获取结果，而不必执行该方法。

@CachePut：该注解表示需要将方法返回结果缓存起来，但与@Cacheable不同的是，该注解每次都会执行方法，并将返回结果缓存起来。

@CacheEvict：该注解表示需要从缓存中清除指定的缓存项或者清除所有缓存项。

执行过程如下：
1. 当调用一个被@Cacheable修饰的方法时，会首先检查缓存中是否存在对应的key，如果存在，则直接从缓存中获取结果，方法不会被执行；
2. 当调用一个被@CachePut修饰的方法时，该方法总是会被执行，并将返回结果缓存起来；
3. 当调用一个被@CacheEvict修饰的方法时，会从缓存中清除指定的缓存项或者清除所有缓存项。

相关问题

springboot整合redis整合@Cacheable、@CachePut、@CacheEvict注解增删改查实例

好的，下面是一个使用Spring Boot整合Redis的`@Cacheable`、`@CachePut`、`@CacheEvict`注解实现增删改查的示例：

1. 添加Redis依赖

在pom.xml中添加以下依赖：

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

2. 配置Redis连接

在application.properties中添加以下配置：

# Redis连接配置
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=

# 开启缓存
spring.cache.type=redis

3. 编写Redis配置类

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
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;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.lang.reflect.Method;
import java.util.Arrays;

@Configuration
@EnableCaching
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        // key序列化方式
        RedisSerializer<String> stringRedisSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringRedisSerializer); // key
        redisTemplate.setHashKeySerializer(stringRedisSerializer); // hash key

        // value序列化方式
        RedisSerializer<Object> valueRedisSerializer = new GenericJackson2JsonRedisSerializer();
        redisTemplate.setValueSerializer(valueRedisSerializer); // value
        redisTemplate.setHashValueSerializer(valueRedisSerializer); // hash value

        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        RedisCacheManager.RedisCacheManagerBuilder builder = RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(redisConnectionFactory);
        return builder.build();
    }

    @Bean
    public KeyGenerator wiselyKeyGenerator() {
        return (Object target, Method method, Object... params) -> {
            StringBuilder sb = new StringBuilder();
            sb.append(target.getClass().getName());
            sb.append(method.getName());
            Arrays.stream(params).forEach(param -> sb.append(param.toString()));
            return sb.toString();
        };
    }
}

4. 编写实体类

import java.io.Serializable;

public class User implements Serializable {
    private static final long serialVersionUID = 1L;

    private Integer id;
    private String name;
    private Integer age;

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

5. 编写Service

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;

@Service
public class UserService {

    @Autowired
    private UserDao userDao;

    @Cacheable(value = "user", keyGenerator = "wiselyKeyGenerator")
    public User getUserById(Integer id) {
        return userDao.getUserById(id);
    }

    @CachePut(value = "user", keyGenerator = "wiselyKeyGenerator")
    public User updateUser(User user) {
        userDao.updateUser(user);
        return user;
    }

    @CacheEvict(value = "user", keyGenerator = "wiselyKeyGenerator")
    public void deleteUserById(Integer id) {
        userDao.deleteUserById(id);
    }
}

6. 编写Controller

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

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

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Integer id) {
        return userService.getUserById(id);
    }

    @PutMapping("")
    public User updateUser(@RequestBody User user) {
        return userService.updateUser(user);
    }

    @DeleteMapping("/{id}")
    public void deleteUserById(@PathVariable Integer id) {
        userService.deleteUserById(id);
    }
}

7. 测试

启动应用后，可以通过以下方式测试：

- 获取用户：GET http://localhost:8080/user/1

- 更新用户：PUT http://localhost:8080/user

请求体：

  {
      "id": 1,
      "name": "Tom",
      "age": 20
  }

- 删除用户：DELETE http://localhost:8080/user/1

以上就是一个使用Spring Boot整合Redis的`@Cacheable`、`@CachePut`、`@CacheEvict`注解实现增删改查的示例。

详解spring缓存注解@cacheable,@cacheput , @cacheevict使用

Spring框架通过Spring Cache提供了一套强大的缓存体系，可以轻松地实现缓存数据，提高应用程序的性能。Spring框架提供了三个主要的注解来实现缓存：@Cacheable、@CachePut和@CacheEvict。

@Cacheable注解用于将方法的结果缓存起来，以便在下次请求时，如果参数相同，则可以直接从缓存中获取结果，而不需要重新计算。该注解适用于如果计算结果比较耗时，或者需要从数据库或其他外部资源中提取数据的情况。

@CachePut注解用于更新缓存中的数据。它与@Cacheable注解类似，但不同的是，它总是更新缓存数据，而不管缓存中是否已经存在该key的值。所以，可以使用这个注解来更新缓存中的数据。

@CacheEvict注解用于从缓存中删除数据。它在需要删除缓存数据的情况下使用。它可以删除指定的key对应的缓存，也可以清空所有缓存数据。

这三个注解都有一个可选参数Named：如果指定了该参数，则缓存将使用指定的名称使用。如果未指定，则使用默认的名称。可以使用不同名称的缓存来存储不同类型的数据，并使用不同的缓存策略来控制它们的存储方式。

除了Spring自带的缓存提供者之外，还可以使用其他的缓存提供者，如Ehcache、Redis、Memcached等等。在使用缓存时，需要注意的是，不同的缓存提供者之间可能会有不同的限制和性能差异。因此，必须根据实际情况选择最适合的缓存提供者和缓存策略，以获取最好的性能和可靠性。