Netty框架介绍（netty 结构）

一 初步了解Netty

Netty是由JBoss公司推出的一个高性能事件驱动型异步非阻塞的IO(NIO)框架。用于建立TCP等底层的连接，基于Netty可以建立高性能的Http服务器。支持HTTP、WebSocket、Protobuf、Binary TCP和UDP。

Netty提供了NIO和BIO(OIO阻塞IO)两种模式处理逻辑，其中NIO主要通过一个BOSS线程处理等待链接的接入，若干个Worker线程(从worder线程池取出一个赋给channel，因为channel持有真正的java网络对象)接过BOSS线程递交过来的Channel进行数据读写并且触发相应的事件传递给pipeline进行数据处理,而BIO(OIO)方式服务器端虽然还是通过一个BOSS线程来处理等待链接的接入，但是客户端还是由主线程直接connect，另外写数据C/S两端都是直接主线程写，而数据读取则是通过一个Worker线程BLOCK方式读取(一直等待，直到读到数据，除非channel关闭)。

总体结构图:(摘自Netty官网)

二 Netty组件

为了更好的理解和进一步深入Netty，我们先总体认识一下Netty中的组件以及在整个框架中如何协调工作的。Netty应用中必不可少的组件:

Bootstrap or ServerBootstrap

EventLoop

EventLoopGroup

ChannelPipeline

Channel

Future or ChannelFuture

ChannelInitializer

ChannelHandler

Bootstrap:一个Netty应用通常由一个Bootstrap开始，它主要作用是配置整个Netty程序，串联起各个组件,ServerBootstrap用于server端，Bootstrap用于client端。

Handler:为了支持各种协议和处理数据的方式,便诞生了Handler组件。Handler主要用来处理各种事件，这里的事件很广泛，比如可以是连接，数据接收，异常，数据转换等。

ChannelInboundHandler：一个最常用的Handler。这个Handler的作用就是处理接收到数据时的事件，也就是说，我们的业务逻辑一般都写在这个Handler里的，ChannelInboundHandler就是用来处理核心业务逻辑的。

ChannelInitializer:当一个链接建立时，我们需要知道怎么来接收或发送数据，当然，我们有各种各样的Handler实现来处理它，那么ChannelInitializer便是用来配置这些Handler，它会提供一个ChannelPipeline并把Handler加入到ChannelPipeline。

ChannelPipeline:一个Netty应用基于ChannelPipeline机制，这种机制需要依赖于EventLoop和EventLoopGroup，因为它们三个都和事件或者事件处理有关。

EventLoop:EventLoop目的是为Channel处理IO操作，一个Channel对应一个EventLop,而一个EventLoop对应一个线程，也就是说，仅有一个线程在负责一个Channel的IO操作。EventLoopGroup会包含多个EventLoop。

Channel:Channel代表了一个Socket链接，或者其它和IO操作相关的组件，它和EventLoop一起用来参与IO处理。

Future:在Netty中所有的IO操作都是异步的，因此，你不能立刻得知消息是否被正确处理，但是我们可以过一会等它执行完成或者直接注册一个监听，具体的实现就是通过Future和ChannelFutures，它们可以注册一个监听，当操作执行成功或失败时监听会自动触发。总之，所有的操作都会返回一个ChannelFuture。

三 Netty处理连接请求和业务逻辑

当一个连接到达，Netty会注册一个channel，然后EventLoopGroup会分配一个EventLoop绑定到这个channel，在这个channel的整个生命周期过程中，都会由绑定的这个EventLoop来为它服务。

四 Netty使用案例

以下例子是使用Netty4.x编写的案例,不详细描述了，直接上代码:

server端:

package com.cn.netty;

import io.netty.bootstrap.ServerBootstrap;

import io.netty.channel.ChannelFuture;

import io.netty.channel.ChannelInitializer;

import io.netty.channel.ChannelOption;

import io.netty.channel.nio.NioEventLoopGroup;

import io.netty.channel.socket.SocketChannel;

import io.netty.channel.socket.nio.NioServerSocketChannel;

import io.netty.handler.codec.LengthFieldBasedFrameDecoder;

import io.netty.handler.codec.LengthFieldPrepender;

import io.netty.handler.codec.string.StringDecoder;

import io.netty.handler.codec.string.StringEncoder;

import java.nio.charset.Charset;

