Gateway集成Netty服务

目录

• 一、Netty简介
  
• 二、Netty入门案例
  
  
  
  • 1、服务端启动
    
  • 2、通道初始化
    
  • 3、自定义处理器
    
  • 4、测试请求
    
  
  
• 三、Gateway集成
  
  
  
  • 1、依赖层级
    
  • 2、自动化配置
    
  
  
• 四、配置加载
  
  
  
  • 1、基础配置
    
  • 2、属性配置类
    
  • 3、配置加载分析
    
  
  
• 五、周期管理方法
  
  
  
  • 1、控制类
    
  • 2、管理类
    
  
  
• 六、参考源码
  

Gateway和Netty都有盲区的感觉；

一、Netty简介

Netty是一个异步的，事件驱动的网络应用框架，用以快速开发高可靠、高性能的网络应用程序。

传输服务：提供网络传输能力的管理；
协议支持：支持常见的数据传输协议；
核心模块：包括可扩展事件模型、通用的通信API、零拷贝字节缓冲；
二、Netty入门案例

1、服务端启动

配置Netty服务器端程序，引导相关核心组件的加载；

1. public class NettyServer {
3.     public static void main(String[] args) {
5.         // EventLoop组，处理事件和IO
6.         EventLoopGroup parentGroup = new NioEventLoopGroup();
7.         EventLoopGroup childGroup = new NioEventLoopGroup();
9.         try {
11.             // 服务端启动引导类
12.             ServerBootstrap serverBootstrap = new ServerBootstrap();
13.             serverBootstrap.group(parentGroup, childGroup)
14.                     .channel(NioServerSocketChannel.class).childHandler(new ChannelInit());
16.             // 异步IO的结果
17.             ChannelFuture channelFuture = serverBootstrap.bind(8082).sync();
18.             channelFuture.channel().closeFuture().sync();
20.         } catch (Exception e){
21.             e.printStackTrace();
22.         } finally {
23.             parentGroup.shutdownGracefully();
24.             childGroup.shutdownGracefully();
25.         }
26.     }
27. }

复制代码

2、通道初始化

ChannelInitializer特殊的通道处理器，提供一种简单的方法，对注册到EventLoop的通道进行初始化；比如此处设置的编码解码器，自定义处理器；

1. public class ChannelInit extends ChannelInitializer<SocketChannel> {
3.     @Override
4.     protected void initChannel(SocketChannel socketChannel) {
6.         // 获取管道
7.         ChannelPipeline pipeline = socketChannel.pipeline();
9.         // Http编码、解码器
10.         pipeline.addLast("DefHttpServerCodec",new HttpServerCodec());
12.         // 添加自定义的handler
13.         pipeline.addLast("DefHttpHandler", new DefHandler());
14.     }
15. }

复制代码

3、自定义处理器

处理对服务器端发起的访问，通常包括请求解析，具体的逻辑执行，请求响应等过程；

1. public class DefHandler extends SimpleChannelInboundHandler<HttpObject> {
3.     @Override
4.     protected void channelRead0(ChannelHandlerContext ctx, HttpObject message) throws Exception {
6.         if(message instanceof HttpRequest) {
7.             // 请求解析
8.             HttpRequest httpRequest = (HttpRequest) message;
9.             String uri = httpRequest.uri();
10.             String method = httpRequest.method().name();
11.             log.info("【HttpRequest-URI:"+uri+"】");
12.             log.info("【HttpRequest-method:"+method+"】");
14.             Iterator<Map.Entry<String,String>> iterator = httpRequest.headers().iteratorAsString();
15.             while (iterator.hasNext()){
16.                 Map.Entry<String,String> entry = iterator.next();
17.                 log.info("【Header-Key:"+entry.getKey()+";Header-Value:"+entry.getValue()+"】");
18.             }
20.             // 响应构建
21.             ByteBuf content = Unpooled.copiedBuffer("Netty服务", CharsetUtil.UTF_8);
22.             FullHttpResponse response = new DefaultFullHttpResponse
23.                                         (HttpVersion.HTTP_1_1, HttpResponseStatus.OK, content);
24.             response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain;charset=utf-8");
25.             response.headers().set(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes());
26.             ctx.writeAndFlush(response);
27.         }
28.     }
29. }

复制代码

4、测试请求

上面入门案例中，简单的配置了一个Netty服务器端，启动之后在浏览器中模拟访问即可；

1. http://127.0.0.1:8082/?id=1&name=Spring

复制代码

三、Gateway集成

1、依赖层级

项目中Gateway网关依赖的版本为2.2.5.RELEASE，发现Netty依赖的版本为4.1.45.Final，是当下比较主流的版本；

1. <dependency>
2.     <groupId>org.springframework.cloud</groupId>
3.     <artifactId>spring-cloud-starter-gateway</artifactId>
4.     <version>2.2.5.RELEASE</version>
5. </dependency>
8. <dependency>
9.   <groupId>org.springframework.boot</groupId>
10.   <artifactId>spring-boot-starter-webflux</artifactId>
11.   <version>2.3.2.RELEASE</version>
12. </dependency>
15. <dependency>
16.   <groupId>org.springframework.boot</groupId>
17.   <artifactId>spring-boot-starter-reactor-netty</artifactId>
18.   <version>2.3.2.RELEASE</version>
19. </dependency>

复制代码

2、自动化配置

在Gateway网关的自动化配置配置类中，提供了Netty配置的管理；

