第一款Netty应用程序
这边开始写一个Demo来熟悉下Netty的使用，Demo主要为写一个Echo服务器来实现服务器和客户端之间的交流问题
ChannelHandler是一个接口簇的父接口，它的实现负责接收并响应事件通知。在Netty应用程序中，所有的数据处理逻辑都是包含在这下核心抽象的实现中。需要响应传入的消息，那么就至少需要实现一个ChannelInboundHandler接口，用来定义入站的事件。
ChannelRead()——对于每个传入的消息都调用
ChannelReadComplete()——通知ChannelInboundHandler最后一次对ChannelRead()调用是当前批量读取中的最后一条消息
exceptionCaught()——在读取操作期间，有异常抛出时候会进行调用
import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelFutureListener; import io.netty.channel.ChannelHandler; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelInboundHandlerAdapter; import java.nio.charset.Charset; /** * description: EchoServerHandler * date: 2021/4/21 17:43 * * @author: SmartCat * version: 1.0.0 */ @ChannelHandler.Sharable public class EchoServerHandler extends ChannelInboundHandlerAdapter { @Override public void channelRead(ChannelHandlerContext ctx, Object msg){ ByteBuf in = (ByteBuf) msg; System.out.println (in.toString (Charset.defaultCharset ())); ctx.write (in); } @Override public void channelReadComplete(ChannelHandlerContext ctx){ ctx.writeAndFlush (Unpooled.EMPTY_BUFFER) .addListener (ChannelFutureListener.CLOSE); } @Override public void exceptionCaught (ChannelHandlerContext ctx, Throwable cause){ cause.printStackTrace (); ctx.close (); } }
ChannelInboundHandlerAdapter有一个直观的API，可以通过重写它的方法来对重新挂钩到事件生命周期的恰当点上。
开始写一个引导类，来对Netty进行启动。
引导类的绑定到服务器将在其上监听并接受传入连接请求的端口；配置Channel，将有关的入站这消息通知给EchoServerHandler实例。
import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioServerSocketChannel; import java.net.InetSocketAddress; /** * description: EchoServer * date: 2021/4/21 17:57 * * @author: SmartCat * version: 1.0.0 */ public class EchoServer { private int port=8080; public EchoServer(int port){ this.port = port; } public static void main(String[] args) throws InterruptedException { new EchoServer (8088).start(); } private void start() throws InterruptedException { EchoServerHandler echoServerHandler = new EchoServerHandler ();
//NioEventLoopGroup无参构建的时候调用MultithreadEventLoopGroup的构造参数，默认的线程数是CPU个数的*2 NioEventLoopGroup group = new NioEventLoopGroup (); try{ ServerBootstrap serverBootstrap = new ServerBootstrap (); serverBootstrap.group(group) .channel (NioServerSocketChannel.class) .localAddress (new InetSocketAddress (8088))
//新连接被接受的时候，一个新的Channel会被创建，ChannelInitializer会将一个你的EchoServerHandler的实例添加到该Channel的ChannelPipeline中 .childHandler (new ChannelInitializer<SocketChannel> () { @Override protected void initChannel(SocketChannel socketChannel) throws Exception { socketChannel.pipeline ().addLast (echoServerHandler); } }); ChannelFuture f = serverBootstrap.bind ().sync (); f.channel ().closeFuture ().sync (); } catch (InterruptedException e) { e.printStackTrace (); } finally { group.shutdownGracefully ().sync (); } } }
主要步骤：
1.实现自己的Handler————>EchoServerHandler
2.main()方法进行引导启动
3.创建一个ServerBootStrap的实例以引导和绑定服务器
4.创建并分配一个NioEventGroup实例线程组来进行事件的处理，接受新连接以及读写操作
5.指定服务器绑定的本地的InetSocketAddress
6.使用EchoServerHandler的实例初始化每一个新的Channel
7.调用ServerBootStrap.bind()以绑定服务器
然后建立一个自己的客户端
和服务端一样，服务端对应的是ChannelInboundHandlerAdapter。客户端也是ChannelInboundHandlerAdapter(這邊使用的相對簡單的SimpleChannelInboundHandler)。重写的方法不同而已，客户端需要重写的是连接后，读，以及异常的处理
import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelHandler; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.SimpleChannelInboundHandler; import java.nio.charset.Charset; /** * description: EchoClinentHandler * date: 2021/4/21 18:11 * * @author: SmartCat * version: 1.0.0 */ @ChannelHandler.Sharable public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf>{ @Override public void channelActive(ChannelHandlerContext ctx){ ctx.writeAndFlush (Unpooled.copiedBuffer ("Netty rocks", Charset.defaultCharset ())); } @Override protected void channelRead0(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf) throws Exception { System.out.println ("channelHandlerContext is get"); } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable t){ t.printStackTrace (); ctx.close (); } }
重写ChannelAdvice方法是为了在连接被调用的时候，数据将被写入服务器，重写ChannelRead0()方法是一个接收数据的时候进行的方法。
为什么使用Simple.....不是EchoServerHandler中的那个呢？因为write是异步的，Simple帮我们又做了一层自动的刷新处理
最后再建立一个客户端的启动引导类就可以完成了。
import io.netty.bootstrap.Bootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioSocketChannel; import java.net.InetSocketAddress; /** * description: EchoClient * date: 2021/4/21 18:27 * * @author: SmartCat * version: 1.0.0 */ public class EchoClient { public void start() { NioEventLoopGroup group = new NioEventLoopGroup (); try { Bootstrap b = new Bootstrap (); b.group (group) .channel (NioSocketChannel.class) .remoteAddress (new InetSocketAddress ("127.0.0.1", 8088)) .handler (new ChannelInitializer<SocketChannel> () { @Override protected void initChannel(SocketChannel socketChannel) { socketChannel.pipeline ().addLast (new EchoClientHandler ()); } }); ChannelFuture f = b.connect ().sync (); f.channel ().closeFuture ().sync (); } catch (InterruptedException e) { e.printStackTrace (); } } public static void main(String[] args) { new EchoClient ().start (); } }
主要的要点：
1.为了初始化客户端，创建一个BootStrap实例
2.为进行实践处理分配了一个NioEventLoopGroup实例，其中实践处理包括创建新的连接以及处理入站和出站数据
3.创建一个InetSocketAddress实例
4.当连接被建立时，一个EchoClientHandler实例会被安装到ChannelPipeline中
