java网络通信：netty

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了java网络通信：netty，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含4830字，纯文字阅读大概需要7分钟。

内容图文

Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。

也就是说，Netty 是一个基于NIO的客户，服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户，服务端应用。Netty相当简化和流线化了网络应用的编程开发过程，例如，TCP和UDP的socket服务开发。

本文示例采用netty 5.0。上代码.

服务端:

            import
             io.netty.bootstrap.ServerBootstrap;

            import
             io.netty.channel.ChannelFuture;

            import
             io.netty.channel.ChannelOption;

            import
             io.netty.channel.EventLoopGroup;

            import
             io.netty.channel.nio.NioEventLoopGroup;

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


            public
            class
             TimeServer {

    
            public
            void bind(int port) throws Exception {
        // 配置服务端的NIO，循环事件线程组
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();//配置类
            //NioServerSocketChannel作为channel类，它的功能对应于JDK NIO类库中的ServerSocketChannel            b.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    .childHandler(new TimeServerHandler());//绑定事件处理类
            // 绑定端口，同步等待成功
            ChannelFuture f = b.bind(port).sync();

            // 等待服务端监听端口关闭            f.channel().closeFuture().sync();
        } finally {
            // 优雅退出，释放线程池资源            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    publicstaticvoid main(String[] args) throws Exception {
        int port = 8080;
        if (args != null && args.length > 0) {
            try {
                port = Integer.valueOf(args[0]);
            } catch (NumberFormatException e) {
                // 采用默认值            }
        }
        new TimeServer().bind(port);
    }
}

服务端事务处理类:

            import
             io.netty.buffer.ByteBuf;

            import
             io.netty.buffer.Unpooled;

            import
             io.netty.channel.ChannelHandlerAdapter;

            import
             io.netty.channel.ChannelHandlerContext;


            public
            class TimeServerHandler extends ChannelHandlerAdapter {
　　/*当有数据时，自动调用，读取msg*/
    publicvoid channelRead(ChannelHandlerContext ctx, Object msg)
        throws Exception {
        ByteBuf buf = (ByteBuf) msg;
        byte[] req = newbyte[buf.readableBytes()];
        buf.readBytes(req);
        String body = new String(req, "UTF-8");
        System.out.println("The time server receive order : " + body);
        String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ? new java.util.Date(
                System.currentTimeMillis()).toString() : "BAD ORDER";
        ByteBuf resp = Unpooled.copiedBuffer(currentTime.getBytes());
        ctx.write(resp);
    }
    publicvoid channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }
    publicvoid exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
    ctx.close();
    }
}

客户端：

            import
             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;

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


            public
            class
             TimeClient {
    
            public
            void connect(int port, String host) throws Exception {
        // 配置客户端NIO线程组
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(group).channel(NioSocketChannel.class)
                    .option(ChannelOption.TCP_NODELAY, true)
                    .handler(new ChannelInitializer<SocketChannel>() {//ChannelInitializer<SocketChannel>匿名类初始化channel的pipeline，将客户端事务处理类加入到队列中
                        @Override
                        publicvoid initChannel(SocketChannel ch)
                                throws Exception {
                            ch.pipeline().addLast(new TimeClientHandler());
                        }
                    });
            // 发起异步连接操作
            ChannelFuture f = b.connect(host, port).sync();

            // 当代客户端链路关闭            f.channel().closeFuture().sync();
        } finally {
            // 优雅退出，释放NIO线程组            group.shutdownGracefully();
        }
    }
    
    publicstaticvoid main(String[] args) throws Exception {
    int port = 8080;
    if (args != null && args.length > 0) {
        try {
        port = Integer.valueOf(args[0]);
        } catch (NumberFormatException e) {
        // 采用默认值        }
    }
    new TimeClient().connect(port, "127.0.0.1");
    }
}

客户端事件处理类：

            import
             io.netty.buffer.ByteBuf;

            import
             io.netty.buffer.Unpooled;

            import
             io.netty.channel.ChannelHandlerAdapter;

            import
             io.netty.channel.ChannelHandlerContext;

            import
             java.util.logging.Logger;


            public
            class TimeClientHandler extends ChannelHandlerAdapter {

    privatestaticfinal Logger logger = Logger
        .getLogger(TimeClientHandler.class.getName());

    privatefinal ByteBuf firstMessage;
    
    public TimeClientHandler() {
        byte[] req = "QUERY TIME ORDER".getBytes();
        firstMessage = Unpooled.buffer(req.length);
        firstMessage.writeBytes(req);
    }
　　/*连接成功后，自动发送消息*/
    publicvoid channelActive(ChannelHandlerContext ctx) {
    　　ctx.writeAndFlush(firstMessage);
    }
　　/*有消息返回时，自动调用该函数读取*/
    publicvoid channelRead(ChannelHandlerContext ctx, Object msg)
        throws Exception {
        ByteBuf buf = (ByteBuf) msg;
        byte[] req = newbyte[buf.readableBytes()];
        buf.readBytes(req);
        String body = new String(req, "UTF-8");
        System.out.println("Now is : " + body);
    }
　　/*发生异常时，自动调用*/
    publicvoid exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        // 释放资源
        logger.warning("Unexpected exception from downstream : "
            + cause.getMessage());
        ctx.close();
    }
}

