devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

springboot2学习-webflux整合redis_webflux redis

作者：小蓝xlanll | 2024-06-14 01:54:34

赞

踩

webflux redis

   前面学习整合了mongodb和 Thymeleaf，这里来整合redis和mongodb。学习参考：http://gitbook.cn/gitchat/column/5acda6f6d7966c5ae1086f2b/topic/5acdaa62d7966c5ae108708a

这里需要用到mongodb，和redis，这两个都可以使用docker来启动redis和mongodb的容器，设置好用户名和密码启动容器就可以建立连接了，具体的操作略掉了，网上资料很多。mongodb容器可以采用之前博客建立的mongodb容器          

1，创建一个springboot2的项目

           pom.xml代码如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3. 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4. 	<modelVersion>4.0.0</modelVersion>
  5.  
  6. 	<groupId>com.jack</groupId>
  7. 	<artifactId>webflux_redis</artifactId>
  8. 	<version>0.0.1-SNAPSHOT</version>
  9. 	<packaging>jar</packaging>
  10.  
  11. 	<name>webflux_redis</name>
  12. 	<description>Demo project for Spring Boot</description>
  13.  
  14. 	<parent>
  15. 		<groupId>org.springframework.boot</groupId>
  16. 		<artifactId>spring-boot-starter-parent</artifactId>
  17. 		<version>2.0.2.RELEASE</version>
  18. 		<relativePath/> <!-- lookup parent from repository -->
  19. 	</parent>
  20.  
  21. 	<properties>
  22. 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  23. 		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  24. 		<java.version>1.8</java.version>
  25. 	</properties>
  26.  
  27. 	<dependencies>
  28. 		<dependency>
  29. 			<groupId>org.springframework.boot</groupId>
  30. 			<artifactId>spring-boot-starter-data-redis-reactive</artifactId>
  31. 		</dependency>
  32. 		<dependency>
  33. 			<groupId>org.springframework.boot</groupId>
  34. 			<artifactId>spring-boot-starter-webflux</artifactId>
  35. 		</dependency>
  36.  
  37. 		<!-- Spring Boot 响应式 MongoDB 依赖 -->
  38. 		<dependency>
  39. 			<groupId>org.springframework.boot</groupId>
  40. 			<artifactId>spring-boot-starter-data-mongodb-reactive</artifactId>
  41. 		</dependency>
  42.  
  43. 		<dependency>
  44. 			<groupId>org.projectlombok</groupId>
  45. 			<artifactId>lombok</artifactId>
  46. 			<optional>true</optional>
  47. 		</dependency>
  48. 		<dependency>
  49. 			<groupId>org.springframework.boot</groupId>
  50. 			<artifactId>spring-boot-starter-test</artifactId>
  51. 			<scope>test</scope>
  52. 		</dependency>
  53. 		<dependency>
  54. 			<groupId>io.projectreactor</groupId>
  55. 			<artifactId>reactor-test</artifactId>
  56. 			<scope>test</scope>
  57. 		</dependency>
  58. 	</dependencies>
  59.  
  60. 	<build>
  61. 		<plugins>
  62. 			<plugin>
  63. 				<groupId>org.springframework.boot</groupId>
  64. 				<artifactId>spring-boot-maven-plugin</artifactId>
  65. 			</plugin>
  66. 		</plugins>
  67. 	</build>
  68.  
  69.  
  70. </project>

 application.properties的配置如下：

  1. ## Redis 配置
  2. ## Redis服务器地址
  3. spring.redis.host=xx.xx.xx.xx
  4. ## Redis服务器连接端口
  5. spring.redis.port=6379
  6. ## Redis服务器连接密码（默认为空）
  7. spring.redis.password=xxxxxxxx
  8. # 连接超时时间（毫秒）,这里注意的是连接超时时间不能太少或者为 0，不然会引起异常 RedisCommandTimeoutException: Command timed out
  9. spring.redis.timeout=5000
  10.  
  1. #mongodb的配置
  2. spring.data.mongodb.host=192.168.0.104
  3. spring.data.mongodb.database=admin
  4. spring.data.mongodb.port=27017
  5. spring.data.mongodb.username=admin
  6. spring.data.mongodb.password=admin

