netty_netty线程模型 - CSDN
netty 订阅
Netty是由JBOSS提供的一个java开源框架,现为 Github上的独立项目。Netty提供异步的、事件驱动的网络应用程序框架和工具,用以快速开发高性能、高可靠性的网络服务器和客户端程序。也就是说,Netty 是一个基于NIO的客户、服务器端的编程框架,使用Netty 可以确保你快速和简单的开发出一个网络应用,例如实现了某种协议的客户、服务端应用。Netty相当于简化和流线化了网络应用的编程开发过程,例如:基于TCP和UDP的socket服务开发。“快速”和“简单”并不用产生维护性或性能上的问题。Netty 是一个吸收了多种协议(包括FTP、SMTP、HTTP等各种二进制文本协议)的实现经验,并经过相当精心设计的项目。最终,Netty 成功的找到了一种方式,在保证易于开发的同时还保证了其应用的性能,稳定性和伸缩性。 [1] 展开全文
Netty是由JBOSS提供的一个java开源框架,现为 Github上的独立项目。Netty提供异步的、事件驱动的网络应用程序框架和工具,用以快速开发高性能、高可靠性的网络服务器和客户端程序。也就是说,Netty 是一个基于NIO的客户、服务器端的编程框架,使用Netty 可以确保你快速和简单的开发出一个网络应用,例如实现了某种协议的客户、服务端应用。Netty相当于简化和流线化了网络应用的编程开发过程,例如:基于TCP和UDP的socket服务开发。“快速”和“简单”并不用产生维护性或性能上的问题。Netty 是一个吸收了多种协议(包括FTP、SMTP、HTTP等各种二进制文本协议)的实现经验,并经过相当精心设计的项目。最终,Netty 成功的找到了一种方式,在保证易于开发的同时还保证了其应用的性能,稳定性和伸缩性。 [1]
信息
依赖平台
JBOSS
新的传输方式
处理大容量数据流更简单
特    点
快速开发高性能、高可靠性
性    质
java开源框架
外文名
Netty
Netty特点
针对多种传输类型的统一接口 - 阻塞和非阻塞简单但更强大的线程模型真正的无连接的数据报套接字支持链接逻辑支持复用大量的 Javadoc 和 代码实例除了在 JDK 1.6 + 额外的限制。(一些特征是只支持在Java 1.7 +。可选的功能可能有额外的限制。)比核心 Java API 更好的吞吐量,较低的延时资源消耗更少,这个得益于共享池和重用减少内存拷贝消除由于慢,快,或重载连接产生的 OutOfMemoryError消除经常发现在 NIO 在高速网络中的应用中的不公平的读/写比完整的 SSL / TLS 和 StartTLS 的支持运行在受限的环境例如 Applet 或 OSGI发布的更早和更频繁社区驱动 [2] 
收起全文
精华内容
参与话题
  • NettyNetty实例开源项目

    万次阅读 2018-08-23 23:07:15
    Netty 前言 netty-introduction-demo:Netty的入门实例 简介 netty-serialization-demo:Netty传输序列化对象 简介 netty-heartbeat-detection-demo:使用Netty进行服务器和客户端的心跳检测 简介 netty-not-...

    Netty

    本篇博客讲解:
    关于netty使用的一些实例
    netty-introduction-demo:Netty的入门实例
    netty-serialization-demo:netty传输序列化对象
    netty-heartbeat-detection-demo:使用netty进行服务器和客户端的心跳检测
    netty-not-sticky-pack-demo:netty解决粘包问题,传输序列化对象

    前言

    挺久没写博客的了。实在是因为时间不够,对大家说声抱歉了。之前临近毕业,学校的事情多得一批,我也很绝望。
    最近来到了杭州一家支付公司工作,有时候也得加加班的。所以平时上班肯定是没啥时间写博客的。并且在7月份,已经和一家出版社签好了合同,将会在明年出版我的第一本书。希望大家多多支持。
    给大家透露一下书的信息吧,是关于Spring,SpringMVC和MyBatis的。其中前面几个章节会对于反射,动态代理,设计模式等学习框架前的基础知识进行一些比较深入的讲解,同时配合一些实例。中间章节的部分主要是针对SSM框架进行逐步分析了。书本中会涉及到比较多的源码分析。很适合想进一步学习的朋友。后面的章节会讲到Redis,然后最后会进行一个企业级项目的整合实例开发。书写的不好,大家可以尽管拿书砸我(书本可能会有800页以上,所以我也在考虑是不是作为两本书出),也希望在书出版前后得到大家的建议。(广告插入很僵硬,表介意)
    虽然自己平时都在学习,但是写博客的时间和学习的时间相比,需要的时间实在要多些,所以种种原因,也就导致了我现在更新博客会比较慢。
    现在对于一些基础的知识可能以后会很少见了,更多的会使用实例加注释,开源的项目为大家演示怎么使用框架。以及简单实现框架的功能。
    比如说这里的Netty,我会进行一些实例项目的分享,另外,可能会有自己使用NIO实现简单类似Netty的功能。
    下一次的博客应该会是讲解搭建RPC框架,以及Java高并发类的使用, SpringBoot集成Shiro的种种实例 (我的GitHub中已经有)。很多实例其实在空闲时间,我也写了很多,但是还不足以用博客的方式分享出来,大家如果想知道我分享的实时动态的话,建议关注我的github,欢迎多来点star。
    后面我的博客方式将不再以博客展示的方式为重点。对于很多知识点,我将会在我的github中开源项目中进行展示。实在是因为时间有限,每天每个人只有24小时,不多不少。望大家谅解。希望大家都能进步,学到知识。

    Netty是基于NIO的客户端、服务端通讯编程框架
    Netty的一些介绍就不多说了。大家可以谷歌百度看官网都行的、
    后面我可能会针对netty再上一篇高级应用或者原理分析
    Netty系列文章我是为后面我会讲解RPC原理而做的铺垫
    接下来就是直接上项目例子了、

    netty-introduction-demo:Netty的入门实例

    简介

    构建并运行第一个Netty的客户端和服务器
    采用ECHO协议,也就是客户端请求什么,服务器就返回什么。

    ChannelOption.SO_BACKLOG:
    服务器的TCP内核维护两个队列A和B
    客户端向服务端请求connect时, 发送SYN(第一次握手)
    服务端收到SYN后, 向客户端发送SYN ACK(第二次握手), TCP内核将连接放入队列A
    客户端收到后向服务端发送ACK(第三次握手), TCP内核将连接从A->B, accept返回, 连接完成
    A/B队列的长度和即为BACKLOG, 当accept速度跟不上(也就是同时握手过多), A/B队列使得BACKLOG满了, 客户端连接就会被TCP内核拒绝
    可以调大SO_BACKLOG缓解这一现象.默认值为50.

    一个最简单的入门实例,在代码中都带了大部分注释,请结合注释和项目进行理解。

    netty-serialization-demo:Netty传输序列化对象

    简介

    对象序列化, 目的是为了实现对象的网络传输和本地持久化
    如果使用java的序列化, 码流较大. 因此多用FastjsonSerialize, KryoSerialize,FSTSerialize等
    在本例中使用FSTSerialize进行编解码传输javabean

    netty-heartbeat-detection-demo:使用Netty进行服务器和客户端的心跳检测

    简介

    使用netty进行服务器和客户端的心跳检测
    或者是主服务器和从服务器之间的心跳检测,让主服务器知道从服务器的状态
    客户端每隔5-10s给服务器进行发送心跳包
    通过netty和定时任务实现
    使用Sigar工具获取服务器的信息,cpu,内存等

    netty-not-sticky-pack-demo:Netty解决粘包问题,传输序列化对象

    简介

    netty-not-sticky-pack-demo

    解决tcp传输数据,粘包问题

    比较主流的解决方法由如下几种:
    1、消息定长,报文大小固定长度,例如每个报文的长度固定为200字节,如果不够空位补空格;
    2、包尾添加特殊分隔符,例如每条报文结束都添加回车换行符(例如FTP协议)或者指定特殊字符作为报文分隔符,接收方通过特殊分隔符切分报文区分;
    3、将消息分为消息头和消息体,消息头中包含表示信息的总长度(或者消息体长度)的字段;
    4、自定义更复杂的应用层协议。

    Netty粘包和拆包解决方案

    Netty提供了多个解码器,可以进行分包的操作,分别是:
    LineBasedFrameDecoder
    DelimiterBasedFrameDecoder(添加特殊分隔符报文来分包)
    FixedLengthFrameDecoder(使用定长的报文来分包)
    LengthFieldBasedFrameDecoder

    LengthFieldBasedFrameDecoder

    本实例使用LengthFieldBasedFrameDecoder屏蔽TCP底层的拆包和粘包问题
    使用对象进行传输
    LengthFieldBasedFrameDecoder的构造函数:

    public class LengthFieldBasedFrameDecoder extends ByteToMessageDecoder {
        //...
      public LengthFieldBasedFrameDecoder(ByteOrder byteOrder, 
                                        int maxFrameLength, 
                                        int lengthFieldOffset, 
                                        int lengthFieldLength, 
                                        int lengthAdjustment, 
                                        int initialBytesToStrip, 
                                        boolean failFast) {
       }
       //...
    }

    byteOrder:表示字节流表示的数据是大端还是小端,因为Netty要读取Length字段的值,所以大端小端要设置好,默认Netty是大端序ByteOrder.BIG_ENDIAN。
    maxFrameLength:表示的是包的最大长度,超出包的最大长度netty将会报错;
    lengthFieldOffset:指的是长度域(Length)的偏移量,表示跳过指定长度个字节之后的才是长度域,也就是length前面的字节,也就是头部信息;
    lengthFieldLength:记录该帧数据长度的字段本身的长度;
    lengthAdjustment:该字段加长度字段等于数据帧的长度,包体长度调整的大小,长度域的数值表示的长度加上这个修正值表示的就是带header的包;
    initialBytesToStrip:从数据帧中跳过的字节数,表示获取完一个完整的数据包之后,忽略前面的指定的位数个字节,应用解码器拿到的就是不带长度域的数据包;
    failFast:如果为true,则表示读取到长度域,TA的值的超过maxFrameLength,就抛出一个 TooLongFrameException,而为false表示只有当真正读取完长度域的值表示的字节之后,才会抛出 TooLongFrameException,默认情况下设置为true,建议不要修改,否则可能会造成内存溢出。

    什么是粘包、拆包?

    对于什么是粘包、拆包问题,我想先举两个简单的应用场景:
    客户端和服务器建立一个连接,客户端发送一条消息,客户端关闭与服务端的连接。
    客户端和服务器简历一个连接,客户端连续发送两条消息,客户端关闭与服务端的连接。
    对于第一种情况,服务端的处理流程可以是这样的:当客户端与服务端的连接建立成功之后,服务端不断读取客户端发送过来的数据,当客户端与服务端连接断开之后,服务端知道已经读完了一条消息,然后进行解码和后续处理…。
    对于第二种情况,如果按照上面相同的处理逻辑来处理,那就有问题了
    我们来看看第二种情况下客户端发送的两条消息递交到服务端有可能出现的情况:

    第一种情况:
    服务端一共读到两个数据包,第一个包包含客户端发出的第一条消息的完整信息,第二个包包含客户端发出的第二条消息,那这种情况比较好处理,服务器只需要简单的从网络缓冲区去读就好了,第一次读到第一条消息的完整信息,消费完再从网络缓冲区将第二条完整消息读出来消费。

    没有发生粘包、拆包示意图
    没有发生粘包、拆包示意图

    第二种情况:
    服务端一共就读到一个数据包,这个数据包包含客户端发出的两条消息的完整信息,这个时候基于之前逻辑实现的服务端就蒙了,因为服务端不知道第一条消息从哪儿结束和第二条消息从哪儿开始,这种情况其实是发生了TCP粘包。
    TCP粘包示意图
    TCP粘包示意图

    第三种情况:
    服务端一共收到了两个数据包,第一个数据包只包含了第一条消息的一部分,第一条消息的后半部分和第二条消息都在第二个数据包中,或者是第一个数据包包含了第一条消息的完整信息和第二条消息的一部分信息,第二个数据包包含了第二条消息的剩下部分,这种情况其实是发送了TCP拆,因为发生了一条消息被拆分在两个包里面发送了,同样上面的服务器逻辑对于这种情况是不好处理的。
    TCP拆包示意图
    TCP拆包示意图
    本段文字参考链接 https://my.oschina.net/andylucc/blog/625315

    项目地址

    GITHUB源码地址:点我进行访问

    本文章由[谙忆]编写, 所有权利保留。
    欢迎转载,分享是进步的源泉。

    转载请注明出处:http://chenhaoxiang.cn
    本文源自谙忆的博客

    展开全文
  • Java NIO框架Netty教程(一) – Hello Netty

    万次阅读 多人点赞 2013-09-09 22:09:03
    先啰嗦两句,如果你还不知道Netty是做什么的能做什么。那可以先简单的搜索了解一下。我只能说Netty是一个NIO的框架,可以用于开发分布式的Java程序。具体能做什么,各位可以尽量发挥想象。技术,是服务于人而不是...

    先啰嗦两句,如果你还不知道Netty是做什么的能做什么。那可以先简单的搜索了解一下。我只能说Netty是一个NIO的框架,可以用于开发分布式的Java程序。具体能做什么,各位可以尽量发挥想象。技术,是服务于人而不是局限住人的。

    如果你已经万事具备,那么我们先从一段代码开始。程序员们习惯的上手第一步,自然是"Hello world",不过Netty官网的例子却偏偏抛弃了"Hello world"。那我们就自己写一个最简单的"Hello world"的例子,作为上手。

    /**
     * Netty 服务端代码
     * 
     * @author lihzh
     * @alia OneCoder
     * @blog http://www.coderli.com
     */
    public class HelloServer {
    
    	public static void main(String args[]) {
    		// Server服务启动器
    		ServerBootstrap bootstrap = new ServerBootstrap(
    				new NioServerSocketChannelFactory(
    						Executors.newCachedThreadPool(),
    						Executors.newCachedThreadPool()));
    		// 设置一个处理客户端消息和各种消息事件的类(Handler)
    		bootstrap
    				.setPipelineFactory(new ChannelPipelineFactory() {
    					@Override
    					public ChannelPipeline getPipeline()
    							throws Exception {
    						return Channels
    								.pipeline(new HelloServerHandler());
    					}
    				});
    		// 开放8000端口供客户端访问。
    		bootstrap.bind(new InetSocketAddress(8000));
    	}
    
    	private static class HelloServerHandler extends
    			SimpleChannelHandler {
    
    		/**
    		 * 当有客户端绑定到服务端的时候触发,打印"Hello world, I'm server."
    		 * 
    		 * @alia OneCoder
    		 * @author lihzh
    		 */
    		@Override
    		public void channelConnected(
    				ChannelHandlerContext ctx,
    				ChannelStateEvent e) {
    			System.out.println("Hello world, I'm server.");
    		}
    	}
    }
    
    /**
     * Netty 客户端代码
     * 
     * @author lihzh
     * @alia OneCoder
     * @blog http://www.coderli.com
     */
    public class HelloClient {
    
    	public static void main(String args[]) {
    		// Client服务启动器
    		ClientBootstrap bootstrap = new ClientBootstrap(
    				new NioClientSocketChannelFactory(
    						Executors.newCachedThreadPool(),
    						Executors.newCachedThreadPool()));
    		// 设置一个处理服务端消息和各种消息事件的类(Handler)
    		bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
    			@Override
    			public ChannelPipeline getPipeline() throws Exception {
    				return Channels.pipeline(new HelloClientHandler());
    			}
    		});
    		// 连接到本地的8000端口的服务端
    		bootstrap.connect(new InetSocketAddress(
    				"127.0.0.1", 8000));
    	}
    
    	private static class HelloClientHandler extends SimpleChannelHandler {
    
    
    		/**
    		 * 当绑定到服务端的时候触发,打印"Hello world, I'm client."
    		 * 
    		 * @alia OneCoder
    		 * @author lihzh
    		 */
    		@Override
    		public void channelConnected(ChannelHandlerContext ctx,
    				ChannelStateEvent e) {
    			System.out.println("Hello world, I'm client.");
    		}
    	}
    }

    既然是分布式的,自然要分多个服务。Netty中,需要区分Server和Client服务。所有的Client都是绑定在Server上的,他们之间是不能通过Netty直接通信的。(自己采用的其他手段,不包括在内。)。白话一下这个通信过程,Server端开放端口,供Client连接,Client发起请求,连接到Server指定的端口,完成绑定。随后便可自由通信。其实就是普通Socket连接通信的过程。

    Netty框架是基于事件机制的,简单说,就是发生什么事,就找相关处理方法。就跟着火了找119,抢劫了找110一个道理。所以,这里,我们处理的是当客户端和服务端完成连接以后的这个事件。什么时候完成的连接,Netty知道,他告诉我了,我就负责处理。这就是框架的作用。Netty,提供的事件还有很多,以后会慢慢的接触和介绍。

    你应该已经可以上手了:)

    展开全文
  • Netty框架学习之(一):Netty框架简介

    万次阅读 多人点赞 2018-05-23 18:43:19
    官方定义为:”Netty 是一款异步的事件驱动的网络应用程序框架,支持快速地开发可维护的高性能的面向协议的服务器 和客户端”,按照惯例贴上一张High Level的架构图: 纵观Java系的多种服务器/大数据框架,都离不...

    1. 简介

    官方定义为:”Netty 是一款异步的事件驱动的网络应用程序框架,支持快速地开发可维护的高性能的面向协议的服务器
    和客户端”,按照惯例贴上一张High Level的架构图:

    这里写图片描述

    纵观Java系的多种服务器/大数据框架,都离不开Netty做出的贡献,本文对Netty做一个简单的概述

    2. 主要特性

    Netty有很多重要的特性,主要特性如下:
    - 优雅的设计
    - 统一的API接口,支持多种传输类型,例如OIO,NIO
    - 简单而强大的线程模型
    - 丰富的文档
    - 卓越的性能
    - 拥有比原生Java API 更高的性能与更低的延迟
    - 基于池化和复用技术,使资源消耗更低
    - 安全性
    - 完整的SSL/TLS以及StartTLS支持
    - 可用于受限环境,如Applet以及OSGI

    Netty的以上特性,比较适合客户端数据较大的请求/处理场景,例如web服务器等,要想知道有哪些系统使用了Netty,可以参考:http://netty.io/wiki/adopters.html

    3. 主要术语

    在正式开始之前,先对Netty涉及到的一些术语做个简单的说明

    3.1 IO模型:BIO/NIO/Netty

    3.1.1 BIO(Blocking IO):阻塞IO

    早期的Java API(java.net)提供了由本地系统套接字库提供的所谓的阻塞函数,样例代码如下:

    ServerSocket serverSocket = new ServerSocket(portNumber);
    Socket clientSocket = serverSocket.accept();
    BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
    PrintWriter out =new PrintWriter(clientSocket.getOutputStream(), true);
    String request, response;
    while ((request = in.readLine()) != null) {
        if ("Done".equals(request)) {
            break;
    }
    response = processRequest(request);
    out.println(response);
    }
    

    这段代码片段将只能同时处理一个连接,要管理多个并发客户端,需要为每个新的客户端
    Socket 创建一个新的 Thread,线程模型如下图所示:

    这里写图片描述

    该种模型存在以下两个问题:
    1. 在任何时候都可能有大量的线程处于休眠状态,只是等待输入或者输出数据就绪,这可能算是一种资源浪费
    2. 需要为每个线程的调用栈都分配内存
    3. 即使 Java 虚拟机(JVM) 在物理上可以支持非常大数量的线程, 但是远在到达该极限之前, 上下文切换所带来的开销就会带来麻烦

    3.1.2 NIO(Non Blocking IO):非阻塞IO

    Java的NIO特性在JDK 1.4中引入,其结构如下:

    这里写图片描述

    从该图可以看出Selector 是Java 的非阻塞 I/O 实现的关键。它使用了事件通知 API
    以确定在一组非阻塞套接字中有哪些已经就绪能够进行 I/O 相关的操作。因为可以在任何的时间检查任意的读操作或者写操作的完成状态。该种模型下,一个单一的线程便可以处理多个并发的连接。
    与BIO相比,该模型有以下特点:
    1. 使用较少的线程便可以处理许多连接,因此也减少了内存管理和上下文切换所带来开销
    2. 当没有 I/O 操作需要处理的时候,线程也可以被用于其他任务

    虽然Java 的NIO在性能上比BIO已经相当的优秀,但是要做到如此正确和安全并
    不容易。特别是,在高负载下可靠和高效地处理和调度 I/O 操作是一项繁琐而且容易出错的任务,此时就时Netty上场的时间了。

    3.1.3 Netty

    Netty对NIO的API进行了封装,通过以下手段让性能又得到了一定程度的提升
    1. 使用多路复用技术,提高处理连接的并发性
    2. 零拷贝:
    1. Netty的接收和发送数据采用DIRECT BUFFERS,使用堆外直接内存进行Socket读写,不需要进行字节缓冲区的二次拷贝
    2. Netty提供了组合Buffer对象,可以聚合多个ByteBuffer对象进行一次操作
    3. Netty的文件传输采用了transferTo方法,它可以直接将文件缓冲区的数据发送到目标Channel,避免了传统通过循环write方式导致的内存拷贝问题
    3. 内存池:为了减少堆外直接内存的分配和回收产生的资源损耗问题,Netty提供了基于内存池的缓冲区重用机制
    4. 使用主从Reactor多线程模型,提高并发性
    5. 采用了串行无锁化设计,在IO线程内部进行串行操作,避免多线程竞争导致的性能下降
    6. 默认使用Protobuf的序列化框架
    7. 灵活的TCP参数配置

    详细说明,可参考: http://www.infoq.com/cn/articles/netty-high-performance#anch111813

    3.1.4 简单的性能测试

    通过在本地分别使用BIO,NIO,Netty NIO实现了一个简单的服务端程序(该程序接收到请求后,sleep 1毫秒,并返回简单的一句话)分别对三种方式使用Jemeter进行性能测试(一百个并发,每个并发发送一百个相同消息),结果如下:

    单线程的java net:

    这里写图片描述

    NIO:
    这里写图片描述

    Netty NIO:
    这里写图片描述

    以上结果或是受到其他条件的影响,结果仅供供参考

    3.2 Callback:

    回调在广泛的编程场景中都有应用,一般是在完成某个特定的操作后对相关方法进行调用。

    Netty 在内部使用回调来处理事件;当一个回调被触发时,相关的事件可以被一个 interfaceChannelHandler 的实现处理,例如Channel激活时会调用ChannelActive方法,样例代码如下:

    public class ConnectHandler extends ChannelInboundHandlerAdapter {
    @Override
        public void channelActive(ChannelHandlerContext ctx)throws Exception {
            System.out.println("Client " + ctx.channel().remoteAddress() + connected");
    
        }
    }

    3.3 Future:

    Future一般用在当执行异步操作时需要获取未来的某个时候才能获取到的结果。

    JDK 预置了 interface java.util.concurrent.Future,但是其所提供的实现,只
    允许手动检查对应的操作是否已经完成,或者一直阻塞直到它完成。这是非常繁琐的,所以 Netty提供了它自己的实现——ChannelFuture,用于在执行异步操作的时候使用。

    ChannelFuture提供了几种额外的方法,这些方法使得我们能够注册一个或者多个
    ChannelFutureListener实例。监听器的回调方法operationComplete(),将会在对应的
    操作完成时被调用。然后监听器可以判断该操作是成功地完成了还是出错了。如果是后者,我们可以检索产生的Throwable。 通过使用ChannelFutureListener机制可以避免对
    操作结果进行手动检查。

    每个 Netty 的出站 I/O 操作都将返回一个ChannelFuture,即不会阻塞后续的操作。

    下面的例子中的connect()方法会直接返回,后续的成功或失败将由其注册的FutureListener来处理。

            try {
                // 使用异步的方式连接Server,不管成功失败,都是执行下面System.out的语句,最后的连接结果由FutureListener进行处理
                ChannelFuture future = bootstrap.connect();
                System.out.println("Finished connect operation");
                future.addListener((ChannelFutureListener) future1 -> {
                    if (future1.isSuccess()){
                        ByteBuf buffer = Unpooled.copiedBuffer(
                                "Hello", Charset.defaultCharset());
                        ChannelFuture wf = future1.channel()
                                .writeAndFlush(buffer);
                        System.out.println("Connect successful!");
                    }else{
                        System.out.println("Connect failed!");
                        Throwable cause = future1.cause();
                        cause.printStackTrace();
                    }
                });
                System.out.println("Finished connect operation2");
                future.channel().closeFuture().sync();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    

    最后的打印结果如下:

    Finished connect operation
    Finished connect operation2
    Connect failed!
    io.netty.channel.AbstractChannel$AnnotatedConnectException: Connection refused: no further information: localhost/127.0.0.1:8888
        at sun.nio.ch.SocketChannelImpl.checkConnect(Native Method)
        at sun.nio.ch.SocketChannelImpl.finishConnect(SocketChannelImpl.java:717)
        at io.netty.channel.socket.nio.NioSocketChannel.doFinishConnect(NioSocketChannel.java:325)
        at io.netty.channel.nio.AbstractNioChannel$AbstractNioUnsafe.finishConnect
        ...............................................
        Caused by: java.net.ConnectException: Connection refused: no further information
        ... 11 more

    3.4 Event

    Netty 使用不同的事件来通知状态的改变或者是操作的状态。事件可能包括:
    - 连接已被激活或者连接失活
    - 数据读取;
    - 用户事件;
    - 错误事件。
    - 打开或者关闭到远程节点的连接;
    - 将数据写到或者冲刷到套接字。

    每个事件都可以被分发给 ChannelHandler 类中的某个用户实现的方法。这是将事件驱动范式直接转换为应用程序逻辑处理比较理想的位置。
    下图展示了事件是怎么被处理的:

    这里写图片描述

    对每个事件可以进行,记录日志,数据转换,应用程序逻辑处理等操作,

    Netty 提供了大量预定义的可以开箱即用的 ChannelHandler 实现,包括用于各种协议
    (如 HTTP 和 SSL/TLS)的 ChannelHandler。后续博文会对一些Handler进行简单的介绍

    展开全文
  • 小白科普:Netty有什么用?

    万次阅读 多人点赞 2017-12-21 10:17:50
    随着移动互联网的爆发性增长,小明公司的电子商务系统访问量越来越大,由于现有系统是个单体的巨型应用,已经无法满足海量的并发请求,拆分势在必行。 ...在微服务的大潮之中, 架构师小明把系统拆分成了多个...

    随着移动互联网的爆发性增长,小明公司的电子商务系统访问量越来越大,由于现有系统是个单体的巨型应用,已经无法满足海量的并发请求,拆分势在必行。


    640?wx_fmt=png&wxfrom=5&wx_lazy=1

    在微服务的大潮之中, 架构师小明把系统拆分成了多个服务,根据需要部署在多个机器上,这些服务非常灵活,可以随着访问量弹性扩展。


    640?wx_fmt=png&wxfrom=5&wx_lazy=1

    世界上没有免费的午餐, 拆分成多个“微服务”以后虽然增加了弹性,但也带来了一个巨大的挑战:服务之间互相调用的开销


    比如说:原来用户下一个订单需要登录,浏览产品详情,加入购物车,支付,扣库存等一系列操作,在单体应用的时候它们都在一台机器的同一个进程中,说白了就是模块之间的函数调用,效率超级高。 


    现在好了,服务被安置到了不同的服务器上,一个订单流程,几乎每个操作都要越网络,都是远程过程调用(RPC), 那执行时间、执行效率可远远比不上以前了。


    远程过程调用的第一版实现使用了HTTP协议,也就是说各个服务对外提供HTTP接口。 小明发现,HTTP协议虽然简单明了,但是废话太多,仅仅是给服务器发个简单的消息都会附带一大堆无用信息:

    GET /orders/1 HTTP/1.1                                                                                             

    Host: order.myshop.com

    User-Agent: Mozilla/5.0 (Windows NT 6.1; )

    Accept: text/html;

    Accept-Language: en-US,en;

    Accept-Encoding: gzip

    Connection: keep-alive

    ......


    看看那User-Agent,Accept-Language ,这个协议明显是为浏览器而生的!但是我这里是程序之间的调用,用这个HTTP有点亏。


    能不能自定义一个精简的协议? 在这个协议中我只需要把要调用方法名和参数发给服务器即可,根本不用这么多乱七八糟的额外信息。


    但是自定义协议客户端和服务器端就得直接使用“低级”的Socket了,尤其是服务器端,得能够处理高并发的访问请求才行。 


    小明复习了一下服务器端的socket编程,最早的Java是所谓的阻塞IO(Blocking IO), 想处理多个socket的连接的话需要创建多个线程, 一个线程对应一个。


    640?wx_fmt=png


    这种方式写起来倒是挺简单的,但是连接(socket)多了就受不了了,如果真的有成千上万个线程同时处理成千上万个socket,占用大量的空间不说,光是线程之间的切换就是一个巨大的开销。


    更重要的是,虽然有大量的socket,但是真正需要处理的(可以读写数据的socket)却不多,大量的线程处于等待数据状态(这也是为什么叫做阻塞的原因),资源浪费得让人心疼。


    后来Java为了解决这个问题,又搞了一个非阻塞IO(NIO:Non-Blocking IO,有人也叫做New IO), 改变了一下思路:通过多路复用的方式让一个线程去处理多个Socket。


    640?wx_fmt=png

    这样一来,只需要使用少量的线程就可以搞定多个socket了,线程只需要通过Selector去查一下它所管理的socket集合,哪个Socket的数据准备好了,就去处理哪个Socket,一点儿都不浪费。


    好了,就是Java NIO了!


    小明先定义了一套精简的RPC的协议,里边规定了如何去调用一个服务,方法名和参数该如何传递,返回值用什么格式......等等。然后雄心勃勃地要把这个协议用Java NIO给实现了。


    可是美好的理想很快被无情的现实给击碎, 小明努力了一周就意识到自己陷入了一个大坑之中,Java NIO虽然看起来简单,但是API还是太“低级”了,有太多的复杂性,没有强悍的、一流的编程能力根本无法驾驭,根本做不到高并发情况下的可靠和高效。


    小明不死心,继续向领导要人要资源,一定要把这个坑给填上,挣扎了6个月以后,终于实现了一个自己的NIO框架,可以执行高并发的RPC调用了。 


    然后又是长达6个月的修修补补,小明经常半夜被叫醒:生产环境的RPC调用无法返回了! 这样的Bug不知道改了多少个。


    在那些不眠之夜中,小明经常仰天长叹:我用NIO做个高并发的RPC框架怎么这么难呐!


    一年之后,自研的框架终于稳定,可是小明也从张大胖那里听到了一个让他崩溃的消息: 小明你知道吗?有个叫Netty的开源框架,可以快速地开发高性能的面向协议的服务器和客户端。 易用、健壮、安全、高效,你可以在Netty上轻松实现各种自定义的协议!咱们也试试?


    小明赶紧研究,看完后不由得“泪流满面”:这东西怎么不早点出来啊!


    好了,这个故事我快编不下去了,要烂尾了。smiley_5.png


    说说Netty到底是何方神圣, 要解决什么问题吧。


    像上面小明的例子,想使用Java NIO来实现一个高性能的RPC框架,调用协议,数据的格式和次序都是自己定义的,现有的HTTP根本玩不转,那使用Netty就是绝佳的选择。


    其实游戏领域是个更好的例子,长连接,自定义协议,高并发,Netty就是绝配。


    因为Netty本身就是一个基于NIO的网络框架, 封装了Java NIO那些复杂的底层细节,给你提供简单好用的抽象概念来编程。


    注意几个关键词,首先它是个框架,是个“半成品”,不能开箱即用,你必须得拿过来做点定制,利用它开发出自己的应用程序,然后才能运行(就像使用Spring那样)。 


    一个更加知名的例子就是阿里巴巴的Dubbo了,这个RPC框架的底层用的就是Netty。 


    另外一个关键词是高性能,如果你的应用根本没有高并发的压力,那就不一定要用Netty了。




    优秀人才不缺工作机会,只缺适合自己的好机会。但是他们往往没有精力从海量机会中找到最适合的那个。

    100offer 会对平台上的人才和企业进行严格筛选,让「最好的人才」和「最好的公司」相遇。

    扫描下方二维码,注册 100offer,谈谈你对下一份工作的期待。一周内,收到 5-10 个满足你要求的好机会!


    0?wx_fmt=jpeg



    展开全文
  • Netty涉及内容很多(比如:设计模式、数据结构、并发、同步、异步,阻塞等),目前网上的Netty课程不多,且普遍讲解晦涩难懂,内容浅尝辄止,导致很多学习者只知道Netty的核心组件,但不知道怎么使用到项目之中。...
  • Netty是什么

    千次阅读 2018-03-02 10:27:07
    链接:https://www.zhihu.com/question/24322387/answer/282001188作为一个学Java的,如果没有研究过Netty,那么你...如果你要进阶,想了解Java服务器的深层高阶知识,Netty绝对是一个必须要过的门槛。有了Netty,你...
  • Netty的使用:Server和Client通信

    万次阅读 多人点赞 2018-10-13 22:33:43
    Netty 是一款基于NIO(Nonblocking I/O,非阻塞IO)开发的网络通信框架,提供异步的、事件驱动的网络应用程序框架和工具,用以快速开发高性能、高可靠性的网络服务器和客户端程序。对比于BIO(Blocking I/O,阻塞IO...
  • Netty作用

    千次阅读 多人点赞 2018-09-18 09:11:33
    随着移动互联网的爆发性增长,小明公司的电子商务系统访问量越来越大,由于现有系统是个单体的巨型应用,已经无法满足海量的并发请求,拆分势在必行。   在微服务的大潮之中, 架构师小明把系统拆分成了多个...
  • Netty整体架构

    千次阅读 多人点赞 2018-09-12 10:18:29
    每学习一门语言或者一种框架,写一个Hello World都是一个不错的入门,上一篇我们用Netty实现了一个简单的Hello World,简单粗暴直接上代码,这篇文章将从Netty整体结构上介绍。本人文笔不好,平时记云笔记只需自己能...
  • Netty框架

    万次阅读 2020-02-15 14:41:17
    什么是netty? 官方解释: Netty is a NIO client server framework which enables quick and easy development of network applications such as protocol servers and clients. It greatly simplifies and ...
  • Netty——基本使用介绍

    万次阅读 多人点赞 2017-10-20 14:12:11
    1.为什么选择Netty 上一篇文章我们已经了解了Socket通信(IO/NIO/AIO)编程,对于通信模型已经有了一个基本的认识。其实上一篇文章中,我们学习的仅仅是一个模型,如果想把这些真正的用于实际工作中,那么还需要不断...
  • Netty工作原理最详细分析

    万次阅读 2018-09-12 15:35:39
    NIO通讯服务端步骤: 1、创建ServerSocketChannel,为它配置非阻塞模式 2、绑定监听,配置TCP参数,录入backlog大小等 3、创建一个独立的IO线程,用于轮询多路复用器Selector ...5、启动IO线程,在循环体中执行S...
  • Netty和Tomcat有什么区别

    万次阅读 2018-04-21 22:55:17
    Netty和Tomcat有什么区别? Netty和Tomcat最大的区别就在于通信协议,Tomcat是基于Http协议的,他的实质是一个基于http协议的web容器,但是Netty不一样,他能通过编程自定义各种协议,因为netty能够通过codec自己来...
  • Netty网络处理之客户端主动关闭

    万次阅读 2018-01-18 09:54:43
    TCP状态变化 应用层及时关闭连接:ESTABLISHED –> CLOSE_WAIT –> LAST_ACK –> CLOSED;...Netty处理过程 TCP状态进入CLOSE_WAIT时会产生OP_READ事件通知应用层,Netty从socket读取数据时返回-1,close被设为
  • 大家好,我想用netty做服务系统,没有用其他的java服务器,服务开启后会一直监听端口,想请问一下怎么停止服务,不用kill _9,谢谢
  • Netty是什么?为什么这么火? Netty是目前最流行的由JBOSS提供的一个Java开源框架NIO框架,Netty提供异步的、事件驱动的网络应用程序框架和工具,用以快速开发高性能、高可靠性的网络服务器和客户端程序。 相比JDK...
  • IntelliJ IDEA 导入Netty

    千次阅读 2017-05-22 10:13:51
    IDEA 导入netty
  • Mina和Netty的选择

    万次阅读 2016-06-16 13:41:24
    Mina和Netty都是Java领域高性能和高可伸缩性网络应用程序的网络应用框架,在实际生产应用中都是不错的佼佼者。 Netty 是由JBOSS提供的一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具,用以...
  • netty5 怎么同时监听843和一个其他端口呢,如843和9229这两个端口,有没有具体的代码呢?谢谢
  • Netty权威指南(第2版) pdf百度网盘下载

    千次阅读 多人点赞 2019-09-25 00:36:45
    链接: https://pan.baidu.com/s/1DfxG9qKU2fshi6ha1a8NkA 提取码: bmt4
1 2 3 4 5 ... 20
收藏数 93,249
精华内容 37,299
关键字:

netty