首页 / 技术问答 / Java问答列表 / 问答详情

Java Spring Boot Redis – 如何知道实体何时更新，以便我可以从数据库而不是 Redis 获取

我刚接触Redis，这可能是一个基本的问题.

我使用@Cacheable()和@CacheEvict()注释.当用户更新时，如果我通过id获取用户，它将获取缓存的(过时的)数据.当然，如果我使用@CacheEvict()，这种情况就不会发生.

然而，我对@CacheEvict()感到困惑，因为结果与我不使用它是一样的--那么使用它有什么意义呢？如果有一个过程需要3秒才能完成，那么使用CacheEvict()也需要3秒.

以下是我的UserServiceImpl.java个班级:

package com.example.demo.serviceImpl;

import lombok.AllArgsConstructor;
import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
import com.example.demo.service.UserService;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.List;

@Service
@EnableCaching
@AllArgsConstructor
public class UserServiceImpl implements UserService {

    private UserRepository userRepository;

    @Override
    public User createUser(User user) {
        return userRepository.save(user);
    }

    @Override
    @CacheEvict(value = "users")
    public User findUser(String userId) {
        doLongRunningTask();
        return userRepository.findById(userId).orElseThrow();
    }

    @Override
    @Cacheable(value = "users")
    public List<User> findAll() {
        return (List<User>) userRepository.findAll();
    }

    @Override
    @CacheEvict(value = "users", key = "#user.id")
    public User updateUser(String userId, User user) {
        doLongRunningTask();
        user.setUpdatedAt(LocalDateTime.now());
        return userRepository.save(user);
    }

    @Override
    @CacheEvict(value = "users", key = "#userId")
    public void deleteUser(String userId) {
        userRepository.deleteById(userId);
    }

    private void doLongRunningTask() {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

我的RedisConfig.java个班级:

package com.example.demo.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;

import java.time.Duration;

import static org.springframework.data.redis.serializer.RedisSerializationContext.SerializationPair.fromSerializer;

@Configuration
public class RedisConfig {

    @Value("${redis.host}")
    private String redisHost;

    @Value("${redis.port}")
    private int redisPort;

    @Bean
    public LettuceConnectionFactory redisConnectionFactory() {
        RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();
        configuration.setHostName(redisHost);
        configuration.setPort(redisPort);
        return new LettuceConnectionFactory(configuration);
    }

    @Bean
    public RedisCacheManager cacheManager() {
        RedisCacheConfiguration cacheConfig = myDefaultCacheConfig(Duration.ofMinutes(10)).disableCachingNullValues();

        return RedisCacheManager
                .builder(redisConnectionFactory())
                .cacheDefaults(cacheConfig)
                .withCacheConfiguration("users", myDefaultCacheConfig(Duration.ofMinutes(5)))
                .build();
    }

    private RedisCacheConfiguration myDefaultCacheConfig(Duration duration) {
        return RedisCacheConfiguration
                .defaultCacheConfig()
                .entryTtl(duration)
                .serializeValuesWith(fromSerializer(new GenericJackson2JsonRedisSerializer()));
    }

}

第一次获取数据需要3秒.下一次获取相同的数据需要5毫秒(这一次从Redis而不是postgres获取).然而，更新该用户并再次获取它时，会给出过时的数据，而不是新更新的用户，从而导致数据不一致.

这是我的model/User.java名模特班

package com.example.demo.model;

import lombok.*;
import org.springframework.data.annotation.Id;
import org.springframework.data.redis.core.RedisHash;

@Data
@Builder
@RedisHash("user")
public class User {

    @Id
    private String id;
    private String name;
    private Integer age;

}

我还有dto/UserDTO.java个用于通过API将模型转换为REST响应/请求:

package com.example.demo.dto;

import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class UserDTO implements Serializable {

    @JsonProperty(value = "id")
    private String id;

    @JsonProperty(value = "name")
    private String name;

    @JsonProperty(value = "age")
    private Integer age;

}

多亏了@Max Kozlov，这个DTO类现在是Serializable，所以Redis缓存可以正常工作.

感谢@Max Kozlov的新RedisCacheConfig.java人如下所示:

package com.example.demo.config;

import com.example.demo.handler.DefaultCacheErrorHandler;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurer;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.CacheErrorHandler;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;

import java.time.Duration;

@Configuration
@EnableCaching
public class RedisCacheConfig implements CachingConfigurer {

    @Value("${redis.host}")
    private String redisHost;

    @Value("${redis.port}")
    private int redisPort;

    @Bean
    public LettuceConnectionFactory redisConnectionFactory() {
        RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();
        configuration.setHostName(redisHost);
        configuration.setPort(redisPort);
        return new LettuceConnectionFactory(configuration);
    }

    @Bean
    public RedisCacheConfiguration redisCacheConfiguration() {
        return RedisCacheConfiguration
                .defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(15));
    }

    @Bean
    @Override
    public CacheErrorHandler errorHandler() {
        return new DefaultCacheErrorHandler();
    }

    @Bean("longLifeCacheManager")
    public CacheManager longLifeCacheManager() {
        RedisCacheConfiguration defaultConfiguration = RedisCacheConfiguration
                .defaultCacheConfig()
                .entryTtl(Duration.ofDays(90));

        return RedisCacheManager
                .RedisCacheManagerBuilder
                .fromConnectionFactory(redisConnectionFactory())
                .cacheDefaults(defaultConfiguration)
                .build();
    }

    @Primary
    @Bean("shortLifeCacheManager")
    public CacheManager shortLifeCacheManager() {
        RedisCacheConfiguration defaultConfiguration = RedisCacheConfiguration
                .defaultCacheConfig()
                .entryTtl(Duration.ofDays(1));

        return RedisCacheManager
                .RedisCacheManagerBuilder
                .fromConnectionFactory(redisConnectionFactory())
                .cacheDefaults(defaultConfiguration)
                .build();
    }

}

推荐答案

您使用注释@Cachable的逻辑是错误的，因为您缓存的是没有特定键的整个用户列表.

换句话说，您需要缓存特定的用户，例如，按id缓存.

现在，您已经有了使用键users缓存的用户的完整列表.但是具有users:id键的条目被删除.因此，您的藏身之处不会被驱逐.

要使缓存工作，您需要以这种方式重写服务类.

@Service
@EnableCaching
@AllArgsConstructor
public class UserServiceImpl implements UserService {

