netty-4-user-guide

netty源码编译Netty是一种高性能的、异步的、事件驱动的网络编程框架。

它提供了简单而强大的API，可以帮助开发人员更轻松地构建各种网络应用程序。

Netty的核心是一个基于NIO的异步事件编程框架，可以更好地利用系统资源，提高网络应用程序的性能。

在本文中，我们将详细介绍如何从源码编译Netty。

首先，我们需要准备编译Netty所需的工具和环境。

一、准备工作要编译Netty源码，我们需要安装以下工具和环境：1. JDK：Netty是用Java编写的，因此我们需要安装JDK。

建议使用JDK 8或更高版本。

2. Git：我们需要使用Git来获取Netty的源代码。

安装Git并配置好环境变量。

3. Maven：Netty使用Maven作为构建工具，因此我们需要安装Maven并配置好环境变量。

4. IDE：你可以选择使用任何你熟悉的Java开发IDE，如IntelliJ IDEA或Eclipse。

二、获取源码1.打开终端或命令提示符，切换到一个你准备存放源码的目录。

2. 运行以下命令来克隆Netty的源代码仓库：```shell```这将会获取Netty的最新源码。

三、编译源码1. 打开终端或命令提示符，切换到Netty源码目录。

2.运行以下命令来开始编译：```shellmvn clean install -DskipTests```这将会使用Maven编译Netty的源码。

`-DskipTests`参数是可选的，用于跳过运行单元测试。

编译完成后，你可以在`target`目录中找到编译生成的JAR包。

四、使用IDE开发如果你想使用IDE来开发Netty源码，你可以导入源码到你的开发IDE中。

1. 打开你的IDE，并打开Netty源码目录作为项目。

2.根据IDE的不同，可能需要执行一些配置步骤来正确导入项目。

请参考你的IDE文档来完成这些步骤。

3. 一旦项目导入成功，你就可以开始在IDE中开发Netty源码了。

netty 实现原理Netty 是一种基于Java NIO（Non-blocking I/O）的网络编程框架，用于开发高性能的、可扩展的网络服务器和客户端应用程序。

Netty 的实现原理主要包括以下几个方面：1. Reactor 模式：Netty 使用 Reactor 模式来处理并发请求。

Reactor 模式由三部分组成：Selector、Acceptor 和 Handler。

Selector 负责监听客户端的连接请求，当有新的连接到达时，Selector 将连接注册到对应的 Handler 中，然后由 Handler 进行处理。

2. NIO Channel 和 Buffer：Netty 使用 NIO 的 Channel 和Buffer 来实现非阻塞的网络通信。

Channel 是对原生 Java NIO 中的SocketChannel 的封装，Channel 可以通过 Selector 来进行事件监听和处理。

Buffer 是对 Java NIO 中的 ByteBuffer 的封装，用于读写网络数据。

3. 线程模型：Netty 采用了多线程模型来处理并发请求。

Netty 将读写事件的处理分离到不同的线程池中，读事件由专门的线程池处理，写事件则由 I/O 线程池处理。

这样能够充分利用多核 CPU 的优势，提高并发处理能力。

4. 异步编程模型：Netty 使用异步的方式处理网络请求。

当有网络事件发生时，Netty 会立即返回，并将相应的处理逻辑提交到线程池中进行处理。

这样可以避免线程的阻塞，提高系统的吞吐量。

5. 编解码器：Netty 提供了一系列的编解码器，用于将 Java 对象转换为网络数据包，并在收到数据包时将其转换为 Java 对象。

这样可以简化编程工作，并提高网络传输的效率。

总的来说，Netty 的实现原理是基于 Reactor 模式、NIO Channel 和 Buffer、多线程模型以及异步编程模型来实现高性能、可扩展的网络编程框架。

【Netty】Netty框架介绍⼀、Netty简介 Netty是由JBOSS提供的⼀个java开源框架，现为 Github上的独⽴项⽬。

Netty提供异步的、事件驱动的⽹络应⽤程序框架和⼯具，⽤以快速开发⾼性能、⾼可靠性的⽹络服务器和客户端程序。

也就是说，Netty 是⼀个基于NIO的客户、服务器端的编程框架，使⽤Netty 可以确保你快速和简单的开发出⼀个⽹络应⽤，例如实现了某种协议的客户、服务端应⽤。

Netty相当于简化和流线化了⽹络应⽤的编程开发过程，例如：基于TCP和UDP的socket服务开发。

“快速”和“简单”并不⽤产⽣维护性或性能上的问题。

Netty 是⼀个吸收了多种协议（包括FTP、SMTP、HTTP等各种⼆进制⽂本协议）的实现经验，并经过相当精⼼设计的项⽬。

最终，Netty 成功的找到了⼀种⽅式，在保证易于开发的同时还保证了其应⽤的性能，稳定性和伸缩性1.1 Netty的特点设计优雅适⽤于各种传输类型的统⼀API - 阻塞和⾮阻塞Socket基于灵活且可扩展的事件模型，可以清晰地分离关注点⾼度可定制的线程模型 - 单线程，⼀个或多个线程池真正的⽆连接数据报套接字⽀持（⾃3.1起）使⽤⽅便详细记录的Javadoc，⽤户指南和⽰例没有其他依赖项，JDK 5（Netty 3.x）或6（Netty 4.x）就⾜够了⾼性能吞吐量更⾼，延迟更低减少资源消耗最⼩化不必要的内存复制安全完整的SSL / TLS和StartTLS⽀持社区活跃，不断更新社区活跃，版本迭代周期短，发现的BUG可以被及时修复，同时，更多的新功能会被加⼊1.2 Netty常见使⽤场景互联⽹⾏业在分布式系统中，各个节点之间需要远程服务调⽤，⾼性能的RPC框架必不可少，Netty作为异步⾼新能的通信框架,往往作为基础通信组件被这些RPC框架使⽤。

典型的应⽤有：阿⾥分布式服务框架Dubbo的RPC框架使⽤Dubbo协议进⾏节点间通信，Dubbo协议默认使⽤Netty作为基础通信组件，⽤于实现各进程节点之间的内部通信。

netty usereventtriggered 原理Netty是一个基于Java的高性能网络编程框架，提供了异步事件驱动、高性能和可扩展性的网络应用程序开发。

在Netty中，UserEventTriggered是一个触发用户事件的Handler方法，它的工作原理如下：1. Netty的事件模型：Netty使用事件驱动的方式实现高效的网络通信。

它使用事件循环模型来处理输入和输出的数据流。

事件循环是一个无限循环，通过不断地处理事件并触发相应的回调方法来驱动网络通信。

Netty中有一个事件循环组（EventLoopGroup），其中包含多个事件循环（EventLoop），每个事件循环都负责处理特定的网络通信任务。

2. 用户定义的事件：在Netty中，用户可以定义自己的事件，并通过UserEventTriggered方法触发这些事件。

UserEventTriggered是一个ChannelInboundHandlerAdapter类中的一个方法，当Netty框架接收到用户定义的事件时，会调用这个方法来处理用户事件。

3. ChannelPipeline和ChannelHandler：Netty中的用户事件是通过ChannelPipeline来传递的。

ChannelPipeline是一个处理器链，用于管理ChannelHandler的执行顺序。

当Netty收到一个事件时，它会根据ChannelPipeline中的Handler顺序来执行处理逻辑。

当用户定义事件被触发时，Netty会根据ChannelHandler的类型选择合适的方法进行回调，其中就包括UserEventTriggered方法。

4. 触发用户事件：用户事件可以由以下几种方式触发：- 用户主动触发：用户可以通过Channel的writeAndFlush方法向网络发送一个事件，然后在ChannelPipeline的后续Handler中接收并处理这个事件。

netty黑马程序员笔记Netty是一个基于Java NIO的异步事件驱动的网络应用框架，它的设计目标是提供一个高性能、高可靠性的网络编程解决方案。

作为网络通信领域的优秀框架，Netty在服务端程序的开发中发挥着重要作用。

本文将围绕Netty的相关知识点展开讲解，以帮助黑马程序员更好地理解和应用Netty。

一、Netty的核心组件1. Channel（通道）：Channel是Netty中最基本的概念，它用于和远程节点进行通信。

在Netty中，数据通过Channel进行读写，Channel相当于传统IO编程中的Socket。

2. EventLoop（事件循环）：EventLoop是Netty的核心，用于处理所有的事件，包括接收连接、读写数据等。

每个Channel都会被关联到一个EventLoop，一个EventLoop可以被多个Channel共享。

3. ChannelHandler（事件处理器）：ChannelHandler用于处理Channel中的事件，比如读写数据、连接建立与关闭等操作。

每个Channel都可以关联多个ChannelHandler，ChannelHandler之间形成一个处理链，通过这个链来处理Channel 中的事件。

4. ChannelPipeline（事件处理链）：ChannelPipeline是ChannelHandler的容器，它负责管理ChannelHandler的调用顺序。

当有事件发生时，ChannelPipeline会依次调用关联的ChannelHandler进行处理。

二、Netty的生命周期1. ChannelOption（通道选项）：ChannelOption用于设置Channel的参数，比如TCP_NODELAY、SO_KEEPALIVE等。

通过设置ChannelOption，可以影响到Channel的行为。

2. ChannelConfig（通道配置）：ChannelConfig用于配置Channel的基本参数，比如接收缓冲区大小、发送缓冲区大小等。

