Netty基础入门（二）

最新推荐文章于 2024-04-30 06:49:00 发布
最新推荐文章于 2024-04-30 06:49:00 发布
阅读量1.4k 收藏 1
点赞数
分类专栏： Netty 系统架构 文章标签： netty
参考： http://wiki.jikexueyuan.com/project/netty-4-user-guide/

1.为什么选择Netty

上一篇文章我们已经了解了Socket通信（IO/NIO/AIO）编程，对于通信模型已经有了一个基本的认识。其实上一篇文章中，我们学习的仅仅是一个模型，如果想把这些真正的用于实际工作中，那么还需要不断的完善、扩展和优化。比如经典的TCP读包写包问题，或者是数据接收的大小，实际的通信处理与应答的处理逻辑等等一些细节问题需要认真的去思考，而这些都需要大量的时间和经历，以及丰富的经验。所以想学好Socket通信不是件容易事，那么接下来就来学习一下新的技术Netty，为什么会选择Netty？因为它简单！使用Netty不必编写复杂的逻辑代码去实现通信，再也不需要去考虑性能问题，不需要考虑编码问题，半包读写等问题。强大的Netty已经帮我们实现好了，我们只需要使用即可。

Netty是最流行的NIO框架，它的健壮性、功能、性能、可定制性和可扩展性在同类框架都是首屈一指的。它已经得到成百上千的商业/商用项目验证，如Hadoop的RPC框架Avro、RocketMQ以及主流的分布式通信框架Dubbox等等。

2.Netty简介

Netty是基于Java NIO client-server的网络应用框架，使用Netty可以快速开发网络应用，例如服务器和客户端协议。Netty提供了一种新的方式来开发网络应用程序，这种新的方式使它很容易使用和具有很强的扩展性。Netty的内部实现是很复杂的，但是Netty提供了简单易用的API从网络处理代码中解耦业务逻辑。Netty是完全基于NIO实现的，所以整个Netty都是异步的。

网络应用程序通常需要有较高的可扩展性，无论是Netty还是其他的基于Java Nio的框架，都会提供可扩展性的解决方案。Netty中一个关键组成部分是它的异步特性，本片文章将讨论同步（阻塞）和异步（非阻塞）的IO来说明为什么使用异步代码解决扩展性问题以及如何使用异步。

3.Netty架构组成（借用一下网上的图片）


Netty实现原理浅析，写的很不错，感兴趣的可以看一下。

4.Helloworld入门

在学习Netty之前，先来回顾一下NIO的通信步骤：

①创建ServerSocketChannel，为其配置非阻塞模式。

②绑定监听，配置TCP参数，录入backlog大小等。

③创建一个独立的IO线程，用于轮询多路复用器Selector。

④创建Selector，将之前创建的ServerSocketChannel注册到Selector上，并设置监听标识位SelectionKey.OP_ACCEPT。

⑤启动IO线程，在循环体中执行Selector.select()方法，轮询就绪的通道。

⑥当轮询到处于就绪状态的通道时，需要进行操作位判断，如果是ACCEPT状态，说明是新的客户端接入，则调用accept方法接收新的客户端。

⑦设置新接入客户端的一些参数，如非阻塞，并将其继续注册到Selector上，设置监听标识位等。

⑧如果轮询的通道标识位是READ，则进行读取，构造Buffer对象等。

⑨更细节的问题还有数据没发送完成继续发送的问题......

好啦，开始学习Netty了。先去http://netty.io/上下载所有的Netty包。

Netty通信的步骤：

①创建两个NIO线程组，一个专门用于网络事件处理（接受客户端的连接），另一个则进行网络通信的读写。

②创建一个ServerBootstrap对象，配置Netty的一系列参数，例如接受传出数据的缓存大小等。

③创建一个用于实际处理数据的类ChannelInitializer，进行初始化的准备工作，比如设置接受传出数据的字符集、格式以及实际处理数据的接口。

④绑定端口，执行同步阻塞方法等待服务器端启动即可。

强烈推荐读一读Netty官方翻译文档。

好了，说了那么多，下面就来HelloWorld入门吧！

