NETTY TCP通信

什么事nettiy:

Netty是一个高性能、异步事件驱动的NIO框架,它提供了对TCP、UDP和文件传输的支持,作为一个异步NIO框架,Netty的所有IO操作都是异步非阻塞的,通过Future-Listener机制,用户可以方便的主动获取或者通过通知机制获得IO操作结果。

为什么选择Netty

Netty是业界最流行的NIO框架之一,它的健壮性、功能、性能、可定制性和可扩展性在同类框架中都是首屈一指的,它已经得到成百上千的商用项目验证,例如Hadoop的RPC框架avro使用Netty作为底层通信框架;很多其他业界主流的RPC框架,也使用Netty来构建高性能的异步通信能力。

通过对Netty的分析,我们将它的优点总结如下:

1、API使用简单,开发门槛低;

2、 功能强大,预置了多种编解码功能,支持多种主流协议;

3、定制能力强,可以通过ChannelHandler对通信框架进行灵活地扩展;

4、 性能高,通过与其他业界主流的NIO框架对比,Netty的综合性能最优;

5、 成熟、稳定,Netty修复了已经发现的所有JDK NIO BUG,业务开发人员不需要再为NIO的BUG而烦恼;

6、社区活跃,版本迭代周期短,发现的BUG可以被及时修复,同时,更多的新功能会加入;

7、经历了大规模的商业应用考验,质量得到验证。在互联网、大数据、网络游戏、企业应用、电信软件等众多行业得到成功商用,证明了它已经完全能够满足不同行业的商业应用了。


NIO和IO的区别

IO                NIO
面向流            面向缓冲
阻塞IO            非阻塞IO
无                选择器


面向流与面向缓冲

Java NIO和IO之间第一个最大的区别是,IO是面向流的,NIO是面向缓冲区的。 Java IO面向流意味着每次从流中读一个或多个字节,直至读取所有字节,它们没有被缓存在任何地方。此外,它不能前后移动流中的数据。如果需要前后移动从流中读取的数据,需要先将它缓存到一个缓冲区。 Java NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区,需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。但是,还需要检查是否该缓冲区中包含所有您需要处理的数据。而且,需确保当更多的数据读入缓冲区时,不要覆盖缓冲区里尚未处理的数据。
阻塞与非阻塞IO

Java IO的各种流是阻塞的。这意味着,当一个线程调用read() 或 write()时,该线程被阻塞,直到有一些数据被读取,或数据完全写入。该线程在此期间不能再干任何事情了。 Java NIO的非阻塞模式,使一个线程从某通道发送请求读取数据,但是它仅能得到目前可用的数据,如果目前没有数据可用时,就什么都不会获取。而不是保持线程阻塞,所以直至数据变的可以读取之前,该线程可以继续做其他的事情。 非阻塞写也是如此。一个线程请求写入一些数据到某通道,但不需要等待它完全写入,这个线程同时可以去做别的事情。 线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作,所以一个单独的线程现在可以管理多个输入和输出通道(channel)。
选择器(Selectors)

Java NIO的选择器允许一个单独的线程来监视多个输入通道,你可以注册多个通道使用一个选择器,然后使用一个单独的线程来“选择”通道:这些通道里已经有可以处理的输入,或者选择已准备写入的通道。这种选择机制,使得一个单独的线程很容易来管理多个通道。
NIO和IO如何影响应用程序的设计

无论您选择IO或NIO工具箱,可能会影响您应用程序设计的以下几个方面:
1、 对NIO或IO类的API调用。
2、数据处理。
3、用来处理数据的线程数。


NETTY TCP NIO代码

maven依赖包