The Netty Project 3.1 User Guide The Proven Approachto Rapid Network Application Development3.1.5.GA, r1772Preface (iii)1. The Problem (iii)2. The Solution (iii)1. Getting Started (1)1.1. Before Getting Started (1)1.2. Writing a Discard Server (1)1.3. Looking into the Received Data (3)1.4. Writing an Echo Server (4)1.5. Writing a Time Server (5)1.6. Writing a Time Client (7)1.7. Dealing with a Stream-based Transport (8)1.7.1. One Small Caveat of Socket Buffer (8)1.7.2. The First Solution (9)1.7.3. The Second Solution (11)1.8. Speaking in POJO instead of ChannelBuffer (12)1.9. Shutting Down Your Application (15)1.10. Summary (18)2. Architectural Overview (19)2.1. Rich Buffer Data Structure (19)2.2. Universal Asynchronous I/O API (19)2.3. Event Model based on the Interceptor Chain Pattern (20)2.4. Advanced Components for More Rapid Development (21)2.4.1. Codec framework (21)2.4.2. SSL / TLS Support (21)2.4.3. HTTP Implementation (22)2.4.4. Google Protocol Buffer Integration (22)2.5. Summary (22)PrefaceThis guide provides an introduction to Netty and what it is about.1. The ProblemNowadays we use general purpose applications or libraries to communicate with each other. For example, we often use an HTTP client library to retrieve information from a web server and to invoke a remote procedure call via web services.However, a general purpose protocol or its implementation sometimes does not scale very well. It is like we don't use a general purpose HTTP server to exchange huge files, e-mail messages, and near-realtime messages such as financial information and multiplayer game data. What's required is a highly optimized protocol implementation which is dedicated to a special purpose. For example, you might want to implement an HTTP server which is optimized for AJAX-based chat application, media streaming, or large file transfer. You could even want to design and implement a whole new protocol which is precisely tailored to your need.Another inevitable case is when you have to deal with a legacy proprietary protocol to ensure the interoperability with an old system. What matters in this case is how quickly we can implement that protocol while not sacrificing the stability and performance of the resulting application.2. The SolutionThe Netty project is an effort to provide an asynchronous event-driven network application framework and tooling for the rapid development of maintainable high-performance high-scalability protocol servers and clients.In other words, Netty is a NIO client server framework which enables quick and easy development of network applications such as protocol servers and clients. It greatly simplifies and streamlines network programming such as TCP and UDP socket server development.'Quick and easy' does not mean that a resulting application will suffer from a maintainability or a performance issue. Netty has been designed carefully with the experiences earned from the implementation of a lot of protocols such as FTP, SMTP, HTTP, and various binary and text-based legacy protocols. As a result, Netty has succeeded to find a way to achieve ease of development, performance, stability, and flexibility without a compromise.Some users might already have found other network application framework that claims to have the same advantage, and you might want to ask what makes Netty so different from them. The answer is the philosophy where it is built on. Netty is designed to give you the most comfortable experience both in terms of the API and the implementation from the day one. It is not something tangible but you will realize that this philosophy will make your life much easier as you read this guide and play with Netty.Chapter 1.Getting StartedThis chapter tours around the core constructs of Netty with simple examples to let you get started quickly. You will be able to write a client and a server on top of Netty right away when you are at the end of this chapter.If you prefer top-down approach in learning something, you might want to start from Chapter 2, Architectural Overview and get back here.1.1. Before Getting StartedThe minimum requirements to run the examples which are introduced in this chapter are only two; the latest version of Netty and JDK 1.5 or above. The latest version of Netty is available in the project download page. To download the right version of JDK, please refer to your preferred JDK vendor's web site.Is that all? To tell the truth, you should find these two are just enough to implement almost any type of protocols. Otherwise, please feel free to contact the Netty project community and let us know what's missing.At last but not least, please refer to the API reference whenever you want to know more about the classes introduced here. All class names in this document are linked to the online API reference for your convenience. Also, please don't hesitate to contact the Netty project community and let us know if there's any incorrect information, errors in grammar and typo, and if you have a good idea to improve the documentation.1.2. Writing a Discard ServerThe most simplistic protocol in the world is not 'Hello, World!' but DISCARD. It's a protocol which discards any received data without any response.To implement the DISCARD protocol, the only thing you need to do is to ignore all received data. Let us start straight from the handler implementation, which handles I/O events generated by Netty.Writing a Discard ServerChannelPipelineCoverage annotates a handler type to tell if the handler instance of the annotated type can be shared by more than one Channel (and its associated ChannelPipeline).DiscardServerHandler does not manage any stateful information, and therefore it is annotated with the value "all".DiscardServerHandler extends SimpleChannelHandler, which is an implementation of ChannelHandler. SimpleChannelHandler provides various event handler methods that you can override. For now, it is just enough to extend SimpleChannelHandler rather than to implement the handler interfaces by yourself.We override the messageReceived event handler method here. This method is called with a MessageEvent, which contains the received data, whenever new data is received from a client. In this example, we ignore the received data by doing nothing to implement the DISCARD protocol.exceptionCaught event handler method is called with an ExceptionEvent when an exception was raised by Netty due to I/O error or by a handler implementation due to the exception thrown while processing events. In most cases, the caught exception should be logged and its associated channel should be closed here, although the implementation of this method can be different depending on what you want to do to deal with an exceptional situation. For example, you might want to send a response message with an error code before closing the connection.So far so good. We have implemented the first half of the DISCARD server. What's left now is to write the main method which starts the server with the DiscardServerHandler.Looking into the Received DataChannelFactory is a factory which creates and manages Channel s and its related resources. It processes all I/O requests and performs I/O to generate ChannelEvent s. Netty provides various ChannelFactory implementations. We are implementing a server-side application in this example, and therefore NioServerSocketChannelFactory was used. Another thing to note is that it does not create I/O threads by itself. It is supposed to acquire threads from the thread pool you specified in the constructor, and it gives you more control over how threads should be managed in the environment where your application runs, such as an application server with a security manager.ServerBootstrap is a helper class that sets up a server. You can set up the server using a Channel directly. However, please note that this is a tedious process and you do not need to do that in most cases.Here, we add the DiscardServerHandler to the default ChannelPipeline. Whenevera new connection is accepted by the server, a new ChannelPipeline will be created fora newly accepted Channel and all the ChannelHandler s added here will be added tothe new ChannelPipeline. It's just like a shallow-copy operation; all Channel and their ChannelPipeline s will share the same DiscardServerHandler instance.You can also set the parameters which are specific to the Channel implementation. We are writing a TCP/IP server, so we are allowed to set the socket options such as tcpNoDelay and keepAlive.Please note that the "child." prefix was added to all options. It means the options will be applied to the accepted Channel s instead of the options of the ServerSocketChannel. You could do the following to set the options of the ServerSocketChannel:We are ready to go now. What's left is to bind to the port and to start the server. Here, we bind to the port 8080 of all NICs (network interface cards) in the machine. You can now call the bind method as many times as you want (with different bind addresses.)Congratulations! You've just finished your first server on top of Netty.1.3. Looking into the Received DataNow that we have written our first server, we need to test if it really works. The easiest way to test it is to use the telnet command. For example, you could enter "telnet localhost 8080" in the command line and type something.However, can we say that the server is working fine? We cannot really know that because it is a discard server. You will not get any response at all. To prove it is really working, let us modify the server to print what it has received.We already know that MessageEvent is generated whenever data is received and the messageReceived handler method will be invoked. Let us put some code into the messageReceived method of the DiscardServerHandler:It is safe to assume the message type in socket transports is always ChannelBuffer.ChannelBuffer is a fundamental data structure which stores a sequence of bytes in Netty. It's similar to NIO ByteBuffer, but it is easier to use and more flexible. For example, Netty allows you to create a composite ChannelBuffer which combines multiple ChannelBuffer s reducing the number of unnecessary memory copy.Although it resembles to NIO ByteBuffer a lot, it is highly recommended to refer to the API reference. Learning how to use ChannelBuffer correctly is a critical step in using Netty without difficulty.If you run the telnet command again, you will see the server prints what has received.The full source code of the discard server is located in the ty.example.discard package of the distribution.1.4. Writing an Echo ServerSo far, we have been consuming data without responding at all. A server, however, is usually supposed to respond to a request. Let us learn how to write a response message to a client by implementing the ECHO protocol, where any received data is sent back.The only difference from the discard server we have implemented in the previous sections is that it sends the received data back instead of printing the received data out to the console. Therefore, it is enough again to modify the messageReceived method:A ChannelEvent object has a reference to its associated Channel. Here, the returned Channelrepresents the connection which received the MessageEvent. We can get the Channel and call the write method to write something back to the remote peer.If you run the telnet command again, you will see the server sends back whatever you have sent to it. The full source code of the echo server is located in the ty.example.echo package of the distribution.1.5. Writing a Time ServerThe protocol to implement in this section is the TIME protocol. It is different from the previous examples in that it sends a message, which contains a 32-bit integer, without receiving any requests and loses the connection once the message is sent. In this example, you will learn how to construct and send a message, and to close the connection on completion.Because we are going to ignore any received data but to send a message as soon as a connection is established, we cannot use the messageReceived method this time. Instead, we should override the channelConnected method. The following is the implementation:As explained, channelConnected method will be invoked when a connection is established. Let us write the 32-bit integer that represents the current time in seconds here.To send a new message, we need to allocate a new buffer which will contain the message. We are going to write a 32-bit integer, and therefore we need a ChannelBuffer whose capacity is 4 bytes. The ChannelBuffers helper class is used to allocate a new buffer. Besides the buffer method, ChannelBuffers provides a lot of useful methods related to the ChannelBuffer. For more information, please refer to the API reference.On the other hand, it is a good idea to use static imports for ChannelBuffers:As usual, we write the constructed message.But wait, where's the flip? Didn't we used to call ByteBuffer.flip() before sending a message in NIO? ChannelBuffer does not have such a method because it has two pointers; one for read operations and the other for write operations. The writer index increases when you write something to a ChannelBuffer while the reader index does not change. The reader index and the writer index represents where the message starts and ends respectively.In contrast, NIO buffer does not provide a clean way to figure out where the message content starts and ends without calling the flip method. You will be in trouble when you forget to flip the buffer because nothing or incorrect data will be sent. Such an error does not happen in Netty because we have different pointer for different operation types. You will find it makes your life much easier as you get used to it -- a life without flipping out!Another point to note is that the write method returns a ChannelFuture. A ChannelFuture represents an I/O operation which has not yet occurred. It means, any requested operation might not have been performed yet because all operations are asynchronous in Netty. For example, the following code might close the connection even before a message is sent:Therefore, you need to call the close method after the ChannelFuture, which was returned by the write method, notifies you when the write operation has been done. Please note that, close might not close the connection immediately, and it returns a ChannelFuture.How do we get notified when the write request is finished then? This is as simple as addinga ChannelFutureListener to the returned ChannelFuture. Here, we created a newanonymous ChannelFutureListener which closes the Channel when the operation is done.Alternatively, you could simplify the code using a pre-defined listener:1.6. Writing a Time ClientUnlike DISCARD and ECHO servers, we need a client for the TIME protocol because a human cannot translate a 32-bit binary data into a date on a calendar. In this section, we discuss how to make sure the server works correctly and learn how to write a client with Netty.The biggest and only difference between a server and a client in Netty is that different Bootstrap and ChannelFactory are required. Please take a look at the following code:NioClientSocketChannelFactory, instead of NioServerSocketChannelFactory was used to create a client-side Channel.Dealing with a Stream-based TransportClientBootstrap is a client-side counterpart of ServerBootstrap.Please note that there's no "child." prefix. A client-side SocketChannel does not have a parent.We should call the connect method instead of the bind method.As you can see, it is not really different from the server side startup. What about the ChannelHandler implementation? It should receive a 32-bit integer from the server, translate it into a human readable format, print the translated time, and close the connection:It looks very simple and does not look any different from the server side example. However, this handler sometimes will refuse to work raising an IndexOutOfBoundsException. We discuss why this happens in the next section.1.7. Dealing with a Stream-based Transport1.7.1. One Small Caveat of Socket BufferIn a stream-based transport such as TCP/IP, received data is stored into a socket receive buffer. Unfortunately, the buffer of a stream-based transport is not a queue of packets but a queue of bytes. It means, even if you sent two messages as two independent packets, an operating system will not treat them as two messages but as just a bunch of bytes. Therefore, there is no guarantee that what you read is exactly what your remote peer wrote. For example, let us assume that the TCP/IP stack of an operating system has received three packets:Because of this general property of a stream-based protocol, there's high chance of reading them in the following fragmented form in your application:Therefore, a receiving part, regardless it is server-side or client-side, should defrag the received data into one or more meaningful frames that could be easily understood by the application logic. In case of the example above, the received data should be framed like the following:1.7.2. The First SolutionNow let us get back to the TIME client example. We have the same problem here. A 32-bit integer is a very small amount of data, and it is not likely to be fragmented often. However, the problem is that it can be fragmented, and the possibility of fragmentation will increase as the traffic increases.The simplistic solution is to create an internal cumulative buffer and wait until all 4 bytes are received into the internal buffer. The following is the modified TimeClientHandler implementation that fixes the problem:This time, "one"was used as the value of the ChannelPipelineCoverage annotation.It's because the new TimeClientHandler has to maintain the internal buffer and therefore cannot serve multiple Channel s. If an instance of TimeClientHandler is shared by multiple Channel s (and consequently multiple ChannelPipeline s), the content of the buf will be corrupted.A dynamic buffer is a ChannelBuffer which increases its capacity on demand. It's very usefulwhen you don't know the length of the message.First, all received data should be cumulated into buf.And then, the handler must check if buf has enough data, 4 bytes in this example, and proceed to the actual business logic. Otherwise, Netty will call the messageReceived method again when more data arrives, and eventually all 4 bytes will be cumulated.There's another place that needs a fix. Do you remember that we added a TimeClientHandler instance to the default ChannelPipeline of the ClientBootstrap? It means one same TimeClientHandler instance is going to handle multiple Channel s and consequently the data will be corrupted. To create a new TimeClientHandler instance per Channel, we have to implement a ChannelPipelineFactory:Now let us replace the following lines of TimeClient:with the following:It might look somewhat complicated at the first glance, and it is true that we don't need to introduce TimeClientPipelineFactory in this particular case because TimeClient creates only one connection.However, as your application gets more and more complex, you will almost always end up with writing a ChannelPipelineFactory, which yields much more flexibility to the pipeline configuration.1.7.3. The Second SolutionAlthough the first solution has resolved the problem with the TIME client, the modified handler does not look that clean. Imagine a more complicated protocol which is composed of multiple fields such as a variable length field. Your ChannelHandler implementation will become unmaintainable very quickly.As you may have noticed, you can add more than one ChannelHandler to a ChannelPipeline, and therefore, you can split one monolithic ChannelHandler into multiple modular ones to reduce the complexity of your application. For example, you could split TimeClientHandler into two handlers:•TimeDecoder which deals with the fragmentation issue, and•the initial simple version of TimeClientHandler.Fortunately, Netty provides an extensible class which helps you write the first one out of the box:There's no ChannelPipelineCoverage annotation this time because FrameDecoder is already annotated with "one".FrameDecoder calls decode method with an internally maintained cumulative buffer whenever new data is received.If null is returned, it means there's not enough data yet. FrameDecoder will call again when there is a sufficient amount of data.If non-null is returned, it means the decode method has decoded a message successfully.FrameDecoder will discard the read part of its internal cumulative buffer. Please remember that you don't need to decode multiple messages. FrameDecoder will keep calling the decoder method until it returns null.If you are an adventurous person, you might want to try the ReplayingDecoder which simplifies the decoder even more. You will need to consult the API reference for more information though.Additionally, Netty provides out-of-the-box decoders which enables you to implement most protocols very easily and helps you avoid from ending up with a monolithic unmaintainable handler implementation. Please refer to the following packages for more detailed examples:•ty.example.factorial for a binary protocol, and•ty.example.telnet for a text line-based protocol.1.8. Speaking in POJO instead of ChannelBufferAll the examples we have reviewed so far used a ChannelBuffer as a primary data structure of a protocol message. In this section, we will improve the TIME protocol client and server example to use a POJO instead of a ChannelBuffer.The advantage of using a POJO in your ChannelHandler is obvious; your handler becomes more maintainable and reusable by separating the code which extracts information from ChannelBuffer out from the handler. In the TIME client and server examples, we read only one 32-bit integer and it is not a major issue to use ChannelBuffer directly. However, you will find it is necessary to make the separation as you implement a real world protocol.First, let us define a new type called UnixTime.We can now revise the TimeDecoder to return a UnixTime instead of a ChannelBuffer.FrameDecoder and ReplayingDecoder allow you to return an object of any type. If they were restricted to return only a ChannelBuffer, we would have to insert another ChannelHandler which transforms a ChannelBuffer into a UnixTime.With the updated decoder, the TimeClientHandler does not use ChannelBuffer anymore:Much simpler and elegant, right? The same technique can be applied on the server side. Let us update the TimeServerHandler first this time:Now, the only missing piece is the ChannelHandler which translates a UnixTime back into a ChannelBuffer. It's much simpler than writing a decoder because there's no need to deal with packet fragmentation and assembly when encoding a message.The ChannelPipelineCoverage value of an encoder is usually "all" because this encoder is stateless. Actually, most encoders are stateless.An encoder overrides the writeRequested method to intercept a write request. Please note that the MessageEvent parameter here is the same type which was specified in messageReceived but they are interpreted differently. A ChannelEvent can be either an upstream or downstreamevent depending on the direction where the event flows. For instance, a MessageEvent can be an upstream event when called for messageReceived or a downstream event when called for writeRequested. Please refer to the API reference to learn more about the difference between a upstream event and a downstream event.Once done with transforming a POJO into a ChannelBuffer, you should forward the new buffer to the previous ChannelDownstreamHandler in the ChannelPipeline. Channels provides various helper methods which generates and sends a ChannelEvent. In this example, Channels.write(...)method creates a new MessageEvent and sends it to the previous ChannelDownstreamHandler in the ChannelPipeline.On the other hand, it is a good idea to use static imports for Channels:The last task left is to insert a TimeEncoder into the ChannelPipeline on the server side, and it is left as a trivial exercise.1.9. Shutting Down Your ApplicationIf you ran the TimeClient, you must have noticed that the application doesn't exit but just keep running doing nothing. Looking from the full stack trace, you will also find a couple I/O threads are running. To shut down the I/O threads and let the application exit gracefully, you need to release the resources allocated by ChannelFactory.The shutdown process of a typical network application is composed of the following three steps:1.Close all server sockets if there are any,2.Close all non-server sockets (i.e. client sockets and accepted sockets) if there are any, and3.Release all resources used by ChannelFactory.To apply the three steps above to the TimeClient, TimeClient.main()could shut itself down gracefully by closing the only one client connection and releasing all resources used by ChannelFactory:The connect method of ClientBootstrap returns a ChannelFuture which notifies whena connection attempt succeeds or fails. It also has a reference to the Channel which is associatedwith the connection attempt.Wait for the returned ChannelFuture to determine if the connection attempt was successful or not.If failed, we print the cause of the failure to know why it failed. the getCause()method of ChannelFuture will return the cause of the failure if the connection attempt was neither successful nor cancelled.Now that the connection attempt is over, we need to wait until the connection is closed by waiting for the closeFuture of the Channel. Every Channel has its own closeFuture so that you are notified and can perform a certain action on closure.Even if the connection attempt has failed the closeFuture will be notified because the Channel will be closed automatically when the connection attempt fails.All connections have been closed at this point. The only task left is to release the resources being used by ChannelFactory. It is as simple as calling its releaseExternalResources() method.All resources including the NIO Selector s and thread pools will be shut down and terminated automatically.Shutting down a client was pretty easy, but how about shutting down a server? You need to unbind from the port and close all open accepted connections. To do this, you need a data structure that keeps track of the list of active connections, and it's not a trivial task. Fortunately, there is a solution, ChannelGroup. ChannelGroup is a special extension of Java collections API which represents a set of open Channel s. If a Channel is added to a ChannelGroup and the added Channel is closed, the closed Channel is removed from its ChannelGroup automatically. You can also perform an operation on all Channel s in the same group. For instance, you can close all Channel s in a ChannelGroup when you shut down your server.To keep track of open sockets, you need to modify the TimeServerHandler to add a new open Channel to the global ChannelGroup, TimeServer.allChannels:。