原文：http://www.cnblogs.com/nazhizq/p/6538813.html

内容总结

以上是互联网集市为您收集整理的java网络通信：netty全部内容，希望文章能够帮你解决java网络通信：netty所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1275760.html

来源：【匿名】

【上一篇】Netty-主从Reactor多线程模式的源码实现【下一篇】一起学Netty（九）之LengthFieldBasedFrameDecoder

更多 ►

【java网络通信：netty】教程文章相关的互联网学习教程文章

Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。也就是说，Netty 是一个基于NIO的客户，服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户，服务端应用。Netty相当简化和流线化了网络应用的编程开发过程，例如，TCP和UDP的socket服务开发。本文示例采用netty 5.0。上代码.服务端:import io.netty.bootstrap.ServerBo...

Java NIO框架Netty课程（一） – Hello Netty【代码】

首先啰嗦2。假如你不知道Netty怎么办怎么办。它可以是一个简单的搜索，找出。我只能说Netty是NIO该框架，它可用于开发分布式Java计划。详细情况可以做，我们可以尝试用你的想象力。技术。它是服务于人，而不是人活的局限性。经万事具备，那么我们先从一段代码開始。程序猿们习惯的上手第一步，自然是"Hello world"。只是Netty官网的样例却偏偏抛弃了"Hello world"。那我们就自己写一个最简单的"Hello world"的样例，作为上手。/***...

Netty快速入门（03）Java NIO 介绍-Buffer【代码】【图】

NIO 介绍NIO，可以说是New IO，也可以说是non-blocking IO，具体怎么解释都可以。NIO 1是在JSR51里面定义的，在JDK1.4中引入，因为BolckingIO不支持高并发网络编程，这也是Java1.4以前被人诟病的原因。NIO 2是在JSR203中定义的，在JDK1.7中引入，这是JavaNIO整个的发展历程。NIO 1和NIO 2并不是一个新旧替代的关系，而是一个补充的关系，NIO 2补充了1中缺少的一些东西。我们可以看一下两个的内容：NIO 1（本系列文章只介绍NIO 1）：...

Java NIO框架Netty教程（一） – Hello Netty【代码】

先啰嗦两句，假设你还不知道Netty是做什么的能做什么。那能够先简单的搜索了解一下。我仅仅能说Netty是一个NIO的框架，能够用于开发分布式的Java程序。详细能做什么，各位能够尽量发挥想象。技术，是服务于人而不是局限住人的。假设你已经万事具备，那么我们先从一段代码開始。程序猿们习惯的上手第一步，自然是"Hello world"，只是Netty官网的样例却偏偏抛弃了"Hello world"。那我们就自己写一个最简单的"Hello world"的样例，作...

（中级篇 NettyNIO编解码开发）第七章-java序列化【代码】

相信大多数Java程序员接触到的第一种序列化或者编解码技术就是.Java的默认序列化，只需要序列化的POJO对象实现java.io.Serializable接口，根据实际情况生成序列ID,这个类就能够通过java.io.Objectlnput和java.io.ObjectOutput序列化和反序列化。不需要考虑跨语言调用，对序列化的性能也没有苛刻的要求时，Java默认的序列化机制是最明智的选择之一。正因为此，虽然Java序列化机制存在着一些弊病，依然得到了广泛的应用。本章主要内容...

Java NIO框架Netty教程(七)-再谈收发信息次数问题

在《Java NIO框架Netty教程（五）- 消息收发次数不匹配的问题》里我们试图分析一个消息收发次数不匹配的问题。当时笔者还是心存疑惑的。所以决定先学习一下Java NIO的Selector机制。经过简单的了解，笔者大胆的猜测和“武断”一下该问题的原因。首先，Selector机制让我们注册一个感兴趣的时间，然后只要有该时间发生，就会传递给接收端。我们写了三次，接收端一定会出发三次的。然后，Netty实现机制里，有个Buffer缓冲池，把收到的...

Netty 中 IOException: Connection reset by peer 与 java.nio.channels.ClosedChannelException: null【代码】

最近发现系统中出现了很多 IOException: Connection reset by peer 与 ClosedChannelException: null深入看了看代码, 做了些测试, 发现 Connection reset 会在客户端不知道 channel 被关闭的情况下, 触发了 eventloop 的 unsafe.read() 操作抛出而 ClosedChannelException 一般是由 Netty 主动抛出的, 在 AbstractChannel 以及 SSLHandler 里都可以看到 ClosedChannel 相关的代码AbstractChannel static final ClosedChannelExcept...

Java Netty (2)【代码】【图】

通过一个实例来说明Netty的使用。用1个服务器连接5个客户端线程，客户端连接上服务器以后就向服务器发送消息，服务器接收到消息后向客户端返回消息，客户端接收到消息以后，等待随机的时间，再向服务端发送消息，这样一直循环下去。项目结构：NettyServer.java:package Server;import java.net.InetSocketAddress; import java.util.concurrent.Executors;import org.jboss.netty.bootstrap.ServerBootstrap; import org.jboss.n...

100万并发连接服务器笔记之Java Netty处理1M连接会怎么样【代码】【图】

前言每一种该语言在某些极限情况下的表现一般都不太一样，那么我常用的Java语言，在达到100万个并发连接情况下，会怎么样呢，有些好奇，更有些期盼。这次使用经常使用的顺手的 netty NIO框架（netty-3.6.5.Final），封装的很好，接口很全面，就像它现在的域名 netty.io，专注于网络IO。整个过程没有什么技术含量，浅显分析过就更显得有些枯燥无聊，准备好，硬着头皮吧。测试服务器配置运行在VMWare Workstation 9中，64位...

[netty] 0.Java NIO 原理【代码】【图】

主要参考：http://tutorials.jenkov.com/java-nio/buffers.html一、Java NIO BufferJava NIO Buffers are used when interacting with NIO Channels. As you know, data is read from channels into buffers, and written from buffers into channels.A buffer is essentially a block of memory into which you can write data, which you can then later read again. This memory block is wrapped in a NIO Buffer object, whic...

Java NIO框架Netty教程(十) Object对象的连续收发解析分析

如果您一直关注OneCoder，我们之前有两篇文章介绍关于Netty消息连续收发的问题。( 《Java NIO框架Netty教程(五) 消息收发次数不匹配的问题》、《 Java NIO框架Netty教程(七)-再谈收发信息次数问题》)。如果您经常的“怀疑”和思考，我们刚介绍过了Object的传递，您是否好奇，在Object传递中是否会有这样的问题？如果Object流的字节截断错乱，那肯定是会出错的。Netty一定不会这么傻的，那么Netty是怎么做的呢？我们先通过代码验证...

java – Netty：如何减少来自服务器的连续消息之间的延迟？【代码】

我是开发团队的一个使用Netty的套接字服务器.当客户端发送请求,并且服务器发送单个响应时,往返时间非常快. (好)我们最近注意到,如果来自客户端的请求触发来自服务器的两条消息,即使服务器几乎同时将两条消息写入客户端,第一条和第二条消息之间的延迟也会超过200毫秒到达远程客户端.使用本地客户端时,两条消息同时到达.如果远程客户端在来自服务器的第二个消息到达之前发送另一个请求,则立即发送该第二个消息,但是来自新请求的两个消...

java – 在Netty中通道处理程序的ChannelInitializer的优势【代码】

直接在ChannelHandler链上使用ChannelInitializer有什么好处？例如,使用服务器引导程序,我可以这样做：bootstrap.childHandler(channel_handler);添加channel_handler的实现我将实现以下内容class simple_channel_handler implements ChannelHandler {public void handlerAdded(ChannelHandlerContext ctx) throws Exception {// TODO Auto-generated method stubSystem.out.println("handler added");ctx.pipeline().addLast(new...

Java与Netty实现高性能高并发【图】

摘要： 1. 背景 1.1. 惊人的性能数据最近一个圈内朋友通过私信告诉我，通过使用Netty4 + Thrift压缩二进制编解码技术，他们实现了10W TPS（1K的复杂POJO对象）的跨节点远程服务调用。1. 背景 1.1. 惊人的性能数据最近一个圈内朋友通过私信告诉我，通过使用Netty4 + Thrift压缩二进制编解码技术，他们实现了10W TPS（1K的复杂POJO对象）的跨节点远程服务调用。相比于传统基于Java序列化+BIO（同步阻塞IO）的通信框架，性能提升了8...

《Java 编写基于 Netty 的 RPC 框架》【代码】【图】

一简单概念 RPC: ( Remote Procedure Call),远程调用过程,是通过网络调用远程计算机的进程中某个方法,从而获取到想要的数据,过程如同调用本地的方法一样. 阻塞IO :当阻塞I/O在调用InputStream.read()方法是阻塞的,一直等到数据到来时才返回,同样ServerSocket.accept()方法时,也是阻塞,直到有客户端连接才返回,I/O通信模式如下: 缺点:当客户端多时,会创建大量的处理线程,并且为每一个线程分配一定的资源;阻塞可能带来频繁切换上下...

NETTY - 最热教程

Netty面试题（2020）尚硅谷2019年Netty教程学习笔记--苟声 Java多线程：Linux多路复用，Java NIO与...当Tomcat遇上Netty netty简介《精通并发与Netty》学习笔记（07 - 基...java-Netty连接限制 Flink1.12源码解读—— Netty通讯模式 Netty 源码解析（二）：Netty 的 Chann...Netty源码解析 -- 对象池Recycler实现原...