NETTY CHANNEL Interface noun comprehension

1.Channel
The channel is responsible for reading the data, writing the object, a bit similar to the old IO inside the stream, the difference between him and stream, the channel is bidirectional
You can write or read, and the stream is divided into OutStream and InputStream. And in NiO, users should not read and write data directly from the channel,
Instead, the data should be read and written to the channel through buffer, and then by using it.
A channel can be provided to the user below a few messages
(1) Current status of the channel, such as Open or closed
(2) A Channelconfig object that represents some of the channel's parameters, such as buffersize
(3) All I/O operations supported by the channel (e.g. Read,write,connect.bind) and Channelpipeline (explained below)

2.ChannelConfig
Channel parameters, which are stored in the map data structure

3.ChannelEvent
Channelevent A generalized view of the channel-related events, whether he upstream events and downstream events two chunks, which need to be noted here, let is the server for
Principal, the process of data from the client to the server is upstream, while the server-to-client data transfer process is called downstream, and if the client is the principal
, The process from server to client is upstream for the client, and the client-to-server process is downstream for the client.
Upstream events includes:
Messagereceived: When information is accepted---messageevent
exceptioncaught:---exceptionevent when an exception is generated
When Channelopen:channel is turned on---channelstateevent
Channelclosed:channel is turned off---channelstateevent
When the Channelbound:channel is turned on and ready to connect but is not connected---channelstateevent
Channelunbound:channel is not ready to connect when it is opened--- Channelstateevent
Channelconnected:channel is connected---channelstateevent
Channeldisconnected:channel When the connection is disconnected ---channelstateevent
Channelinterestchanged:channel when the interestops is changed------channelstateevent
Writecomplete: Write to--writecompletionevent

when the remote end is complete

Downstream events includes:
Write: When sending messages to the channel--messageevent
Bind: Binds a channel to the specified local address--channelstateevent
Unbind: Unbind the current local port--channelstateevent
Connect: Connecting the Channel to a remote machine--channelstateevent
Disconnect: Disconnect the channel from the remote machine--channelstateevent
Close: Turn off channel--channelstateevent

Note that there is no open event, because when a channel is created by ChannelFactory, the channel is always opened.

There are also two event types where a child channel exists when the parent channel is present
Childchannelopen: Sub channel is opened---channelstateevent
Childchannelclosed: Child channel is closed---channelstateevent

4.ChannelHandler
Channel is the carrier responsible for transmitting the data, then the data must be processed according to the requirements, then this time to use the Channelhandler
Different processes can be used to build different channelhandler and then put into channelpipeline
It is also necessary to have channelevent trigger to reach Channelhandler, so there are two sub interfaces below according to the event Channelupstreamhandler
and Channeldownstreamhandler.
A channelhandler usually needs to store some state information as a judgment message, and a common practice defines a variable
Like what
public class Dataserverhandler extends {@link Simplechannelhandler} {
*
* <b>private Boolean loggedin;</b>
*
* {@code @Override}
* public void messagereceived ({@link Channelhandlercontext} ctx, {@link messageevent} e) {
* {@link Channel} ch = E.getchannel ();
* Object o = e.getmessage ();
* IF (o instanceof loginmessage) {
* Authenticate ((loginmessage) o);
* <b>loggedin = true;</b>
*} else (o instanceof getdatamessage) {
* if (<b>loggedIn</b>) {
* Ch.write (Fetchsecret ((getdatamessage) o));
*} else {
* FAIL ();
*             }
*         }
*     }
*     ...
* }

Create a new handler instance per channel.
*//See {@link bootstrap#setpipelinefactory (channelpipelinefactory)}.
* Public class Dataserverpipelinefactory implements {@link Channelpipelinefactory} {
* Public {@link channelpipeline} getpipeline () {
* Return {@link channels}.pipeline (<b>new dataserverhandler () </b>);
*     }
* }