netty应用案例Netty是一个用于快速开发可扩展的网络应用程序的Java框架。

它的设计目标是提供一个高性能、高速度和可靠的网络服务器和客户端框架。

Netty是一个事件驱动的网络编程框架，通过轻量级的、非阻塞的异步网络通信，提供了快速的数据传输和处理。

下面将介绍几个Netty的应用案例。

1.聊天服务器一个常见的使用Netty的案例是构建一个实时聊天服务器。

Netty可以通过NIO的非阻塞方式处理大量的并发连接，使得用户可以实时地发送和接收消息。

使用Netty可以轻松地实现高性能的聊天服务器，支持多种协议和编解码方式。

2.实时数据流处理Netty可以用于构建实时数据流处理应用程序，比如实时数据分析、实时监控等。

Netty提供了高性能的异步网络通信能力，可以快速地传输大量的数据流，并同时支持高并发连接。

这使得Netty成为处理实时数据流的理想框架。

3.代理服务器Netty可以作为代理服务器的核心框架，用于实现HTTP、HTTPS、SOCKS等多种类型的代理服务器。

Netty提供了高性能的异步网络通信，可以有效地处理代理请求，并将其转发到目标服务器。

同时，Netty支持自定义的编解码器，可以对请求进行解析和编码。

4.游戏服务器Netty在构建游戏服务器方面也有广泛的应用。