2，实体类代码如下：

  1. package com.jack.webflux_redis.domain;
  2.  
  3. import lombok.Data;
  4. import org.springframework.data.annotation.Id;
  5.  
  6. import java.io.Serializable;
  7.  
  8. /**
  9.  * create by jack 2018/5/13
  10.  * City 必须实现序列化，因为需要将对象序列化后存储到 Redis。如果没实现 Serializable，
  11.  * 会引出异常：java.lang.IllegalArgumentException: DefaultSerializer requires a Serializable
  12.  * payload but received an object of type。
  13.  如果不是用默认的序列化，需要自定义序列化实现，只要实现 RedisSerializer 接口去实现即可，
  14.  然后在使用 RedisTemplate.setValueSerializer 方法去设置你实现的序列化实现，支持 JSON、XML 等。
  15.  */
  16. @Data
  17. public class City implements Serializable {
  18.  
  19.     private static final long serialVersionUID = -1L;
  20.  
  21.     /**
  22.      * 城市编号
  23.      * @Id 注解标记对应库表的主键或者唯一标识符。因为这个是我们的 DO，数据访问对象一一映射到数据存储。
  24.      */
  25.     @Id
  26.     private Long id;
  27.  
  28.     /**
  29.      * 省份编号
  30.      */
  31.     private Long provinceId;
  32.  
  33.     /**
  34.      * 城市名称
  35.      */
  36.     private String cityName;
  37.  
  38.     /**
  39.      * 描述
  40.      */
  41.     private String description;
  42. }

3，redis的测试代码如下：

redis的测试controller如下，此代码不具有reactive特性：

  1. package com.jack.webflux_redis.controller;
  2.  
  3. import com.jack.webflux_redis.domain.City;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.data.redis.core.RedisTemplate;
  6. import org.springframework.data.redis.core.ValueOperations;
  7. import org.springframework.web.bind.annotation.*;
  8. import reactor.core.publisher.Mono;
  9.  
  10. import java.util.concurrent.TimeUnit;
  11.  
  12. /**
  13.  * create by jack 2018/5/13
  14.  *
  15.  * 使用 @Autowired 注入 RedisTemplate 对象，这个对象和 Spring 的 JdbcTemplate 功能十分相似，RedisTemplate 封装了 RedisConnection，具有连接管理、序列化和各个操作等，还有针对 String 的支持对象 StringRedisTemplate。
  16.  删除 Redis 某对象，直接通过 key 值调用 delete(key)。
  17.  Redis 操作视图接口类用的是 ValueOperations，对应的是 Redis String/Value 操作，get 是获取数据；set 是插入数据，可以设置失效时间，这里设置的失效时间是 60 s。
  18.  还有其他的操作视图，ListOperations、SetOperations、ZSetOperations 和 HashOperations。
  19.  */
  20. @RestController
  21. @RequestMapping(value = "/city")
  22. public class CityWebFluxController {
  23.     /**
  24.      * RedisTemplate 实现操作 Redis，但操作是同步的，不是 Reactive 的
  25.      */
  26.     @Autowired
  27.     private RedisTemplate redisTemplate;
  28.  
  29.     @GetMapping(value = "/{id}")
  30.     public Mono<City> findCityById(@PathVariable("id") Long id) {
  31.         String key = "city_" + id;
  32.         ValueOperations<String, City> operations = redisTemplate.opsForValue();
  33.         boolean hasKey = redisTemplate.hasKey(key);
  34.         City city = operations.get(key);
  35.  
  36.         if (!hasKey) {
  37.             return Mono.create(monoSink -> monoSink.success(null));
  38.         }
  39.         return Mono.create(monoSink -> monoSink.success(city));
  40.     }
  41.  
  42.     @PostMapping()
  43.     public Mono<City> saveCity(@RequestBody City city) {
  44.         String key = "city_" + city.getId();
  45.         ValueOperations<String, City> operations = redisTemplate.opsForValue();
  46.         operations.set(key, city, 60, TimeUnit.SECONDS);
  47.  
  48.         return Mono.create(monoSink -> monoSink.success(city));
  49.     }
  50.  
  51.     @DeleteMapping(value = "/{id}")
  52.     public Mono<Long> deleteCity(@PathVariable("id") Long id) {
  53.         String key = "city_" + id;
  54.         boolean hasKey = redisTemplate.hasKey(key);
  55.         if (hasKey) {
  56.             redisTemplate.delete(key);
  57.         }
  58.         return Mono.create(monoSink -> monoSink.success(id));
  59.     }
  60. }
运行程序打开postman，添加一个城市信息，

通过redis获取一个城市代码如下：



4，添加一个reactive的redis操作