服务器端 

package com.alen.netty.s1.bhz.netty.helloworld;

import io.netty.bootstrap.ServerBootstrap;
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.NioServerSocketChannel;

public class Server {

    public static void main(String[] args) throws Exception {
        //1 创建线两个程组
        //一个是用于处理服务器端接收客户端连接的
        //一个是进行网络通信的（网络读写的）
        EventLoopGroup pGroup = new NioEventLoopGroup();
        EventLoopGroup cGroup = new NioEventLoopGroup();
        try {
            //2 创建辅助工具类，用于服务器通道的一系列配置
            ServerBootstrap b = new ServerBootstrap();
            b.group(pGroup, cGroup)        //绑定俩个线程组
                    .channel(NioServerSocketChannel.class)        //指定NIO的模式
                    .option(ChannelOption.SO_BACKLOG, 1024)        //设置tcp缓冲区
                    .option(ChannelOption.SO_SNDBUF, 32 * 1024)    //设置发送缓冲大小
                    .option(ChannelOption.SO_RCVBUF, 32 * 1024)    //这是接收缓冲大小
                    .option(ChannelOption.SO_KEEPALIVE, true)    //保持连接
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel sc) throws Exception {
                            //3 在这里配置具体数据接收方法的处理
                            sc.pipeline().addLast(new ServerHandler());
                        }
                    })
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childOption(ChannelOption.SO_KEEPALIVE, true); // (6);
            /**
             * (5)
             * 对于ChannelOption.SO_BACKLOG的解释：
             * 服务器端TCP内核维护有两个队列，我们称之为A、B队列。客户端向服务器端connect时，会发送带有SYN标志的包（第一次握手），服务器端
             * 接收到客户端发送的SYN时，向客户端发送SYN ACK确认（第二次握手），此时TCP内核模块把客户端连接加入到A队列中，然后服务器接收到
             * 客户端发送的ACK时（第三次握手），TCP内核模块把客户端连接从A队列移动到B队列，连接完成，应用程序的accept会返回。也就是说accept
             * 从B队列中取出完成了三次握手的连接。
             * A队列和B队列的长度之和就是backlog。当A、B队列的长度之和大于ChannelOption.SO_BACKLOG时，新的连接将会被TCP内核拒绝。
             * 所以，如果backlog过小，可能会出现accept速度跟不上，A、B队列满了，导致新的客户端无法连接。要注意的是，backlog对程序支持的
             * 连接数并无影响，backlog影响的只是还没有被accept取出的连接
             */

            //4 绑定端口，开始接收进来的连接
            ChannelFuture cf1 = b.bind(8765).sync();
            //ChannelFuture cf2 = b.bind(8764).sync();
            //5 等待关闭
            cf1.channel().closeFuture().sync();
            //cf2.channel().closeFuture().sync();
        } finally {
            //shutdownGracefully() 方法来关闭你构建的所有的 EventLoopGroup。
            //当EventLoopGroup 被完全地终止,并且对应的所有 channel 都已经被关闭时，
            //Netty 会返回一个Future对象来通知你。
            pGroup.shutdownGracefully();
            cGroup.shutdownGracefully();
        }

    }

}

ServerHandler类： 
package com.alen.netty.s1.bhz.netty.helloworld;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.ReferenceCountUtil;

public class ServerHandler extends ChannelInboundHandlerAdapter {

	//channelActive()：客户端连接服务器后被调用
	@Override
	public void channelActive(ChannelHandlerContext ctx) throws Exception {
		System.out.println("server channel active... ");
	}