    private UserRepository userRepository;

    @Override
    public User createUser(User user) {
        return userRepository.save(user);
    }

    @Override
    @Cacheable(value = "users", key = "#userId")
    public User findUser(String userId) {
        doLongRunningTask();
        return userRepository.findById(userId).orElseThrow();
    }

    @Override
    public List<User> findAll() {
        return (List<User>) userRepository.findAll();
    }

    @Override
    @CacheEvict(value = "users", key = "#user.id")
    public User updateUser(String userId, User user) {
        doLongRunningTask();
        user.setUpdatedAt(LocalDateTime.now());
        return userRepository.save(user);
    }

    @Override
    @CacheEvict(value = "users", key = "#userId")
    public void deleteUser(String userId) {
        userRepository.deleteById(userId);
    }

}

在这里，我将注释@Cacheable(value = "users", key = "#userId")从方法findAll()移到了方法findUser(String userId).我还更正了注释@Cacheable，并在那里添加了键key = "#userId".

无论如何，如果你想在Redis中缓存数据.您需要避免列表缓存，并且只将此方法应用于特定实体.您还需要注意，如果希望在缓存中存储实体，则需要在实体本身中创建一个序列版本.

无论如何，如果你想在Redis中缓存数据.您需要设置为avoid list caching，并且仅将此方法应用于特定实体.您还知道您正在序列化json中的实体.这是非常不鼓励这样做的，因为像@ManyToOne和@OneToMany这样的关系会导致你得recursive call to these relationships at the time of serialization分.

希望我的回答能帮到你=)

UPDATE个

CacheConfiguration类，用于spring-boot 2.7.*版本.

@EnableCaching
@Configuration
public class CacheConfiguration extends CachingConfigurerSupport {

    @Bean
    public RedisCacheConfiguration redisCacheConfiguration() {
        return RedisCacheConfiguration.defaultCacheConfig()
                                      .entryTtl(Duration.ofMinutes(15));
    }

