Java搭建简单Netty开发环境入门教程

<!-- https://mvnrepository测试数据/artifact/io.netty/netty-all -->

     < dependency >

       < groupId >io.netty</ groupId >

       < artifactId >netty-all</ artifactId >

       < version >4.1.16.Final</ version >

     </ dependency >

import io.netty.buffer.ByteBuf;

import io.netty.buffer.Unpooled;

import io.netty.channel.ChannelFutureListener;

import io.netty.channel.ChannelHandler.Sharable;

import io.netty.channel.ChannelHandlerContext;

import io.netty.channel.ChannelInboundHandlerAdapter;

import io.netty.util.CharsetUtil;

@Sharable

public class EchoServerHandler extends ChannelInboundHandlerAdapter{

     @Override

     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {

         //将客户端传入的消息转换为Netty的ByteBuf类型

         ByteBuf in = (ByteBuf) msg;

         // 在控制台打印传入的消息

         System.out.println(

                 "Server received: " + in.toString(CharsetUtil.UTF_8)

         );

         //将接收到的消息写给发送者，而不冲刷出站消息

         ctx.write(in);

     }

     @Override

     public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

         // 将未处决消息冲刷到远程节点， 并且关闭该Channel

         ctx.writeAndFlush(Unpooled.EMPTY_BUFFER)

                 .addListener(ChannelFutureListener.CLOSE);

     }

     /**

      * 异常处理

      * @param ctx

      * @param cause

      * @throws Exception

      */

     @Override

     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {

         //打印异常栈跟踪

         cause.printStackTrace();

         // 关闭该Channel

         ctx.close();

     }

}

import io.netty.bootstrap.ServerBootstrap;

import io.netty.channel.ChannelFuture;

import io.netty.channel.ChannelInitializer;

import io.netty.channel.EventLoopGroup;

import io.netty.channel.nio.NioEventLoopGroup;

import io.netty.channel.socket.SocketChannel;

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

import java.net.InetSocketAddress;

public class EchoServer {

     private final static int port = 8080 ;

     public static void main(String[] args) {

         start();

     }

     private static void start() {

         final EchoServerHandler serverHandler = new EchoServerHandler();

         // 创建EventLoopGroup

         EventLoopGroup bossGroup = new NioEventLoopGroup();

         EventLoopGroup workerGroup = new NioEventLoopGroup();

         // 创建EventLoopGroup

         ServerBootstrap b = new ServerBootstrap();

         b.group(bossGroup, workerGroup)

                 //指定所使用的NIO传输Channel

         .channel(NioServerSocketChannel. class )

                 //使用指定的端口设置套接字地址

         .localAddress( new InetSocketAddress(port))

                 // 添加一个EchoServerHandler到Channle的ChannelPipeline

         .childHandler( new ChannelInitializer<SocketChannel>() {

             @Override

             protected void initChannel(SocketChannel socketChannel) throws Exception {

                 //EchoServerHandler被标注为@shareable,所以我们可以总是使用同样的案例

                 socketChannel.pipeline().addLast(serverHandler);

             }

         });

         try {

             // 异步地绑定服务器;调用sync方法阻塞等待直到绑定完成

             ChannelFuture f = b.bind().sync();

             // 获取Channel的CloseFuture，并且阻塞当前线程直到它完成

             f.channel().closeFuture().sync();

         } catch (InterruptedException e) {

             e.printStackTrace();

         } finally {

             // 优雅的关闭EventLoopGroup，释放所有的资源

             bossGroup.shutdownGracefully();

             workerGroup.shutdownGracefully();

         }

     }

}

import io.netty.buffer.ByteBuf;

import io.netty.buffer.Unpooled;

import io.netty.channel.ChannelHandler.Sharable;

import io.netty.channel.ChannelHandlerContext;

import io.netty.channel.SimpleChannelInboundHandler;

import io.netty.util.CharsetUtil;

@Sharable

public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf> {

     @Override

     public void channelActive(ChannelHandlerContext ctx) throws Exception {

         //当被通知Channel是活跃的时候，发送一条消息

         ctx.writeAndFlush(Unpooled.copiedBuffer( "Netty rocks!" , CharsetUtil.UTF_8));

     }

     @Override

     protected void channelRead0(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf) throws Exception {

         System.out.println(

                 "Client received: " + byteBuf.toString(CharsetUtil.UTF_8)

         );

     }

     @Override

     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {

         cause.printStackTrace();

         ctx.close();

     }

}

import io.netty.bootstrap.Bootstrap;

import io.netty.channel.ChannelFuture;

import io.netty.channel.ChannelInitializer;

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 java.net.InetSocketAddress;

public class EchoClient {

     private final static String HOST = "localhost" ;

     private final static int PORT = 8080 ;

     public static void start() {

         EventLoopGroup group = new NioEventLoopGroup();

         Bootstrap bootstrap = new Bootstrap();

         bootstrap.group(group)

                 .channel(NioSocketChannel. class )

                 .remoteAddress( new InetSocketAddress(HOST, PORT))

                 .handler( new ChannelInitializer<SocketChannel>() {

                     @Override

                     protected void initChannel(SocketChannel socketChannel) throws Exception {

                         socketChannel.pipeline().addLast( new EchoClientHandler());

                     }

                 });

         try {

             ChannelFuture f = bootstrap.connect().sync();

             f.channel().closeFuture().sync();

         } catch (InterruptedException e) {

             e.printStackTrace();

         } finally {

             group.shutdownGracefully();

         }

     }

     public static void main(String[] args) {

         start();

     }

}