	//从服务器接收到数据后调用
	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg)
			throws Exception {
		try {
			// Do something with msg
			ByteBuf buf = (ByteBuf) msg;
			byte[] req = new byte[buf.readableBytes()];
			buf.readBytes(req);
			String body = new String(req, "utf-8");
			System.out.println("Server :" + body );
			String response = "进行返回给客户端的响应：" + body ;
//			ctx.write(Object) 方法不会使消息写入到通道上，他被缓冲在了内部，
//			你需要调用 ctx.flush() 方法来把缓冲区中数据强行输出。
//			或者你可以用更简洁的 cxt.writeAndFlush(msg) 以达到同样的目的。
			ctx.writeAndFlush(Unpooled.copiedBuffer(response.getBytes()));
			//.addListener(ChannelFutureListener.CLOSE);
		} finally {
			ReferenceCountUtil.release(msg);
		}

	}

	@Override
	public void channelReadComplete(ChannelHandlerContext ctx)
			throws Exception {
		System.out.println("读完了");
		ctx.flush();
	}

	//	发生异常时被调用
	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable t)
			throws Exception {
		ctx.close();
	}

}

客户端： 
package com.alen.netty.s1.bhz.netty.helloworld;

import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
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 Client {
	public static void main(String[] args) throws Exception{
		EventLoopGroup group = new NioEventLoopGroup();
		try {
		       //BootStrap 和 ServerBootstrap 类似,不过他是对非服务端的 channel 而言，比如客户端或者无连接传输模式的 channel。
			Bootstrap b = new Bootstrap();
			b.group(group)
					.channel(NioSocketChannel.class)
					.handler(new ChannelInitializer<SocketChannel>() {
						@Override
						protected void initChannel(SocketChannel sc) throws Exception {
							sc.pipeline().addLast(new ClientHandler());
						}
					});
			ChannelFuture cf1 = b.connect("127.0.0.1", 8765).sync();
			//ChannelFuture cf2 = b.connect("127.0.0.1", 8764).sync();
			//发送消息
			Thread.sleep(1000);
			cf1.channel().writeAndFlush(Unpooled.copiedBuffer("777".getBytes()));
			cf1.channel().writeAndFlush(Unpooled.copiedBuffer("666".getBytes()));
			//cf2.channel().writeAndFlush(Unpooled.copiedBuffer("888".getBytes()));
			Thread.sleep(2000);
			cf1.channel().writeAndFlush(Unpooled.copiedBuffer("888".getBytes()));
			//cf2.channel().writeAndFlush(Unpooled.copiedBuffer("666".getBytes()));
			cf1.channel().closeFuture().sync();
			//cf2.channel().closeFuture().sync();
		} finally {
			group.shutdownGracefully();
		}

	}
}

ClientHandler类： 

package com.alen.netty.s1.bhz.netty.helloworld;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.ReferenceCountUtil;

public class ClientHandler extends ChannelInboundHandlerAdapter {


	@Override
	public void channelActive(ChannelHandlerContext ctx) throws Exception {
	}

	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
		try {
			ByteBuf buf = (ByteBuf) msg;
			byte[] req = new byte[buf.readableBytes()];
			buf.readBytes(req);
			String body = new String(req, "utf-8");
			System.out.println("Client :" + body );
			String response = "收到服务器端的返回信息：" + body;
		} finally {
			ReferenceCountUtil.release(msg);
		}
	}

	@Override
	public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

	}

	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
			throws Exception {
		ctx.close();
	}

}