Netty的非阻塞和事件驱动的设计使得它能够支持高并发连接和实时的消息传输，非常适合用于构建多人在线游戏服务器。

此外，Netty还提供了一些常用的功能，如心跳检测、断线重连等，方便开发者构建稳定可靠的游戏服务器。

5.分布式系统通信Netty可以作为分布式系统中节点之间通信的框架。

在一个分布式系统中，节点之间需要快速地发送和接收消息，以实现数据同步和协调工作。

Netty提供了高性能的网络通信能力，并支持各种通信协议和编解码方式，使得节点之间的通信变得简单和高效。

在以上应用示例中，Netty都发挥了它异步非阻塞的优势，通过事件驱动的方式处理并发连接，提供了高性能的网络通信能力。

netty服务器解析参数Netty服务器是一种基于Java的异步事件驱动的网络应用程序框架，广泛应用于构建高性能、可扩展的网络服务器。

本文将重点介绍Netty服务器如何解析参数。

一、参数解析的重要性在网络应用程序中，参数解析是一项基本而关键的任务。

当客户端发送请求时，其中可能包含各种参数，例如表单数据、请求头、URL参数等。

服务器需要能够准确地解析这些参数，并根据参数的不同进行相应的处理。

参数解析的准确性和效率直接影响着服务器的性能和用户体验。

二、Netty服务器的参数解析Netty服务器提供了丰富的API和工具类，使得参数解析变得简单而高效。

下面将介绍几种常见的参数解析方式。

1. 解析URL参数URL参数通常包含在请求的URL中，格式为key=value的形式，多个参数之间使用&符号分隔。

Netty提供了QueryStringDecoder类来解析URL参数。

通过调用QueryStringDecoder的decode方法，可以将URL参数解析为一个Map对象，便于后续处理。

2. 解析表单数据当客户端以POST方式提交表单数据时，Netty服务器需要能够解析这些数据。

Netty提供了HttpPostRequestDecoder类来解析表单数据。

通过调用HttpPostRequestDecoder的offer方法，可以将请求的内容逐步解析为一个或多个HttpContent对象。

然后，可以通过HttpContent的content方法获取具体的表单数据。

3. 解析请求头请求头包含了客户端的一些元信息，例如User-Agent、Content-Type等。

Netty提供了HttpRequestDecoder类来解析请求头。

通过调用HttpRequestDecoder的decode方法，可以将请求头解析为一个HttpRequest对象，然后可以通过HttpRequest的headers方法获取具体的请求头信息。

Netty技术要点包括以下几点：1. 心跳机制设计：当网络处于空闲状态持续时间达到T（连续周期T没有读写消息）时，客户端主动发送Ping心跳消息给服务端。

如果在下一个周期T到来时客户端没有收到对方发送到Pong心跳应答消息或者读取到服务端发送到其他业务消息，则心跳失败计数器加1。

每当客户端接收到服务的业务消息或者Pong应答消息时，将心跳失败计数器清零，连续N 此没有接收到服务端的Pong消息或者业务消息，则关闭链路，间隔INTERVAL时间后发起重连操作。

服务端网络空闲状态持续时间达到T后，服务端将心跳失败计数器加1，只要接收到客户端发送到Ping消息或者其他业务消息，计数器请零。

服务端连续N次没有接收到客户端的Ping消息或者其他业务消息，则关闭链路，释放自由，等待客户端重连。

2. 重连机制：如果链路中断，等待INTERVAL时间后，由客户端发起重连操作，如果重连失败，间隔周期INTERVAL后再次发起重连，直到连接成功。

重连失败，客户端必须及时释放自身的资源并打印异常堆栈信息，方便后续的问题定位。

3. 重复登录保护：当客户端握手成功之后，在链路处于正常状态下，不允许客户端重复登录，以防止客户端在异常状态下反复重连导致句柄资源被耗尽。

服务端接收到客户端的握手请求消息之后，首先对IP地址进行合法性检验，如果校验成功，在缓存的地址表中查看客户端是否已经登录，如果已经登录，则拒绝重复登录，返回错误码-1，同时关闭TCP链路，并在服务端的日志中打印握手失败的原因。

服务端主动关闭链路时，清空客户端的地址缓存信息。

4. 消息缓存重发：无论客户端还是服务端，当发生链路中断之后，在链路恢复之前，缓存在消息队列中待发送的消息不能丢失，等链路恢复之后，重新发送这些消息，保证链路中断期间消息不丢失。

考虑到内存溢出的风险，消息缓存队列设置上限，当达到上限之后，应该拒绝继续向该队列添加新的消息。

5. 安全性设计：为了保证整个集群环境的安全，内部长连接采用基于IP地址的安全认证机制，服务端对握手请求消息的IP地址进行合法性校验，如果在白名单之内，则校验通过，否则，拒绝对方连接。

Netty获取连接时的参数1. 引言Netty是一个高性能、异步事件驱动的网络编程框架，它提供了简单而强大的API，用于快速开发可扩展的网络应用程序。

在使用Netty构建网络应用程序时，获取连接时的参数是非常重要的一环。

本文将详细介绍Netty获取连接时的参数及其相关知识。

2. 连接参数在Netty中，连接参数是指在客户端与服务器建立连接时需要设置的一些参数。

这些参数包括：2.1 连接超时时间连接超时时间指定了客户端在尝试与服务器建立连接时最长等待时间。

如果超过这个时间仍然无法建立连接，则会抛出ConnectTimeoutException异常。

可以通过以下方式设置连接超时时间：Bootstrap b = new Bootstrap();b.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, timeout);2.2 连接重试次数连接重试次数指定了客户端在尝试与服务器建立连接失败后的重试次数。

可以通过以下方式设置连接重试次数：Bootstrap b = new Bootstrap();b.option(ChannelOption.MAX_CONNECTION_ATTEMPTS, maxAttempts);2.3 TCP_NODELAY选项TCP_NODELAY选项决定了是否启用Nagle算法。

Nagle算法通过延迟发送小数据包来优化网络传输效率，但会增加延迟。

在某些场景下，禁用Nagle算法可以提高网络传输性能。

可以通过以下方式设置TCP_NODELAY选项：Bootstrap b = new Bootstrap();b.option(ChannelOption.TCP_NODELAY, true);2.4 SO_KEEPALIVE选项SO_KEEPALIVE选项决定了是否启用TCP心跳机制。

TCP心跳机制可以检测连接是否存活，并在连接断开时及时关闭资源。

可以通过以下方式设置SO_KEEPALIVE选项：Bootstrap b = new Bootstrap();b.option(ChannelOption.SO_KEEPALIVE, true);2.5 连接缓冲区大小连接缓冲区大小指定了客户端与服务器之间传输数据时的缓冲区大小。

ci4 手册CodeIgniter 4 是一款优秀的开源 PHP 框架，能够极大地提升开发效率。

它提供了灵活的架构、简单的设计和可扩展的框架，使开发者可以更快、更方便地创建高质量的 Web 应用程序。

本篇文章将介绍如何使用官方提供的“CI4 手册”来进行学习和参考。

一、打开 CI4 手册页。

CI4 官网提供了完整的手册页面，包含了框架概述、安装和配置、路由、控制器、模型、数据库、视图、辅助函数、HTTP 请求等各个方面。

在浏览器中输入 https://codeigniter4.github.io/userguide/即可打开。

二、选择具体模块查看。

手册页面以目录树的形式呈现，选择左侧目录中你感兴趣或者需要了解的模块进行查看。

例如，你需要去查看控制器的使用方法，点击左侧的"Controllers"目录节点，右侧页面就会出现控制器的详细介绍。

三、学习和理解文档内容。

文档中提供了丰富的示例和代码片段，帮助我们对每个模块和功能有一个深入的理解和认识。

需要认真阅读文档内容，注重理解概念，熟悉常用方法和属性。

四、实战联系并熟练掌握。

阅读完文档后，我们可以结合实际应用来巩固学习，这样可以让我们更深入地掌握知识点。

不断地实践，加深对框架的理解，提高开发的效率。

总之，CI4 手册是使用 CodeIgniter 4 开发 Web 应用程序的必备参考资料。

