java netty 实现 websocket 服务端和客户端双向通信 实现心跳和断线重连
java netty 实现 websocket 服务端和客户端双向通信 实现心跳和断线重连
maven依赖
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
<version>4.1.97.Final</version>
</dependency>
服务端
一个接口 IGetHandshakeFuture
package com.sux.demo.websocket2;
import io.netty.channel.ChannelPromise;
public interface IGetHandshakeFuture {
ChannelPromise getHandshakeFuture();
}
服务端心跳 ServerHeartbeatHandler
package com.sux.demo.websocket2;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.codec.http.websocketx.PongWebSocketFrame;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;
public class ServerHeartbeatHandler extends ChannelInboundHandlerAdapter {
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
if (evt instanceof IdleStateEvent) {
IdleStateEvent event = (IdleStateEvent) evt;
if (event.state() == IdleState.READER_IDLE) { // 读空闲
// System.out.println("关闭客户端连接, channel id=" + ctx.channel().id());
// ctx.channel().close();
} else if (event.state() == IdleState.WRITER_IDLE) { // 写空闲
System.out.println("服务端向客户端发送心跳");
ctx.writeAndFlush(new PongWebSocketFrame());
} else if (event.state() == IdleState.ALL_IDLE) { // 读写空闲
}
}
}
}
服务端封装 WebSocketServer
package com.sux.demo.websocket2;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;
import io.netty.handler.timeout.IdleStateHandler;
import java.util.concurrent.TimeUnit;
public class WebSocketServer {
private EventLoopGroup bossGroup;
private EventLoopGroup workerGroup;
public WebSocketServer() {
//创建两个线程组 boosGroup、workerGroup
bossGroup = new NioEventLoopGroup();
workerGroup = new NioEventLoopGroup();
}
public void start(int port, WebSocketServerHandler handler, String name) {
try {
//创建服务端的启动对象，设置参数
ServerBootstrap bootstrap = new ServerBootstrap();
//设置两个线程组boosGroup和workerGroup
bootstrap.group(bossGroup, workerGroup)
//设置服务端通道实现类型
.channel(NioServerSocketChannel.class)
//设置线程队列得到连接个数
.option(ChannelOption.SO_BACKLOG, 128)
//设置保持活动连接状态
.childOption(ChannelOption.SO_KEEPALIVE, true)
//使用匿名内部类的形式初始化通道对象
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception {
//给pipeline管道设置处理器
socketChannel.pipeline().addLast(new HttpServerCodec());
socketChannel.pipeline().addLast(new HttpObjectAggregator(65536));
socketChannel.pipeline().addLast(new WebSocketServerProtocolHandler("/websocket"));
socketChannel.pipeline().addLast(new IdleStateHandler(5, 2, 0, TimeUnit.SECONDS));
socketChannel.pipeline().addLast(new ServerHeartbeatHandler());
socketChannel.pipeline().addLast(handler);
}
});//给workerGroup的EventLoop对应的管道设置处理器
//绑定端口号，启动服务端
ChannelFuture channelFuture = bootstrap.bind(port).sync();
System.out.println(name + " 已启动");
//对通道关闭进行监听
channelFuture.channel().closeFuture().sync();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
}
}
}
服务端消息处理 WebSocketServerHandler
package com.sux.demo.websocket2;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.handler.codec.http.websocketx.*;
import io.netty.util.CharsetUtil;
import java.util.ArrayList;
import java.util.List;
@ChannelHandler.Sharable
public class WebSocketServerHandler extends SimpleChannelInboundHandler<Object> {
private List<Channel> channelList;
public WebSocketServerHandler() {
channelList = new ArrayList<>();
}
public boolean hasClient() {
return channelList.size() > 0;
}
@Override
protected void channelRead0(ChannelHandlerContext ctx, Object msg) {
if (msg instanceof PingWebSocketFrame) {
System.out.println("收到客户端" + ctx.channel().remoteAddress() + "发来的心跳：PING");
}
if (msg instanceof TextWebSocketFrame) {
TextWebSocketFrame frame = (TextWebSocketFrame) msg;
System.out.println("收到客户端" + ctx.channel().remoteAddress() + "发来的消息：" + frame.text());
/*for (Channel channel : channelList) {
if (!ctx.channel().id().toString().equals(channel.id().toString())) {
channel.writeAndFlush(new TextWebSocketFrame(Unpooled.copiedBuffer(frame.text(), CharsetUtil.UTF_8)));
System.out.println("服务端向客户端 " + channel.id().toString() + " 转发消息：" + frame.text());
}
}*/
}
}
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
channelList.add(ctx.channel());
System.out.println("客户端连接：" + ctx.channel().id().toString());
}
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
channelList.remove(ctx.channel());
}
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
ctx.flush();
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
ctx.close();
channelList.remove(ctx.channel());
}
public void send(String text) {
for (Channel channel : channelList) {
channel.writeAndFlush(new TextWebSocketFrame(Unpooled.copiedBuffer(text, CharsetUtil.UTF_8)));
}
}
}
服务端测试主机 WebSocketClientHost
package com.sux.demo.websocket2;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import io.netty.util.CharsetUtil;
public class WebSocketClientHost {
public static void main(String[] args) {
WebSocketClient webSocketClient = new WebSocketClient();
SendDataToServerThread thread = new SendDataToServerThread(webSocketClient);
thread.start();
webSocketClient.connect("127.0.0.1", 40005, "WebSocket客户端");
}
}
class SendDataToServerThread extends Thread {
private WebSocketClient webSocketClient;
private int index = 1;
public SendDataToServerThread(WebSocketClient webSocketClient) {
this.webSocketClient = webSocketClient;
}
@Override
public void run() {
try {
while (index <= 5) {
Channel channel = webSocketClient.getChannel();
if (channel != null && channel.isActive()) {
String msg = "客户端发送的测试消息, index= " + index;
channel.writeAndFlush(new TextWebSocketFrame(Unpooled.copiedBuffer(msg, CharsetUtil.UTF_8)));
index++;
}
Thread.sleep(1000);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
客户端
客户端心跳 ClientHeartbeatHandler
package com.sux.demo.websocket2;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.codec.http.websocketx.PingWebSocketFrame;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;
public class ClientHeartbeatHandler extends ChannelInboundHandlerAdapter {
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) {
if (evt instanceof IdleStateEvent) {
IdleStateEvent event = (IdleStateEvent) evt;
if (event.state() == IdleState.READER_IDLE) { // 读空闲
System.out.println("断线重连");
ctx.channel().close();
} else if (event.state() == IdleState.WRITER_IDLE) { // 写空闲
System.out.println("客户端向服务端发送心跳");
ctx.writeAndFlush(new PingWebSocketFrame());
// ctx.writeAndFlush(new TextWebSocketFrame(Unpooled.copiedBuffer("PING", CharsetUtil.UTF_8)));
} else if (event.state() == IdleState.ALL_IDLE) { // 读写空闲
}
}
}
}
客户端封装 WebSocketClient
package com.sux.demo.websocket2;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.http.DefaultHttpHeaders;
import io.netty.handler.codec.http.HttpClientCodec;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.websocketx.WebSocketClientHandshaker;
import io.netty.handler.codec.http.websocketx.WebSocketClientHandshakerFactory;
import io.netty.handler.codec.http.websocketx.WebSocketClientProtocolHandler;
import io.netty.handler.codec.http.websocketx.WebSocketVersion;
import io.netty.handler.timeout.IdleStateHandler;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.concurrent.TimeUnit;
public class WebSocketClient {
private NioEventLoopGroup eventExecutors;
private Channel channel;
public WebSocketClient() {
eventExecutors = new NioEventLoopGroup();
}
public Channel getChannel() {
return channel;
}
public void connect(String ip, int port, String name) {
try {
WebSocketClientHandshaker handshaker = WebSocketClientHandshakerFactory.newHandshaker(
new URI("ws://" + ip + ":" + port + "/websocket"), WebSocketVersion.V13, null, false, new DefaultHttpHeaders());
WebSocketClientHandler handler = new WebSocketClientHandler(handshaker);
ClientHeartbeatHandler heartbeatHandler = new ClientHeartbeatHandler();
//创建bootstrap对象，配置参数
Bootstrap bootstrap = new Bootstrap();
//设置线程组
bootstrap.group(eventExecutors)
//设置客户端的通道实现类型
.channel(NioSocketChannel.class)
//使用匿名内部类初始化通道
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
//添加客户端通道的处理器
ch.pipeline().addLast(new HttpClientCodec());
ch.pipeline().addLast(new HttpObjectAggregator(65536));
ch.pipeline().addLast(new WebSocketClientProtocolHandler(handshaker, true, false));
ch.pipeline().addLast(new IdleStateHandler(5, 2, 0, TimeUnit.SECONDS));
ch.pipeline().addLast(heartbeatHandler);
ch.pipeline().addLast(handler);
}
});
// 连接服务端
ChannelFuture channelFuture = bootstrap.connect(ip, port);
// 在连接关闭后尝试重连
channelFuture.channel().closeFuture().addListener(future -> {
try {
Thread.sleep(2000);
System.out.println("重新连接");
connect(ip, port, name); // 重新连接
} catch (Exception e) {
e.printStackTrace();
}
});
channelFuture.sync();
// 等待握手完成
// IGetHandshakeFuture getHadnshakeFuture = handler;
// getHadnshakeFuture.getHandshakeFuture().sync();
channel = channelFuture.channel();
System.out.println(name + " 已启动");
//对通道关闭进行监听
channelFuture.channel().closeFuture().sync();
} catch (InterruptedException | URISyntaxException e) {
e.printStackTrace();
} finally {
}
}
}
客户端消息处理 WebSocketClientHandler
package com.sux.demo.websocket2;
import io.netty.channel.*;
import io.netty.handler.codec.http.FullHttpResponse;
import io.netty.handler.codec.http.websocketx.*;
@ChannelHandler.Sharable
public class WebSocketClientHandler extends SimpleChannelInboundHandler<Object> implements IGetHandshakeFuture {
private WebSocketClientHandshaker handshaker;
private ChannelPromise handshakeFuture;
public WebSocketClientHandler(WebSocketClientHandshaker handshaker) {
this.handshaker = handshaker;
}
public ChannelPromise getHandshakeFuture() {
return this.handshakeFuture;
}
@Override
protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
if (!handshaker.isHandshakeComplete()) {
try {
handshaker.finishHandshake(ctx.channel(), (FullHttpResponse) msg);
handshakeFuture.setSuccess();
} catch (WebSocketHandshakeException e) {
handshakeFuture.setFailure(e);
}
return;
}
if (msg instanceof PongWebSocketFrame) {
System.out.println("收到服务端" + ctx.channel().remoteAddress() + "发来的心跳：PONG");
}
if (msg instanceof TextWebSocketFrame) {
TextWebSocketFrame frame = (TextWebSocketFrame) msg;
System.out.println("收到服务端" + ctx.channel().remoteAddress() + "发来的消息：" + frame.text()); // 接收服务端发送过来的消息
}
}
@Override
public void handlerAdded(ChannelHandlerContext ctx) {
handshakeFuture = ctx.newPromise();
}
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
// handshaker.handshake(ctx.channel());
}
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
}
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
ctx.flush();
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
ctx.close();
}
}
客户端测试主机 WebSocketServerHost
package com.sux.demo.websocket2;
public class WebSocketServerHost {
public static void main(String[] args) {
WebSocketServerHandler handler = new WebSocketServerHandler();
WebSocketServer webSocketServer = new WebSocketServer();
SendDataToClientThread thread = new SendDataToClientThread(handler);
thread.start();
webSocketServer.start(40005, handler, "WebSocket服务端");
}
}
class SendDataToClientThread extends Thread {
private WebSocketServerHandler handler;
private int index = 1;
public SendDataToClientThread(WebSocketServerHandler handler) {
this.handler = handler;
}
@Override
public void run() {
try {
while (index <= 5) {
if (handler.hasClient()) {
String msg = "服务端发送的测试消息, index= " + index;
handler.send(msg);
index++;
}
Thread.sleep(1000);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
测试
测试一
步骤：先启动服务端，再启动客户端
现象：客户端与服务端互发消息，消息发完后，互发心跳
测试二
步骤：先启动服务端，再启动客户端，然后关闭服务端，过一会再启动服务端
现象：客户端断线重连，通信恢复，正常发消息和心跳
测试三
步骤：先启动客户端，过一会再启动服务端
现象：服务端启动后，客户端连上服务端，正常通信，互发消息，消息发完互发心跳
遇到的问题
以上测试，客户端可以收到服务端发送的心跳，但是服务端无法收到客户端发送的心跳，导致服务端触发读空闲，从而关闭连接(代码已注释掉)
java netty 实现 websocket 服务端和客户端双向通信 实现心跳和断线重连的更多相关文章
- Netty 搭建 WebSocket 服务端
一.编码器.解码器 ... ... @Autowired private HttpRequestHandler httpRequestHandler; @Autowired private TextW ...
- java http post/get 服务端和客户端实现json传输
注:本文来源于<java http post/get 服务端和客户端实现json传输> 最近需要写http post接口所以学习下. 总的还是不难直接上源码! PostHttpClient ...
- Java的oauth2.0 服务端与客户端的实现
oauth原理简述 oauth本身不是技术,而是一项资源授权协议,重点是协议!Apache基金会提供了针对Java的oauth封装.我们做Java web项目想要实现oauth协议进行资源授权访问,直 ...
- Netty搭建WebSocket服务端
Netty服务端 1.引入依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns=& ...
- 使用Netty做WebSocket服务端
使用Netty搭建WebSocket服务器 1.WebSocketServer.java public class WebSocketServer { private final ChannelGro ...
- java网络编程-单线程服务端与客户端通信
该服务器一次只能处理一个客户端请求;p/** * 利用Socket进行简单服务端与客户端连接 * 这是服务端 */public class EchoServer { private ServerSoc ...
- WebSocket服务端和客户端使用
using System;using System.Collections.Generic;using System.IO;using System.Linq;using System.Net;usi ...
- Java WebService 简单实例-服务端和客户端
转载自ITeye:https://www.iteye.com/topic/1135747/
- Netty服务端与客户端（源码一）
首先,整理NIO进行服务端开发的步骤: (1)创建ServerSocketChannel,配置它为非阻塞模式. (2)绑定监听,配置TCP参数,backlog的大小. (3)创建一个独立的I/O线程, ...
- Netty学习笔记(二) 实现服务端和客户端
在Netty学习笔记(一) 实现DISCARD服务中,我们使用Netty和Python实现了简单的丢弃DISCARD服务,这篇,我们使用Netty实现服务端和客户端交互的需求. 前置工作 开发环境 J ...
随机推荐
- Python设置电脑桌面壁纸
其实 Python 设置电脑桌面壁纸是很简单的,主要是调用 win32gui 这个库来实现的 代码如下: import win32api import win32con import win32gu ...
- elasticsearch映射创建查询 和Spring Data ElasticSearch入门
Elasticsearch核心概念 Elasticsearch是面向文档(document oriented)的,这意味着它可以存储整个对象或文档(document).然而它不仅 仅是存储,还会索引( ...
- 堆结构（Heap）的基本实现【数据结构与算法—TypeScript 实现】
笔记整理自 coderwhy 『TypeScript 高阶数据结构与算法』课程 概念 本质:一种特殊的树结构,由 完全二叉树 实现 多数情况为二叉堆 二叉堆:最大堆.最小堆 最大堆:堆上的每个节点都的 ...
- ES6~ES9
ES6 1. let 1.1 let 变量声明及声明特性 let 用来声明变量,具有以下特性: 一.相较于 var ,let 变量不能重复声明 let a = 'a'; let a = 'a'; // ...
- 简单写一个eventbus
前言 闲暇之余,简单写一个eventbus. 正文 什么是eventbus? eventbus 是一个开源的发布订阅模式的框架,用于简化程序间不同组件的通信. 它允许不同组件间松耦合通信,组件之间不通 ...
- 重新点亮linux 命令树————权限的修改[十]
前言 简单介绍一下文件的权限修改. 正文 chmod 修改文件.目录的权限 chmod u+x /tmp/testfile chmod u-x /tmp/testfile u 表示用户 g 表示组 o ...
- Faiss 向量库编译安装
Faiss 是 Facebook 开源的一套高效相似性搜索以及向量聚类的开发库,支持各类相似性搜索的算法,Faiss 项目本身是使用 C++ 编写的,但是提供 Python 的绑定,可以直接使用 nu ...
- 【NOIP2013模拟联考8】匹配(match) 题解
B 组都说看不懂--我也解释不清啊--只能写这么详细了 其实就是道板题 省流:f[i][s][j]表示字符串长度i,匹配情况s,ac自动机节点j Problem Description 给定k个字符串 ...
- EMAS移动测试-远程真机篇
简介: 导读:本文将介绍申请远程真机以及在远程真机上执行测试任务的详细操作,包括申请远程真机.安装应用.扫码.定位.性能测试等. 一.移动测试概览 移动测试服务(Mobile Testing)是为企业 ...
- 多年锤炼，迈向Kata 3.0 ！走进开箱即用的安全容器体验之旅| 龙蜥技术
简介: 袋鼠与 Kata 将会碰撞出什么样的火花? 文/云原生 SIG(Special Interest Group) 一.Kata 的过去 让我们将时钟拨回 2015 年 5 月,Hyper.sh ...