<dependency>  
        <groupId>io.netty</groupId>  
        <artifactId>netty-all</artifactId>  
        <version>4.1.4.Final</version>  
 </dependency> 


    import io.netty.bootstrap.ServerBootstrap;  
    import io.netty.channel.ChannelInitializer;  
    import io.netty.channel.ChannelPipeline;  
    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 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 io.netty.util.CharsetUtil;  
    import util.LogCore;  
      
    public class TcpServer {  
        private static final String IP = "127.0.0.1";  
        private static final int PORT = 9999;  
        /** 用于分配处理业务线程的线程组个数 */  
        protected static final int BIZGROUPSIZE = Runtime.getRuntime().availableProcessors() * 2; // 默认  
        /** 业务出现线程大小 */  
        protected static final int BIZTHREADSIZE = 4;  
        /*
         * NioEventLoopGroup实际上就是个线程池,
         * NioEventLoopGroup在后台启动了n个NioEventLoop来处理Channel事件,
         * 每一个NioEventLoop负责处理m个Channel,
         * NioEventLoopGroup从NioEventLoop数组里挨个取出NioEventLoop来处理Channel
         */  
        private static final EventLoopGroup bossGroup = new NioEventLoopGroup(BIZGROUPSIZE);  
        private static final EventLoopGroup workerGroup = new NioEventLoopGroup(BIZTHREADSIZE);  
      
        protected static void run() throws Exception {  
            ServerBootstrap b = new ServerBootstrap();  
            b.group(bossGroup, workerGroup);  
            b.channel(NioServerSocketChannel.class);  
            b.childHandler(new ChannelInitializer<SocketChannel>() {  
                @Override  
                public void initChannel(SocketChannel ch) throws Exception {  
                    ChannelPipeline pipeline = ch.pipeline();  
                    pipeline.addLast("frameDecoder", new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4, 0, 4));  
                    pipeline.addLast("frameEncoder", new LengthFieldPrepender(4));  
                    pipeline.addLast("decoder", new StringDecoder(CharsetUtil.UTF_8));  
                    pipeline.addLast("encoder", new StringEncoder(CharsetUtil.UTF_8));  
                    pipeline.addLast(new TcpServerHandler());  
                }  
            });  
      
            b.bind(IP, PORT).sync();  
            LogCore.BASE.info("TCP服务器已启动");  
        }  
      
        protected static void shutdown() {  
            workerGroup.shutdownGracefully();  
            bossGroup.shutdownGracefully();  
        }  
      
        public static void main(String[] args) throws Exception {  
            LogCore.BASE.info("启动TCP服务器...");  
            TcpServer.run();  
            // TcpServer.shutdown();  
        }  
    } 


    import io.netty.channel.ChannelHandlerContext;  
    import io.netty.channel.SimpleChannelInboundHandler;  
    import util.LogCore;  
      
    public class TcpServerHandler extends SimpleChannelInboundHandler<Object> {  
      
        @Override  
        protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {  
            LogCore.BASE.info("SERVER接收到消息:" + msg);  
            ctx.channel().writeAndFlush("server accepted msg:" + msg);  
        }  
      
        @Override  
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {  
            LogCore.BASE.warn("exceptionCaught!", cause);  
            ctx.close();  
        }  
    } 


    import io.netty.bootstrap.Bootstrap;  
    import io.netty.channel.Channel;  
    import io.netty.channel.ChannelInitializer;  
    import io.netty.channel.ChannelOption;  
    import io.netty.channel.ChannelPipeline;  
    import io.netty.channel.EventLoopGroup;  
    import io.netty.channel.nio.NioEventLoopGroup;  
    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 io.netty.util.CharsetUtil;  
    import util.LogCore;  
      
    public class TcpClient {  
        public static String HOST = "127.0.0.1";  
        public static int PORT = 9999;  
      
        public static Bootstrap bootstrap = getBootstrap();  
        public static Channel channel = getChannel(HOST, PORT);  
      
        /**
         * 初始化Bootstrap
         */  
        public static final Bootstrap getBootstrap() {  
            EventLoopGroup group = new NioEventLoopGroup();  
            Bootstrap b = new Bootstrap();  
            b.group(group).channel(NioSocketChannel.class);  
            b.handler(new ChannelInitializer<Channel>() {  
                @Override  
                protected void initChannel(Channel ch) throws Exception {  
                    ChannelPipeline pipeline = ch.pipeline();  
                    pipeline.addLast("frameDecoder", new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4, 0, 4));  
                    pipeline.addLast("frameEncoder", new LengthFieldPrepender(4));  
                    pipeline.addLast("decoder", new StringDecoder(CharsetUtil.UTF_8));  
                    pipeline.addLast("encoder", new StringEncoder(CharsetUtil.UTF_8));  
                    pipeline.addLast("handler", new TcpClientHandler());  
                }  
            });  
            b.option(ChannelOption.SO_KEEPALIVE, true);  
            return b;  
        }  
      
        public static final Channel getChannel(String host, int port) {  
            Channel channel = null;  
            try {  
                channel = bootstrap.connect(host, port).sync().channel();  
            } catch (Exception e) {  
                LogCore.BASE.error("连接Server(IP{},PORT{})失败", host, port, e);  
                return null;  
            }  
            return channel;  
        }  
      
        public static void sendMsg(String msg) throws Exception {  
            if (channel != null) {  
                channel.writeAndFlush(msg).sync();  
            } else {  
                LogCore.BASE.warn("消息发送失败,连接尚未建立!");  
            }  
        }  
      
        public static void main(String[] args) throws Exception {  
            try {  
                long t0 = System.nanoTime();  
                for (int i = 0; i < 100; i++) {  
                    TcpClient.sendMsg(i + "你好1");  
                }  
                long t1 = System.nanoTime();  
                LogCore.BASE.info("time used:{}", t1 - t0);  
            } catch (Exception e) {  
                LogCore.BASE.error("main err:", e);  
            }  
        }  
    } 


    import io.netty.channel.ChannelHandlerContext;  
    import io.netty.channel.SimpleChannelInboundHandler;  
    import util.LogCore;  
      
    public class TcpClientHandler extends SimpleChannelInboundHandler<Object> {  
      
        @Override  
        protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {  
            LogCore.BASE.info("client接收到服务器返回的消息:" + msg);  
        }  
    } 


评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值