zoukankan      html  css  js  c++  java
  • springboot 整合 redis 共享Session-spring-session-data-redis

    参考:https://www.cnblogs.com/ityouknow/p/5748830.html

    如何使用

    1、引入 spring-boot-starter-redis

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

    2、添加配置文件

    # REDIS (RedisProperties)
    # Redis数据库索引(默认为0)
    spring.redis.database=0  
    # Redis服务器地址
    spring.redis.host=192.168.0.58
    # Redis服务器连接端口
    spring.redis.port=6379  
    # Redis服务器连接密码(默认为空)
    spring.redis.jedispassword=  
    # 连接池最大连接数(使用负值表示没有限制)
    spring.redis.pooljedis.max-active=8  
    # 连接池最大阻塞等待时间(使用负值表示没有限制)
    spring.redis.pooljedis.max-wait=-1  
    # 连接池中的最大空闲连接
    spring.redis.pooljedis.max-idle=8  
    # 连接池中的最小空闲连接
    spring.redis.pooljedis.min-idle=0  
    # 连接超时时间(毫秒)
    #timeout: 60s # 数据库连接超时时间,2.0 中该参数的类型为Duration,这里在配置的时候需要指明单位 spring.redis.timeout=60s

    3、添加cache的配置类

    @Configuration
    public class RedisConfig extends CachingConfigurerSupport {
    
        @Bean
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
    
            RedisTemplate<String, Object> template = new RedisTemplate<>();
    
            RedisSerializer<String> redisSerializer = new StringRedisSerializer();
    
            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.setConnectionFactory(factory);
            //key序列化方式
            template.setKeySerializer(redisSerializer);
            //value序列化
            template.setValueSerializer(jackson2JsonRedisSerializer);
            //value hashmap序列化
            template.setHashValueSerializer(jackson2JsonRedisSerializer);
    
            return template;
        }
    
        @Bean
        public CacheManager cacheManager(RedisConnectionFactory factory) {
            RedisSerializer<String> redisSerializer = new StringRedisSerializer();
            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);
    
            // 配置序列化(解决乱码的问题),过期时间30秒
            RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                    .entryTtl(Duration.ofSeconds(30))
                    .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                    .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                    .disableCachingNullValues();
    
            RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                    .cacheDefaults(config)
                    .build();
            return cacheManager;
        }
    }

    一個比較好的redisConfig配置(建议使用)

    package com.goku.demo.config;
    
    
    import java.time.Duration;
    import java.util.HashMap;
    import java.util.Map;
    
    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.serializer.Jackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.RedisSerializationContext;
    
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    
    /***
     * *************************************************************************
     * <PRE>
     *  @ClassName:    : RedisConfig 
     *
     *  @Description:    : 使用 redis  做默认缓存
     *
     *  @Creation Date   : 25 Feb 2019 3:54:19 PM
     *
     *  @Author          :  Sea
     *
     * </PRE>
     **************************************************************************
     */
    @SuppressWarnings("all")
    @Configuration
    @EnableCaching
    public class RedisConfig extends CachingConfigurerSupport {
    
         @Bean
            public KeyGenerator simpleKeyGenerator() {
                return (o, method, objects) -> {
                    StringBuilder stringBuilder = new StringBuilder();
                    stringBuilder.append(o.getClass().getSimpleName());
                    stringBuilder.append(".");
                    stringBuilder.append(method.getName());
                    stringBuilder.append("[");
                    for (Object obj : objects) {
                        stringBuilder.append(obj.toString());
                    }
                    stringBuilder.append("]");
    
                    return stringBuilder.toString();
                };
            }
    
            
            
           @Bean
            public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
                return new RedisCacheManager(
                    RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
                    this.getRedisCacheConfigurationWithTtl(5), // 默认策略,未配置的 key 会使用这个
                    this.getRedisCacheConfigurationMap() // 指定 key 策略
                );
            }
           
                /**
                 * @how to use   eg:
                  @Cacheable(value = "MIN10", keyGenerator = "simpleKeyGenerator") // 3000秒
                  @Cacheable(value = "MIN30", keyGenerator = "simpleKeyGenerator") // 18000秒
                  @Cacheable(value = "MIN60", keyGenerator = "simpleKeyGenerator") // 600秒,未指定的key,使用默认策略
                     ****/      
           private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() {
                Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
                redisCacheConfigurationMap.put("MIN10", this.getRedisCacheConfigurationWithTtl(10));
                redisCacheConfigurationMap.put("MIN30", this.getRedisCacheConfigurationWithTtl(30));
                redisCacheConfigurationMap.put("MIN60", this.getRedisCacheConfigurationWithTtl(60));
                return redisCacheConfigurationMap;
            }
           
           
           /**
            * @param Minute
            * @return
            */
           private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer Minute) {
                Jackson2JsonRedisSerializer<Object> 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);
    
                RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
                redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(
                    RedisSerializationContext
                        .SerializationPair
                        .fromSerializer(jackson2JsonRedisSerializer)
                ).entryTtl(Duration.ofMinutes(Minute));
    
                return redisCacheConfiguration;
            }
           
           
           
    
    
           
           
           
           
    }
    View Code

    3、好了,接下来就可以直接使用了

    @RunWith(SpringJUnit4ClassRunner.class)
    @SpringApplicationConfiguration(Application.class)
    public class TestRedis {
    
        @Autowired
        private StringRedisTemplate stringRedisTemplate;
        
        @Autowired
        private RedisTemplate redisTemplate;
    
        @Test
        public void test() throws Exception {
            stringRedisTemplate.opsForValue().set("aaa", "111");
            Assert.assertEquals("111", stringRedisTemplate.opsForValue().get("aaa"));
        }
        
        @Test
        public void testObj() throws Exception {
            User user=new User("aa@126.com", "aa", "aa123456", "aa","123");
            ValueOperations<String, User> operations=redisTemplate.opsForValue();
            operations.set("com.neox", user);
            operations.set("com.neo.f", user,1,TimeUnit.SECONDS);
            Thread.sleep(1000);
            //redisTemplate.delete("com.neo.f");
            boolean exists=redisTemplate.hasKey("com.neo.f");
            if(exists){
                System.out.println("exists is true");
            }else{
                System.out.println("exists is false");
            }
           // Assert.assertEquals("aa", operations.get("com.neo.f").getUserName());
        }
    }
    

    以上都是手动使用的方式,如何在查找数据库的时候自动使用缓存呢,看下面;

    4、自动根据方法生成缓存

    @RequestMapping("/getUser")
    @Cacheable(value="user-key")
    public User getUser() {
        User user=userRepository.findByUserName("aa");
        System.out.println("若下面没出现“无缓存的时候调用”字样且能打印出数据表示测试成功");  
        return user;
    }

    其中value的值就是缓存到redis中的key

  • 相关阅读:
    Martix工作室考核题 —— 打印一个菱形
    Martix工作室考核题 —— 打印一个菱形
    Martix工作室考核题 —— 打印九九乘法表
    Martix工作室考核题 —— 打印九九乘法表
    Martix工作室考核题 —— 打印九九乘法表
    Martix工作室考核题 —— 201938 第三题
    Martix工作室考核题 —— 201938 第三题
    Martix工作室考核题 —— 201938 第三题
    Martix工作室考核题 —— 201938 第一题
    fiddler模拟发送post请求
  • 原文地址:https://www.cnblogs.com/lshan/p/10271204.html
Copyright © 2011-2022 走看看