In addition to this, each channelhandler can get or set data from the Channelhandlercontext, so the following is the way to use Channelhandlercontext
Setting variables
* {@code @Sharable}
* Public class Dataserverhandler extends {@link Simplechannelhandler} {
*
* {@code @Override}
* public void messagereceived ({@link Channelhandlercontext} ctx, {@link messageevent} e) {
* {@link Channel} ch = E.getchannel ();
* Object o = e.getmessage ();
* IF (o instanceof loginmessage) {
* Authenticate ((loginmessage) o);
* <b>ctx.setattachment (TRUE) </b>;
*} else (o instanceof getdatamessage) {
* IF (<b>boolean.true.equals (Ctx.getattachment ()) </b>) {
* Ch.write (Fetchsecret ((getdatamessage) o));
*} else {
* FAIL ();
*             }
*         }
*     }
*     ...
* }

* Public class Dataserverpipelinefactory implements {@link Channelpipelinefactory} {
*
* Private static final Dataserverhandler <b>SHARED</b> = new Dataserverhandler ();
*
* Public {@link channelpipeline} getpipeline () {
* Return {@link channels}.pipeline (<b>SHARED</b>);
*     }
* }
These two practices are still different, the above variable practices, each new handler object, the variable is not shared, and the following channelhandlercontext is shared

If you need to share data between different handler, then what to do, then use channellocal
Example:
Public final class Dataserverstate {
*
* <b>public static final {@link channellocal}&lt; Boolean&gt; LoggedIn = new {@link channellocal}&lt; Boolean&gt; () {
* Protected Boolean InitialValue (channel channel) {
* return false;
*         }
*}</b>
*     ...
* }
*
* {@code @Sharable}
* Public class Dataserverhandler extends {@link Simplechannelhandler} {
*
* {@code @Override}
* public void messagereceived ({@link Channelhandlercontext} ctx, {@link messageevent} e) {
* Channel ch = e.getchannel ();
* Object o = e.getmessage ();
* IF (o instanceof loginmessage) {
* Authenticate ((loginmessage) o);
* <b>dataserverstate.loggedin.set (CH, true);</b>
*} else (o instanceof getdatamessage) {
* IF (<b>dataserverstate.loggedin.get (CH) </b>) {
* Ctx.getchannel (). Write (Fetchsecret ((getdatamessage) o));
*} else {
* FAIL ();
*             }
*         }
*     }
*     ...
* }
*
*//Print The remote addresses of the authenticated clients:
* {@link Channelgroup} allclientchannels = ...;
* for ({@link Channel} ch:allclientchannels) {
* IF (<b>dataserverstate.loggedin.get (CH) </b>) {
* SYSTEM.OUT.PRINTLN (Ch.getremoteaddress ());
*     }
* }
* </pre>

5.ChannelPipeline
Channelpipeline is a collection of Channelhandler, which is implemented by referring to the intercepting filter pattern in Java EE,
Let the user fully grasp if the event is handled in a handler while allowing multiple handler inside the pipeline to interact with each other.
Intercepting filter:http://java.sun.com/blueprints/corej2eepatterns/patterns/interceptingfilter.html
For each channel need to have a corresponding channelpipeline, when the channel set Channelpipeline can no longer be reset for channel
Channelpipeline. Also the recommended practice is to build channelpipeline instead of building channelpipeline by channels this helper class

