redis缓存中value为long类型,读出来强转变成了int类型报错

这是因为 long 类型的数据转换为 int 类型时可能会发生溢出，导致数据异常。在 Redis 中，存储的数据类型是字符串类型，因此在读取数据时需要将其转换为目标类型。如果 Redis 中存储的是 long 类型的数据，读取时需要将其转换为 long 类型，然后再进行强制类型转换为 int 类型。可以使用 RedisTemplate 的 opsForValue().get() 方法获取 Redis 缓存中的数据，然后进行类型转换。例如：

RedisTemplate<String,Long> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(redisConnectionFactory);
redisTemplate.setDefaultSerializer(new Jackson2JsonRedisSerializer<>(Long.class));
Long value = redisTemplate.opsForValue().get("key");
int intValue = value.intValue();

其中，Jackson2JsonRedisSerializer 是 RedisTemplate 内置的序列化器，可以将 Long 类型的数据转换为字符串类型存储在 Redis 中。在读取数据时，需要将字符串类型的数据转换为 Long 类型，然后再进行强制类型转换为 int 类型。

相关问题

mybatisplus自定义redis缓存管理器

MyBatis Plus提供了默认的Redis缓存管理器，但是有时候我们需要根据自己的业务需求来定制一个适合自己的缓存管理器，这里简单介绍一下如何自定义Redis缓存管理器：

1. 实现Cache接口

首先需要实现MyBatis的Cache接口，该接口定义了缓存操作的基本接口方法。可以参考默认的RedisCache实现。

public interface Cache {
    String getId();
    void putObject(Object key, Object value);
    Object getObject(Object key);
    Object removeObject(Object key);
    void clear();
    int getSize();
    default void putObject(Object key, Object value, long ttl) {
        throw new UnsupportedOperationException("not support");
    }
}

2. 实现CacheManager接口

接着需要实现MyBatis的CacheManager接口，该接口负责管理各个缓存实例的生命周期以及提供创建缓存的方法。可以参考默认的RedisCacheManager实现。

public interface CacheManager {
    Cache getCache(String var1);
    void addCache(String var1);
    Set<String> getCacheNames();
    default void destroy() {
    }
}

3. 配置缓存管理器

在MyBatis的配置文件中配置自定义的缓存管理器和缓存实现类。可以像下面这样配置：

<cache type="com.example.MyCacheManager">
    <!-- 缓存过期时间，单位：秒，默认为永不过期 -->
    <property name="ttl" value="3600"></property>
    <!-- RedisHost -->
    <property name="host" value="localhost"></property>
    <!-- RedisPort -->
    <property name="port" value="6379"></property>
    <!-- RedisPassword -->
    <property name="password" value=""></property>
    <!-- RedisDatabase -->
    <property name="database" value="0"></property>
    <!-- RedisTimeout -->
    <property name="timeout" value="5000"></property>
</cache>

其中type属性值为自定义的CacheManager实现类。

4. 使用缓存

在Mapper接口方法上使用@CacheNamespace注解开启缓存功能并指定缓存管理器，例如：

@Mapper
@CacheNamespace(implementation = MyCacheManager.class)
public interface UserMapper {
    @Select("select * from user where id = #{id}")
    @Options(useCache = true, flushCache = Options.FlushCachePolicy.FALSE)
    User selectById(@Param("id") int id);
}

这样就可以在查询User对象时自动使用自定义的Redis缓存管理器进行缓存。

使用mybatisplus的redis自定义缓存

MybatisPlus提供了自定义Redis缓存的功能，可以通过自定义Redis缓存实现数据的快速查询。

1. 引入Redis依赖

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

2. 自定义缓存

@Component
public class RedisCache implements Cache {

    private final RedisTemplate<Object, Object> redisTemplate;
    private final String cacheName;
    private final long ttl;

    public RedisCache(RedisTemplate<Object, Object> redisTemplate, String cacheName) {
        this.redisTemplate = redisTemplate;
        this.cacheName = cacheName;
        this.ttl = 60 * 5; //默认5分钟过期时间
    }

    public RedisCache(RedisTemplate<Object, Object> redisTemplate, String cacheName, long ttl) {
        this.redisTemplate = redisTemplate;
        this.cacheName = cacheName;
        this.ttl = ttl;
    }

    @Override
    public String getId() {
        return cacheName;
    }

    @Override
    public void putObject(Object key, Object value) {
        redisTemplate.opsForValue().set(key, value, ttl, TimeUnit.SECONDS);
    }

    @Override
    public Object getObject(Object key) {
        return redisTemplate.opsForValue().get(key);
    }

    @Override
    public Object removeObject(Object key) {
        redisTemplate.delete(key);
        return null;
    }

    @Override
    public void clear() {
        redisTemplate.delete(redisTemplate.keys("*" + cacheName + "*"));
    }

    @Override
    public int getSize() {
        return Math.toIntExact(redisTemplate.keys("*" + cacheName + "*").size());
    }

    @Override
    public ReadWriteLock getReadWriteLock() {
        return null;
    }
}

3. 注册自定义缓存

@Configuration
@EnableCaching
public class CacheConfig extends CachingConfigurerSupport {

    private final RedisConnectionFactory redisConnectionFactory;

    public CacheConfig(RedisConnectionFactory redisConnectionFactory) {
        this.redisConnectionFactory = redisConnectionFactory;
    }

    @Bean
    public CacheManager cacheManager() {
        RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(10))
                .disableCachingNullValues();

        RedisCacheConfiguration userCacheConfig = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(5))
                .disableCachingNullValues()
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));

        Map<String, RedisCacheConfiguration> cacheConfigurations = new HashMap<String, RedisCacheConfiguration>() {{
            put("user", userCacheConfig);
        }};
        RedisCacheManager cacheManager = RedisCacheManager.builder(redisConnectionFactory)
                .cacheDefaults(defaultCacheConfig)
                .withInitialCacheConfigurations(cacheConfigurations)
                .build();

        return cacheManager;
    }

    @Bean
    @Override
    public CacheResolver cacheResolver() {
        return new SimpleCacheResolver(cacheManager());
    }

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

    @Bean
    public Cache redisCache(RedisTemplate<Object, Object> redisTemplate) {
        return new RedisCache(redisTemplate, "product");
    }
}

4. 使用自定义缓存

在Mapper接口方法上添加@Cacheable注解，指定使用自定义的Redis缓存即可。

@Mapper
public interface UserMapper extends BaseMapper<User> {

    @Cacheable(value = "user", key = "#id")
    User getById(Long id);

}