netty(1)

**Netty入门指南**

Netty是一个高性能、异步I/O网络框架，支持多种协议，如TCP、UDP、HTTP等。它的设计目标是提供一个轻量级、易用的API，让开发者能够快速构建高性能的网络应用。

### Netty的特点* **异步I/O**:Netty使用异步I/O来处理网络请求，这意味着它不会阻塞线程，提高了系统的吞吐率和响应速度。
* **多种协议支持**:Netty支持多种协议，如TCP、UDP、HTTP等，使得开发者能够轻松构建不同类型的网络应用。
* **高性能**:Netty使用NIO（Java NIO）来处理网络请求，这使得它具有很高的性能，能够处理大量的连接和数据传输。

### Netty的基本组成部分* **Channel**:代表一个网络连接，例如TCP连接或UDP连接。
* **Pipeline**:代表一个链条式的处理流程，用于处理网络请求。
* **Handler**:代表一个具体的处理逻辑，用于处理特定的网络请求。

### Netty的基本使用步骤1. **创建一个ServerBootstrap对象**：这是Netty提供的一个启动类，用于配置服务器端的参数，如绑定地址、端口等。
2. **添加ChannelHandler**：将具体的处理逻辑添加到pipeline中，这样当有网络请求时，就会触发对应的处理逻辑。
3. **启动ServerBootstrap**：通过调用`bind()`方法来启动服务器，开始监听客户端的连接。

### Netty示例代码

javaimport io.netty.bootstrap.ServerBootstrap;
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;

public class NettyServer {

 public static void main(String[] args) throws Exception {
 // 创建一个EventLoopGroup对象，用于处理网络请求 EventLoopGroup group = new NioEventLoopGroup();

 try {
 // 创建一个ServerBootstrap对象 ServerBootstrap bootstrap = new ServerBootstrap();
 bootstrap.group(group)
 .channel(io.netty.channel.nio.NioSocketChannel.class)
 .option(ChannelOption.SO_BACKLOG,128)
 .childHandler(new ChannelInitializer() {

 @Override protected void initChannel(SocketChannel ch) throws Exception {
 // 添加一个处理逻辑到pipeline中 ch.pipeline().addLast(new NettyServerHandler());
 }
 });

 // 启动服务器，开始监听客户端的连接 ChannelFuture future = bootstrap.bind(8080).sync();

 System.out.println("Netty Server started, listening on port8080...");

 // 等待服务器关闭 future.channel().closeFuture().sync();
 } finally {
 // 关闭EventLoopGroup对象 group.shutdownGracefully();
 }
 }

}

javaimport io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToMessageEncoder;

public class NettyServerHandler extends MessageToMessageEncoder {

 @Override protected void encode(ChannelHandlerContext ctx, ByteBuf msg, ByteOutBuffer out) throws Exception {
 // 处理网络请求的逻辑 System.out.println("Received message from client: " + msg.toString());

 // 将处理结果写入到out中 out.writeBytes(msg.array());
 }

}

javaimport io.netty.bootstrap.Bootstrap;
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;

public class NettyClient {

 public static void main(String[] args) throws Exception {
 // 创建一个EventLoopGroup对象，用于处理网络请求 EventLoopGroup group = new NioEventLoopGroup();

 try {
 // 创建一个Bootstrap对象 Bootstrap bootstrap = new Bootstrap();
 bootstrap.group(group)
 .channel(io.netty.channel.nio.NioSocketChannel.class)
 .option(ChannelOption.SO_BACKLOG,128)
 .handler(new ChannelInitializer() {

 @Override protected void initChannel(SocketChannel ch) throws Exception {
 // 添加一个处理逻辑到pipeline中 ch.pipeline().addLast(new NettyClientHandler());
 }
 });

 // 连接服务器 ChannelFuture future = bootstrap.connect("localhost",8080).sync();

 System.out.println("Netty Client connected to server, sending message...");

 // 发送消息给服务器 ByteBuf msg = Unpooled.copiedBuffer("Hello, Server!".getBytes());
 future.channel().writeAndFlush(msg);

 // 等待服务器的响应 future.channel().closeFuture().sync();
 } finally {
 // 关闭EventLoopGroup对象 group.shutdownGracefully();
 }
 }

}

javaimport io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToMessageDecoder;

public class NettyClientHandler extends MessageToMessageDecoder {

 @Override protected void decode(ChannelHandlerContext ctx, ByteBuf msg, List