    @Bean
    @Override
    public CacheErrorHandler errorHandler() {
        return new DefaultCacheErrorHandler();
    }

    @Bean("longLifeCacheManager")
    public CacheManager longLifeCacheManager(
        RedisConnectionFactory redisConnectionFactory
    ) {
        RedisCacheConfiguration defaultConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofDays(90));

        return RedisCacheManager.RedisCacheManagerBuilder
                .fromConnectionFactory(redisConnectionFactory)
                .cacheDefaults(defaultConfiguration)
                .build();
    }

    @Bean("shortLifeCacheManager")
    @Primary
    public CacheManager shortLifeCacheManager(
        RedisConnectionFactory redisConnectionFactory
    ) {
        RedisCacheConfiguration defaultConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofDays(1));

        return RedisCacheManager.RedisCacheManagerBuilder
                .fromConnectionFactory(redisConnectionFactory)
                .cacheDefaults(defaultConfiguration)
                .build();
    }

}

和用于异常处理的DefaultCacheErrorHandler个类

public class DefaultCacheErrorHandler extends SimpleCacheErrorHandler {

    private static final Logger LOG = LoggerFactory.getLogger(DefaultCacheErrorHandler.class);

    @Override
    public void handleCacheGetError(
        @NotNull RuntimeException exception,
        @NotNull Cache cache,
        @NotNull Object key
    ) {
        LOG.info(
            "handleCacheGetError ~ {}: {} - {}",
            exception.getMessage(),
            cache.getName(),
            key
        );
    }

    @Override
    public void handleCachePutError(
        @NotNull RuntimeException exception,
        @NotNull Cache cache,
        @NotNull Object key,
        Object value
    ) {
        LOG.info(
            "handleCachePutError ~ {}: {} - {}",
            exception.getMessage(),
            cache.getName(),
            key
        );
        super.handleCachePutError(exception, cache, key, value);
    }

    @Override
    public void handleCacheEvictError(
        @NotNull RuntimeException exception,
        @NotNull Cache cache,
        @NotNull Object key
    ) {
        LOG.info(
            "handleCacheEvictError ~ {}: {} - {}",
            exception.getMessage(),
            cache.getName(),
            key
        );
        super.handleCacheEvictError(exception, cache, key);
    }

    @Override
    public void handleCacheClearError(
        @NotNull RuntimeException exception,
        @NotNull Cache cache
    ) {
        LOG.info(
            "handleCacheClearError ~ {}: {}",
            exception.getMessage(),
            cache.getName()
        );
        super.handleCacheClearError(exception, cache);
    }
}

在本例中，使用了一个简单的Java序列化程序.需要缓存的对象类需要从Serializable接口实现.


public class User implements Serializable {

    private Long id;
    provate Long name;

    // getters/setters

}

Java相关问答推荐

Java应用程序RAC感知

收听RDX中用户数据的变化

我可以从Java模块中排除maven资源文件夹吗？

JPackaged应用程序启动MSI调试，然后启动System. exit()

我的scala文件失败了Scala.g4 ANTLR语法

AlarmManager没有在正确的时间发送alert

JUnit—如何模拟局部变量对象方法调用

RichFaces 3.x-Spring Boot-迁移web.xml

对Java中的通配符参数的混淆

与Spring Boot相关的实体未正确保存

我如何知道MediaDiscoverer何时完成发现介质？

如何从Keyloak映射Hibernate实体中的用户

Spring Security不允许加载js

如何在JavaFX中处理多个按钮

Java 11 HttpCookie.parse在解析包含JSON的Cookie时引发IlLegalArgumentException

AWS Java SDK v2.x中没有setObjectAcl方法

JavaFX标签中的奇怪字符

Java KeyListener不工作或被添加

为什么Spring要更改Java版本配置以及如何正确设置？

由于可为null，无法在kotlin中实现java接口

实用课程推荐
相关教程推荐
休闲君评测 |  TOOLFK工具网 |  古诗文网 |  良许Linux教程网 |  Python之禅 |  红色石头 |  入党申请书 | 

© 2020 Hi LearnFk 意见反馈 免责声明 关于我们 桂ICP备11002319号-3 友链&广告位+QQ: 1963612630