从零单排，使用 Netty 构建 IM 聊天室~

本文在供给无缺代码示例，可见 github.com/YunaiV/Spri… 的 lab-67 目录。

原创不易，给点个 Star 嘿，一起冲鸭！rocketmq布置

ps：肝的字数过多，部分代码转换成图片，胖友能够点击链接传送到 gayhub 查看详细rocketmq教程的代码 = =

1.http 404 概https和http的差异述

在《芋道 Spring Boot WebSogoogle翻译cket 入门》文章中，咱们运用 WebSocket 完毕了一个简略的 IM 功用，支操作体系的主要功用是撑身份认证、私聊音讯、群聊音讯。

然后就操作体系有胖友私信艿操作体系是计算机体系的一种艿，期望运用纯 Netty 完毕google谷歌查找主页一个相似的功用。良知的艿艿，当然不会给她发红人卡，因此就有了本文。或许有胖友不知道 Netty 是什么，这儿简略介绍下：

Netty 是一个 Java 开源HTTP结构。

Netty 供springboot菜鸟教程应异步的、作业驱动的网络运用https和http的差异程序结构和东西，用以快速开发高功用、高可靠性的网络服务器和客户端程序。

也便是说，Netty 是一个依据 NIO 的客户、服务器端编程结构，运用Netty 能够确保你快速和简略的开宣告一个网络运用，http://192.168.1.1登录例如完毕了某种协议google服务结构的客户，服务端运用。

Netty 适当简化和流线化了网络运用的编程开发进程，例如，TCP 和 UDP 的 Socket 服务开发。

下面，咱们来新建三个项目，如下图所示：

• lab-67-netty-demo-server 项目：树立 Netty 服务端。
• lab-6操作体系期末考试试题及答案7-netty-google翻译demo-client 项目：树立 Netty 客户端。
• lab-67-netty-demo-common 项目：供给 Netty 的根底封装，供给音讯的编解码、分发的功用。

别的，咱们也会供给 Netty 常用功用的示例：

• 心跳机制，完毕服务端对客户端的存活检测。
• 断线重连，完毕客户端对服http 404务端的从头联接。

不哔哔，直接开干。

友谊提示：或许会胖友忧虑，没操作体系是计算机体系的一种有 Netty 根底是不是http://192.168.1.1登录无法阅览本文？！

艿艿的主见，看！就硬看，按照代码先自己能树立一下哈rocketmq源码~文末，艿艿会供给一波 Netty 根底入门的文章。

2. 构建 Netty 服务端与客户端

本文在供给无缺代码示例，可见 github.com/YunaiV/springboot发动进程Spri… 的 lab-67 目录。

原创不易，给HTTP点个 Star 嘿，一起冲鸭！

本末节，咱们先来运用 Netty 构建服务端与客户端的中心代码，让胖友对项意图代码操作体系的基本特征有个初始的RocketMQ认知。

2.操作体系的基本特征1 构建 Netty 服务端

创立 lab-67-netty-demo-servrocketmq面试题er 项目，树立 Netty 服务端。如下图所示：

下面，咱们只会暂rocketmq教程时看看 server 包下的代码，防止信息量过大，击穿胖友的秃头。

2https和http的差异.1.1 NettyServer

创立 NettyServer 类，Netty 服务端。代码如下https和http的差异：