Often pipeline add multiple handler, which are based on business logic
Like below.
{@link Channelpipeline} p = {@link channels}.pipeline ();
* P.addlast ("1", New Upstreamhandlera ());
* P.addlast ("2", New Upstreamhandlerb ());
* P.addlast ("3", New Downstreamhandlera ());
* P.addlast ("4", New Downstreamhandlerb ());
* P.addlast ("5", New Simplechannelhandler ());
Upstream event execution handler in order should be 125
Downstream event execution handler in order should be 543
Simplechannelhandler is a class that implements both Channelupstreamhandler and Channeldownstreamhandler.
It just has logic, and if the data needs to be encoded in a format, it needs to be written
* {@link Channelpipeline} pipeline = {@link channels#pipeline () Channels.pipeline ()};
* Pipeline.addlast ("decoder", New Myprotocoldecoder ());
* Pipeline.addlast ("encoder", New Myprotocolencoder ());
* Pipeline.addlast ("executor", new {@link Executionhandler} (New {@link Orderedmemoryawarethreadpoolexecutor} (16, 1048576, 1048576)));
* Pipeline.addlast ("handler", New Mybusinesslogichandler ());
which
Protocol Decoder-Convert binary to Java object
Protocol Encoder-Converting Java objects to binary
Executionhandler-applies a thread model.
Business logic handler-performs The actual business logic (e.g. database access)
Although Channelpipeline cannot be reset for the channel, the Channelpipeline itself is thread-safe, so you can add delete Channelhandler at any time for Channelpipeline

It is important to note that the following code does not have the desired effect
* Public class Firsthandler extends {@link Simplechannelupstreamhandler} {
*
* {@code @Override}
* public void messagereceived ({@link Channelhandlercontext} ctx, {@link messageevent} e) {
*//Remove This handler from the pipeline,
* Ctx.getpipeline (). Remove (this);
*//And let SecondHandler handle the current event.
* Ctx.getpipeline (). AddLast ("2nd", New SecondHandler ());
* Ctx.sendupstream (e);
*     }
* }
The premise now pipeline only the last Firsthandler,
It is obvious that you want to remove the Firsthandler from the pipeline and then add the SecondHandler. and pipeline need as long as there is a handler, so if you think of reaching this effect, then you can
Add the SecondHandler first, and then remove the Firsthandler.

6.ChannelFactory
The channel's factory class, which is the class used to generate the channel, ChannelFactory generates the corresponding channel according to the specified communication and network, such as
The channel generated by Nioserversocketchannelfactory is based on the NIO server socket.
When a channel is created, Channelpipeline is attached as a parameter to the channel.
Two-step operation is required for ChannelFactory shutdown
First, close all the factory produced by the channel including the Sub channel. Channelgroup#close () is usually called.
Second, release the ChannelFactory resource, call Releaseexternalresources ()

7.ChannelGroup
A set of channel groups that contains one or more open channel,closed the channel is automatically removed from the group, and a channel can be in one or more channelgroup
If you want to broadcast a message to multiple channel, you can use group to implement
Like what:
{@link Channelgroup} recipients = new {@link Defaultchannelgroup} ()
Recipients.add (Channela);
Recipients.add (CHANNELB);
Recipients.write (Channelbuffers.copiedbuffer ("Service would shut down for maintenance in 5 minutes.", Charsetutil.utf_8) );

When Serverchannel and non-Serverchannel are both in Channelgroup, any IO request operation is performed in the Serverchannel first and then in the other channel.
This rule is very useful for shutting down a server.

8.ChannelFuture
In Netty, all IO transmissions are asynchronous, all of which require a data + state to determine if all the transmissions are successful, and this is channelfuture.

9.ChannelGroupFuture
For the result of a channelgroup asynchronous operation, he, like Channelfuture, includes data and status. The difference was that all the channelfuture he had by the Channelgroup inside the channel
Composition

10.ChannelGroupFutureListener
For channelgroupfuture listeners, it is also recommended to use Channelgroupfuturelistener instead of await ();

11.ChannelFutureListener
Channelfuture Listener, monitoring the results of channelfuture.

12.ChannelFutureProgressListener
Monitor the channelfuture process, such as the transfer of a large file. and Channelfuturelistener only listens channelfuture complete unfinished

13.ChannelHandlerContext
How to get handler and his pipeline and other handler in pipeline to Exchange, then use Channelhandlercontext,
Channelhandler can pass the event to the nearest handler through Channelhandlercontext's Sendxxxstream (channelevent)
Can get pipeline through Channelhandlercontext Getpipeline, and modify him, Channelhandlercontext can also store state information attments.
A Channelhandler instance can have one or more channelhandlercontext

14.ChannelPipelineFactory
Factory class for producing Channelpipe

15.ChannelState
Record channel State constants

NETTY CHANNEL Interface noun comprehension