Netty学习一

1.Reactor模式：主动模式，所谓主动，是指应用程序不断轮询，询问操作系统或者网络框架，IO是否就绪。其中java的NIO就属于这种模式。在这种模式下，实际的IO操作还是应用程序执行的。2.Procator模式：被动模式，应用程序的读写函数操作交给操作系统或者网络框架，实际IO操作由操作系统或者网络框架完成，之后再回调应用程序。微软的asio库就是这种模式。

1.采用轮询的方式：线程不断轮询询问相关事件发生源有没有发生事件，有发生事件就调用事件处理逻辑2.事件驱动方式：发生事件，主线程把事件加入到事件队列，在另外线程不断循环消费事件列表的事件，调用事件对应的处理逻辑事件。事件驱动方式也被称为消息通知方式，其实是设计模式中观察者模式的思路。基于事件驱动的优点：可扩展性好，高性能。

Reactor:Reactor在一个单独的线程运行，负责监听和分发事件，分发给适当的处理程序来对IO事件做出反应。Handlers:处理程序执行I/O事件要完成的实际事件。

1）MainReactor负责客户端的连接请求，并将请求转交给SubReactor2）SubReactor负责相应通道的IO读写请求3）非IO请求（具体业务逻辑处理)的任务则会直接写入队列，等待worker线程进行处理。EventLoopGroupbossGroup=newNioEventLoopGroup();
EvenLoopGroupworkerGroup=newNioEventLoopGroup();
ServerBootstrapserver=newServerBootstrap();
server.group(bossGroup,workerGroup).channel(NioServerSocketChannel.class);

I/O任务：即selectionKey中的ready的事件，如accept、connect、read、write等，由processSelectKeys方法触发。非I/O任务：添加到taskQueue中的任务，如register0、bind0等任务，由runAllTasks方法触发。

/*** Echoes back any received data from a client.* Netty的服务端引导*/publicfinalclassEchoServer {
staticfinalbooleanSSL=System.getProperty("ssl") !=null;
//端口staticfinalintPORT=Integer.parseInt(System.getProperty("port", "8007"));
publicstaticvoidmain(String[] args) throwsException {
// Configure SSL.finalSslContextsslCtx;
if (SSL) {
SelfSignedCertificatessc=newSelfSignedCertificate();
sslCtx=SslContextBuilder.forServer(ssc.certificate(), ssc.privateKey()).build();
        } else {
sslCtx=null;
        }
// Configure the server.boss和worker线程组EventLoopGroupbossGroup=newNioEventLoopGroup(1);
EventLoopGroupworkerGroup=newNioEventLoopGroup();
//创建服务端业务处理器对象，进行业务处理，添加线程组，同时开启通道添加so_backlog//同时添加childHandler，重写initChannel方法finalEchoServerHandlerserverHandler=newEchoServerHandler();
try {
//服务端引导ServerBootstrapb=newServerBootstrap();
b.group(bossGroup, workerGroup)
             .channel(NioServerSocketChannel.class)
             .option(ChannelOption.SO_BACKLOG, 100)
             .handler(newLoggingHandler(LogLevel.INFO))
             .childHandler(newChannelInitializer<SocketChannel>() {
@OverridepublicvoidinitChannel(SocketChannelch) throwsException {
//流水线ChannelPipelinep=ch.pipeline();
if (sslCtx!=null) {
p.addLast(sslCtx.newHandler(ch.alloc()));
                     }
//添加日志信息//p.addLast(new LoggingHandler(LogLevel.INFO));//添加serverHandlerp.addLast(serverHandler);
                 }
             });
// Start the server.//启动服务器ChannelFuturef=b.bind(PORT).sync();
// Wait until the server socket is closed.f.channel().closeFuture().sync();
        } finally {
// Shut down all event loops to terminate all threads.bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
        }
    }
}

/*** Handler implementation for the echo server.* Netty服务端业务处理器,继承ChannelInboundHandlerAdapter，* 同时重写channelRead、ChannelReadComplete、exceptionCaught三个方法*/@SharablepublicclassEchoServerHandlerextendsChannelInboundHandlerAdapter {
@OverridepublicvoidchannelRead(ChannelHandlerContextctx, Objectmsg) {
ctx.write(msg);
    }
@OverridepublicvoidchannelReadComplete(ChannelHandlerContextctx) {
ctx.flush();
    }
@OverridepublicvoidexceptionCaught(ChannelHandlerContextctx, Throwablecause) {
// Close the connection when an exception is raised.cause.printStackTrace();
ctx.close();
    }
}

/*** Sends one message when a connection is open and echoes back any received* data to the server.  Simply put, the echo client initiates the ping-pong* traffic between the echo client and server by sending the first message to* the server.* Netty客户端引导*/publicfinalclassEchoClient {
staticfinalbooleanSSL=System.getProperty("ssl") !=null;
//ip、端口号staticfinalStringHOST=System.getProperty("host", "127.0.0.1");
staticfinalintPORT=Integer.parseInt(System.getProperty("port", "8007"));
staticfinalintSIZE=Integer.parseInt(System.getProperty("size", "256"));
publicstaticvoidmain(String[] args) throwsException {
// Configure SSL.gitfinalSslContextsslCtx;
if (SSL) {
sslCtx=SslContextBuilder.forClient()
                .trustManager(InsecureTrustManagerFactory.INSTANCE).build();
        } else {
sslCtx=null;
        }
// Configure the client.EventLoopGroupgroup=newNioEventLoopGroup();
try {
Bootstrapb=newBootstrap();
b.group(group)
             .channel(NioSocketChannel.class)
             .option(ChannelOption.TCP_NODELAY, true)
             .handler(newChannelInitializer<SocketChannel>() {
@OverridepublicvoidinitChannel(SocketChannelch) throwsException {
ChannelPipelinep=ch.pipeline();
if (sslCtx!=null) {
p.addLast(sslCtx.newHandler(ch.alloc(), HOST, PORT));
                     }
//p.addLast(new LoggingHandler(LogLevel.INFO));p.addLast(newEchoClientHandler());
                 }
             });
// Start the client.ChannelFuturef=b.connect(HOST, PORT).sync();
// Wait until the connection is closed.f.channel().closeFuture().sync();
        } finally {
// Shut down the event loop to terminate all threads.group.shutdownGracefully();
        }
    }
}

/*** Handler implementation for the echo client.  It initiates the ping-pong* traffic between the echo client and server by sending the first message to* the server.* Netty客户端业务处理器，重写四个方法：channelActive、channelRead、channelReadComplete、exceptionCaught*/publicclassEchoClientHandlerextendsChannelInboundHandlerAdapter {
privatefinalByteBuffirstMessage;
/*** Creates a client-side handler.* 创建客户端处理器*/publicEchoClientHandler() {
//使用类似byteBuffer方式创建bufferfirstMessage=Unpooled.buffer(EchoClient.SIZE);
for (inti=0; i<firstMessage.capacity(); i++) {
firstMessage.writeByte((byte) i);
        }
    }
@OverridepublicvoidchannelActive(ChannelHandlerContextctx) {
ctx.writeAndFlush(firstMessage);
    }
@OverridepublicvoidchannelRead(ChannelHandlerContextctx, Objectmsg) {
ctx.write(msg);
    }
@OverridepublicvoidchannelReadComplete(ChannelHandlerContextctx) {
ctx.flush();
    }
@OverridepublicvoidexceptionCaught(ChannelHandlerContextctx, Throwablecause) {
// Close the connection when an exception is raised.cause.printStackTrace();
ctx.close();
    }
}