Spring Boot 2整合Redis做缓存

时间：2024-07-22 22:05:50

既然是要用Redis做缓存，自然少不了安装了。但是本文主要讲Spring Boot与Redis整合。安装教程请另行百度！

1.首先是我们的Redis配置类

 package com.tyc;

 import com.fasterxml.jackson.annotation.JsonAutoDetect;

 import com.fasterxml.jackson.annotation.PropertyAccessor;

 import com.fasterxml.jackson.databind.ObjectMapper;

 import org.springframework.cache.annotation.EnableCaching;

 import org.springframework.context.annotation.Bean;

 import org.springframework.context.annotation.Configuration;

 import org.springframework.data.redis.connection.RedisConnectionFactory;

 import org.springframework.data.redis.core.RedisTemplate;

 import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

 import org.springframework.data.redis.serializer.StringRedisSerializer;

 /**

  * @Description: Redis配置类

  * @Author: wushumin

  * @CreateDate: 2019/9/12 16:00

  * @Version: 1.0

  */

 @Configuration

 public class RedisConfig {

     @Bean

     @SuppressWarnings("all")

     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {

         RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();

         template.setConnectionFactory(factory);

         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

         ObjectMapper om = new ObjectMapper();

         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);

         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

         jackson2JsonRedisSerializer.setObjectMapper(om);

         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

         // key采用String的序列化方式

         template.setKeySerializer(stringRedisSerializer);

         // hash的key也采用String的序列化方式

         template.setHashKeySerializer(stringRedisSerializer);

         // value序列化方式采用jackson

         template.setValueSerializer(jackson2JsonRedisSerializer);

         // hash的value序列化方式采用jackson

         template.setHashValueSerializer(jackson2JsonRedisSerializer);

         template.afterPropertiesSet();

         return template;

     }

 }
package com.tyc.annotation;

import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;

import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;

import org.springframework.boot.autoconfigure.data.redis.RedisProperties;

import org.springframework.boot.context.properties.EnableConfigurationProperties;

import org.springframework.cache.CacheManager;

import org.springframework.cache.annotation.CachingConfigurerSupport;

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.cache.RedisCacheWriter;

import org.springframework.data.redis.connection.RedisConnectionFactory;

import org.springframework.data.redis.core.RedisOperations;

import org.springframework.data.redis.core.StringRedisTemplate;

import java.net.UnknownHostException;

import java.time.Duration;

import java.util.HashMap;

import java.util.Map;

@Configuration

@ConditionalOnClass(RedisOperations.class)

@EnableConfigurationProperties(RedisProperties.class)

public class RedisAutoConfiguration extends CachingConfigurerSupport {//缓存管理器

    @Bean

    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {

        //缓存配置

        RedisCacheConfiguration userCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()

                .entryTtl(Duration.ofSeconds(60)).disableCachingNullValues();

        Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
　　　　　//手动指定缓存模块

        redisCacheConfigurationMap.put("legal", userCacheConfiguration);

        redisCacheConfigurationMap.put("fuzzySearch", userCacheConfiguration);

        //初始化一个RedisCacheWriter

        RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(connectionFactory);

        RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig();

        //设置默认超过期时间是半小时

        defaultCacheConfig.entryTtl(Duration.ofSeconds(60 * 30));

//        //初始化RedisCacheManager

        RedisCacheManager cacheManager = new RedisCacheManager(redisCacheWriter, defaultCacheConfig, redisCacheConfigurationMap);

        return cacheManager;

    }

}
  @Cacheable(cacheNames = "fuzzySearch", key = "targetClass+methodName+#fuzzySearchName")

    public Map fuzzySearch(String fuzzySearchName) {

        //返回结果集合

        Map resultMap = new LinkedHashMap();

        return resultMap

}

到这就可以测试了。由于时间原因就先不贴测试截图了。

相关文章