1. @AutoConfigureBefore({ HttpHandlerAutoConfiguration.class,WebFluxAutoConfiguration.class })
2. @ConditionalOnClass(DispatcherHandler.class)
3. public class GatewayAutoConfiguration {
5.     @Configuration(proxyBeanMethods = false)
6.     @ConditionalOnClass(HttpClient.class)
7.     protected static class NettyConfiguration {
9.         @Bean
10.         @ConditionalOnProperty(name = "spring.cloud.gateway.httpserver.wiretap")
11.         public NettyWebServerFactoryCustomizer nettyServerWiretapCustomizer(
12.                 Environment environment, ServerProperties serverProperties) {
13.             return new NettyWebServerFactoryCustomizer(environment, serverProperties) {
14.                 @Override
15.                 public void customize(NettyReactiveWebServerFactory factory) {
16.                     factory.addServerCustomizers(httpServer -> httpServer.wiretap(true));
17.                     super.customize(factory);
18.                 }
19.             };
20.         }
21.     }
22. }

复制代码

四、配置加载

1、基础配置

在工程的配置文件中，简单做一些基础性的设置；

1. server:
2.   port: 8081                  # 端口号
3.   netty:                      # Netty组件
4.     connection-timeout: 3000  # 连接超时

复制代码

2、属性配置类

在ServerProperties类中，并没有提供很多显式的Netty配置参数，更多信息需要参考工厂类；

1. @ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
2. public class ServerProperties {
3.     private Integer port;
4.     public static class Netty {
5.         private Duration connectionTimeout;
6.     }
7. }

复制代码

3、配置加载分析

• 基于配置的属性，定制化管理Netty服务的信息；
  

1. public class NettyWebServerFactoryCustomizer
2.         implements WebServerFactoryCustomizer<NettyReactiveWebServerFactory>{
3.     private final Environment environment;
4.     private final ServerProperties serverProperties;
5.     @Override
6.     public void customize(NettyReactiveWebServerFactory factory) {
7.         PropertyMapper propertyMapper = PropertyMapper.get().alwaysApplyingWhenNonNull();
8.         ServerProperties.Netty nettyProperties = this.serverProperties.getNetty();
9.         propertyMapper.from(nettyProperties::getConnectionTimeout).whenNonNull()
10.                 .to((connectionTimeout) -> customizeConnectionTimeout(factory, connectionTimeout));
11.     }
12. }

复制代码

• NettyReactiveWeb服务工厂，基于上述入门案例，创建WebServer时，部分参数信息出自LoopResources接口；
  

1. public class NettyReactiveWebServerFactory extends AbstractReactiveWebServerFactory {
3.     private ReactorResourceFactory resourceFactory;
5.     @Override
6.     public WebServer getWebServer(HttpHandler httpHandler) {
7.         HttpServer httpServer = createHttpServer();
8.         ReactorHttpHandlerAdapter handlerAdapter = new ReactorHttpHandlerAdapter(httpHandler);
9.         NettyWebServer webServer = new NettyWebServer(httpServer, handlerAdapter, this.lifecycleTimeout);
10.         webServer.setRouteProviders(this.routeProviders);
11.         return webServer;
12.     }
13.    
14.     private HttpServer createHttpServer() {
15.                 HttpServer server = HttpServer.create();
16.                 if (this.resourceFactory != null) {
17.                 LoopResources resources = this.resourceFactory.getLoopResources();
18.                 server = server.tcpConfiguration(
19.                                 (tcpServer) -> tcpServer.runOn(resources).addressSupplier(this::getListenAddress));
20.         }
21.         return applyCustomizers(server);
22.         }
23.        
24. }

复制代码

五、周期管理方法

1、控制类


Gateway项目中，Netty服务核心控制类，通过NettyReactiveWebServerFactory工厂类创建，对Netty生命周期的管理提供了一层包装；

1. public class NettyWebServer implements WebServer {
3.     private final HttpServer httpServer;
4.     private final ReactorHttpHandlerAdapter handlerAdapter;
6.     /**
7.      * 启动方法
8.      */
9.     @Override
10.     public void start() throws WebServerException {
11.         if (this.disposableServer == null) {
12.             this.disposableServer = startHttpServer();
13.             // 控制台日志
14.             logger.info("Netty started on port(s): " + getPort());
15.             startDaemonAwaitThread(this.disposableServer);
16.         }
17.     }
18.     private DisposableServer startHttpServer() {
19.         HttpServer server = this.httpServer;
20.         if (this.routeProviders.isEmpty()) {
21.             server = server.handle(this.handlerAdapter);
22.         }
23.         return server.bindNow();
24.     }
26.     /**
27.      * 停止方法
28.      */
29.     @Override
30.     public void stop() throws WebServerException {
31.         if (this.disposableServer != null) {
32.             // 释放资源
33.             if (this.lifecycleTimeout != null) {
34.                 this.disposableServer.disposeNow(this.lifecycleTimeout);
35.             }
36.             else {
37.                 this.disposableServer.disposeNow();
38.             }
39.             // 对象销毁
40.             this.disposableServer = null;
41.         }
42.     }
43. }

复制代码

2、管理类

Netty组件中抽象管理类，以安全的方式构建Http服务；
[code]public abstract class HttpServer {    public static HttpServer create() {        return HttpServerBind.INSTANCE;    }    public final DisposableServer bindNow() {        return bindNow(Duration.ofSeconds(45));    }    public final HttpServer handle(BiFunction