@Component
public class NettyServer {
private Logger logger = LoggerFact操作体系ory.getLogger(getClass());
@Value("${netty.port}")
private Integer port;
@Autowired
pr操作体系ivatespringboot面试题 Nettspringboot和springcloud差异yServerHandlerInitializer nettyServerHangoogle商铺dlerocketmq教程rInitiali操作体系的主要功用是zer;
/**
* boss 线程组，用于服务端承受rocketmq和rabbitmq的差异客户端的联接
*/
private EventLoopGroup bossspringboot是什么结构Group = new NioEventhttp 302LoopGroup();
/**
* worker 线程组，用于服务端承受客户端的数据读写
*/
private EventLoopGrouhttps和http的差异p workerGroup = new NioEvegoogle服务结构ntLoopGroup();
/**
* Netty Server Channel
*/
private Channel channel;
/**
* 建议 Netty Server
*/
@PostCogoogle空间nstruct
public void start() throws InterruptedException {
// <2.1> 创立 Servgoogle商铺erBootstrap 政策，用springboot自动装备的原理于 Netty Server 建议
ServerBootstrap bootstrap = new ServerBootstrap();
// <2.2> 设置 Servegoogle商铺rBootstrap 的各种特征
bootstrap.group(bossGroup, workerGroup) // <2.2.1> 设置两个 EventLoopGroup 政策
.channel(NioServerSocketChannel.class)  // <2.2.2> 指定 Channel 为服务端 NioServerSocketChannel
.locrocketmq集群alAddress(new InetSocketgoogle空间Address(port))httpclient // <2.2.3> 设置 Netty Server 的端口
.option(ChannelOption.SO_BACKLOG, 1024http署理) // <2.2.4> 服务端 acc操作体系期末考试试题及答案ept 部队的巨细
.childOption(ChannelOption.SO_KEEPALIVE, true) // &lrocketmq教程t;2http://www.baidu.com.2.5> TCP Keepalive 机制，完毕 TCP 层级的心跳保活功用
.childOption(ChannelOptspringboot是什么结构ion.操作体系的基本特征TCP_NOhttpclientDELAY, true) // <2.2.6> 容springboot装备文件许较小的数据包的发送，下降推延
.childHspringboot面试题andler(netrocketmq和rabbitmq的差异tyServerHandlerInitializer);
// <2> 绑定端口，并同步等候成功，即建议服务端
ChannelFuture future = bootstrap.bind().sync();
if (future.isSuccess()) {
channel = future.channel();
logger.info("[start][Netty Server 建议在 {} 端口]", port);
}
}
/**
* 封闭 Netty Server
*/
@PreDesthttp 404roy
publicHTTP void shutdown() {
// <3.1> 封闭 Netty Sergooglever
ifspringboot自动装备的原理 (channel != null) {
channel.close();
}
// <3.2> 高雅封闭两个 EventLoopGroup 政策
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}

① 在类上，添加 @Component 注解，把 NettyServer 的创立交给 Spring 处理。

• port 特征，读取rocketmq教程 applicationhttp://192.168.1.1登录.yml 装备文件的 netty.port 装备项。
• #start() 办法，添加 @PostConrocketmq和rabbitmq的差异struct 注解，建议 Netty 服务器。
• #springboot面试题shutdown() 办法，添加HTTP @PreDestroy 注解，封闭 Netty 服务器。

② 咱们来详细看看 #start() 办法的代码，怎样完毕 Netty Server 的建议。

<2.1> 处，创立 Sspringboot是什么结构erverBootstrhttpclientap 类，Netty 供给的服务器的建议类，便利咱们初始化 Server。

<2.2&ggooglet; 处，设置 ServerBootstrahttpwatchp 的各种特操作体系是一种色。

友谊提示：这儿触及较多 Nspringboot项目树立etty 组件的常识，艿艿先以简略的言语描绘，后续胖友在文末的 Netty 根底入门的文章，补偿学噢。

<2.2.1> 处，调用 #group(EventLoopGroup parentGroup, EventLoopGroup childGroup) 办法，设置运用 bossGroup 和 workerGroup操作体系是什么的接口。其间：

• bossGroup 特征：Boss 线程组，用于服务端承受springboot是什么结构客户端的联接。
• workerGrorocketmq集群up 特征：Worker 线程组，用于服务端承受客户端的数据读写。

Netty 选用的是多 Reactor 多线程的模型，服务端能够承受更多客户端的数据读写的才干。原因是：

• 创立专门用于承受客户端联接的 bossGroup 线程组，防止由于已联接的客户端的数据httpclient读写再三，影响新的客户端的联接。
• 创rocketmq集群建专门用于接纳客户端读写的 workerGroup 线程组，操作体系的主要功用是多个线程进行客户端的数据读写，能够支撑更多客户端。

课后习题：感兴趣的胖友，后续能够看看《【NIO 系列】——之 Reactor 模型》文章。

<2.2.2> 处，调用 #channel(Class<? extends C> channelClass) 办法，设置运用 NioServerSocketChannerocketmq原理l 类，它是 Netty 界说的 NIO 服务端 TCP Socket 完毕类。

<2.操作体系是一种什么软件2.3&springboot是什么结构gt; 处rocketmq集群，调用 #localAddress(SocketAdd操作体系的主要功用是ress localAddress) 办法，设置服务端的端口。

<2.2.4> 处，调用 option#(ChannelOrocketmq源码ption&lt操作体系当时的装备不能运转此应用程序;T> option, T value) 办法，设置服务端承受客户端的联接部队巨细。由于 TCP 树立联接是三次握手，所以第一springboot装备文件次握手完毕后，会添加到服务端的联接部队中。

课后习题：更多相关内容，后续能够看看《浅谈 TCP Sockspringboot和springcloud差异et 的 backlog 参数》文章。

<2.2.5> 处，调用 #childOption(ChannelOption<T> childOption, T value) 办法，TCP Keepalive 机制，完毕 TCP 层级的心跳保活功用。

课后习题操作体系的基本特征：更多相关内容，后续能够看看《TCP Keepalive 机制追本溯源http协议》文章。

<2.2http协议.6> 处，调用 #childOprocketmq集群tion(ChannelOption<T> childOption, T value) 办法，容许较小的数据包的发送，下降推延。

课后习题：更多相关内容，后续能够看看《详http协议解 Socket 编程 — TCP_NODELAspringboot装备文件Y 选项》文章。

<2.2.7> 处，调用 #childHandler(ChannelHandler childHandler) 办法，设置客户端联接上来的 Channel 的处理器为 NettyServerHandlerInitializer。稍后咱们在「2.1.2 NettyhttpclientServerHandlerInitializer」末节来看看。

<2.3>操作体系的基本特征 处，调用 #bind() + #sync() 办法，绑定端口，并同步等候成功，即建议服务端。

③ 咱们来详细看看 #shutdown() 办法的代码，怎样完毕 Netty Server 的封闭。

<3.1> 处，调用 Channel 的 #close() 办法，封闭 Netty Server，这样客户端就不再能联接了。

<3.2> 处，调用 EventLoopGroup 的 #shrocketmq和rabbitmq的差异ugoogle浏览器tdownGracerocketmq和rabbitmq的差异fully() 办法，高雅封闭 Evrocketmq源码entLoopGroup。例如说，它们里边的线程池。

2.1.2 NettyServerHandlerInitializer

在看 Netspringboot装备文件tyServerHandlerInitializer 的代rocketmq布置码之前，咱们需求先了解下 Netty 的 ChannelHagoogle服务结构ndler 组件，用来处理 Channel 的各种作业。这儿的作业很广泛，比方能够是联接、数据读写、异常、数据转换等等。

Chahttp://www.baidu.comnnel操作体系是一种什么软件Handler 有十分多的子类，其间有个十分特别的 ChannelInitializer，它用于 Channel 创立时，完毕自界说的初始化逻辑。这儿咱们创立的 NettySpring+BootServerHarocketmq集群ndlerIniti操作体系是什么的接口alizer 类，就承继了 ChannelInitializer 抽象类，代码如下：

@Comgoogle浏览器ponent
public class NettyServerHandlerInitializer extends ChannelInitializer<Channel> {
/**
* 心跳超时http署理时刻
*/
private static final Integer READ_TIMEOUT_SECONDS =springboot装备文件 3 * 60;
@Autowired
private MessageDispatcher messageDispatcher;
@Autowired
private NettyServerHandler netgoogle浏览器tyServerHandler;
@Override
protected void initChannel(rocketmq源码Channel ch) {
// <1> 取得 Channel 对应的 ChannelPipeline
ChannelPipeline channelPipeline = ch.pipeline();
// <2> 添加一堆 NettyServerHandler 到 ChannelPipeline 中
channelPipeline
// 闲暇检测
.addLast(newhttpclient Readrocketmq面试题TimeoutHandlerhttp 302(READ_TIMEOUT_SECONrocketmq运用DS, TimeUnit.SECONDS))
// 编码器
.addLast(new InvocationEncoder())
// 解码器
.addLast(new InvocationDecoder())
// 音讯分发器
.addLast(messageDispatcher)
// 服务端处理器
.addLaspringboot和springcloud差异st(nettyServerHandler)
;
}
}

在每一个客户端与服springboot菜鸟教程务端树立完毕联接时，服务端会创立一个 Channel 与之对应。此刻，NettyServerHandlerInitializer 会进行实施 #inispringboot项目树立tChannel(Channel c) 办法，进行自界说的初始化。

友谊提示：创立的客户端的 Channel，不要和「2.1.1 NettyServer」末节的 Niogoogle服务结构ServerSocketChannel 稠浊，不是同一个哈。

在 #initChannel(Channel ch) 办法的 ch 参数，便是操作体系当时的装备不能运转此应用程序此刻创立的客户端 Channel。

① <1> 处，调用 Channel 的 #pipeline() 办法，取得客户端 Channel 对应的 ChannelPipeline。ChannelPipeline 由一系列的 Cspringboot菜鸟教程hannelHandler 组成，又或许说是 ChannelHspringboot装备文件andler 链。这样， Channel 悉数上悉数的作业都会经过 ChannelPipeline，被其上操作体系是一种的 ChannelHandler 所处理。

② <2> 处，rocketmq布置添加五个 ChannelHandler 到 Ch操作体系期末考试试题及答案annrocketmq源码elPipeline 中，每一个的作用看其上的注释。详细的，咱们会在后续的末节详细说明。

2.1.3 NettyServerHandler

创立 NettyServerHandler 类，承继 ChannelInboundHandlerAdapter 类，完毕客户端 Chgoogle商铺annel 树立联接、断开google空间联接、异常时的处理。代码如下：

@Component
@ChannelHandler.Sharable
publihttp://192.168.1.1登录c class NettyServerHandler extends ChannelInboundHandlerAdapter {
private Logger logger =rocketmq教程 LoggerFacspringboot菜鸟教程tory.getLogger(getClgoogle空间ashttp://www.baidu.coms(操作体系是计算机体系的一种));
@Autowired
private Nerocketmq教程ttyChannelManager channelManager;
@Ovespringboot装备文件rride
public void channelActive(Ch操作体系是一种什么软件annelHandlerContext ctx) {
// 从处理器中添加
channelManager.add(ctx.channel());
}
@Override
public void channelUnregistered(ChannelHandlerContext ctx) {
// 从办http 500理器中移除
charocketmq教程nnelManager.remove(ctx.channel());
}
@Override
public void exc操作体系是什么的接口eptionCaught(ChannelHandlerContext ctx, Throwable cause) {
logger.error("[exceptionCaught][联接({})操作体系是一种什么软件 产生异常]", ctx.channel().id(), cause);
// 断开联接
ctx.channel().close();
}
}

① 在类上添加 @ChannelHa操作体系是一种什么软件ndler.Sharable 注解，符号这个 Chanhttp 500nelHandler 能够被多个 Channel 运用。

② channelManager 特征，是咱们完毕的客户端 Channel 的处理器。

• #channelActive(ChannelHandlerContext ctgoogleplayx) 办法，在客户端和服务端树立联接完毕时，调用 NettyChannelManager 的 #add(Channel channel) 办法Spring+Boot，添加到其间。
• #channelUnregistered(Chan操作体系有哪些nelHandlerContext ctx) 办法，在客户端和服务端断开联接时，调用 NettyChannelManager 的 #add(Channel channel) 办法，从其间移除。springboot守时使命

详细的 NettyChannelMhttp 404anagspringboot守时使命er 的源码，咱们在「2.1.4 NettyChannelManager」 末节中来瞅瞅~

③ #exceptionCaught(ChannelHandlerContext ctx, Throwable cause) 办法，在处理 Channel 的作业产生失rocketmq和rabbitmq的差异常时，调用 Channel 的 #close() 办法，断开和客户端的联接。

2.1.4 NettyChannelManager

创立 NettyChannelHTTPManager 类，供给两种功用。

① 客户端 Channel 的处理。代码如下：

@rocketmq教程Comspringboot和springcloud差异ponent
public class NettyChaspringboot面试题nnelManager {
/**
* {@link C操作体系是什么的接口hannel#attr(AttributeKey)} 特征中操作体系的基本特征，标明 Channel 对应的用户
*/
private sspringboot常用注解tatic final AttributeKey<String> CHANNEL_ATTR_KEY_USER = AttribhttpclientuteKey.n操作体系ewInstance("user");
private Logger logger = LoggerFactory.getLogger(getClass());
/**
* Channelspringboot常用注解 映射
*/
private ConcurrentMaprocketmq教程<Charocketmq原理nnelId, Channel> channels = new ConcurrentHashMap<>();
/**
* 用户与 Channel 的映射。
*
* 经过它httpwatch，能够获取用户对应的 Channel。这样，咱们能够向指定用户发送消http 500息。
*/
private ConcurrentMap<String, Channel> userChannels = new ConcurrentHashMap<>();
/**
* 添加 Channel 到 {@link #channels} 中
*
* @param channel Channel
*/
public void add(Channerocketmq和rabbitmq的差异l channel) {
channels.put(channel.id(), ch操作体系有哪些annel);
logger.info("[add][一个联接({})参与]", channel.id());
}
/**
* 添加指定用google服务结构户到 {@link #userChannels} 中
*
* @param channel Channel
* @param user 用户
*/
public void addUser(Channel channel, String user) {
Channel existChanhttp 404nel = cspringboot守时使命hannels.get(channel操作体系的基本特征.id());
if (existChannel == null) {
logger.errorrocketmq教程("[addUrocketmq确保音讯不丢掉ser][联接({}) 不存在]", channelspringboot守时使命.id());
return;
}
// 设置特征
channel.attr(CHANNEL_ATTR_KEY_USER).set(user);
// 添加到 userChannels
userChannels.pugooglet(user, channel);
}
/**
* 将 Channel 从 {@link #channels} 和 {@link #userChannels} 中移除
*
* @param channel Channel
*/
public void r操作体系是计算机体系的一种emo操作体系是一种什么软件ve(Channel channel) {
// 移除 channels
channelsrocketmq布置.removHTTPe(channel.idspringboot面试题());
// 移除 userChannels
if (channel.hasAttr(CHANNEL_ATTR_KEY_USER)) {
userCha操作体系的主要功用是nnels.remove(channel.att操作体系期末考试试题及答案r(CHANNEL_ATTR_KEY_USER).get());
}
logger.info("[remove][一个联接({})HTTP脱离]", channel.id());
}
}

② 向客户端 Channel 发送音讯。代码如下：

@Component
public class NettyChannespringboot是什么结构lManag操作体系有哪些er {
/**
* 向指定用户发送音讯
*
* @param user 用户
* @param invocation 音讯体
*/
public void send(String user, Invocation invochttp://www.baidu.comation) {
// 取得用户对应的 Channel
Chrocketmq布置annel channel = userChannels.get(user);
if (channel == null) {
logger.error("[send][联接不存在]");
retu操作体系的五大功用rn;
}
if (!channel.isActive()) {
logger.error("[send][联接({})未激活]", channel.id());
rerocketmq面试题tspringboot常用注解urn;
}
// 发送音讯
channel.writeAndFlush(invocation);
}
/**
* 向悉数用户发送音讯
*
* @param invocation 音讯体rocketmq运用
*/
public void sendAll(Invrocketmq源码ocationrocketmq确保音讯不丢掉 invocation) {
for (Channel channgoogleel : channels.values()) {
if (!crocketmq运用hannel.isActive()) {
logger.error("[send][联接({})未激活]", channel.id());
retur操作体系有哪些n;
}
/http://www.baidu.com/ 发送音讯
channel.writeAndFlush(invocation);
}
}
}

2.1.5 引进依托

创立 pom.xml 文件，引进 Netty 依托。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="操作体系是一种http://www.w3.org/google商铺2001/XMLS操作体系是一种什么软件chema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maHTTPven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>lab-67-nettrocketmq和rabbitmq的差异y-demo</artifactId>
<springboot常用注解groupId>cn.iocoder.spspringboot项目树立rinspringboot自动装备的原理gboot.labs</groupId>
<version>1.0-SNAPSHOT&lrocketmq原理t;/version>
</parent>
<modelVersion>4.0.操作体系0</modelVersiongoogle地球>
<artifspringboot菜鸟教程actId>lab-67-netty-demo-server</artifactId&Spring+Bootgt;
<properties>
<!-- 依托相关装备 -->
<spring.boot.vers操作体系的主要功用是ion>2.2.4.RErocketmq源码LEASE</spring.boot.version&gspringboot面试题t;
<!-springboot守时使命- 插件相关配RocketMQ备 -->
<maven.compiler.taspringboot发动进程rget>1.8</maven.compiler.target>
<maven.compiler.source&ghttpclientt;1.8</maven.compiler.source>
</properties>
<dependencyManagement>
&l操作体系的主要功用是t;dependencies>
<dependency>
<grouhttp://192.168.1.1登录pId>org.springframework.boot<googleplay安卓版下载/groupId>
<artifagooglectId>spring-boot-starter-parent&rocketmq集群lt;/artrocketmq原理ifactId>
<versio操作体系是什么的接口n>${spring.boot.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies&springboot面试题gt;
</dependencyManagement>
<dependgoogle谷歌查找主页encies&google谷歌查找主页gt;
<!-googleplay安卓版下载- Spring Boot 根底依托 -->
<dependency&gtspringboot面试题;
<groupId>org.springframework.bootspringboot装备文件</groupIdgoogle谷歌查找主页>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<!-- Netty 依托 -->
<dependency>
<groupId>io.netty</grourocketmq集群pId>
<artifactId>nettyrocketmq集群-all</artifactId>
<verhttpclientsion>4.1rocketmq面试题.50.Final</version>
</dependency>
<!-- 引进 netty-demo-common 封装 -->
<dependency>
<groupId操作体系有哪些>cn.iocoder.springboot.lahttp 302bs</groupId>
<arocketmq次序消费rtgoogle服务结构ifactId>lab-67-netty-demo-common</artifactId>
<version>1.0-SNAPSHOT</version>
&rocketmq布置lt;/dependenspringboot是什么结构cy>
</dependencies>
</project>

2.1.6 NettyShttp://www.baidu.comerverApplication

创立 NettyServerApplication 类操作体系的主要功用是，Netty ServHTTPer 建议类。代码如下：

@SpringBootApplication
public class NettyServerApplication {
publicSpring+Boot static void main(String[] args) {
SpringArocketmq集群pplication.run(NettyServerApplication.class, args);
}
}

2.1.7 简略查验

实施 NettyServerApplication 类，建议 Netty Server 服务器。日志如下：

... //rocketmq教程 省掉其他日志
2020-06-21 00:16:38.801  INFO 41948springboot是什么结构 --- [           main] c.i.s.l.n.server.NettyServer             : [start][Netty Server 建议在 88rocketmq布置88 端口]
2020-06-21 00:16:38.893  INFO 41948 --- [           main] c.i.s.l.n.NettyServerApplication         : Started NettyServerApplication in 0.96 seconds (JVM running for 1.4)

Netty Server 建议在 8888 端口。

2.2 构建http 302 Netty 客户端

创立 lab-67-springboot常用注解netty-demo-client 项目，树立 Nettrocketmq和rabbitmq的差异y 客户端。如下图所示：

下面，咱们只会暂时看google浏览器看 client 包下的代码，防止信息量过大，击穿胖友的秃头。

2.2.1 NettyClient

创立 NettyClient 类，Netty 客户端。代码如下：

友谊提示：全体代码，是和「2.1.1 Net操作体系期末考试试题及答案tyServer」对等，且根柢是一起的。

① 在类上，添加 @Comphttp://www.baidu.comonent 注解，把 NettyClient 的创立交给 Spring 处理。

• serverHost 和 serverPort 特征，读取 application.yml 装备文件的 netty.server.http 404host 和 netty.server.port 装备项。
• #start() 办法，添加 @PostConstruct 注解，建议 Netty 客户端。
• #shutdown() 办法，添加 @PreDestroy 注解，封闭 Netty 客户端。

② 我Google们来详细看看 #start() 办法的代码，怎样完毕 Nespringboot发动进程tty Client 的建议，树立和服务器的联接。

<2rocketmq教程.1> 处，创立 Bootstrap 类，Netty 供给的客户端的建议类，便利咱们初http://192.168.1.1登录始化 Client。

<2.2> 处，设置 Bootstrap 的各种特征。

<2.2.1&gt操作体系是什么的接口; 处，调用 #group(EventLoopGroup group) 办法，设置运用 eventGroup 线程组，完毕客户端对服务端的联接、数据读写。

<2.2.2> 处，调用 #channel(Class<? extends C> channelClass) 办法，设置运用 NioSocketChannel 类，它是rocketmq确保音讯不丢掉 Netty 界说的 NIO 服务端 TCP Client 完毕类。

<2.2.3> 处，调用 #remoteAddress(SocketAddress localAddress) 办法HTTP，设置联接服务端的地址。

&lgoogleplayt;2.2.4> 处，调用 #option(ChannhttpwatchelOption<T> childOption, T value) 办法，TCP Keepalive 机制，完毕 TCP 层级的心rocketmq集群跳保google谷歌查找主页活功用。

<2.2.5> 处，调用 #childOption(Chanhttp://www.baidu.comnelOption<T> childOption, T value)rocketmq原理 办法，容许较小的数据包的发送，下降推延。

<2.2.7> 处，调用 #handrocketmq和rabbitmq的差异ler(ChannelHandler childHandler) 办法，设置自己 Channel 的操作体系是什么的接口处理器为 N操作体系期末考试试题及答案ettyClientHandlerInitializer操作体系。稍后咱们在「2.2.2rocketmq运用 Netspringboot发动进程tyClientHandlerInitrocketmq集群ializer」末节来看看。

<2.3> 处，调用 #cspringboot项目树立onnecrocketmq次序消费t() 办法，联接服务器，并异步等候springboot守时使命成功，即建议客户端。一起，添加回调监听器 ChannelFutureListener，在联接服务端失利的时分，调用 #reconspringboot项目树立nect() 办法，完毕守时重连。 详细 #reconSpring+Bootnect() 办法的代码，咱们稍后在瞅瞅哈。

③ 咱们来详细看看 #shutdown() 办法的代码，怎样完毕 Netty Client 的封闭。

<3.1>http 500 处，调用 Channel 的 #close() 办法，封闭http 404 Netty Client，这样客户端就断开和服务端的联接。

<3.2> 处，调用 EventLoopGroup 的 #shutdownGracefully() 办法，高雅封闭 Eventrocketmq布置LoopGroup。例如说，它们springboot是什么结构里springboot自动装备的原理面的线程池。

④ #send(Invocation invocation) 办法，完毕向服务端发送音讯。

由于 NettyClient 是客户端，所以无需像 NettyServer 相同运用「2.1.4 NettyChannelManager」保护 Channel 的集结。

2.2.2 NettyClientHandlerInitializer

创立的 NSpring+BootettyClientHandlerInitialgoogle空间izer 类，就承继了 ChannelInitializer 抽象类，完毕和服务端树立联接后，添加相应的 ChannelHandler 处理器。代码如下：

@Component
public class NettyClientHandlerInitializer extends ChannelInitializerhttpclient<Channel> {
/**
* 心跳超时时刻
*/
private static final Integer READ_TIMEOUT_SECONDS = 60;
@Autowired
private MessageDispatcher messagehttpclientDispatcher;
@Autowired
private NettyClientHandler nettyClientHandlespringboot发动进程r;
@Override
protected vo操作体系期末考试试题及答案id initChannel(Channel ch) {
ch.pipeline()
// 闲暇检测
.addLast(new IdleStateHagoogle翻译ndler(READ_TIMEOUT_SECONDS, 0, 0))
.addLast(new ReadTimeoutHandler(3 * READ_TIMEOUT_SECONDS))
// 编码器
.addLast(new InvocationEncoder())
//springboot和springcloud差异 解码器
.addLast(new InvocationDecoder())
// 音讯分发器
.adrocketmq面试题dLast(messageDispatcher)
// 客户端处理器
.addLast(nettyClientHandler)
;
}
}

和「2.1.2 Net操作体系是一种什么软件tySe操作体系的基本特征rverHandlerInitializer」的代码根柢相同，不同在于闲暇检测额外添加 IdleStateHandler，客户端处理器换成了 NettyClientHandler。

2.2.3 NettyClientHandler

创立 NettyClientHandler 类，完毕rocketmq运用客户端 Channel 断开联接、异常时的处理。代码如下：

@Component
@ChannelHandler.Sharable
public class NettyClientHandler extends ChannelInboundHandlerAdapter {
private Logger logger = LoggerFactory.getLogger(getClass());
@Autowired
private NettyClient nettyClient;
@Override
public void channelIspringboot面试题nactive(ChannelHandlerContext ctx)googleplay安卓版下载 throwsRocketMQ Exception {
//rocketmq运用 建议重连
nettyClie操作体系有哪些nt.reconnect();
// 持续触发作业
super.channelInactive(ctx);
}
@Override
public void exceptionCaught(ChannelHaspringboot装备文件ndlerContext ctx, Throwable cause) {
logger.error("[exceptspringboot常用注解ionCaught][联接({}) 产生异常]", ctx.channel().id(), cause);
// 断开联接
crocketmq和rabbitmq的差异tx.channel().close();
}
@Override
public void userEventTrgoogle地球iggered(ChannelHandlerControcketmq原理ext ctx, Object event) throws Exception {
// 闲暇时，向服务端建议一次心跳
if (event instanceof IdleStateEvent) {操作体系期末考试试题及答案
logger.info("[userEventTriggered][建议一次心跳]");
HeartbeatRe操作体系是计算机体系的一种quest heartbeatRequest = new HeartbeatRequest();
ctx.writeAndFlush(new Invocation(springboot常用注解HeartbeatRequest.TYPE, heartbeatRequest))
.addListener(ChannelFutureList操作体系ener.CLOSE_ON_FAILURE);
} else {
super.userEventTriggered(ctx, e操作体系vent);
}
}
}

① 在类上添加 @ChannelHarocketmq和rabbitmq的差异ndler.rocketmq集群Sharable 注解，符号这个 Ch操作体系annelHandler 能够被多个 Channel 运用。

② #channelInactive(ChannelHandlerContext ctx) 办法，完毕在和springboot面试题服务端断开联接时，调用 NettyClient 的 #reconngoogle商铺ect() 办法，完毕客户端守时和服务端重连google。

③ #exception操作体系有哪些Caught(ChannelHandlerContext ctx, Throwable cause) 办法，在处理 Channel 的作业产生异常时，调用 Channel 的 #close() 办法，断开和客户端的联rocketmq面试题接。

④ #userEventTriggered(ChannelHandlerContext ctx, Object event) 办法，在客户端在闲暇时，向服务端发送一次心google谷歌查找主页跳，即心跳机制。这块的rocketmq原理内容，咱们稍后详细讲讲。

2.2.4 引进依托

创立 pom.xml 文件，引进 Netty 依托。

2springboot是什么结构.2.5 NettyClientApplication

创立 NettyClientApplication 类，Netty Client 建议类。代码如下：

@SpringBootApplication
public class NettyClientApplication {
public static void main(String[] args) {
SpringApplic操作体系是计算机体系的一种ation.run(NettyClientApplication.class, args);
}
}

2.2.google谷歌查找主页6 简略查验

实施 NettyClientApplication 类，建议 Nett操作体系当时的装备不能运转此应用程序y Client 客户端。日志如下：

... // 省掉其他日志
2020-06-21 09:06:12.springboot发动进程205  INFO 44029 --- [ntLoopGroup-2-1] c.i.s.l.n.client.NettyClientspringboot是什么结构             : [rocketmq确保音讯不丢掉start][Netty Client 联接服务器(127.0.0.1:8888) 成功操作体系的主要功用是]

一springboot守时使命同 Nehttpclienttty Server 服务端发现有一个客户端接入，打印如下日志：

2020-06-21 09:06:12.268  INFO 4194httpclient8google浏览器 --- [ntLoopGroup-3-1] c.i.Spring+Boots.l.n.server.NettyChannelManager     : [add][一个联接(db652822)参与]

2http 500.3 小结

至此，咱们现已构建 Netgoogleplayty 服务端和客户端完毕。由于 Netty 供给的 API 十分便利，所以咱们不会像直接运用 NIO 时，需求处理许多底层且细节的代码。

不过，如上的内容仅仅是本文的开胃菜，正片即将初步！喜洋洋，持续往下看，奥利给！

3. 通信协议

在「2. 构建 Nehttp协议tty 服务端与客户端」末节中，咱们完毕了客户端和服务端的联接功用。而本末节，咱们要让它们两能够rocketmq和rabbitmq的差异说上话，即进行数据的读写。

在操作体系日常项意图开发中，前端和后端之间选google地球用 HTTP 作为通信协议，运用文本内容进行交互，数据格局一般是 JSON。可是在 TCP 的世rocketmq和rabbitmq的差异界里，咱们需求自己依据二进制rocketmq确保音讯不丢掉构建，构建客户端和服务端的通信协议。

咱们以客户端向服务端发送音讯来举个比如，假定客户google空间端要发送一个登录央求，对应的类如下：

public class AuthRe操作体系当时的装备不能运转此应用程序quest {
/** 用户名 **/
private String username;
/** 暗码 **/
private String password;
}

• 显着，咱们无法将一操作体系是什么的接口个 Java 政策直接丢到 TCP Socket 傍边，而是需求将其转换成 byte 字节数组，才干写入到 TC操作体系的主要功用是P Socket 中去。即，需求将音讯政策经过序列化，转换成 byte 字节数组。
• 一起，在服务端收到 byrocketmq集群te 字节数组时，需求将其又转换成 Java 政策，即反序列化。否则，服务端对着一串 byte 字节处理个毛线？！

友谊提示：服务端向客户端发音讯，也是google相同的进程哈！

序列化的东西十分多，例如说 Google 供给的 Protobuf，功用高效，且序列化出来的二进制数据较小。Netty 对 Protobuf 进行集成，供给了相应的编解码器。如下图所示：

可是考虑到许多胖友对 Protrocketmq次序消费obuf 并不了解，由于它完毕序列化又添加胖友的额外学习google谷歌查找主页成本。因此，艿艿仔细一个捉摸，仍是选用 JSON 办法进行序列化。或许胖友会疑操作体系是一种什么软件惑，JSONRocketMQ 不是将政策转换成字符串吗？嘿嘿，咱们再把字符串转换成 byte 字节数组就能够啦~

下面，咱们新建 lab-67-ne操作体系期末考试试题及答案tty-demo-common 项目，并在 codec 包下，完毕我rocketmq布置们自界说的通信协议。如下图所示：

3.1 Invocation

创立 Invocation 类，通信协议的音讯体。代码如下：

/**
* 通信协议的音讯体
*/
public class Inhttp 302vocation {
/**
* 类型
*/
private String type;
/**
* 音讯，JSON 格局
*rocketmq面试题/
prihttp://192.168.1.1登录vate String messa操作体系ge;
// 空结构办法
public Invocation() {
}google服务结构
public Invocation(String type, String message) {
this.type = type;
this.message = message;
}
public Invocation(String type, Mrocketmq确保音讯不丢掉essage message) {
this.type = type;
this.message = JSON.toJSONString(mes操作体系的主要功用是sage)rocketmq次序消费;rocketmq运用
}
// ...http://www.baidu.com 省掉 setter、getter、toString 方google翻译法
}

① type 特征，类型，用于匹配对应的音讯处理器。假定类比 HTTP 协议，type 特征适当于央求地址。

② message 特征，springboot菜鸟教程音讯内容，运用 JSON 格局。

别的，Mrocketmq次序消费essage 是咱们界说的音讯接口。代码如下：

public inte操作体系的五大功用rface Message {
// ... 空，作为符号接口
}

3.2 粘包与拆包

在初步看 Invocation 的编解码处理器之前，咱们先了解下粘包与拆包的概念。googleplay安卓版下载

假定的内容，引用《Netty 处理粘包和拆包问题的四种计划》文章的内容，进行二次编辑。

3.2.1 产生原因

产生粘包和拆包问题的首要原因是，操作体系在发送 TCP 数据的时分，底层会有一个缓冲区，例如 1024 个字节巨细。

• 假定一次央求发送的数据量比较小，没抵达缓冲区巨细，TCP 则会将多个央求兼并为同一个googleplay央求进行发送，这就形成了粘包问题。

  例如说，在《详解 Socket 编程 — TCP_NODELAY 选项》文章中咱们能够看到，在封闭 Nagle 算法时，央求不会等候满意缓冲区巨细，而是赶快宣告，下降推延。

• 假定一次央求发送的数据量比较大，跨越了缓冲区巨细，TCP 就会将其拆分为屡次发送，这便是拆包，也便是将一个大的包拆分为多个小包进行发送。

如下图展现了粘包和拆包的一个示意图，演示了粘包和拆包操作体系的三种状况：操作体系的基本特征

• A 和 B 两个包都刚好满意 TCP 缓冲区的巨细，或许说其等候时刻现已抵达 TCP 等候时长，然后仍是运用两个独立的包进行发送。
• A 和 B 两次央求距离时刻内较短，并且数据包较小，因此兼并为同一个包发送给服务端。
• B 包比较大，因此将其拆分为两个包 B_1 和 B_2 进行发送，而这儿由于拆分后的 B_2 比较小，其又与 A 包兼并在一起发送。rocketmq原理

3.2.2 处理计划

关于粘包和拆包问题，常见的处理计划有三种：

① 客户端在发送数据包的时分，每个包google地球都固定长度。比方 1024 个字节巨细，假定客户端发送的数据长度缺乏 1024 个字节，则经过补偿空格的办法补全到指定长度。

这种springboot和springcloud差异办法，艿艿暂时没有找到选用这种办法的事例。

② 客户端在每个包的结尾运用固定的分隔符。例如 rn，假定一个包被拆分了，则等候下一个包发送过来之后找到其间的 rRocketMQn，然后对其拆分后的头部部分与前一个包的剩余部分进行兼并，这样就得到了一个无缺的包。

详细的事例，有 HTTP、Werocketmq原理bSocket、Redis。google服务结构

③ 将音讯分为头部和音讯体，在头部中保存有其时整个音讯的长度，只要在读取到满意长度springboot菜鸟教程的音讯之后才算是读到了一个无缺的音讯。

友谊提示：计划 ③ 是操作体系 ① 的升级版，动态长度。

本文，艿艿将选用这种办法，在每次 Invocation 序列化成字节数组写入 TCP Socket 之前，先将字节数组的长度写到其间。如操作体系是一种下图所示：

3.3 InvocationEncoder

创立 InvocationEncoder 类，完毕将 Invocation 序列化，并写入到 TCP Socket 中。http 500代码如下springboot项目树立：

public class InvocationEncoder extends MessageToByteEncoder<Invocation> {
private Logger logger = LoggerFgoogle翻译actory.http署理getLogger(getClashttpwatchs());
@Override
protected void encode(ChannelHandlerContext ctx, Invocation invocation, ByteBuf ospringboot守时使命ut) {
// <2.1> 将 Invocation 转换成 byte[] 数组
byte[] content = JSON.toJSONBytes(invocation);
// <2.2> 写入 length
out.writeInt(content.length);
/google地球/ <2.3> 写入内容
out.springboot常用注解writeBytes(content);
logger.info("[encodehttp://www.baidu.com][联接({}) 编码了一条音讯({})]", ctx.channespringboot是什么结构l(springboot项目树立).id(), invocation.toString());
}
}

① MessageToByteEn操作体系的主要功用是coder 是 Netty 界说的编码 ChannelHandler 抽象类，将泛型 <I> 音讯转换成字节数组。

② #encode(ChannelHandlerContext ctx, Invocation invocation, ByteBuf out) 办法httpwatch，进行编码的逻辑。

<2.1> 处，调用 JSON 的 #toJSONBytes(Object object, Serializgoogle服务结构erFeaturespringboot面试题... features) 办法，将 Invocation 转换成 字节数组。

<2.2> 处，将字节数组的长度，写入到 TCP Socket 傍边。这样，后续「3.4 InvocationDecodergoogle」能够依据该长度，解析到音讯，处理粘包和拆包的问题。

友谊提示：MessageToByteEnc操作体系是一种什么软件oder 会毕竟将 ByteBuf out 写到 TCP Socket 中操作体系是什么的接口。

<2.3> 处，将字节数组，写入到 TCP Socket 傍边。

3.4 InvocationDecoder

创立 InvocationDecoder 类，完毕从 TCP Socket 读取字节数组，反序列rocketmq面试题化成 Invocation。代码如下：

① ByteToMessageDecoder 是 Nehttp协议tty 界说的解码 ChannelHandler 抽象类，在 TCP Socket 读取到新数据时，触发进行解码。

② 在 <2.1>、<2.2>、<2.3> 处，从 TCP Socket 中读取长度。

③ 在 <3.1>、<3.2>、<3.3> 处，从 TCP Socket 中读取字节数组，并反序列化成 Invocation 政策。

毕竟，添加 List<Object> out 中，交给后续的 ChannelHandler 进行处理。稍后，咱们将在「4. 音讯分发」小结中，会看到 MessageDispatcher 将 Invocation 分发到其对应的 MessageHandlspringboot守时使命er 中，进行事务googleplay逻辑的实施。

3.5 引进依托

创立 pom.xml 文件，引进 Netty、FastJSON 等等依托。

3.6 小结

至此，咱们现已完毕通信协议的界说、编解码rocketmq运用的逻辑，是不是蛮诙谐的？！

别的，咱们在 NettyServerhttp 404HandlerInitializer 和 NettyClientHandlerInitializer 的初始化代码中，将编解码器添加到其间。如下图所操作体系的主要功用是示：

4. 音讯分发

在 SpringMVhttpwatchC 中，googleDispatcherServlethttpclient 会依据央求地址、办法等，将央求分发到匹配的rocketmq和rabbitmq的差异 Controller 的 Method 办法上。

在 lab-67-netty-demo-clihttpwatchent 项意图 dispatcher 包中，咱们创立了 MessageDispatche操作体系期末考试试题及答案r 类，完毕和 DispatcherServlet 相似的功用，将 Invocation 分发到其对应的 MessageHanspringboot面试题dhttp 500ler 中springboot自动装备的原理，进行事务逻辑的实施。

下面，咱们来看看详细的代码完毕。

4.1 Message

创立 Message 接口，界说音讯的符号接口。代码如下：

public interfaceRocketMQ Message {
}

下图，是咱们触及到的 Message 完毕类。如下图所示：

4.2 MessageHandler

创立 Mhttp 302essageHandler 接口，音讯处理器接口。代码如下：

public interface MessageHandler<T extends Message> {
/**
* 实施处理音讯
*
* @param channel 通道
* @param message 音讯
*/
void execute(Channel channel, T message);
/**
* @return 音讯类型，即每个 Message 完毕类上的 TYPE 静态字段
*/
String getType();
}

• 界说了泛型 <T>googleplay ，需求是rocketmq面试题 Message 的完毕类。
• 界说的两个接口办法，胖友自己看下注释哈。

下图，是咱们触及到的 Merocketmq教程ssageHandler 完毕类。如下图所示：

4.3 Messrocketmq教程ageHandlerContainer

创立 MessageHandlerContainerspringboot和springcloud差异 类，作为 MessageHan操作体系是一种dler 的容器。代码如httpclient下：

① 完毕 InitializingBspringboot常用注解ean 接口，在 #afterProgoogle空间pertiesShttpwatchet() 办法中，扫描悉数 MessageHandler Bean ，添加到 MessageHandler 集结中。

② 在 #getMrocketmq集群essageHandler(String type) 办法中，取得类型对应的 MessageHgoogle浏览器andler 政策。稍后，咱们会在 MessageDispatcher 调用该办法http://192.168.1.1登录。

③ 在 #getMessaggoogleeClass(M操作体系当时的装备不能运转此应用程序essageHandler handler) 办法中，经过 MessageHandler 中，经过解析其类上的泛型，取得音讯类型对应的 Class 类。这是参考 rocketmqrocketmq原理-spring 项意图 DefaultRocketMQListenerContainer#getMessageType() 办法，进行稍微修改。

友谊提示操作体系期末考试试题及答案：假定胖友对 Java 的泛型机制没有做过一点了解，或许稍微有点硬核。能够先暂时越过，知springboot菜鸟教程道rocketmq面试题意图即可。

4.4 MessageDispatcher

创立 MessageDispspringboot常用注解atcher操作体系当时的装备不能运转此应用程序 类，将 Invocation 分发到其对应的 Mrocketmq集群essageHa操作体系有哪些ndler 中https和http的差异，进行事务逻辑的实施。rocketmq面试题代码如下：

@ChannelHandler.Sh操作体系是什么的接口ahttpclientrable
public class MessageDispatcher extends SimpleChannelInboundHandler<Invocation> {
@Autowired
private MessageHandlerContainer messageHandlerContainer;
private final ExecutorSerrocketmq教程vice executor =  Execu操作体系当时的装备不能运转此应用程序tors.newF操作体系的基本特征ixedThreadPool(200);
@Override
protected void channelRead0(ChannelHandhttps和http的差异lerContext ctx, Invocation invocation) {
// <3.1> 取得 type 对应的 MessageHandler 处理器
MessageHandler messageHandler = messageHandlerContainer.getMessageHandler(invocation.getType());
// 取得  MessageHandler 处理器的音讯类
Class<? extends Message> messageClass = MessageHandlerCongoogle空间tain操作体系当时的装备不能运转此应用程序er.getMessageClass(messageHandler);
// <3.2> 解析音讯
Message message = JSON.parseObject(invocation.getMessagehttp://192.168.1.1登录(), messageClass);
// <3.3&ggoogle服务结构t; 实施逻辑
executor.submit(new Runnable() {
@Override
public void run() {
// nhttp://192.168.1.1登录oinspection unchecked
messageHandler.execute(ctrocketmq集群x.channel(), message);
}
});
}
}

① 在类上添加 @ChannelHandler.Srocketmq原理harable 注解，符号这个 ChannelHandler 能够被多个 Channel 运用。

② SimpleChannelInboundHandler 是 Netty 界说的音讯处理 ChannelHandler 抽象类，处理音讯的类型是 <I> 泛型时。

③ #channelRead0(ChannelHandlerContext ctx, Invocation invoca操作体系的主要功用是tion) 办法，处理音讯，进行分发。

<3.1> 处，调用 MessageHandlerContainer 的 #getMessageHandlerrocketmq布置(String type) 办法，取得 Invocatihttp://www.baidu.comon 的 type 对应的 MessageHandler 处理器。

然后，调用 MessageHandlerContainer 的 #getMessageClass(messageHandler) 办法，取得 MessageHandler 处理器操作体系有哪些的音讯类。

<3.2> 处，调用 JSON 的 ## parseObject(String text, Class<T> clazz) 办法，将 Invocation 的 message 解析成 MessageHandler 对应的音讯政策。

&l操作体系的基本特征t;3.3> 处，丢到线程池中，然后调用 MessageHandgoogle谷歌查找主页ler 的 #executspringboot是什么结构e(Channel channel, T message) 办法，实施事务逻辑。

留神，为什么要丢到 executor 线程池中呢？咱们先来了解下 Eve操作体系的主要功用是ntGrourocketmq教程p 的线http 404程模型。

友谊提示：在咱们建议 Nrocketmq源码etty 服务端或许客户端时，都会设置其 EventGroup。

EventGroup 咱们能够先简略了解成一个线程池，并且线程池的巨细仅仅是 CPU 数量 * 2。每个 Chspringboot菜鸟教程annel 仅仅会被分配到其间的一个线程上，进行操作体系的五大功用数据的读写。并且，多个 Channel 会共享一个线程，即运用同一google个线程进行数据的读写http署理。

那么胖友试着考虑下，MessageHandler 的springboot自动装备的原理详细逻辑视界中，往往会触及httpclient到 IO 处理，例如说进行数据库的读取。这样，就会导致一个 Channel 在实施 MessageHandler 的进程中，堵塞了共享其时线程的其它 Channel 的数据读取。

因此，rocketmq次序消费咱们在这儿创立了 executor 线程池，进行 MessageHandler 的逻辑实施，防止堵塞 Channel 的数据读取。

或许会有胖友说，咱们是不是能够把 EventGroup操作体系当时的装备不能运转此应用程序 的线程池设置大一点，springboot面试题例如说 200 呢？关于长联接的 Nettgoogle浏览器y 服务端，往往会有 1000 ~ 100000 的 Netty 客户端联接上来，这样不论设置多大的线程池，都会出现堵塞数据读取的状况。

友谊提示：executor 线程池，咱们一般称之为事务线程池或许逻辑线程池，望文生义，便是实操作体系是计算机体系的一种行事务逻辑的。

这样的规google翻译划办法，现在 Dubbo 等等 RPC 结构，都选用这种办法。

后续，胖友能够认真阅览下《【NIO 系列】——之 Reaspringboot自动装备的原理ctor 模型》文章，进一步了解。

4.5 NettyServerConfig

创立 NettyServerConfig 装备类，创立 MessageDispatcher 和 MessageHandlerContainer Bean。代码如下：

@Configuration
public class NettyServerConfig {
@Bean
public MessageDispatcher m操作体系有哪些essageDisgoogle翻译patcher() {
return new Message操作体系的基本特征Dispatcher();
}
@Bean
public MessageHandlerContainer messageHandlespringboot发动进程rContainer() {
rehttp 302turn new MessageHandlerContainer();
}
}

4.6 Nettspringboot常用注解yClientC操作体系是一种onfig

友谊提示：rocketmq次序消费和「4.5 NettyServerChttp协议onfig」小结一起。

创立 NettyClientConfig 装备类，创立 MessageDispatcher 和 MessageHandlehttp://www.baidu.comrContainer Bean。代码如下：

@Configuration
public class NettyClientConfig {
@Bean
public MessageDisgoogle服务结构patcher messageDispatcher() {
return new MessageDispatcher();
}
@Bean
public MessageHandlerContainrocketmq运用er messageHandlerConrocketmq教程tainer() {
return new Messagerocketmq布置Hanrocketmq源码dlerContainer();
}
}

4.7 小结

后续，咱们将在如下Spring+Boot末节，详细演示音讯分发的运用：

• 「6. 心跳机制与闲暇检测」
• 「7. 认证逻辑」
• 「7. 单聊逻辑」
• 「8. 群聊逻辑」

5rocketmq面试题. 断开重连

Netty 客户端需求完毕断开重连机制，处理各种状况下的断开状况。例如说：

• Netty 客户端建议时，Netty 服务端处于挂掉，导致无法联接上。
• 在运转进程中，RocketMQNetty 服务端挂掉，导致联接被断开。
• 任一一端网络颤动，导致联接异常断开。

详细的代码rocketmq面试题完毕http://www.baidu.com比较简略，只需google商铺求在两个当地添加重连机制。

• Netty 客户端建议时，无法联接 Netty 服务端时，建议重连。
• Netty 客户端运转时，和 Netty 断开联接时，主操作体系是什么的接口张重rocketmq集群连。

考虑到重连会存在失利的状况，咱们选用守时重连的办法，防止占用过多资源。

5.1 详细代码

① 在http 302 NettyClient 中，供给 #reconnect() 办法，完毕守时重操作体系的五大功用连的逻辑。代码如下：

// NettyClient.java
publ操作体系是一种ic vrocketmq和rabbitmq的差异oid reconnect() {
eventGroup.schedule(new Runnable() {
@Override
public void run() {
logger.info("[reconnect][初步重连]");
try {
start();
} catch (Interru操作体系是什么的接口ptedException e) {
logger.error("[reconnect][重连失利Spring+Boot]", e);
}
}
}, RECONspringboot发动进程NECT_SECONDS, TimeUnit.SECONDS)操作体系的基本特征;
logger.info("[reconnect][{} 秒后将建议重连]", RECONNECT_SECONDS);
}

经过调用 EventLoop 供给的 #schedule(Runnable command, longhttp协议 delay, TimeUnit unit) 办法，完毕守时逻辑。而在内部的详细逻辑，调用 NettyClient 的 #sta操作体系是计算机体系的一种rt() 办法，建议联接 Netty 服务端。

又由于 NettRocketMQyClient 在 #start() 办法在联接 Netty 服务端失利时，又会调用 #reconnect() 办法，然后再次建议守时重连。如此循环反复，知道 Netty 客户端rocketmq源码联接上操作体系有哪些 Netty 服务端。如下图所示：

② 在 NettyClientHandler 中，完毕 #channelInactive(ChannelHandlerContext ctx) 办法，在发现和 Netty 服务端断开操作体系是一种时，调用 Nettyhttpwatch Client 的 #reconhttpwatchnect() 办法，建议重连。代码如下：

// Nettygoogle空间Cliespringboot发动进程ntHandler.java
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
// 建议重连
netrocketmq布置tyClient.rec操作体系是计算机体系的一种onnect();
// 持续触发作业
super.channelInactive(ctx);
}

5.2 简略查验

① 建议 Nspringboot是什么结构etty Client，不要建议 Netty Server，操控台打印日志如下图：

能够看到 Netty Client 在联接失利时，不断建议守时重连。

② 建议 Netty Server操作体系当时的装备不能运转此应用程序，操控springboot装备文件台打印如rocketmq面试题下图：

能够看到 Netty Client 成功重google服务结构连上 Netty Server。

6. 心跳机制与闲暇检测

在上文中，艿艿举荐胖友阅览《TCP Keepalive 机制追本溯源》文章，咱们能够了解到 TCP 自springboot项目树立带的闲暇检测http署理机制，默许是 2 小时。这样的检测机制，从体系资源层面上来说是能够承受的。

可是在事务层面，假定 2 小时才发现客户端与服务端的联接实践现已断开，会导致中心十分多的消springboot装备文件息丢掉，影响客户的运用体会。

因此，咱们需求在事务层面，自己完毕闲暇检测，确保赶快发现客户端与服务端实践现已断开的状况。完毕逻辑如下：

• 服务端发现 180 秒未从客户端读取googleplay到音讯，自动断开联接。rocketmq运用
• 客户端发现 180 秒未从服务端读取到音讯，自动断开联接。

考虑到客户端和服务端之间并不httpwatch是一贯有音讯的交互，所以咱们需求添加心跳机制：

• 客户端每 60 秒向服务端建议一次心跳消springboot项目树立息，确保服务端能够读取到音讯google。
• 服务端在收到心跳音讯时，回复客户端一条招认音讯，google谷歌查找主页确保客户端能够读取到音讯。

友谊提示HTTP：

• 为什么是 180 秒？能够加大或许减小，看自己期望多快检测到联接异常。过短的时刻，会导致心越过于再三，占用过多资源。
• 为什么是 60 秒？三次机会，招认是否心跳超时。

虽然听起来有点杂乱，可是完毕起来并不杂乱哈。

6.1 服务端的闲暇检测

在 NettyServerHandlerInitializer 中，咱们添加了一个 ReadT操作体系是什么的接口imeoutHandler 处理器，它在跨越指守时刻未从对端读取到数据，会抛出 ReadTimeoutException 异常。如下图所示：

经过这样的办法https和http的差异，完毕服务端发现 180 秒未从客户端读取到操作体系的基本特征音讯，自动断开联接。

6.2 客户端的闲暇检测

友谊提示：和「6.1 服务端的闲暇检测」一起。

在 NettyClientHandlerInitializer 中，咱们添加了一个 ReadTimeoutHandler 处理器，它在跨越指守时刻未从对端读取到数据，会抛出 Rspringboot面试题eadTimeoutException 异常。如下图所示：

经过这样的办法，完毕客户端发现 180 秒rocketmq和rabbitmq的差异未从服务端读取到音讯，自动断开联接。

6.3 心跳机制

Netty 供给了 IdleStateHandler 处理器，供给闲暇检测的功用，在 Channel 的读或许写闲暇时刻太长时，将会触发一个 IdleStateEvent 工HTTP作。

这样，google谷歌查找主页咱们只需求在 NettyClientHandler 处理器中，在接纳到 IdleStateEvent 作业时，客户端向客户端发送一次心跳音讯。如下图所示：

• 其间，HeartbeatRequest 是心跳央求。

一起，咱们在服务端项目中，创立了一rocketmq原理个 HeartbeatRequestHandler 音讯处理器，在收到客户端的心跳央求时，回复客户端一条招认音讯。代码如下：

@Component
public class HeartbeatRequestHandler implements MessageHandler<HeartbeatRe操作体系quest> {
private Logger logger = LoggerFactory.getLogger(getCspringboot项目树立lass());
@Override
public void e操作体系xe操作体系有哪些cute(ChanGooglenel channel, HeartbeatRequest message) {
logger.info("[exe操作体系cute][收到联接操作体系是什么的接口({}) 的心跳央求]", channel.id());
// 照顾心跳
HeartbeatResgoogle浏览器p操作体系期末考试试题及答案onse response = new HeartbeatResponse();
channel.writeAndFlush(new Irocketmq面试题nvocation(HeartbeatResponhttp署理se.TYPE, response));
}
@Override
procketmq布置ublic String get操作体系的主要功用是Type() {http://192.168.1.1登录
return HeartbeatRequest.TYPE;
}
}

• 其间，HeartbeatResponse 是心跳招认照顾

6.4 简略查验

建议 Netty Server 服务端，再建议 Netty Client 客户端，耐性等候 60 秒后，能够看到心跳日志rocketmq确保音讯不丢掉如下：

7. 认证逻辑

友谊提示：从本末节初步，咱们就详细看看事务逻辑的处理示例。

认证的进程，如下图所示：

7.1 AuthRequest

创立 AuthRequest 类，界说用户认证央求。代操作体系码如下：

public class AuthReque操作体系是计算机体系的一种st implemen操作体系的主要功用是ts Message {
public static final String TYPE = "AUTH_REQUEST";
/**
* 认证 Tokengoogle谷歌查找主页
*/
private String accessToken;
// ... 省掉 setter、getter、toString 办法
}

这儿咱们运用 accespringboot面试题ssToken 认证令牌进行认证。

由于一springboot装备文件般状况下，rocketmq和rabbitmq的差异咱们运用 HTTP 进操作体系是计算机体系的一种行登录体系，然后运用登录后的身份标识（例如说 accessToken 认证令牌），将客户端和其时用户进行认证绑定。

7.2 AuthResponse

创立 AuthResponse 类，界说用户认证照顾。操作体系的五大功用代码如下：

public class AuthResponse implements Message {
public static final String TYPE = "AUTH_RESPONSE";
/**
* 照顾状况码
*/
private Integer code;
/**
* 照顾提示
*/
private String message;
// ... 省掉 setter、getter、操作体系是一种什么软件toString 办法
}

7.3 AuthReques操作体系的五大功用tHandler

服务端…

创立 Autrocketmq面试题hRequestHandler 类，为服务端处理客户端的认证央求。代码如下：

代码比较简略，胖友看看 <1>、<2>、<3>、<4> 上的注释。

7.4 AuthResponseHandler

客户端…

创立 AuthResponseHandler 类，为客户端http://www.baidu.com处理服务端的认证照顾。代码如下：

@Component
public class AuthResponseHandler implements Messagegoogle空间Handlerhttpwatch&lrocketmq原理t;AuthResponse> {
private Logger logger = LoggerFactory.getLogger(getClass());
@Override
public void execute(Channel channel, AuthResponse message) {
loggerocketmq集群r.info("[execute][认证作用：{}]", message);
}
@Override
public String getType() {
return AuthResponse.TYPE;
}
}

打印个认证作用，便利调试。

7.5 TestController

客户端…

创立 Tesspringboot常用注解tController 类，供给 /test/mock 接口，仿HTTP照客户端向服务端发送央求。代码如下：

@RestController
@RequestMapping("/thttp 500est")
public class TestCrocketmq源码ontrorocketmq面试题ller {
@Autowired
private NettyClient nettyClient;
@PostMapping("/mocGooglek")
public String morocketmq确保音讯不丢掉ck(String typgoogleplaye, String message) {
// 创立 Invocation 政策
Inhttp://www.baidu.comvocation invocation = new Invocation(type, message);
// 发送音讯
nettyClient.send(invocation);
return "success";
}
}

7.6 简略查验

建议 Netty Server 服务端，再http协议建议 Netty Cligoogle浏览器ent 客户端，然后运用 Postman 模仿一次认证央求。如下图所示：

一起，Google能够看到认证成功的日志如下：

8. 单聊逻辑

私聊的进程，如下图所示：

服务端担任将客户端 A 发送的私聊音讯，转发给客户端 B。

8.1 ChatSendToOneRequest

创立 ChatSendToOneRequest 类，发送给指定人的私聊音讯的央求。代码如下：

public class ChatSendToOneRequest implements Message {
public statgoogle商铺ic final String TYPE = "CHAT_SEND_TO_ONE_REQUEST";
/**
* 发送给的用户
*/
private String toUser;
/**
* 音讯编号
*/
private String msgId;
/**
* 内容
*/
prGoogleivate String content;
// ... 省掉 setter、getter、toString 办法
}

8.2 ChatSendResponse

创立 ChatSendResponse 类，谈天发送音讯作用的照顾。代码如下操作体系当时的装备不能运转此应用程序：

public class ChatSendResponse implements Message {
public static final String TYPE = "CHAT_SEND_RESPONSE";
/**
* 音讯编号
*/
private String msgId;
/**
* 照顾状况码
*/
private Integer code;
/**
* 照顾提示
*/
private String message;
// ... 省rocketmq集群掉 setter、getspringboot面试题ter、toString 办法
}

8.3 Chatgoogle服务结构RedirectToUserRequest

创立 ChatRedirectToUserRequest 类， 转发音讯给一个用户的央求。代码如下：

publirocketmq教程c class ChatRedirectToUserRequest implements Message {
public static操作体系是一种 final String TYPE = "CHAT_REDIRECT_TO_USER_REQUEST";
/**操作体系是一种
* 音讯编号
*/
private StSpring+Bootring msgId;
/**
* 内容
*/
private String content;
// ... 省掉 setter、getter、toString 办法
}

友谊提示：写完之后，艿艿遽然发现少了一个 fromUsegoogle商铺r 字段，标明来自谁的音讯。

8.4 ChatSendToOneHandler

服务端…

创立 ChatSendToOneHandler 类，为服务端处理客户端的私聊央求。代码rocketmq集群如下：

代码比较简略，胖友看看 <1>、<2> 上springboot菜鸟教程的注释。

8.5 ChatSendResponseHhttps和http的差异andler

客户端…

创立 ChatSendResponseHandler 类，为客户端处理服务端的谈天照顾。代码如下：

@Component
public class ChatSendResponseHandler implements MessageHandler<ChatSendResponse> {
private Logger logger = LoggerFactory.getLogger(getClass());
@Override
public void execute(Channel channel, ChatSendResponsspringboot守时使命e message) {
logger.info("[execute][发送作用：{}]", message);
}
@Override
public String gethttp://192.168.1.1登录Type() {
return ChatSendResponse.TYPE;
}
}

打印个谈天发送作用，便利调试。

8.6 ChatRedirespringboot是什么结构ctToUserReques操作体系的基本特征tHandler

客户端

创立 ChatRedirespringboot常用注解ctToUserRequestHgoogle谷歌查找主页andler 类，为客户Google端处理服务端的转发http://192.168.1.1登录音讯的央求。代码如下：

@Component
public class ChatRedirectToUserRequestHandler implements MessageHandler<ChatRedirectToUserRequest> {
private Logger loggrocketmq面试题er = LoggerFactory.getLogger(getClahttp署理ss());
@Override
public void execute(Channel channel, ChatRedirectToUserRequest message) {
logger.info("[execute][收到音讯：{rocketmq确保音讯不丢掉}]", message);
}
@Override
public String getType() {
return ChatRedirectToUserRe操作体系是什么的接口quest.TYPE;
}
}

打印个谈天接纳音讯，便利调试。

8.7 简略查验

① 建议 Netty Server 服务端。

② 建议 Netty Client 客户端 A。然google地球后操作体系的基本特征运用 Postman 模仿一次认证央求(用户为 yspringboot发动进程unai)。如下图所示：

③ 建议 Netty Client 客户端 B。留神，需求设置 --server.phttp 500ort 端口为 8081，防止抵触。如下图所示：

然springboot面试题后运用 Postman 模仿一次认证央求(用户为 tutou)。如下图所示：

④ 终究运用 Postmarocketmq源码n 模仿一次 yunai 芋艿给 tutou 马铃薯发送一次私聊音讯。如下图所示：

一起，能够看到客户端 A 向客户端 B 发送私springboot常用注解聊音讯的日志如下：

9springboot装备文件. 群聊逻辑

群聊的进程，如下图所示：

服务端担任将客户端http 302 A 发送的群聊音讯，转发给客户端 A、B、C。

友谊提示：考虑到逻辑简练，艿艿供给的本末节的示例，并不是一个一个群，而是悉数人在一个大的群聊中哈~

9.1 ChatSendToAllRequest

创立 ChatSendToOneRequest 类，发送给悉数人的群聊音讯的央求。代码如下：

public class ChatSendToAllRequest implements Message {
publrocketmq次序消费ic static final String TYPE = "CHAT_SEND_TO_ALL_REQUEST";googleplay
/**
* 音讯编号
*/
priva操作体系是一种te Strspringboot装备文件ing msgId;
/**springboot常用注解
* 内容
*/
private String content;
// ... 省掉 setter、gethttp 404ter、toString 办法
}

友谊提示：假定是正派的群聊，会有一个 groupId 字段，标明群编号。操作体系是什么的接口

9.2 ChatSendResponse

和「8.2 ChatSendResponse」末节一起。

9.3 ChatRedirectToUserRequest

和「8.3 ChatRedirectToUserRequest」末节一起。

9.4 ChatSendToAlrocketmq教程lHandler

服务端…

创立 ChatSendToAllHandlerrocketmq源码 类，为服务端处理客户端的群聊央求。代码如下：

代码比较简略，胖友看看 <1>、<2> 上的注释。

9.5 ChatSendResponseHandler

和「8.5 ChatSendResponseHandler」末节一起。

9.6 ChatRerocketmq布置directToUserRequestHandler

和「8.6 ChatRedirectToUserRequestHandler」末节一起。

9.7 简略查验

① 建议 Nettrocketmq和rabbitmq的差异y Server 服务端http 302。

② 建议 Netty Client 客户端 A。然后运用 Postman 模仿一次认证央求(用户为 yunai)。操作体系期末考试试题及答案如下图所示：

③ 建议 Netty Client 客户端 B。留神httpclient，需求设置 --server.port 端口为 8081，防止抵触。

④ 建议 Netty Client 客户端 C。留神，需求设置 --springboot发动进程server.port 端口为 8082，防止抵触。

⑤ 终究运用 Postman 模仿一次发送操作体系的基本特征群聊音讯。如下图所示：

一起，能够看到客户端google服务结构 A 群发给悉数客户端的日志如下：

666. 彩蛋

至此，咱们现现已过 Netty 完毕了一个简略的 IM 功用，是不是收成蛮大的，嘿嘿。

下面，良知的艿艿，再来举荐一波文章，嘿嘿。

• 想要了解 Netty 源码的，能够阅览《Netty 完毕原理与源码解析体系 —— 精品合集》文章。
• 想要操作体系入门 Netty 根底的，能够阅览《Netty Bootstrap（图解）》文章。

等后续，艿艿会在 github.com/YunaiV/onem… 开源项目中，完毕一个相对无缺的客服功用，哈哈操作体系的基本特征哈~