在学习和开发过程中，使用官方手册能够快速地解决开发过程中的任何问题，提高开发效率。

通过阅读手册，实践并掌握知识点，能够帮助我们更好地利用 CI4 来开发更好的 Web 应用程序。

目录1初始步骤 (1)1.1加入项目站点 (1)1.2加入项目 (1)1.3获取代码 (2)1.4查找论坛 (2)1.5阅读项目新闻 (2)1.6查找项目资源 (2)2计划和跟踪各项内容 (3)2.1查找变更管理工件 (3)2.1.1显示变更管理工件信息 (4)2.1.2过滤变更管理工件 (4)2.1.3搜索变更管理 (4)2.2创建变更管理工件 (6)2.3通过电子邮件创建变更管理工件 (6)2.4更新变更管理工件 (7)2.5通过电子邮件编辑变更管理工件 (7)2.6编辑多个工件 (7)2.7移动变更管理工件 (8)2.8将变更管理工件与其他项相关联 (8)2.8.1将变更管理工件与文档、任务或论坛关联 (9)2.8.2将变更管理工件与文件发布相关联 (9)2.8.3将变更管理工件和代码提交相关联 (9)2.9将变更管理工件设置为依赖于其他工件 (10)2.10设置工件类型 (10)2.10.1创建变更管理 (11)2.10.2启用或禁用字段 (11)2.10.3设置必填或可选字段 (11)2.10.4创建用户定义字段 (11)2.10.5配置工件类型字段值 (12)2.10.6配置自动分配 (13)2.10.7更改工件类型 (13)2.11创建变更管理工作流 (13)2.12导出变更管理工件 (14)3记录工作 (14)3.1查找和查看文档 (15)3.1.1转到文档 (15)3.1.2搜索文档 (15)3.2创建文档 (16)3.3编辑文档 (16)3.3.1更新文档 (16)3.3.2更改活动文档版本 (17)3.3.3锁定文档 (17)3.3.4解除锁定文档 (17)3.4评审文档 (17)3.4.1开始文档评审 (18)3.4.2阅读评审响应 (18)3.4.3编辑评审详细信息 (19)3.4.4发送提醒邮件 (19)3.4.5关闭文档评审 (19)3.5评审文档 (19)3.6将文档与其他项关联 (20)3.7管理文档 (20)3.7.1复制文档 (20)3.7.2移动文档 (21)3.7.3删除文档 (21)3.8组织文档 (21)3.8.1创建文档文件夹 (22)3.8.2重命名文档文件夹 (22)3.8.3移动文档文件夹 (22)3.8.4新排序文档文件夹 (22)3.8.5删除文档文件夹 (23)4任务管理 (23)4.1创建任务 (23)4.2编辑任务 (24)4.3查找任务 (24)4.3.1过滤任务 (25)4.3.2搜索任务 (25)4.3.3查看分配给您的任务 (25)4.3.4更新任务状态 (26)4.4将任务设置为依赖于其他任务 (26)4.5查看任务依赖关系 (27)4.6将任务与其他项关联 (27)4.7管理任务 (27)4.7.1复制任务 (27)4.7.2移动任务 (28)4.7.3任务报告 (28)4.8组织任务 (29)4.8.1创建任务文件夹 (29)4.8.2重命名任务文件夹 (29)4.8.3对任务文件夹重新排序 (29)4.8.4删除任务文件夹 (30)4.9管理任务工作流 (30)4.9.1任务延误时向项目成员发送告警 (30)4.9.2要求对更改任务进行批准 (31)4.9.3处理更改请求 (31)4.9.4使用颜色指示任务状态 (31)4.9.5评估任务工作量 (32)4.9.6设置默认的任务日历 (32)5管理配置管理 (32)5.1查看代码提交 (32)5.2将代码提交与其他项关联 (33)5.2.1提交时将代码与其他项关联 (33)5.4存储SSH 密钥 (34)6与项目成员交流 (34)6.1讨论论坛和邮件列表 (35)6.1.1创建论坛主题 (35)6.1.2回复论坛消息 (35)6.1.3订阅邮件列表 (35)6.1.4通过电子邮件发布到论坛 (36)6.1.5将论坛消息与其他项关联 (36)6.1.6管理论坛和邮件列表 (36)6.2项目新闻 (38)6.2.1发布新闻项 (38)6.2.2删除新闻项 (38)6.3Wiki (38)6.3.1启动Wiki (38)6.3.2添加Wiki 内容 (39)6.3.3新建Wiki 页面 (39)6.3.4搜索Wiki (39)7发布产品 (40)7.1下载发布版本 (40)7.2创建程序包 (41)7.3创建发布版本 (41)7.4向发布版本中添加文件 (41)7.5更新发布版本中的文件 (42)7.6删除发布版本中的文件 (42)7.7更新发布版本属性 (42)7.8更改程序包名称或说明 (42)7.9将发布版本与其他项关联 (42)7.10删除程序包 (43)7.11删除发布版本 (43)8监控更改 (43)8.1监控项 (44)8.2监控文件夹 (44)8.3监控应用组件 (44)8.4查看受监控的项 (45)8.5查看谁正在监控项 (45)8.6配置全局监控电子邮件频率 (45)8.7配置应用组件监控电子邮件频率 (45)8.8为其他人增加监控项 (46)9参考信息 (46)9.1项目仪表盘 (46)9.1.1概述 (46)9.1.2访问“项目仪表盘” (46)9.1.3内容 (47)9.2我的页面 (47)9.2.1访问“我的页面” (47)9.2.2内容 (47)9.3.1内容 (48)9.4Wiki语法 (48)9.5Wiki 编辑按钮 (49)10关于使用工具的背景知识 (50)10.1什么是工件类型？ (51)10.2可以使用何种类型的变更管理搜索？ (51)10.3在CSFE中有哪些可用的软件配置管理工具？ (51)10.4是否支持合并跟踪？ (51)10.5我如何获得有关我的SourceForge 站点中事件的通知？ (52)10.6我可以将哪些过滤器应用于监控电子邮件？ (52)10.7在CollabNet 中什么是文档？ (53)10.8哪些人员可以对文档进行操作？ (53)10.9什么是任务依赖关系？ (53)10.10什么是发布版本？ (54)10.11搜索CollabNet 用户信息中心的最佳方式是什么？ (54)注：版本有改动或升级，具体功能可能与本套文档不同，应根据安装版本进行设置。

