SpringBoot整合Redis

部署Redis

1.引入redis依赖

    <!--引入redis作为缓存-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

2.redis配置

在application.properties中配置redis参数

    #config redis配置
    #使用指定的库
    spring.redis.database=0
    #redis ip
    spring.redis.host=127.0.0.1
    #端口号
    spring.redis.port=6379
    #最大连接数
    spring.redis.jedis.pool.max-active=8
    #最小连接数
    spring.redis.jedis.pool.min-active=1
    #最长等待时间
    spring.redis.jedis.pool.max-wait=-1ms
    #空闲连接保存数
    spring.redis.jedis.pool.max-idle=8
    spring.redis.jedis.pool.min-idle=1
    #失效时间 0=无失效时间
    spring.redis.timeout=5000ms

3.在Applichation启动类添加注解

    //开启springboot中的缓存
    @EnableCaching
    @SpringBootApplication
    public class RedisApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(RedisApplication.class, args);
        }
    
    }

4.写一个config 用来redis序列化

    package com.example.demo.config;
    
    import java.lang.reflect.Method;
    import java.time.Duration;
    
    import org.springframework.cache.CacheManager;
    import org.springframework.cache.annotation.CachingConfigurerSupport;
    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.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.RedisTemplate;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    
    @Configuration
    @EnableCaching
    public class RedisCacheConfig extends CachingConfigurerSupport {
    
        @Bean
        public KeyGenerator KeyGenerator() {
            return new KeyGenerator() {
                @Override
                public Object generate(Object target, Method method, Object... params) {
                    StringBuilder sb = new StringBuilder();
                    sb.append( target.getClass().getName() );
                    sb.append( method.getName() );
                    for (Object obj : params) {
                        sb.append( obj.toString() );
                    }
                    return sb.toString();
                }
            };
        }
    
       /* @Bean
        public CacheManager cacheManager(RedisTemplate redisTemplate) {
            RedisCacheManager manager = new RedisCacheManager(redisTemplate);
            manager.setUsePrefix(true);
            RedisCachePrefix cachePrefix = new RedisPrefix("prefix");
            manager.setCachePrefix(cachePrefix);
            // 整体缓存过期时间
            manager.setDefaultExpiration(3600L);
            // 设置缓存过期时间。key和缓存过期时间，单位秒
            Map<String, Long> expiresMap = new HashMap<>();
            expiresMap.put("user", 1000L);
            manager.setExpires(expiresMap);
            return manager;
        }*/
    
        @Bean
        CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
            //初始化一个RedisCacheWriter
            RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter( connectionFactory );
            //设置CacheManager的值序列化方式为JdkSerializationRedisSerializer,但其实RedisCacheConfiguration默认就是使用StringRedisSerializer序列化key，JdkSerializationRedisSerializer序列化value,所以以下注释代码为默认实现
            //ClassLoader loader = this.getClass().getClassLoader();
            //JdkSerializationRedisSerializer jdkSerializer = new JdkSerializationRedisSerializer(loader);
            //RedisSerializationContext.SerializationPair<Object> pair = 
            //  RedisSerializationContext.SerializationPair.fromSerializer(jdkSerializer);
            //RedisCacheConfiguration defaultCacheConfig=
            //  RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(pair);
            RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig();
            //设置默认超过期时间是30秒
            defaultCacheConfig.entryTtl( Duration.ofSeconds( 30 ) );
            //初始化RedisCacheManager
            RedisCacheManager cacheManager = new RedisCacheManager( redisCacheWriter, defaultCacheConfig );
            return cacheManager;
        }
    
        @Bean
        public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
            StringRedisTemplate template = new StringRedisTemplate( 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 );
            template.setValueSerializer( jackson2JsonRedisSerializer );
            template.afterPropertiesSet();
            return template;
        }
    }

--------------------------------------------------------------------------------cjz

框架搭建完毕

小白也能快速搭建Redis,学习框架不入坑!
这里是spring-boot-demo:
https://pan.baidu.com/s/1jN5udzNr_WUsosPIYvqrew
提取码:jiml
关注赞赏我:更新更多框架搭建内容!你们的坑我来跳,帮你规避百度上的那些问题教程!