上面的redis操作不具有reactive的特性，下面是具有reactive特性的redis操作，代码如下：

  1. package com.jack.webflux_redis.controller;
  2.  
  3. import com.jack.webflux_redis.domain.City;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.data.redis.core.ReactiveRedisTemplate;
  6. import org.springframework.data.redis.core.ReactiveValueOperations;
  7. import org.springframework.web.bind.annotation.*;
  8. import reactor.core.publisher.Mono;
  9.  
  10. /**
  11.  * create by jack 2018/5/13
  12.  */
  13. @RestController
  14. @RequestMapping(value = "/city2")
  15. public class CityWebFluxReactiveController {
  16.  
  17.     /**
  18.      *
  19.      * 持 Reactive 的操作类为 ReactiveRedisTemplate
  20.      * @Autowired 注入 ReactiveRedisTemplate 对象。
  21.     ReactiveValueOperations 是 String（或 value）的操作视图，
  22.     操作视图还有 ReactiveHashOperations、ReactiveListOperations、ReactiveSetOperations 和 ReactiveZSetOperations 等。
  23.     不一样的是，操作视图 set 方法是操作 City 对象，但可以 get 回 Mono 或者 Flux 对象
  24.      */
  25.     @Autowired
  26.     private ReactiveRedisTemplate reactiveRedisTemplate;
  27.  
  28.     @GetMapping(value = "/{id}")
  29.     public Mono<City> findCityById(@PathVariable("id") Long id) {
  30.         String key = "city_" + id;
  31.         ReactiveValueOperations<String, City> operations = reactiveRedisTemplate.opsForValue();
  32.         Mono<City> city = operations.get(key);
  33.         return city;
  34.     }
  35.  
  36.     @PostMapping
  37.     public Mono<City> saveCity(@RequestBody City city) {
  38.         String key = "city_" + city.getId();
  39.         ReactiveValueOperations<String, City> operations = reactiveRedisTemplate.opsForValue();
  40.         return operations.getAndSet(key, city);
  41.     }
  42.  
  43.     @DeleteMapping(value = "/{id}")
  44.     public Mono<Long> deleteCity(@PathVariable("id") Long id) {
  45.         String key = "city_" + id;
  46.         return reactiveRedisTemplate.delete(key);
  47.     }
  48. }

测试结果和上面的redis测试结果一样，只是具有reactive的特性，是异步非阻塞的。


5，整合redis和mongodb

dao层的代码如下：

  1. package com.jack.webflux_redis.dao;
  2.  
  3. import com.jack.webflux_redis.domain.City;
  4. import org.springframework.data.mongodb.repository.ReactiveMongoRepository;
  5. import org.springframework.stereotype.Repository;
  6.  
  7. /**
  8.  * create by jack 2018/5/12
  9.  */
  10. @Repository
  11. public interface CityRepository extends ReactiveMongoRepository<City, Long> {
  12. }

新增一个handler，代码如下：

  1. package com.jack.webflux_redis.handler;
  2.  
  3. import com.jack.webflux_redis.dao.CityRepository;
  4. import com.jack.webflux_redis.domain.City;
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.data.redis.core.RedisTemplate;
  9. import org.springframework.data.redis.core.ValueOperations;
  10. import org.springframework.stereotype.Component;
  11. import reactor.core.publisher.Flux;
  12. import reactor.core.publisher.Mono;
  13.  
  14. /**
  15.  * create by jack 2018/5/13
  16.  */
  17. @Component
  18. public class CityHandler {
  19.     private static final Logger LOGGER = LoggerFactory.getLogger(CityHandler.class);
  20.  
  21.     @Autowired
  22.     private RedisTemplate redisTemplate;
  23.  
  24.     private final CityRepository cityRepository;
  25.  
  26.     @Autowired
  27.     public CityHandler(CityRepository cityRepository) {
  28.         this.cityRepository = cityRepository;
  29.     }
  30.  
  31.     public Mono<City> save(City city) {
  32.         return cityRepository.save(city);
  33.     }
  34.  
  35.  
  36.     /**
  37.      * 如果缓存存在，从缓存中获取城市信息；
  38.      如果缓存不存在，从 DB 中获取城市信息，然后插入缓存
  39.      * @param id
  40.      * @return
  41.      */
  42.     public Mono<City> findCityById(Long id) {
  43.  
  44.         // 从缓存中获取城市信息
  45.         String key = "city_" + id;
  46.         ValueOperations<String, City> operations = redisTemplate.opsForValue();
  47.  
  48.         // 缓存存在
  49.         boolean hasKey = redisTemplate.hasKey(key);
  50.         if (hasKey) {
  51.             City city = operations.get(key);
  52.  
  53.             LOGGER.info("CityHandler.findCityById() : 从缓存中获取了城市 >> " + city.toString());
  54.             return Mono.create(cityMonoSink -> cityMonoSink.success(city));
  55.         }
  56.  
  57.         // 从 MongoDB 中获取城市信息
  58.         Mono<City> cityMono = cityRepository.findById(id);
  59.  
  60.         if (cityMono == null)
  61.             return cityMono;
  62.  
  63.         // 插入缓存
  64.         cityMono.subscribe(cityObj -> {
  65.             operations.set(key, cityObj);
  66.             LOGGER.info("CityHandler.findCityById() : 城市插入缓存 >> " + cityObj.toString());
  67.         });
  68.  
  69.         return cityMono;
  70.     }
  71.  
  72.     public Flux<City> findAllCity() {
  73.         return cityRepository.findAll().cache();
  74.     }
  75.  
  76.     public Mono<City> modifyCity(City city) {
  77.  
  78.         Mono<City> cityMono = cityRepository.save(city);
  79.  
  80.         // 缓存存在，删除缓存
  81.         String key = "city_" + city.getId();
  82.         boolean hasKey = redisTemplate.hasKey(key);
  83.         if (hasKey) {
  84.             redisTemplate.delete(key);
  85.  
  86.             LOGGER.info("CityHandler.modifyCity() : 从缓存中删除城市 ID >> " + city.getId());
  87.         }
  88.  
  89.         return cityMono;
  90.     }
  91.  
  92.  
  93.     /**
  94.      * 如果缓存存在，删除；
  95.      如果缓存不存在，不操作
  96.      * @param id
  97.      * @return
  98.      */
  99.     public Mono<Long> deleteCity(Long id) {
  100.  
  101.         cityRepository.deleteById(id);
  102.  
  103.         // 缓存存在，删除缓存
  104.         String key = "city_" + id;
  105.         boolean hasKey = redisTemplate.hasKey(key);
  106.         if (hasKey) {
  107.             redisTemplate.delete(key);
  108.  
  109.             LOGGER.info("CityHandler.deleteCity() : 从缓存中删除城市 ID >> " + id);
  110.         }
  111.  
  112.         return Mono.create(cityMonoSink -> cityMonoSink.success(id));
  113.     }
  114. }
  115.

