【Redis】Spring Boot 整合 Redis

导入依赖

导入Redis的starter场景依赖：

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

<!-- spring2.X 集成redis所需common-pool2-->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

<!--导入jedis-->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

Redis相关的组件都由 RedisAutoConfiguration 完成配置和注入：

其绑定了 spring.redis 属性，并且向容器中注入了：

• RedisTemplate<Object, Object>
• StringRedisTemplate，其 key-value 都是String类型

提供了两种 Redis 客户端：

• Lettuce：默认，基于Netty框架的客户端，线程安全，性能较好。
• Jedis

配置文件

spring:
  redis:
    host: 192.168.1.203
    port: 6379
    password:  
    database: 0             # Redis 数据库索引（默认为0）
    client-type: lettuce    # Redis 客户端类型
    timeout: 1800000        # 连接超时时间（毫秒）
    lettuce:
       pool:
         max-active: 10     # 连接池最大连接数（使用负值表示没有限制）
         max-wait: -1       # 最大阻塞等待时间（负数表示没限制）
         min-idle: 5        # 连接池中的最大空闲连接
         min-idle: 0        # 连接池中的最小空闲连接

    # 也可以配置客户端为 jedis      
    # jedis:
      # pool:
        # max-active: 10

Redis 配置类

@EnableCaching
@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);
        // 配置序列化（解决乱码的问题）, 过期时间600秒
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofSeconds(600))
            .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
            .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
            .disableCachingNullValues();
        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
            .cacheDefaults(config)
            .build();
        return cacheManager;
    }
}

业务类测试

@RestController
@RequestMapping("/redisTest")
public class RedisTestController {
    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private StringRedisTemplate redisTemplate;

    @Autowired
    private RedisConnectionFactory redisConnectionFactory;

    @GetMapping
    public String testRedis01() {
        // 设置值到redis
        redisTemplate.opsForValue().set("name","lucy");

        // 从redis获取值
        String name = (String)redisTemplate.opsForValue().get("name");
        return name;
    }

    @GetMapping
    void testRedis02(){
        ValueOperations<String, String> operations = redisTemplate.opsForValue();
        operations.set("hello","world");
        String hello = operations.get("hello");

        System.out.println(hello);
        System.out.println(redisConnectionFactory.getClass());
    }
}

统计 URL 访问次数

自定义拦截器统计URL的访问次数

@Component
public class RedisUrlCountInterceptor implements HandlerInterceptor {
    @Autowired
    StringRedisTemplate redisTemplate;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String uri = request.getRequestURI();
        // 默认每次访问当前uri就会计数+1
        redisTemplate.opsForValue().increment(uri);
        return true;
    }
}

注册URL统计拦截器：

@Configuration
public class AdminWebConfig implements WebMvcConfigurer{
    @Autowired
    RedisUrlCountInterceptor redisUrlCountInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(redisUrlCountInterceptor)
            .addPathPatterns("/**")
            .excludePathPatterns("/","/login","/css/**","/fonts/**","/images/**",
                                 "/js/**","/aa/**");
    }
}

调用Redis内的统计数据：

@Slf4j
@Controller
public class IndexController {
    @Autowired
    StringRedisTemplate redisTemplate;

    @GetMapping("/main.html")
    public String mainPage(HttpSession session,Model model){
        log.info("当前方法是：{}","mainPage");

        ValueOperations<String, String> opsForValue =
            redisTemplate.opsForValue();

        String s = opsForValue.get("/main.html");
        String s1 = opsForValue.get("/sql");

        model.addAttribute("mainCount",s);
        model.addAttribute("sqlCount",s1);

        return "main";
    }
}