闻道☞
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
netty的基本介绍
weixin_42408447的博客
05-21 1万+
一.什么是netty？为什么要用netty netty是jboss提供的一个java开源框架，netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可用性的网络服务器和客户端程序。也就是说netty是一个基于nio的编程框架，使用netty可以快速的开发出一个网络应用。 由于java 自带的nio api使用起来非常复杂，并且还可能出现 Epoll Bug，这使得我们使用原生的nio来进行网络编程存在很大的难度且非常耗时。但是netty良好的设计可以使开发人员快速高效的进行网络应用开
netty入门进阶之前
06-01
Netty 是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议...这些知识点构成了Netty的核心部分，为初学者提供了扎实的入门基础。学习并理解这些内容，将有助于构建高效、稳定的网络应用。
搭建简单的Netty开发环境
热门推荐
Stormer的博客
10-23 2万+
今天准备学学声明显赫的Netty框架，自然要先学会怎么搭建一个简单的Netty开发环境啦。话不多说，下面进入正文。 编辑器方面自然是推荐IntelJ idea了，idea的强大不必多说，百度一下你就知道。哈哈 下面就是准备Netty的jar包了，如果你会maven的话自然是使用maven最为方便了。只需要在pom文件中导入以下几行 &lt;!-- https://mvnrepository...
Netty（二）
残影的博客
01-16 539
Netty一、Netty概述1.1 原生NIO存在的问题1.2 Netty官网说明 一、Netty概述 1.1 原生NIO存在的问题 NIO 的类库和 API 繁杂，使用麻烦:需要熟练掌握 Selector、ServerSocketChannel、SocketChannel、ByteBuffer 等。 需要具备其他的额外技能:要熟悉 Java 多线程编程，因为 NIO 编程涉及到 Reactor模式，你必须对多线程 和网络编程非常熟悉，才能编写出高质量的 NIO 程序。 开发工作量和难度都非常大:例如客户
Netty最全入门教程！
最新发布
2301_76348344的博客
04-30 964
看完美团、字节、腾讯这三家的一二三面试问题，是不是感觉问的特别多，可能咱们真的又得开启面试造火箭、工作拧螺丝的模式去准备下一次的面试了。开篇有提及我可是足足背下了Java互联网工程师面试1000题，多少还是有点用的呢，换汤不换药，不管面试官怎么问你，抓住本质即可！能读到此处的都是真爱Java互联网工程师面试1000题。
什么是netty--通俗易懂
lisheng19870305的专栏
07-02 1万+
一．Netty介绍 1.什么是netty Netty是由JBOSS提供的一个Java开源框架。Netty提供异步的、基于事件驱动的网络应用程序框架，用以快速开发高性能、高可靠性的网络IO程序,是目前最流行的NIO框架，Netty在互联网领域、大数据分布式计算领域、游戏行业、通信行业等获得了广泛的应用，知名的Elasticsearch、Dubbo框架内部都采用了Netty。 2.为什么要用netty 原生NIO存在问题: 1.NIO的类库和API繁杂 2.需...
一文理解Netty模型架构
weixin_34082789的博客
11-01 1221
作者 陈彩华 贝聊后端开发工程师 文章转载交流请联系 caison@aliyun.com 复制代码本文基于Netty4.1展开介绍相关理论模型，使用场景，基本组件、整体架构，知其然且知其所以然，希望给读者提供学习实践参考。 1 Netty简介 Netty是 一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。 JDK原生NIO程序的问题 JDK原生也有一套网络应用...
netty入门案例.zip
04-18
Netty 是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和...这个案例对于初学者来说是一个很好的起点，可以帮助你快速掌握 Netty 的基础，并为进一步深入学习打下坚实的基础。
netty开发入门
01-25
这个“netty开发入门”资料主要涵盖了如何使用Netty进行基础的网络通信，包括创建简单的"Hello World"示例以及实现服务器与客户端的交互。 一、Netty简介 Netty是由JBOSS提供的一个Java开源框架，它简化了网络编程...
Netty-入门Netty编码
08-14
这个教程将引导我们入门 Netty 编码，让我们深入理解其核心概念和实际应用。 首先，Netty 的核心是其设计模式，即 Reactor 模式，也称为事件驱动模型。Reactor 模式允许 Netty 高效地处理大量并发连接，通过非阻塞 ...
netty从入门到精通所有代码
12-27
这个“Netty 从入门到精通所有代码”压缩包包含了一系列的示例代码，帮助开发者逐步理解并掌握 Netty 的核心概念和实际应用。 1. **Netty 基本概念** - **NIO (Non-blocking I/O)**：Netty 是基于 Java NIO 构建的...
Netty 介绍
木牛的博客
06-30 2913
1.1. Netty 原理Netty 是一个高性能、异步事件驱动的 NIO 框架，基于 JAVA NIO 提供的 API 实现。它提供了对TCP、UDP 和文件传输的支持，作为一个异步 NIO 框架，Netty 的所有 IO 操作都是异步非阻塞的，通过 Future-Listener 机制，用户可以方便的主动获取或者通过通知机制获得 IO 操作结果。1.2. Netty 高性能在 IO 编程过程中，当需要同时处理多个客户端接入请求时，可以利用多线程或者 IO 多路复用技术进行处理。IO 多路复用技术通过把多
Netty 介绍、使用场景及案例
日常记录
01-11 5257
https://github.com/netty/nettyNetty是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可扩展的网络服务器和客户端。它是一个开源项目，最初由JBoss公司开发，现在由社区维护。Netty的设计和实现以处理高并发、低延迟、可靠性和灵活性为目标，因此非常适合构建各种网络应用，包括网络服务器、代理、聊天应用、在线游戏、实时通信和分布式系统等。以下是一些Netty的主要特点和优势：异步和事件驱动：Netty采用异步非阻塞的IO模型，允许处理大量并发连接而不会阻塞应用程序线程。
Netty全面解析
qq_45443475的博客
08-19 2642
Netty全面解析
Netty（一）
hd20086996的博客
01-29 1646
netty（一）第 1 章 Netty 介绍和应用场景1.1 本课程学习要求1.2 Netty 的介绍1.3 Netty 的应用场景1.4 Netty 的学习资料参考第 2 章 Java BIO 编程2.1 I/O 模型2.2 BIO、NIO、AIO 使用场景分析2.3 Java BIO 基本介绍2.4 Java BIO 工作机制2.5 Java BIO 应用实例2.6 Java BIO 问题分析第 3 章 Java NIO 编程3.1 Java NIO 基本介绍3.2 NIO 和 BIO 的比较3.3 N
Netty和Tomcat区别
weixin_42354735的博客
11-02 8560
Netty与Tomcat区别 它们的区别不少，最大的区别就在于通信协议，这是众所周知的，Tomcat是一个服务器，它一定是基于Http协议的，它的实质是一个基于http协议的web容器，Netty则不同，Netty可以通过编程自定义各种协议，这是因为netty能够通过codec自己来编码/解码字节流，完成一种类似redis访问的功能，这就是它们之间最大的不同。 事实上很多人都说netty的性能肯定比tomcat性能高，实际tomcat从6.x开始就一直支持nio模式，且后续还有arp模式，这是一种通过j
Netty
飘然生的博客
05-06 2087
Netty实战精髓篇 常见的网络通信框架？ Netty（JBoss） Mina（Apach） Grizzly（sum） 前言。BIO和NIO的通信流程区别 中间多插入一个多路复用器 BIO:服务端——线程——socket——客户端 （有几个客户端就有几个线程） NIO:服务端——线程——selector——socket——客户端 （一个线程，一个多路复用器进行轮询） 一。...
Netty 是什么，我们为什么使用 Netty
不会骑摩托的程序员不是好的摄影师
04-17 1962
为什么要学习Netty： 在java的网络编程方面，最开始的BIO 到现在被广泛使用的NIO，它们都能完成网络编程的工作，但是使用原生的java API去完成网络编程，往往非常困难。连接管理、消息分割、数据编解码，还有对应应用层协议的实现，这些对开发人员的要求非常高。所以使用和学习Netty这样的网络框架是非常有必要的。 Netty是什么： Netty是对 Java NIO 的进一步封装，实现了众多的协议，并且提供了更加易用的API来帮助我们进行网络编程。本篇博客对Netty的概念进行了详细说名，并且介绍
Netty详解
summer07071126的博客
06-01 1614
Netty 是基于 Java NIO 的异步事件驱动的网络应用框架，使用 Netty 可以快速开发网络应用，Netty 提供了高层次的抽象来简化 TCP 和 UDP 服务器的编程，但是你仍然可以使用底层的 API。Netty 的内部实现是很复杂的，但是 Netty 提供了简单易用的API从网络处理代码中解耦业务逻辑。Netty 是完全基于 NIO 实现的，所以整个 Netty 都是异步的。
Netty 基础知识点学习汇总
11-18
Netty基础知识点学习汇总涵盖了NIO（Non-blocking I/O）在Java网络编程中的核心应用，适合初学者系统理解和掌握。主要内容包括： 1. **概述** - Netty是一款高性能的异步事件驱动的网络通信框架，主要利用NIO（Non...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值