Netty笔记（4）-对Http和WebSocket的⽀持、⼼跳检测机制对HTTP的⽀持服务端代码:向 PipeLine中注册 HttpServerCodec Http协议的编码解码⼀体的Handler 处理Http请求封装Http响应public class TestServer {public static void main(String[] args) throws Exception {EventLoopGroup bossGroup = new NioEventLoopGroup(1);EventLoopGroup workerGroup = new NioEventLoopGroup();try {ServerBootstrap serverBootstrap = new ServerBootstrap();serverBootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).childHandler(new ChannelInitializer<SocketChannel>{@Overrideprotected void initChannel(SocketChannel ch) throws Exception {//向管道加⼊处理器//得到管道ChannelPipeline pipeline = ch.pipeline();//加⼊⼀个netty 提供的httpServerCodec codec =>[coder - decoder]//HttpServerCodec 说明//1. HttpServerCodec 是netty 提供的处理http的编-解码器pipeline.addLast("MyHttpServerCodec",new HttpServerCodec());//2. 增加⼀个⾃定义的handlerpipeline.addLast("MyTestHttpServerHandler", new TestHttpServerHandler());System.out.println("ok~~~~");}});ChannelFuture channelFuture = serverBootstrap.bind(6668).sync();channelFuture.channel().closeFuture().sync();}finally {bossGroup.shutdownGracefully();workerGroup.shutdownGracefully();}}}⾃定义Handler:过滤浏览器请求 favicon.ico 的请求并回送信息public class TestHttpServerHandler extends SimpleChannelInboundHandler<HttpObject> {//channelRead0 读取客户端数据@Overrideprotected void channelRead0(ChannelHandlerContext ctx, HttpObject msg) throws Exception {System.out.println("对应的channel=" + ctx.channel() + " pipeline=" + ctx.pipeline() + " 通过pipeline获取channel" + ctx.pipeline().channel());System.out.println("当前ctx的handler=" + ctx.handler());//判断 msg 是不是 httprequest请求if(msg instanceof HttpRequest) {System.out.println("msg 类型=" + msg.getClass());System.out.println("客户端地址" + ctx.channel().remoteAddress());//获取到HttpRequest httpRequest = (HttpRequest) msg;//获取uri, 过滤指定的资源URI uri = new URI(httpRequest.uri());if("/favicon.ico".equals(uri.getPath())) {System.out.println("请求了 favicon.ico, 不做响应");return;}//回复信息给浏览器 [http协议]ByteBuf content = Unpooled.copiedBuffer("hello, 我是服务器", CharsetUtil.UTF_8);//构造⼀个http的相应，即 httpresponseFullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, content);response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain");response.headers().set(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes());//将构建好 response返回ctx.writeAndFlush(response);}}}浏览器地址栏输⼊连接服务端并收到服务端信息对WebSocket 的⽀持服务端代码:添加将Http协议升级为 webSocket协议的拦截器 WebSocketServerProtocolHandler 并指定路径public class MyServer {public static void main(String[] args) throws Exception{//创建两个线程组EventLoopGroup bossGroup = new NioEventLoopGroup(1);EventLoopGroup workerGroup = new NioEventLoopGroup(); //8个NioEventLooptry {ServerBootstrap serverBootstrap = new ServerBootstrap();serverBootstrap.group(bossGroup, workerGroup);serverBootstrap.channel(NioServerSocketChannel.class);serverBootstrap.handler(new LoggingHandler());serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {@Overrideprotected void initChannel(SocketChannel ch) throws Exception {ChannelPipeline pipeline = ch.pipeline();//因为基于http协议，使⽤http的编码和解码器pipeline.addLast(new HttpServerCodec());//是以块⽅式写，添加ChunkedWriteHandler处理器pipeline.addLast(new ChunkedWriteHandler());/*说明1. http数据在传输过程中是分段, HttpObjectAggregator ，就是可以将多个段聚合2. 这就就是为什么，当浏览器发送⼤量数据时，就会发出多次http请求*/pipeline.addLast(new HttpObjectAggregator(8192));/*说明1. 对应websocket ，它的数据是以帧(frame) 形式传递2. 可以看到WebSocketFrame 下⾯有六个⼦类3. 浏览器请求时 ws://localhost:7000/hello 表⽰请求的uri4. WebSocketServerProtocolHandler 核⼼功能是将 http协议升级为 ws协议 , 保持长连接*/pipeline.addLast(new WebSocketServerProtocolHandler("/hello"));//⾃定义的handler ，处理业务逻辑pipeline.addLast(new MyTextWebSocketFrameHandler());}});//启动服务器ChannelFuture channelFuture = serverBootstrap.bind(7000).sync();channelFuture.channel().closeFuture().sync();}finally {bossGroup.shutdownGracefully();workerGroup.shutdownGracefully();}}}服务端Handler:websocket 协议中传输数据为数据帧 (TextWebSocketFrame)//这⾥ TextWebSocketFrame 类型，表⽰⼀个⽂本帧(frame)public class MyTextWebSocketFrameHandler extends SimpleChannelInboundHandler<TextWebSocketFrame>{@Overrideprotected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception {System.out.println("服务器收到消息 " + msg.text());//回复消息ctx.channel().writeAndFlush(new TextWebSocketFrame("服务器时间" + LocalDateTime.now() + " " + msg.text())); }//当web客户端连接后，触发⽅法@Overridepublic void handlerAdded(ChannelHandlerContext ctx) throws Exception {//id 表⽰唯⼀的值，LongText 是唯⼀的 ShortText 不是唯⼀System.out.println("handlerAdded 被调⽤" + ctx.channel().id().asLongText());System.out.println("handlerAdded 被调⽤" + ctx.channel().id().asShortText());}@Overridepublic void handlerRemoved(ChannelHandlerContext ctx) throws Exception {System.out.println("handlerRemoved 被调⽤" + ctx.channel().id().asLongText());}@Overridepublic void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {System.out.println("异常发⽣ " + cause.getMessage());ctx.close(); //关闭连接}}前端html:可以给客户端发送信息可以接受客户端信息<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><title>Title</title></head><body><script>var socket;//判断当前浏览器是否⽀持websocketif(window.WebSocket) {socket = new WebSocket("ws://localhost:7000/hello");//相当于channelReado, ev 收到服务器端回送的消息socket.onmessage = function (ev) {var rt = document.getElementById("responseText");rt.value = rt.value + "\n" + ev.data;}//相当于连接开启(感知到连接开启)socket.onopen = function (ev) {var rt = document.getElementById("responseText");rt.value = "连接开启了.."}//相当于连接关闭(感知到连接关闭)socket.onclose = function (ev) {var rt = document.getElementById("responseText");rt.value = rt.value + "\n" + "连接关闭了.."}} else {alert("当前浏览器不⽀持websocket")}//发送消息到服务器function send(message) {if(!window.socket) { //先判断socket是否创建好return;}if(socket.readyState == WebSocket.OPEN) {//通过socket 发送消息socket.send(message)} else {alert("连接没有开启");}}</script><form onsubmit="return false"><textarea name="message" style="height: 300px; width: 300px"></textarea><input type="button" value="发⽣消息" onclick="send(this.form.message.value)"><textarea id="responseText" style="height: 300px; width: 300px"></textarea><input type="button" value="清空内容" onclick="document.getElementById('responseText').value=''"></form></body></html>Netty 的⼼跳检测机制向pipeLine中加⼊⼼跳检测的Handler ,监听读空闲写空闲读写空闲,并设置时间.,如果在设定时间内没有发⽣读写事件, 则会产⽣⼀个相关事件,并传递到下⼀个 Handler 中 (⾃定义处理Handler)服务端代码:⼼跳检测Handler 在监听到相应的事件后会交由注册的下⼀个Handler的userEventTriggered⽅法处理 ,这⾥注册⼀个⾃定义Handlerpublic class MyServer {public static void main(String[] args) throws Exception{//创建两个线程组EventLoopGroup bossGroup = new NioEventLoopGroup(1);EventLoopGroup workerGroup = new NioEventLoopGroup(); //8个NioEventLooptry {ServerBootstrap serverBootstrap = new ServerBootstrap();serverBootstrap.group(bossGroup, workerGroup);serverBootstrap.channel(NioServerSocketChannel.class);serverBootstrap.handler(new LoggingHandler());serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {@Overrideprotected void initChannel(SocketChannel ch) throws Exception {ChannelPipeline pipeline = ch.pipeline();//加⼊⼀个netty 提供 IdleStateHandler/*说明1. IdleStateHandler 是netty 提供的处理空闲状态的处理器2. long readerIdleTime : 表⽰多长时间没有读, 就会发送⼀个⼼跳检测包检测是否连接3. long writerIdleTime : 表⽰多长时间没有写, 就会发送⼀个⼼跳检测包检测是否连接4. long allIdleTime : 表⽰多长时间没有读写, 就会发送⼀个⼼跳检测包检测是否连接* 5. 当 IdleStateEvent 触发后 , 就会传递给管道的下⼀个handler去处理* 通过调⽤(触发)下⼀个handler 的 userEventTiggered , 在该⽅法中去处理 IdleStateEvent(读空闲，写空闲，读写空闲) */pipeline.addLast(new IdleStateHandler(7000,7000,10, TimeUnit.SECONDS));//加⼊⼀个对空闲检测进⼀步处理的handler(⾃定义)pipeline.addLast(new MyServerHandler());}});//启动服务器ChannelFuture channelFuture = serverBootstrap.bind(7000).sync();channelFuture.channel().closeFuture().sync();}finally {bossGroup.shutdownGracefully();workerGroup.shutdownGracefully();}}}处理事件的Handler (userEventTriggered⽅法中处理) :public class MyServerHandler extends ChannelInboundHandlerAdapter {/**** @param ctx 上下⽂* @param evt 事件* @throws Exception*/@Overridepublic void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {if(evt instanceof IdleStateEvent) {//将 evt 向下转型 IdleStateEventIdleStateEvent event = (IdleStateEvent) evt;String eventType = null;switch (event.state()) {case READER_IDLE:eventType = "读空闲";break;case WRITER_IDLE:eventType = "写空闲";break;case ALL_IDLE:eventType = "读写空闲";break;}System.out.println(ctx.channel().remoteAddress() + "--超时时间--" + eventType);System.out.println("服务器做相应处理..");//如果发⽣空闲，我们关闭通道// ctx.channel().close();}}}。

Netty⼊门使⽤教程原创：转载需注明原创地址本⽂介绍Netty的使⽤, 结合我本⼈的⼀些理解和操作来快速的让初学者⼊门Netty, 理论知识会有, 但是不会太深⼊, 够⽤即可, 仅供⼊门! 需要想详细的知识可以移步Netty官⽹查看官⽅⽂档!理论知识 : Netty提供异步的、事件驱动的⽹络应⽤程序框架和⼯具，⽤以快速开发⾼性能、⾼可靠性的⽹络服务器和客户端程序当然, 我们这⾥主要是⽤Netty来发送消息, 接收消息, 测试⼀下demo, 更厉害的功能后⾯再慢慢发掘, 我们先看看这玩意怎么玩, 后⾯再深⼊需要⼯具和Java类: netty-4.1.43 netty服务器类 SayHelloServer.java netty服务端处理器类 SayHelloServerHandler.java netty客户端类 SayHelloClient.java netty客户端处理器类 SayHelloClientHandler.java 服务器main⽅法测试类 MainNettyServer.java 客户端main⽅法测试类 MainNettyClient.java⾸先先来⼀张演⽰图, 最下⾯也会放:我们看完以下部分就能实现这个东西了!话不多说, 先贴代码:package netty.server;import ty.bootstrap.ServerBootstrap;import ty.channel.ChannelFuture;import ty.channel.ChannelInitializer;import ty.channel.ChannelOption;import ty.channel.EventLoopGroup;import ty.channel.nio.NioEventLoopGroup;import ty.channel.socket.SocketChannel;import ty.channel.socket.nio.NioServerSocketChannel;import netty.handler.SayHelloServerHandler;/*** sayhello 服务器*/public class SayHelloServer {/*** 端⼝*/private int port ;public SayHelloServer(int port){this.port = port;}public void run() throws Exception{/*** Netty 负责装领导的事件处理线程池*/EventLoopGroup leader = new NioEventLoopGroup();/*** Netty 负责装码农的事件处理线程池*/EventLoopGroup coder = new NioEventLoopGroup();try {/*** 服务端启动引导器*/ServerBootstrap server = new ServerBootstrap();server.group(leader, coder)//把事件处理线程池添加进启动引导器.channel(NioServerSocketChannel.class)//设置通道的建⽴⽅式,这⾥采⽤Nio的通道⽅式来建⽴请求连接.childHandler(new ChannelInitializer<SocketChannel>() {//构造⼀个由通道处理器构成的通道管道流⽔线@Overrideprotected void initChannel(SocketChannel socketChannel) throws Exception {/*** 此处添加服务端的通道处理器*/socketChannel.pipeline().addLast(new SayHelloServerHandler());}})/*** ⽤来配置⼀些channel的参数，配置的参数会被ChannelConfig使⽤* BACKLOG⽤于构造服务端套接字ServerSocket对象，* 标识当服务器请求处理线程全满时，* ⽤于临时存放已完成三次握⼿的请求的队列的最⼤长度。

Netty学习（⼆）使⽤及执⾏流程Netty简单使⽤1.本⽂先介绍⼀下 server 的 demo2.(重点是这个)根据代码跟踪⼀下 Netty 的⼀些执⾏流程和事件传递的 pipeline.⾸先到官⽹看⼀下Netty Server 和 Client的demo, https://netty.io/wiki/user-guide-for-4.x.html,我⽤的是4.1.xx,⼀般来说不是⼤版本变更, 变化不会很⼤.下⾯是 Netty Server 的demo,跟官⽹的是⼀样的.// 下⾯是⼀个接收线程, 3个worker线程// ⽤ Netty 的默认线程⼯⼚,可以不传这个参数private final static ThreadFactory threadFactory = new DefaultThreadFactory("Netty学习之路");// Boss 线程池,⽤于接收客户端连接private final static NioEventLoopGroup boss = new NioEventLoopGroup(1,threadFactory);// Worker线程池,⽤于处理客户端操作private final static NioEventLoopGroup worker = new NioEventLoopGroup(3,threadFactory);/** 下⾯是在构造⽅法中, 如果不传线程数量,默认是0, super 到 MultithreadEventLoopGroup 这⾥后, 最终会⽤ CPU核数*2 作为线程数量, Reactor多线程模式的话,就指定 boss 线程数量=1 * private static final int DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt("ty.eventLoopThreads", NettyRuntime.availableProcessors() * 2));* protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) {* super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args);* }*/public static void main(String[] args) throws Exception{try {new NettyServer(8888).start();}catch(Exception e){System.out.println("netty server启动失败");e.printStackTrace();}}static class NettyServer{private int port;NettyServer(int port){this.port = port;}void start()throws Exception{try {ServerBootstrap serverBootstrap = new ServerBootstrap();ChannelFuture future = serverBootstrap.group(boss, worker).channel(NioServerSocketChannel.class)// 客户端连接等待队列⼤⼩.option(ChannelOption.SO_BACKLOG, 1024)// 接收缓冲区.option(ChannelOption.SO_RCVBUF, 32*1024)// 连接超时.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 10*1000).childHandler(new ChildChannelHandle()).bind(this.port).sync();future.channel().closeFuture().sync();}catch(Exception e){throw e;}finally {boss.shutdownGracefully();worker.shutdownGracefully();}}}static class ChildChannelHandle extends ChannelInitializer<SocketChannel> {@Overrideprotected void initChannel(SocketChannel socketChannel) throws Exception {ChannelPipeline pipeline = socketChannel.pipeline();// 字符串编码pipeline.addLast(new StringEncoder());// 字符串解码pipeline.addLast(new StringDecoder());// ⾃定义的handle, 状态变化后进⾏处理的 handlepipeline.addLast(new StatusHandle());// ⾃定义的handle, 现在是对读取到的消息进⾏处理pipeline.addLast(new CustomHandle());}}客户端的操作就简单的使⽤终端来操作了这⾥对 inactive 和 active 进⾏了状态的输出, 输出接收数据并且原样返回给客户端接下来看⼀下代码CustomHandle这⾥对接收到的客户端的数据进⾏处理public class CustomHandle extends ChannelInboundHandlerAdapter {private Thread thread = Thread.currentThread();@Overridepublic void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {System.out.println(thread.getName()+": channelRead content : "+msg);ctx.writeAndFlush(msg);}}StatusHandle对状态变化后进⾏处理的Handle(客户端上下线事件) ### public class StatusHandle extends ChannelInboundHandlerAdapter { private Thread thread = Thread.currentThread(); private String ip;@Overridepublic void channelActive(ChannelHandlerContext ctx) throws Exception {this.ip = ctx.channel().remoteAddress().toString();System.out.println(thread.getName()+": ["+this.ip+"] channelActive -------");}@Overridepublic void channelInactive(ChannelHandlerContext ctx) throws Exception {System.out.println(thread.getName()+": ["+this.ip+"] channelInactive -------");}}上⾯标记了两个地⽅, 从这两个地⽅可以窥探到 Netty 的执⾏流程到底是怎么样的*NioServerSocketChannel 作⽤相当于NIO ServerSocketChannel*ChildChannelHandle extends ChannelInitializer , 实现 initChannel ⽅法, 这⾥主要是引申出来的事件传输通道pipeline1.NioServerSocketChannel这个类是 Netty ⽤于服务端的类,⽤于接收客户端连接等. ⽤过NIO的同学都知道, serverSocket开启的时候,需要注册 ACCEPT 事件来监听客户端的连接(⼩插曲)下⾯是Java NIO 的事件(netty基于NIO,⾃然也会有跟NIO⼀样的事件)public static final int OP_READ = 1 << 0; // 读消息事件public static final int OP_WRITE = 1 << 2; // 写消息事件public static final int OP_CONNECT = 1 << 3; // 连接就绪事件public static final int OP_ACCEPT = 1 << 4; // 新连接事件先看⼀下 NioServerSocketChannel 的继承类图从上⾯的demo的 channel(NioServerSocketChannel.class) 开始说起吧,可以看到是⼯⼚⽣成channel. public B channel(Class<? extends C> channelClass) {if (channelClass == null) {throw new NullPointerException("channelClass");} else {return this.channelFactory((ty.channel.ChannelFactory)(new ReflectiveChannelFactory(channelClass)));}}⼯⼚⽅法⽣成 NioServerSocketChannel 的时候调⽤的构造⽅法:public NioServerSocketChannel(ServerSocketChannel channel) {super(null, channel, SelectionKey.OP_ACCEPT);config = new NioServerSocketChannelConfig(this, javaChannel().socket());}继续往下跟,跟到 AbstractNioChannel 的构造⽅法:protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {super(parent);this.ch = ch;// 记住这个地⽅记录了 readInterestOpthis.readInterestOp = readInterestOp;try {// 设置为⾮阻塞ch.configureBlocking(false);} catch (IOException e) {try {ch.close();} catch (IOException e2) {if (logger.isWarnEnabled()) {logger.warn("Failed to close a partially initialized socket.", e2);}}throw new ChannelException("Failed to enter non-blocking mode.", e);}}回到 ServerBootstrap 的链式调⽤, 接下来看 bind(port) ⽅法,⼀路追踪下去,会看到private ChannelFuture doBind(final SocketAddress localAddress) {// 初始化和注册final ChannelFuture regFuture = initAndRegister();final Channel channel = regFuture.channel();if (regFuture.cause() != null) {return regFuture;}if (regFuture.isDone()) {ChannelPromise promise = channel.newPromise();doBind0(regFuture, channel, localAddress, promise);return promise;} else {final PendingRegistrationPromise promise = new PendingRegistrationPromise(channel);regFuture.addListener(new ChannelFutureListener() {@Overridepublic void operationComplete(ChannelFuture future) throws Exception {Throwable cause = future.cause();if (cause != null) {promise.setFailure(cause);} else {promise.registered();doBind0(regFuture, channel, localAddress, promise);}}});return promise;}}看 initAndRegister ⽅法final ChannelFuture initAndRegister() {Channel channel = null;try {channel = channelFactory.newChannel();init(channel);} catch (Throwable t) {if (channel != null) {channel.unsafe().closeForcibly();return new DefaultChannelPromise(channel, GlobalEventExecutor.INSTANCE).setFailure(t);}return new DefaultChannelPromise(new FailedChannel(), GlobalEventExecutor.INSTANCE).setFailure(t);}// 看到这⾥的注册, 继续往下看ChannelFuture regFuture = config().group().register(channel);if (regFuture.cause() != null) {if (channel.isRegistered()) {channel.close();} else {channel.unsafe().closeForcibly();}}return regFuture;}config().group().register(channel); 往下看, 追踪到 AbstractChannel 的 register --> regist0(promise) (由于调⽤太多,省去了中间的⼀些调⽤代码) private void register0(ChannelPromise promise) {try {// check if the channel is still open as it could be closed in the mean time when the register// call was outside of the eventLoopif (!promise.setUncancellable() || !ensureOpen(promise)) {return;}boolean firstRegistration = neverRegistered;// 执⾏注册doRegister();neverRegistered = false;registered = true;// Ensure we call handlerAdded(...) before we actually notify the promise. This is needed as the// user may already fire events through the pipeline in the ChannelFutureListener.// 这⾥官⽅也说得很清楚了,确保我们在使⽤ promise 的通知之前真正的调⽤了 pipeline 中的 handleAdded ⽅法pipeline.invokeHandlerAddedIfNeeded();safeSetSuccess(promise);// 先调⽤ regist ⽅法pipeline.fireChannelRegistered();// Only fire a channelActive if the channel has never been registered. This prevents firing// multiple channel actives if the channel is deregistered and re-registered.// 只有 channel 之前没有注册过才会调⽤ channelActive// 这⾥防⽌ channel deregistered(注销) 和 re-registered(重复调⽤ regist) 的时候多次调⽤ channelActiveif (isActive()) {if (firstRegistration) {// 执⾏ channelActive ⽅法pipeline.fireChannelActive();} else if (config().isAutoRead()) {// This channel was registered before and autoRead() is set. This means we need to begin read// again so that we process inbound data.//// channel 已经注册过并且已经设置 autoRead().这意味着我们需要开始再次读取和处理 inbound 的数据// See https:///netty/netty/issues/4805beginRead();}}} catch (Throwable t) {// Close the channel directly to avoid FD leak.closeForcibly();closeFuture.setClosed();safeSetFailure(promise, t);}}看到 doRegister() ⽅法,继续跟下去, 跟踪到 AbstractNioChannel 的 doRegister() ⽅法protected void doRegister() throws Exception {boolean selected = false;for (;;) {try {// 这⾥调⽤java的 NIO 注册selectionKey = javaChannel().register(eventLoop().unwrappedSelector(), 0, this);return;} catch (CancelledKeyException e) {if (!selected) {eventLoop().selectNow();selected = true;} else {throw e;}}}}写过NIO的同学应该熟悉上⾯的这句话:selectionKey = javaChannel().register(eventLoop().unwrappedSelector(), 0, this);这⾥就是调⽤了java NIO的注册, ⾄于为什么注册的时候ops = 0, 继续追踪下去,此处省略⼀堆调⽤....(实在是过于繁杂)最后发现, 最终都会调⽤AbstractNioChannel 的 doBeginRead() ⽅法修改 selectionKey 的interestOps ,客户端连接后,注册的读事件在这⾥也是相同的操作.protected void doBeginRead() throws Exception {// Channel.read() or ChannelHandlerContext.read() was calledfinal SelectionKey selectionKey = this.selectionKey;if (!selectionKey.isValid()) {return;}readPending = true;final int interestOps = selectionKey.interestOps();// // 这⾥是判断有没有注册过相同的事件,没有的话才修改 opsif ((interestOps & readInterestOp) == 0) {// 就是这⾥, 记得刚才注册的时候,ops == 0 吗, this.readInterestOp 在上⾯的初始化的时候赋了值// 与 0 逻辑或, 所以最终值就是 this.readInterestOp , 注册事件的数值不清楚的话可以看⼀下最上⾯selectionKey.interestOps(interestOps | readInterestOp);}}上⾯介绍的服务端 ACCEPT 最后调⽤的 NIO 的 register ⽅法, read 也是调⽤ nio 的 register, 但是在SocketChannel(client) 调⽤ register 之前, 服务端是有⼀个 server.accept() ⽅法获取客户端连接, 以此为契机, 最后我们在 NioServerSocketChannel ⾥⾯找到了accept ⽅法.// 1protected int doReadMessages(List<Object> buf) throws Exception {// accept 客户端, 传⼊ serverSocketChannelSocketChannel ch = SocketUtils.accept(javaChannel());try {if (ch != null) {// 创建新的 Netty 的 Channel , 并设置 ops =1 (read). 这是在调⽤ doBeginRead的时候修改的 ops 的值 , 跟 server 的⼀样buf.add(new NioSocketChannel(this, ch));return 1;}} catch (Throwable t) {logger.warn("Failed to create a new channel from an accepted socket.", t);try {ch.close();} catch (Throwable t2) {logger.warn("Failed to close a socket.", t2);}}return 0;}// 2public static SocketChannel accept(final ServerSocketChannel serverSocketChannel) throws IOException {try {return AccessController.doPrivileged(new PrivilegedExceptionAction<SocketChannel>() {@Overridepublic SocketChannel run() throws IOException {// nio 的⽅法return serverSocketChannel.accept();}});} catch (PrivilegedActionException e) {throw (IOException) e.getCause();}}客户端连接的时候,会触发上⾯的 server.accept(), 然后会触发 AbstractChannel 的 register ⽅法从⽽调⽤下⾯2个⽅法AbstractChannel.this.pipeline.fireChannelRegistered();// 这个⽅法会调⽤下⾯的两个⽅法static void invokeChannelRegistered(final AbstractChannelHandlerContext next) {EventExecutor executor = next.executor();if (executor.inEventLoop()) {next.invokeChannelRegistered();} else {executor.execute(new Runnable() {@Overridepublic void run() {next.invokeChannelRegistered();}});}}private void invokeChannelRegistered() {if (invokeHandler()) {try {((ChannelInboundHandler) handler()).channelRegistered(this);} catch (Throwable t) {notifyHandlerException(t);}} else {fireChannelRegistered();}}接下来我们开始讲上⾯提到的那个 handlerAdded ⽅法, 这会引申到另⼀个东西 pipeline.2.ChannelInitializer在解析这个类之前, 要先说⼀下 pipeline (管道,传输途径啥的都⾏)它就是⼀条 handle 消息传递链, 客户端的任何消息(事件)都经由它来处理.先看⼀下 AbstractChannelHandlerContext 中的两个⽅法 ###// 查找下⼀个 inboundHandle (从当前位置往后查找 intBound)private AbstractChannelHandlerContext findContextInbound() {AbstractChannelHandlerContext ctx = this;do {ctx = ctx.next; // 往后查找} while (!ctx.inbound);return ctx;}// 查找下⼀个 OutboundHandle (从当前位置往前查找 outBound )private AbstractChannelHandlerContext findContextOutbound() {AbstractChannelHandlerContext ctx = this;do {ctx = ctx.prev; // 往前查找} while (!ctx.outbound);return ctx;}so , inbound 消息传递为从前往后, outbound 的消息传递为从后往前, 所以最先添加的 outbound 将会最后被调⽤###pipeline.addLast(new StringEncoder());// 字符串解码pipeline.addLast(new StringDecoder());// ⾃定义的handle, 状态变化后进⾏处理的 handlepipeline.addLast(new StatusHandle());// ⾃定义的handle, 现在是对读取到的消息进⾏处理pipeline.addLast(new CustomHandle());我们上⾯4个 handle 添加的顺序为 out, in , in, in , 所以最终调⽤的话,会变成下⾯这样再看看 ChannelInitializer 这个类###public abstract class ChannelInitializer<C extends Channel> extends ChannelInboundHandlerAdapter/*** This method will be called once the {@link Channel} was registered. After the method returns this instance* will be removed from the {@link ChannelPipeline} of the {@link Channel}.** @param ch the {@link Channel} which was registered.* @throws Exception is thrown if an error occurs. In that case it will be handled by* {@link #exceptionCaught(ChannelHandlerContext, Throwable)} which will by default close* the {@link Channel}.* 上⾯的意思是说,当 channel(客户端通道)⼀旦被注册,将会调⽤这个⽅法, 并且在⽅法返回的时候, 这个实例(ChannelInitializer)将会被从 ChannelPipeline (客户端的 pipeline) 中移除 */protected abstract void initChannel(C ch) throws Exception;// 第⼀步public void handlerAdded(ChannelHandlerContext ctx) throws Exception {if (ctx.channel().isRegistered()) {initChannel(ctx);}// 除了这个抽象⽅法, 这个类还有⼀个重载⽅法private boolean initChannel(ChannelHandlerContext ctx) throws Exception {if (initMap.putIfAbsent(ctx, Boolean.TRUE) == null) { // Guard against re-entrance.try {// 第⼆步// 这⾥调⽤我们⾃⼰实现的那个抽象⽅法 , 将我们前⾯定义的 handle 都加⼊到 client 的 pipeline 中initChannel((C) ctx.channel());} catch (Throwable cause) {exceptionCaught(ctx, cause);} finally {// 第三步remove(ctx);}return true;}return false;}private void remove(ChannelHandlerContext ctx) {try {ChannelPipeline pipeline = ctx.pipeline();if (pipeline.context(this) != null) {pipeline.remove(this);}} finally {initMap.remove(ctx);}}终于写完了这⼀篇, 这篇的代码有点多, 如果只是demo的话, 不需要花费什么时间, 如果想要深⼊了解⼀下 Netty 的话, 可以从这⾥开始对源码的⼀点点分析.最后这次的内容到这⾥就结束了,最后的最后,⾮常感谢你们能看到这⾥!!你们的阅读都是对作者的⼀次肯定觉得⽂章有帮助的看官顺⼿点个赞再⾛呗(终于暴露了我就是来骗赞的(◒。

Netty4.x中⽂教程系列（七）UDP协议 将近快⼀年时间没有更新Netty的博客。

⼀⽅⾯原因是因为项⽬进度的问题。

另外⼀⽅⾯是博主有⼀段时间去熟悉Unity3D引擎。

本章节主要记录博主⾃⼰Netty的UDP协议使⽤。

1. 构建UDP服务端 ⾸先我们应该清楚UDP协议是⼀种⽆连接状态的协议。

所以Netty框架区别于⼀般的有链接协议服务端启动程序（ServerBootstrap）。

Netty开发基于UDP协议的服务端需要使⽤Bootstrap1package dev.tinyz.game;23import ty.bootstrap.Bootstrap;4import ty.buffer.Unpooled;5import ty.channel.*;6import ty.channel.nio.NioEventLoopGroup;7import ty.channel.socket.DatagramPacket;8import ty.channel.socket.nio.NioDatagramChannel;9import ty.handler.codec.MessageToMessageDecoder;1011import .InetSocketAddress;12import java.nio.charset.Charset;13import java.util.List;1415/**16 * @author TinyZ on 2015/6/8.17*/18public class GameMain {1920public static void main(String[] args) throws InterruptedException {2122final NioEventLoopGroup nioEventLoopGroup = new NioEventLoopGroup();2324 Bootstrap bootstrap = new Bootstrap();25 bootstrap.channel(NioDatagramChannel.class);26 bootstrap.group(nioEventLoopGroup);27 bootstrap.handler(new ChannelInitializer<NioDatagramChannel>() {2829 @Override30public void channelActive(ChannelHandlerContext ctx) throws Exception {31super.channelActive(ctx);32 }3334 @Override35protected void initChannel(NioDatagramChannel ch) throws Exception {36 ChannelPipeline cp = ch.pipeline();37 cp.addLast("framer", new MessageToMessageDecoder<DatagramPacket>() {38 @Override39protected void decode(ChannelHandlerContext ctx, DatagramPacket msg, List<Object> out) throws Exception {40 out.add(msg.content().toString(Charset.forName("UTF-8")));41 }42 }).addLast("handler", new UdpHandler());43 }44 });45// 监听端⼝46 ChannelFuture sync = bootstrap.bind(9009).sync();47 Channel udpChannel = sync.channel();4849// String data = "我是⼤好⼈啊";50// udpChannel.writeAndFlush(new DatagramPacket(Unpooled.copiedBuffer(data.getBytes(Charset.forName("UTF-8"))), new InetSocketAddress("192.168.2.29", 9008))); 5152 Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {53 @Override54public void run() {55 nioEventLoopGroup.shutdownGracefully();56 }57 }));58 }59 }View Code 于Tcp协议的客户端启动程序基本⼀样。