欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

【Netty入门】基于Netty的Server / Client

程序员文章站 2022-06-14 10:19:25
...

回顾NIO

我在之前介绍了NIO的server与client,虽然说编程相对于BIO比较复杂,但是性能高啊,而且Netty的server/client也是基于NIO的。所以,在介绍Netty的server/client 之前,先回顾一下NIO 的server / Client的步骤还是很有必要的!

1.NIO 服务端Server开发步骤:

(1)创建ServerSocketChannel,配置它为非阻塞模式;

(2)绑定监听,配置TCP参数,例如:backlog大小;

(3)创建一个独立的I/O线程,用于轮询多路复用器Selector;

(4)创建Selector,将之前创建的ServerSocketChannel注册到Selector上,监听SelectorKey.ACCEPT;

(5)启动I/O,在循环体中执行Selector.select() 方法,轮询就绪的Channel;

(6)当轮询到了处于就绪状态的Channel时,需要对其进行判断,如果是OP_ACCEPT状态,说明是新的客户端接入,则调用ServerSocketChannel.accept() 方法接受新的客户端;

(7)设置新接入的客户端链路SocketChannel为非阻塞模式,配置其他的一些TCP参数;

(8)将SocketChannel注册到Selector,监听OP_READ操作位;

(9)如果轮询的Channel为OP_READ,则说明SocketChannel中有新的就绪的数据包需要读取,则构造ByteBuffer对象,读取数据包;

(10)如果轮询的Channel为OP_WRITE,说明还有数据没有发送完成,需要继续发送。

2.NIO 客户端client开发步骤:

(1)打开SocketChannel,配置它为非阻塞模式,同时设置TCP参数

(2)异步连接到服务端,若连接成功,就向多路复用器注册读事件OP_READ,否则注册OP_CONNECT事件,请求再次连接。

(3)创建Selector,启动线程;

(4)Selector轮询就绪的SelectionKey

(5)若SelectionKey是连接事件,则判断连接是否成功,若连接成功,向多路复用器注册读事件OP_READ;

(6)若SelectionKey是可读事件,就创建ByteBuffer,用于读取数据;

(7)对ByteBuffer进行编解码;

(8)异步写ByteBuffer到SocketChannel。

小结:
你是不是感到“巨复杂”,步骤怎么这么多,直接使用NIO编程的步骤的确很繁琐,所以,Netty应运而生,它简化了步骤,更易上手,我将在接下来介绍Netty的Server / Client程序。

版本 :基于Netty 4.1.11

Netty的服务端代码

public class Server4 {
    public static void main(String[] args) throws SigarException {

        //boss线程监听端口,worker线程负责数据读写
        EventLoopGroup boss = new NioEventLoopGroup();
        EventLoopGroup worker = new NioEventLoopGroup();

        try{
            //辅助启动类
            ServerBootstrap bootstrap = new ServerBootstrap();
            //设置线程池
            bootstrap.group(boss,worker);

            //设置socket工厂
            bootstrap.channel(NioServerSocketChannel.class);

            //设置管道工厂
            bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel socketChannel) throws Exception {
                    //获取管道
                    ChannelPipeline pipeline = socketChannel.pipeline();
                    //字符串解码器
                    pipeline.addLast(new StringDecoder());
                    //字符串编码器
                    pipeline.addLast(new StringEncoder());
                    //处理类
                    pipeline.addLast(new ServerHandler4());
                }
            });

            //设置TCP参数
            //1.链接缓冲池的大小(ServerSocketChannel的设置)
            bootstrap.option(ChannelOption.SO_BACKLOG,1024);
            //维持链接的活跃,清除死链接(SocketChannel的设置)
            bootstrap.childOption(ChannelOption.SO_KEEPALIVE,true);
            //关闭延迟发送
            bootstrap.childOption(ChannelOption.TCP_NODELAY,true);

            //绑定端口
            ChannelFuture future = bootstrap.bind(8866).sync();
            System.out.println("server start ...... ");

            //等待服务端监听端口关闭
            future.channel().closeFuture().sync();

        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            //优雅退出,释放线程池资源
            boss.shutdownGracefully();
            worker.shutdownGracefully();
        }
    }

}


class ServerHandler4 extends SimpleChannelInboundHandler<String> {

    //读取客户端发送的数据
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        System.out.println("client response :"+msg);
        ctx.channel().writeAndFlush("i am server !");

//        ctx.writeAndFlush("i am server !").addListener(ChannelFutureListener.CLOSE);
    }

    //新客户端接入
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("channelActive");
    }

    //客户端断开
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("channelInactive");
    }

    //异常
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        //关闭通道
        ctx.channel().close();
        //打印异常
        cause.printStackTrace();
    }
}

Netty的客户端代码

public class Client4 {

    public static void main(String[] args) {

        //worker负责读写数据
        EventLoopGroup worker = new NioEventLoopGroup();

        try {
            //辅助启动类
            Bootstrap bootstrap = new Bootstrap();

            //设置线程池
            bootstrap.group(worker);

            //设置socket工厂
            bootstrap.channel(NioSocketChannel.class);

            //设置管道
            bootstrap.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel socketChannel) throws Exception {
                    //获取管道
                    ChannelPipeline pipeline = socketChannel.pipeline();
                    //字符串解码器
                    pipeline.addLast(new StringDecoder());
                    //字符串编码器
                    pipeline.addLast(new StringEncoder());
                    //处理类
                    pipeline.addLast(new ClientHandler4());
                }
            });

            //发起异步连接操作
            ChannelFuture futrue = bootstrap.connect(new InetSocketAddress("127.0.0.1",8866)).sync();

            //等待客户端链路关闭
            futrue.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //优雅的退出,释放NIO线程组
            worker.shutdownGracefully();
        }
    }

}

class ClientHandler4 extends SimpleChannelInboundHandler<String> {

    //接受服务端发来的消息
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        System.out.println("server response : "+msg);
    }

    //与服务器建立连接
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //给服务器发消息
        ctx.channel().writeAndFlush("i am client !");

        System.out.println("channelActive");
    }

    //与服务器断开连接
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("channelInactive");
    }

    //异常
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        //关闭管道
        ctx.channel().close();
        //打印异常信息
        cause.printStackTrace();
    }

}

服务端运行结果:

【Netty入门】基于Netty的Server / Client



客户端运行结果:
【Netty入门】基于Netty的Server / Client

注:我使用的Netty的版本为Netty 4.1.11,Netty各个版本之间的代码或有些许差异,请注意。

小结:可以明确感觉到Netty的服务器客户端程序明显看起来顺眼了不少,当然,它比NIO用起来顺手多了。同时,Netty的性能也是很高的。



本人才疏学浅,若有错误,请指出
谢谢!

相关标签: server nio