• 从0到1学SpringCloud——14 gateway 获取请求报文RequestBody

    目录

    一、前言

    二、代码实现

    1、参考源码

    2、自定义请求报文解析

    3、自定义请求报文对象

    4、使用RouteLocator路由

    一、前言

    gateway使用webflux，底层使用异步非阻塞IO模型，在获取请求报文信息时，经常为null。

    本篇主要讲解以下两个方面：

    1、如何异步获取请求报文

    2、自定义请求报文数据类型

    二、代码实现

    1、参考源码

    关于异步获取请求报文的代码，官方提供了参考：ReadBodyRoutePredicateFactory.java

    1. public class ReadBodyRoutePredicateFactory extends AbstractRoutePredicateFactory {
    2.     protected static final Log log = LogFactory.getLog(ReadBodyRoutePredicateFactory.class);
    3.     private static final String TEST_ATTRIBUTE = "read_body_predicate_test_attribute";
    4.     private static final String CACHE_REQUEST_BODY_OBJECT_KEY = "cachedRequestBodyObject";
    5.     private final List> messageReaders;
    6.  
    7.     public ReadBodyRoutePredicateFactory() {
    8.         super(ReadBodyRoutePredicateFactory.Config.class);
    9.         this.messageReaders = HandlerStrategies.withDefaults().messageReaders();
    10.     }
    11.  
    12.     public ReadBodyRoutePredicateFactory(List> messageReaders) {
    13.         super(ReadBodyRoutePredicateFactory.Config.class);
    14.         this.messageReaders = messageReaders;
    15.     }
    16.  
    17.     public AsyncPredicate applyAsync(ReadBodyRoutePredicateFactory.Config config) {
    18.         return new AsyncPredicate() {
    19.             public Publisher apply(ServerWebExchange exchange) {
    20.                 Class inClass = config.getInClass();
    21.                 Object cachedBody = exchange.getAttribute("cachedRequestBodyObject");
    22.                 if (cachedBody != null) {
    23.                     try {
    24.                         boolean test = config.predicate.test(cachedBody);
    25.                         exchange.getAttributes().put("read_body_predicate_test_attribute", test);
    26.                         return Mono.just(test);
    27.                     } catch (ClassCastException var6) {
    28.                         if (ReadBodyRoutePredicateFactory.log.isDebugEnabled()) {
    29.                             ReadBodyRoutePredicateFactory.log.debug("Predicate test failed because class in predicate does not match the cached body object", var6);
    30.                         }
    31.  
    32.                         return Mono.just(false);
    33.                     }
    34.                 } else {
    35.                     return ServerWebExchangeUtils.cacheRequestBodyAndRequest(exchange, (serverHttpRequest) -> {
    36.                         return ServerRequest.create(exchange.mutate().request(serverHttpRequest).build(), ReadBodyRoutePredicateFactory.this.messageReaders).bodyToMono(inClass).doOnNext((objectValue) -> {
    37.                             exchange.getAttributes().put("cachedRequestBodyObject", objectValue);
    38.                         }).map((objectValue) -> {
    39.                             return config.getPredicate().test(objectValue);
    40.                         });
    41.                     });
    42.                 }
    43.             }
    44.  
    45.             public String toString() {
    46.                 return String.format("ReadBody: %s", config.getInClass());
    47.             }
    48.         };
    49.     }
    50.  
    51.     public Predicate apply(ReadBodyRoutePredicateFactory.Config config) {
    52.         throw new UnsupportedOperationException("ReadBodyPredicateFactory is only async.");
    53.     }
    54.  
    55.     public static class Config {
    56.         private Class inClass;
    57.         private Predicate predicate;
    58.         private Map hints;
    59.  
    60.         public Config() {
    61.         }
    62.  
    63.         public Class getInClass() {
    64.             return this.inClass;
    65.         }
    66.  
    67.         public ReadBodyRoutePredicateFactory.Config setInClass(Class inClass) {
    68.             this.inClass = inClass;
    69.             return this;
    70.         }
    71.  
    72.         public Predicate getPredicate() {
    73.             return this.predicate;
    74.         }
    75.  
    76.         public ReadBodyRoutePredicateFactory.Config setPredicate(Predicate predicate) {
    77.             this.predicate = predicate;
    78.             return this;
    79.         }
    80.  
    81.         public  ReadBodyRoutePredicateFactory.Config setPredicate(Class inClass, Predicate predicate) {
    82.             this.setInClass(inClass);
    83.             this.predicate = predicate;
    84.             return this;
    85.         }
    86.  
    87.         public Map getHints() {
    88.             return this.hints;
    89.         }
    90.  
    91.         public ReadBodyRoutePredicateFactory.Config setHints(Map hints) {
    92.             this.hints = hints;
    93.             return this;
    94.         }
    95.     }
    96. }

    源码中提供了异步获取方法、断言规则、对象类型，根据这里的逻辑，我们可以自定义一个解析j规则。

    2、自定义请求报文解析

    继承AbstractRoutePredicateFactory，自定义一个json请求报文解析工厂：

    ZhufengJsonReadBodyRoutePredicateFactory.java

    1. /**
    2.  * @ClassName: ZhufengJsonRoutePredicateFactory
    3.  * @Description 解析json请求
    4.  * @author 月夜烛峰
    5.  * @date 2022/9/14 19:52
    6.  */
    7. @Slf4j
    8. @Component
    9. public class ZhufengJsonReadBodyRoutePredicateFactory extends AbstractRoutePredicateFactory {
    10.  
    11.     private static final String JSON_ATTRIBUTE = "msg_type_predicate_json_attribute";
    12.     private static final String CACHE_REQUEST_BODY_OBJECT_KEY = "cachedMsgTypeObject";
    13.  
    14.     private final List> messageReaders;
    15.  
    16.     public ZhufengJsonReadBodyRoutePredicateFactory() {
    17.         super(Config.class);
    18.         this.messageReaders = HandlerStrategies.withDefaults().messageReaders();
    19.     }
    20.  
    21.     public ZhufengJsonReadBodyRoutePredicateFactory(List> messageReaders) {
    22.         super(Config.class);
    23.         this.messageReaders = messageReaders;
    24.     }
    25.  
    26.     @Override
    27.     public ShortcutType shortcutType() {
    28.         return ShortcutType.GATHER_LIST;
    29.     }
    30.  
    31.     @Override
    32.     public List shortcutFieldOrder() {
    33.         return Arrays.asList("patterns");
    34.     }
    35.  
    36.     @Override
    37.     public AsyncPredicate applyAsync(Config config) {
    38.         return new AsyncPredicate() {
    39.             @Override
    40.             public Publisher apply(ServerWebExchange exchange) {
    41.  
    42.                 Class inClass = JSONObject.class;
    43.  
    44.                 Predicate predicate = msgInfo -> {
    45.                     log.info("请求数据:" + msgInfo);
    46.                     log.info("patterns:" + JSONObject.toJSONString(config.patterns));
    47.  
    48.                     String msgtype = msgInfo.getString("msgType");
    49.                     if (config.patterns.contains(msgtype)) {
    50.                         log.info("验证成功");
    51.                         return true;
    52.                     }
    53.                     log.error("报文格式错误");
    54.                     return false;
    55.                 };
    56.  
    57.                 Object cachedBody = exchange.getAttribute(CACHE_REQUEST_BODY_OBJECT_KEY);
    58.                 log.info("打印属性cachedBody:" + cachedBody);
    59.                 if (cachedBody != null) {
    60.                     try {
    61.                         boolean test = predicate.test((JSONObject) cachedBody);
    62.                         exchange.getAttributes().put(JSON_ATTRIBUTE, test);
    63.                         return Mono.just(test);
    64.                     } catch (ClassCastException e) {
    65.                         log.error("Predicate test failed because class in predicate "
    66.                                 + "does not match the cached body object", e);
    67.                     }
    68.                     return Mono.just(false);
    69.                 } else {
    70.                     return ServerWebExchangeUtils.cacheRequestBodyAndRequest(exchange,
    71.                             (serverHttpRequest) -> ServerRequest
    72.                                     .create(exchange.mutate().request(serverHttpRequest)
    73.                                             .build(), messageReaders)
    74.                                     .bodyToMono(inClass)
    75.                                     .doOnNext(objectValue -> exchange.getAttributes().put(CACHE_REQUEST_BODY_OBJECT_KEY, objectValue))
    76.                                     .map(objectValue -> predicate.test(objectValue)));
    77.                 }
    78.             }
    79.  
    80.             @Override
    81.             public String toString() {
    82.                 return String.format("ReadBody: %s", String.class);
    83.             }
    84.         };
    85.     }
    86.  
    87.     @Override
    88.     public Predicate apply(Config config) {
    89.         throw new UnsupportedOperationException(
    90.                 "ReadBodyPredicateFactory is only async.");
    91.     }
    92.  
    93.     public static class Config {
    94.  
    95.         private List patterns = new ArrayList();
    96.  
    97.  
    98.         public List getPatterns() {
    99.             return patterns;
    100.         }
    101.  
    102.         public Config setPatterns(List patterns) {
    103.             this.patterns = patterns;
    104.             return this;
    105.         }
    106.  
    107.     }
    108. }

    在数据库新增请求报文的断言规则，断言代码和数据库结构可参考：

    《从0到1学SpringCloud——12 gateway 动态配置网关路由规则》

    新增数据：

    1. INSERT INTO `zf_gateway_route` (`route_id`, `uri`, `path_name`, `path_pattern`, `method_name`, `method_pattern`, `msg_name`, `msg_type`, `filter_name`, `new_path`, `remark`, `status`, `index`) VALUES ('zhufeng-body-json', 'lb://zhufeng-web-msg', 'Path', '/msg/json', 'Method', 'Post', 'ZhufengJsonReadBody', 'json', NULL, NULL, '路由测试', 0, 5);
    2. INSERT INTO `zf_gateway_route` (`route_id`, `uri`, `path_name`, `path_pattern`, `method_name`, `method_pattern`, `msg_name`, `msg_type`, `filter_name`, `new_path`, `remark`, `status`, `index`) VALUES ('zhufeng-body-user', 'lb://zhufeng-web-msg', 'Path', '/msg/user', 'Method', 'Post', 'ZhufengUserReadBody', 'user', NULL, NULL, '路由测试', 0, 5);

    请求测试报文：

    1. {
    2.     "message": "json测试",
    3.     "msgType":"json",
    4.     "name": "yueyezhufeng"
    5. }

    当发送 Post 请求 /msg/json 路径时，如果请求报文中 msgType 值为 json ，则校验通过。

    控制台信息：

    3、自定义请求报文对象

    虽然请求可以正常获取，也可以正常校验，但是使用json格式容易引起误解，毕竟json格式的字符串一定场合也会解析，为了更好对比，我们定义一个UserInfo对象：

    1. /**
    2.  * @ClassName: UserInfo
    3.  * @Description 自定义对象
    4.  * @author 月夜烛峰
    5.  * @date 2022/9/16 18:12
    6.  */
    7. public class UserInfo {
    8.     private String userId;
    9.  
    10.     private String userName;
    11.  
    12.     public String getUserId() {
    13.         return userId;
    14.     }
    15.  
    16.     public void setUserId(String userId) {
    17.         this.userId = userId;
    18.     }
    19.  
    20.     public String getUserName() {
    21.         return userName;
    22.     }
    23.  
    24.     public void setUserName(String userName) {
    25.         this.userName = userName;
    26.     }
    27. }

    在刚才新增数据时，添加了两条数据，一个是json请求报文的，一个就是用来解析UserInfo。

    ZhufengUserReadBodyRoutePredicateFactory.java代码：

    1. /**
    2.  * @ClassName: ZhufengUserReadBodyRoutePredicateFactory
    3.  * @Description 自定义User报文体解析类
    4.  * @author 月夜烛峰
    5.  * @date 2022/9/18 12:16
    6.  */
    7. @Slf4j
    8. @Component
    9. public class ZhufengUserReadBodyRoutePredicateFactory extends ReadBodyRoutePredicateFactory {
    10.  
    11.     private static final String ZF_USER_ATTRIBUTE = "read_body_predicate_user_attribute";
    12.  
    13.     private static final String CACHE_REQUEST_BODY_OBJECT_KEY = "cachedRequestBodyObject";
    14.  
    15.     private static final List> messageReaders = HandlerStrategies
    16.             .withDefaults().messageReaders();
    17.  
    18.     public ZhufengUserReadBodyRoutePredicateFactory() {
    19.         super();
    20.     }
    21.  
    22.     @Override
    23.     public AsyncPredicate applyAsync(ReadBodyRoutePredicateFactory.Config config) {
    24.  
    25.         return exchange -> {
    26.             Predicate predicate = msgInfo -> {
    27.                 log.info("请求数据:" + msgInfo.getUserName());
    28.                 return true;
    29.             };
    30.  
    31.             config.setPredicate(predicate);
    32.             config.setInClass(UserInfo.class);
    33.  
    34.             log.info("打印属性formdata:{}",exchange.getFormData().toString());
    35.             log.info("打印属性queryparam:{}",exchange.getRequest().getQueryParams());
    36.  
    37.             Class inClass = config.getInClass();
    38.  
    39.             Object cachedBody = exchange.getAttribute(CACHE_REQUEST_BODY_OBJECT_KEY);
    40.  
    41.             if (cachedBody != null) {
    42.                 try {
    43.                     boolean test = config.getPredicate().test(cachedBody);
    44.                     exchange.getAttributes().put(ZF_USER_ATTRIBUTE, test);
    45.                     return Mono.just(test);
    46.                 } catch (ClassCastException e) {
    47.                     if (log.isDebugEnabled()) {
    48.                         log.debug("Predicate test failed because class in predicate "
    49.                                 + "does not match the cached body object", e);
    50.                     }
    51.                 }
    52.                 return Mono.just(false);
    53.             } else {
    54.                 return ServerWebExchangeUtils.cacheRequestBodyAndRequest(exchange, (serverHttpRequest) -> ServerRequest.create(exchange.mutate().request(serverHttpRequest).build(), messageReaders).bodyToMono(inClass).doOnNext((objectValue) -> {
    55.                     exchange.getAttributes().put(CACHE_REQUEST_BODY_OBJECT_KEY, objectValue);
    56.                 }).map((objectValue) -> {
    57.                     UserInfo userInfo = (UserInfo)objectValue;
    58.                     log.info(userInfo.getUserId()+":"+userInfo.getUserName());
    59.                     return config.getPredicate().test(objectValue);
    60.                 }));
    61.             }
    62.         };
    63.     }
    64. }

    通过restTemplate发起测试：

    1. @RequestMapping("postUser")
    2. public String postUser() {
    3.     //请求参数，仅作为演示参数传递
    4.     UserInfo user = new UserInfo();
    5.     user.setUserId("zf1001");
    6.     user.setUserName("月夜烛峰");
    7.     //zhufeng-gateway-db 为访问的微服务名称
    8.     String pref = "http://zhufeng-gateway-db";
    9.     //uri为微服务中访问的地址
    10.     String uri = "/msg/user";
    11.     ResponseEntity res = restTemplate.postForEntity(pref+uri, user, UserInfo.class);
    12.     return "postUser UserInfo";
    13. }

    User信息正常打印 

    4、使用RouteLocator路由

    如果使用RouteLocator可以指定请求报文的对象类型，如下：

    1. @Bean
    2. public RouteLocator customRouteLocator(RouteLocatorBuilder routeLocatorBuilder) {
    3. 	// 构建多个路由routes
    4. 	RouteLocatorBuilder.Builder routes = routeLocatorBuilder.routes();
    5.  
    6.    routes.route("zhufeng-route-msg",
    7. 			r -> r.readBody(UserInfo.class, requestBody -> {
    8. 						log.info("requestBody is {}", requestBody);
    9. 						return true;
    10. 					}).and().path("/msg/**").
    11.  
    12. 					uri("lb://zhufeng-web-msg"));
    13.  
    14. 	return routes.build();
    15. }

    RouteLocator使用过程参考：

    《从0到1学SpringCloud——13 gateway RouteLocator配置路由规则》

  • 相关阅读:
    Python爬虫数据存哪里|数据存储到文件的几种方式
    Linux内核（十六）Linux 内核态进行读写文件的函数 使用和解析
    .net程序员的android studio 初体验 (环境设置2022年10月）
    jar添加到本地maven仓库
    Unity--Configurable Joint——实战带你了解可配置关节
    指针与引用
    End-to-end 3D Human Pose Estimation with Transformer
    优化|优化处理可再生希尔伯特核空间的非参数回归中的协变量偏移
    webstorage
    【HTML】筑基篇
  • 原文地址：https://blog.csdn.net/yueyezhufeng/article/details/126947143