新增一个controller，代码如下：

  1. package com.jack.webflux_redis.controller;
  2.  
  3. import com.jack.webflux_redis.domain.City;
  4. import com.jack.webflux_redis.handler.CityHandler;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.web.bind.annotation.*;
  7. import reactor.core.publisher.Flux;
  8. import reactor.core.publisher.Mono;
  9.  
  10. /**
  11.  * create by jack 2018/5/13
  12.  */
  13. @RestController
  14. @RequestMapping(value = "/city3")
  15. public class CityWebFluxMongodbController {
  16.     @Autowired
  17.     private CityHandler cityHandler;
  18.  
  19.     @GetMapping(value = "/{id}")
  20.     public Mono<City> findCityById(@PathVariable("id") Long id) {
  21.         return cityHandler.findCityById(id);
  22.     }
  23.  
  24.     @GetMapping()
  25.     public Flux<City> findAllCity() {
  26.         return cityHandler.findAllCity();
  27.     }
  28.  
  29.     @PostMapping()
  30.     public Mono<City> saveCity(@RequestBody City city) {
  31.         return cityHandler.save(city);
  32.     }
  33.  
  34.     @PutMapping()
  35.     public Mono<City> modifyCity(@RequestBody City city) {
  36.         return cityHandler.modifyCity(city);
  37.     }
  38.  
  39.     @DeleteMapping(value = "/{id}")
  40.     public Mono<Long> deleteCity(@PathVariable("id") Long id) {
  41.         return cityHandler.deleteCity(id);
  42.     }
  43. }
运行测试，http://127.0.0.1:8080/city3

新增一个城市



查询一个城市：http://127.0.0.1:8080/city3/3


后台输出

2018-05-13 10:52:40.283  INFO 8444 --- [ntLoopGroup-4-3] c.j.webflux_redis.handler.CityHandler    : CityHandler.findCityById() : 城市插入缓存 >> City(id=3, provinceId=6410, cityName=海南, description=海南岛是一个历史不长、但风景优美的沿海岛屿，为中国第二大岛)

进行第二次查询，直接从缓存获取数据：

2018-05-13 10:54:30.253  INFO 8444 --- [ctor-http-nio-2] c.j.webflux_redis.handler.CityHandler    : CityHandler.findCityById() : 从缓存中获取了城市 >> City(id=3, provinceId=6410, cityName=海南, description=海南岛是一个历史不长、但风景优美的沿海岛屿，为中国第二大岛)
源码地址： https://github.com/wj903829182/springcloud5/tree/master/webflux_redis

总结：上面演示了webflux整合redis和mongodb的案例，代码都十分的简单和之前的webflux的CRUD差不多，只是采用了数据存储的方式，引入了nosql数据库mongodb和内存数据库redis。






声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/715793
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号