public class MyNettyServer {

public static void main(String[] args) {

new MyNettyServer().serverStart();

}

//用于分配处理业务线程的线程组个数

private static final int PARENTGROUPSIZE = Runtime.getRuntime().availableProcessors();

private static final int CHILDGROUPSIZE = PARENTGROUPSIZE*2;

private static final String HOST = "127.0.0.1";

private static final int PORT = 9999;

NioEventLoopGroup parentGroup;

NioEventLoopGroup childGroup;

/**

*服务端启动方法

*/

public void serverStart(){

try {

final ServerBootstrap server = new ServerBootstrap();

parentGroup = new NioEventLoopGroup(PARENTGROUPSIZE);

childGroup = new NioEventLoopGroup(CHILDGROUPSIZE);

server.group(parentGroup, childGroup);//设置线程组

server.channel(NioServerSocketChannel.class);

server.option(ChannelOption.SO_KEEPALIVE,true);//保持连接

server.option(ChannelOption.SO_BACKLOG,1024);

server.option(ChannelOption.TCP_NODELAY,true);

server.childHandler(new ChannelInitializer<SocketChannel>() {

@Override

protected void initChannel(SocketChannel channel) throws Exception {

channel.pipeline().addLast("frameDecoder",new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4));

channel.pipeline().addLast("frameEncoder",new LengthFieldPrepender(4));

channel.pipeline().addLast("decoder",new StringDecoder(Charset.forName("GBK")));

channel.pipeline().addLast("encoder",new StringEncoder(Charset.forName("GBK")));

channel.pipeline().addLast(new MyServerHandler());

}

});

ChannelFuture future = server.bind(HOST,PORT).sync();

if(future.isSuccess()){

System.out.println("......Netty Server Started......");

}else{

System.out.println("......Netty Server Failed......");

}

future.channel().closeFuture().sync();

} catch (Exception e) {

e.printStackTrace();

}finally{

this.parentGroup.shutdownGracefully();

this.childGroup.shutdownGracefully();

}

}

}

package com.cn.netty;

import io.netty.channel.ChannelHandlerContext;

import io.netty.channel.SimpleChannelInboundHandler;

public class MyServerHandler extends SimpleChannelInboundHandler<String>{

/*

*收到消息时调用

*/

@Override

protected void channelRead0(ChannelHandlerContext context, String msg)throws Exception {

System.out.println("server received msg:"+msg);

context.writeAndFlush(new String("客户端你好"));

}

@Override

public void exceptionCaught(ChannelHandlerContext context, Throwable cause)

throws Exception {

cause.printStackTrace();

context.flush();

context.close();

}

}

Client端:

package com.cn.netty;

import io.netty.bootstrap.Bootstrap;

import io.netty.channel.Channel;

import io.netty.channel.ChannelFuture;

import io.netty.channel.ChannelInitializer;

import io.netty.channel.ChannelOption;

import io.netty.channel.EventLoopGroup;

import io.netty.channel.nio.NioEventLoopGroup;

import io.netty.channel.socket.SocketChannel;

import io.netty.channel.socket.nio.NioSocketChannel;

import io.netty.handler.codec.LengthFieldBasedFrameDecoder;

import io.netty.handler.codec.LengthFieldPrepender;

import io.netty.handler.codec.string.StringDecoder;

import io.netty.handler.codec.string.StringEncoder;

import java.nio.charset.Charset;

public class MyNettyClient {

public static void main(String[] args) {

Channel channel = new MyNettyClient().clientStart();

channel.writeAndFlush(new String("服务器你好"));

}

private static final String HOST = "127.0.0.1";

private static final int PORT = 9999;

public Channel clientStart(){

Channel channel = null;

Bootstrap client = new Bootstrap();

EventLoopGroup group = new NioEventLoopGroup();

try {

client.group(group);

client.channel(NioSocketChannel.class);

client.option(ChannelOption.SO_KEEPALIVE,true);

client.handler(new ChannelInitializer<SocketChannel>() {

@Override

protected void initChannel(SocketChannel channel)throws Exception {

channel.pipeline().addLast("frameDecoder",new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4));

channel.pipeline().addLast("frameEncoder",new LengthFieldPrepender(4));

//编码格式

channel.pipeline().addLast("encoder",new StringEncoder(Charset.forName("GBK")));

//解码格式

channel.pipeline().addLast("decoder",new StringDecoder(Charset.forName("GBK")));

channel.pipeline().addLast(new MyClientHandler());

}

});

ChannelFuture future = client.connect(HOST, PORT).sync();

if(future.isSuccess()){

System.out.println("......netty client started......");

}

channel = future.channel();

} catch (InterruptedException e) {

e.printStackTrace();

}

return channel;

}

}

packagecom.cn.netty;

importio.netty.channel.ChannelHandlerContext;

importio.netty.channel.SimpleChannelInboundHandler;

publicclassMyClientHandlerextendsSimpleChannelInboundHandler<String>{

/*

*收到消息时调用

*/

@Override

protectedvoidchannelRead0(ChannelHandlerContext context, String msg)throwsException {

System.out.println("收到服务器发来的消息:"+msg);

}

/*

*建立连接时调用

*/

@Override

publicvoidchannelActive(ChannelHandlerContext context)throwsException {

super.channelActive(context);

}

}