netty长连接实例

最新推荐文章于 2023-10-30 22:43:49 发布
最新推荐文章于 2023-10-30 22:43:49 发布
阅读量1.1w 收藏 5
点赞数 5
分类专栏： netty

通过netty实现服务端与客户端的长连接通讯，及心跳检测。

       基本思路：netty服务端通过一个Map保存所有连接上来的客户端SocketChannel,客户端的Id作为Map的key。每次服务器端如果要向某个客户端发送消息，只需根据ClientId取出对应的SocketChannel,往里面写入message即可。心跳检测通过IdleEvent事件，定时向服务端放送Ping消息，检测SocketChannel是否终断。

        环境JDK1.8 和netty5

        以下是具体的代码实现和介绍：

1公共的Share部分(主要包含消息协议类型的定义)

     设计消息类型：

?
1
2
3
public  enum   MsgType {
     PING,ASK,REPLY,LOGIN
}

    Message基类：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//必须实现序列,serialVersionUID 一定要有,否者在netty消息序列化反序列化会有问题，接收不到消息！！！
public  abstract  class  BaseMsg   implements  Serializable {
     private  static  final  long  serialVersionUID = 1L;
     private  MsgType type;
     //必须唯一，否者会出现channel调用混乱
     private  String clientId;
 
     //初始化客户端id
     public  BaseMsg() {
         this .clientId = Constants.getClientId();
     }
 
     public  String getClientId() {
         return  clientId;
     }
 
     public  void  setClientId(String clientId) {
         this .clientId = clientId;
     }
 
     public  MsgType getType() {
         return  type;
     }
 
     public  void  setType(MsgType type) {
         this .type = type;
     }
}

常量设置：

?
1
2
3
4
5
6
7
8
9
public  class  Constants {
     private  static  String clientId;
     public  static  String getClientId() {
         return  clientId;
     }
     public  static  void  setClientId(String clientId) {
         Constants.clientId = clientId;
     }
}

登录类型消息：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public  class  LoginMsg  extends  BaseMsg {
     private  String userName;
     private  String password;
     public  LoginMsg() {
         super ();
         setType(MsgType.LOGIN);
     }
 
     public  String getUserName() {
         return  userName;
     }
 
     public  void  setUserName(String userName) {
         this .userName = userName;
     }
 
     public  String getPassword() {
         return  password;
     }
 
     public  void  setPassword(String password) {
         this .password = password;
     }
}

 心跳检测Ping类型消息：

?
1
2
3
4
5
6
public  class  PingMsg  extends  BaseMsg {
     public  PingMsg() {
         super ();
         setType(MsgType.PING);
     }
}

请求类型消息：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public  class  AskMsg  extends  BaseMsg {
     public  AskMsg() {
         super ();
         setType(MsgType.ASK);
     }
     private  AskParams params;
 
     public  AskParams getParams() {
         return  params;
     }
 
     public  void  setParams(AskParams params) {
         this .params = params;
     }
}
//请求类型参数
//必须实现序列化接口
public  class  AskParams  implements  Serializable {
     private  static  final  long  serialVersionUID = 1L;
     private  String auth;
 
     public  String getAuth() {
         return  auth;
     }
 
     public  void  setAuth(String auth) {
         this .auth = auth;
     }
}

响应类型消息：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public  class  ReplyMsg  extends  BaseMsg {
     public  ReplyMsg() {
         super ();
         setType(MsgType.REPLY);
     }
     private  ReplyBody body;
 
     public  ReplyBody getBody() {
         return  body;
     }
 
     public  void  setBody(ReplyBody body) {
         this .body = body;
     }
}
//相应类型body对像
public  class  ReplyBody  implements  Serializable {
     private  static  final  long  serialVersionUID = 1L;
}
public  class  ReplyClientBody  extends  ReplyBody {
     private  String clientInfo;
 
     public  ReplyClientBody(String clientInfo) {
         this .clientInfo = clientInfo;
     }
 
     public  String getClientInfo() {
         return  clientInfo;
     }
 
     public  void  setClientInfo(String clientInfo) {
         this .clientInfo = clientInfo;
     }
}
public  class  ReplyServerBody  extends  ReplyBody {
     private  String serverInfo;
     public  ReplyServerBody(String serverInfo) {
         this .serverInfo = serverInfo;
     }
     public  String getServerInfo() {
         return  serverInfo;
     }
     public  void  setServerInfo(String serverInfo) {
         this .serverInfo = serverInfo;
     }
}

2 Server端：主要包含对SocketChannel引用的Map,ChannelHandler的实现和Bootstrap.

Map:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public  class  NettyChannelMap {
     private  static  Map<String,SocketChannel> map= new  ConcurrentHashMap<String, SocketChannel>();
     public  static  void  add(String clientId,SocketChannel socketChannel){
         map.put(clientId,socketChannel);
     }
     public  static  Channel get(String clientId){
        return  map.get(clientId);
     }
     public  static  void  remove(SocketChannel socketChannel){
         for  (Map.Entry entry:map.entrySet()){
             if  (entry.getValue()==socketChannel){
                 map.remove(entry.getKey());
             }
         }
     }
 
}

Handler

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
public  class  NettyServerHandler  extends  SimpleChannelInboundHandler<BaseMsg> {
     @Override
     public  void  channelInactive(ChannelHandlerContext ctx)  throws  Exception {
         //channel失效，从Map中移除
         NettyChannelMap.remove((SocketChannel)ctx.channel());
     }
     @Override
     protected  void  messageReceived(ChannelHandlerContext channelHandlerContext, BaseMsg baseMsg)  throws  Exception {
 
         if (MsgType.LOGIN.equals(baseMsg.getType())){
             LoginMsg loginMsg=(LoginMsg)baseMsg;
             if ( "robin" .equals(loginMsg.getUserName())&& "yao" .equals(loginMsg.getPassword())){
                 //登录成功,把channel存到服务端的map中
                 NettyChannelMap.add(loginMsg.getClientId(),(SocketChannel)channelHandlerContext.channel());
                 System.out.println( "client" +loginMsg.getClientId()+ " 登录成功" );
             }
         } else {
             if (NettyChannelMap.get(baseMsg.getClientId())== null ){
                     //说明未登录，或者连接断了，服务器向客户端发起登录请求，让客户端重新登录
                     LoginMsg loginMsg= new  LoginMsg();
                     channelHandlerContext.channel().writeAndFlush(loginMsg);
             }
         }
         switch  (baseMsg.getType()){
             case  PING:{
                 PingMsg pingMsg=(PingMsg)baseMsg;
                 PingMsg replyPing= new  PingMsg();
                 NettyChannelMap.get(pingMsg.getClientId()).writeAndFlush(replyPing);
             } break ;
             case  ASK:{
                 //收到客户端的请求
                 AskMsg askMsg=(AskMsg)baseMsg;
                 if ( "authToken" .equals(askMsg.getParams().getAuth())){
                     ReplyServerBody replyBody= new  ReplyServerBody( "server info $$$$ !!!" );
                     ReplyMsg replyMsg= new  ReplyMsg();
                     replyMsg.setBody(replyBody);
                     NettyChannelMap.get(askMsg.getClientId()).writeAndFlush(replyMsg);
                 }
             } break ;
             case  REPLY:{
                 //收到客户端回复
                 ReplyMsg replyMsg=(ReplyMsg)baseMsg;
                 ReplyClientBody clientBody=(ReplyClientBody)replyMsg.getBody();
                 System.out.println( "receive client msg: " +clientBody.getClientInfo());
             } break ;
             default : break ;
         }
         ReferenceCountUtil.release(baseMsg);
     }
}

ServerBootstrap:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public  class  NettyServerBootstrap {
     private  int  port;
     private  SocketChannel socketChannel;
     public  NettyServerBootstrap( int  port)  throws  InterruptedException {
         this .port = port;
         bind();
     }
 
     private  void  bind()  throws  InterruptedException {
         EventLoopGroup boss= new  NioEventLoopGroup();
         EventLoopGroup worker= new  NioEventLoopGroup();
         ServerBootstrap bootstrap= new  ServerBootstrap();
         bootstrap.group(boss,worker);
         bootstrap.channel(NioServerSocketChannel. class );
         bootstrap.option(ChannelOption.SO_BACKLOG,  128 );
         //通过NoDelay禁用Nagle,使消息立即发出去，不用等待到一定的数据量才发出去
         bootstrap.option(ChannelOption.TCP_NODELAY,  true );
         //保持长连接状态
         bootstrap.childOption(ChannelOption.SO_KEEPALIVE,  true );
         bootstrap.childHandler( new  ChannelInitializer<SocketChannel>() {
             @Override
             protected  void  initChannel(SocketChannel socketChannel)  throws  Exception {
                 ChannelPipeline p = socketChannel.pipeline();
                 p.addLast( new  ObjectEncoder());
                 p.addLast( new  ObjectDecoder(ClassResolvers.cacheDisabled( null )));
                 p.addLast( new  NettyServerHandler());
             }
         });
         ChannelFuture f= bootstrap.bind(port).sync();
         if (f.isSuccess()){
             System.out.println( "server start---------------" );
         }
     }
     public  static  void  main(String []args)  throws  InterruptedException {
         NettyServerBootstrap bootstrap= new  NettyServerBootstrap( 9999 );
         while  ( true ){
             SocketChannel channel=(SocketChannel)NettyChannelMap.get( "001" );
             if (channel!= null ){
                 AskMsg askMsg= new  AskMsg();
                 channel.writeAndFlush(askMsg);
             }
             TimeUnit.SECONDS.sleep( 5 );
         }
     }
}

3 Client端：包含发起登录，发送心跳，及对应消息处理

handler

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
public  class  NettyClientHandler  extends  SimpleChannelInboundHandler<BaseMsg> {
     //利用写空闲发送心跳检测消息
     @Override
     public  void  userEventTriggered(ChannelHandlerContext ctx, Object evt)  throws  Exception {
         if  (evt  instanceof  IdleStateEvent) {
             IdleStateEvent e = (IdleStateEvent) evt;
             switch  (e.state()) {
                 case  WRITER_IDLE:
                     PingMsg pingMsg= new  PingMsg();
                     ctx.writeAndFlush(pingMsg);
                     System.out.println( "send ping to server----------" );
                     break ;
                 default :
                     break ;
             }
         }
     }
     @Override
     protected  void  messageReceived(ChannelHandlerContext channelHandlerContext, BaseMsg baseMsg)  throws  Exception {
         MsgType msgType=baseMsg.getType();
         switch  (msgType){
             case  LOGIN:{
                 //向服务器发起登录
                 LoginMsg loginMsg= new  LoginMsg();
                 loginMsg.setPassword( "yao" );
                 loginMsg.setUserName( "robin" );
                 channelHandlerContext.writeAndFlush(loginMsg);
             } break ;
             case  PING:{
                 System.out.println( "receive ping from server----------" );
             } break ;
             case  ASK:{
                 ReplyClientBody replyClientBody= new  ReplyClientBody( "client info **** !!!" );
                 ReplyMsg replyMsg= new  ReplyMsg();
                 replyMsg.setBody(replyClientBody);
                 channelHandlerContext.writeAndFlush(replyMsg);
             } break ;
             case  REPLY:{
                 ReplyMsg replyMsg=(ReplyMsg)baseMsg;
                 ReplyServerBody replyServerBody=(ReplyServerBody)replyMsg.getBody();
                 System.out.println( "receive client msg: " +replyServerBody.getServerInfo());
             }
             default : break ;
         }
         ReferenceCountUtil.release(msgType);
     }
}

bootstrap

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
public  class  NettyClientBootstrap {
     private  int  port;
     private  String host;
     private  SocketChannel socketChannel;
     private  static  final  EventExecutorGroup group =  new  DefaultEventExecutorGroup( 20 );
     public  NettyClientBootstrap( int  port, String host)  throws  InterruptedException {
         this .port = port;
         this .host = host;
         start();
     }
     private  void  start()  throws  InterruptedException {
         EventLoopGroup eventLoopGroup= new  NioEventLoopGroup();
         Bootstrap bootstrap= new  Bootstrap();
         bootstrap.channel(NioSocketChannel. class );
         bootstrap.option(ChannelOption.SO_KEEPALIVE, true );
         bootstrap.group(eventLoopGroup);
         bootstrap.remoteAddress(host,port);
         bootstrap.handler( new  ChannelInitializer<SocketChannel>() {
             @Override
             protected  void  initChannel(SocketChannel socketChannel)  throws  Exception {
                 socketChannel.pipeline().addLast( new  IdleStateHandler( 20 , 10 , 0 ));
                 socketChannel.pipeline().addLast( new  ObjectEncoder());
                 socketChannel.pipeline().addLast( new  ObjectDecoder(ClassResolvers.cacheDisabled( null )));
                 socketChannel.pipeline().addLast( new  NettyClientHandler());
             }
         });
         ChannelFuture future =bootstrap.connect(host,port).sync();
         if  (future.isSuccess()) {
             socketChannel = (SocketChannel)future.channel();
             System.out.println( "connect server  成功---------" );
         }
     }
     public  static  void  main(String[]args)  throws  InterruptedException {
         Constants.setClientId( "001" );
         NettyClientBootstrap bootstrap= new  NettyClientBootstrap( 9999 , "localhost" );
 
         LoginMsg loginMsg= new  LoginMsg();
         loginMsg.setPassword( "yao" );
         loginMsg.setUserName( "robin" );
         bootstrap.socketChannel.writeAndFlush(loginMsg);
         while  ( true ){
             TimeUnit.SECONDS.sleep( 3 );
             AskMsg askMsg= new  AskMsg();
             AskParams askParams= new  AskParams();
             askParams.setAuth( "authToken" );
             askMsg.setParams(askParams);
             bootstrap.socketChannel.writeAndFlush(askMsg);
         }
     }
}

具体的例子和相应pom.xml 见 https://github.com/WangErXiao/ServerClient

转发请注明来源：http://my.oschina.net/robinyao/blog/399060

小飞侠-2
关注
专栏目录
netty 实现长连接
04-30
NULL 博文链接：https://gjp014.iteye.com/blog/2390925
ESXi安装【真机和虚拟机】（超详细）
最新发布
五指山的网络员
07-26 5902
ESXi（Elastic Sky X Integrated）是VMware公司开发的一种裸机虚拟化管理程序，允许用户在单一物理服务器上运行多个虚拟机（VM）。它直接安装在服务器硬件上，而不是操作系统之上，从而提高了性能和效率。ESXi的关键特性和管理方法。
netty入门（十六）netty心跳监测机制
zhufei463738313的博客
03-07 1018
在 client 与 server 之间，一定时间内没有数据交互时, 即处于 idle 状态时, 客户端或服务器就会发送一个特殊的数据包给对方, 当接收方收到这个数据报文后, 也立即发送一个特殊的数据报文, 回应发送方, 此即一个 PING-PONG 交互。所以, 当某一端收到心跳消息后, 就知道了对方仍然在线, 这就确保 TCP 连接的有效性。
Netty——心跳机制与断线重连
共勉
03-02 3135
在长连接模式下，为了保证系统的稳定行和可用性，心跳包和重连机制是必不可少的，让我们看看在Netty中怎么简单的实现吧
使用 Netty+SpringBoot 打造的 TCP 长连接通讯方案
Java知音
04-17 658
项目背景最近公司某物联网项目需要使用socket长连接进行消息通讯，捣鼓了一版代码上线，结果BUG不断，本猿寝食难安，于是求助度娘，数日未眠项目终于平稳运行了，本着开源共享的精神，本猿把项目代码提炼成了一个demo项目，尽量摒弃了其中丑陋的业务部分，希望与同学们共同学习进步。正文一、项目架构本项目使用了netty、redis以及springboot2.2.0二、项目模块本项目目录结构如下图：net...
netty5长连接.自动重连
09-28
在“netty5长连接.自动重连”这个主题中，我们将深入探讨 Netty 如何实现长连接以及自动重连的机制。 首先，让我们理解什么是长连接。在传统的 TCP/IP 协议中，每次通信都需要建立一次连接（三次握手），完成数据...
netty并发服务器实例代码
09-28
在描述中提到的"netty并发服务器实例代码"，意味着这个压缩包可能包含了使用Netty框架搭建的一个服务器端应用的源码。通常，这样的服务器会处理大量的并发连接，并且能够高效地处理来自客户端的请求。Netty的非阻塞I...
netty:netty 实例
06-13
这个实例很可能是 Netty 框架的一个源码仓库，名为 "netty-master"，通常包含了 Netty 的核心组件、示例代码、测试用例以及相关的文档。 在深入探讨 Netty 的知识点之前，先来理解一下什么是框架。框架是一种半成品...
Spring+Netty+WebSocket实例
12-06
Netty提供了对WebSocket协议的全面支持，允许开发者直接在Netty服务器上处理WebSocket连接，提高了性能和灵活性。 在实际项目中，Spring与Netty的结合可以发挥各自的优势。Spring负责业务逻辑和路由控制，而Netty...
Netty学习（七）：心跳检测机制
m0_49499183的博客
03-13 4235
所谓心跳, 即在TCP长连接中, 客户端和服务器之间定期发送的一种特殊的数据包, 通知对方自己还在线, 以确保TCP连接的有效性.心跳机制主要是客户端和服务端长时间连接时，客户端需要定时发送心跳包来保证自己是存活的，否则一个连接长时间没有作用就会浪费服务端的资源。
Netty 中的心跳机制
深圳市多克创新科技有限公司
10-16 3380
Netty 中的心跳检测机制，好文分享
netty实现长连接
Capsq的博客
05-18 2172
使用netty实现websocket长连接通信 WebSocket 是 HTML5 开始提供的一种在单个 TCP 连接上进行全双工通讯的协议。 WebSocket 使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。 实现长连接主要代码为 pipeline.addLast(new WebSocketServerProtocolHandler("/websocket")); 这段代码是指在服务端的处理通道上改变服务之间通信的协议 具体的实现如下 @Author bumpworld
Netty 心跳机制详解
qq_33807380的博客
10-30 1419
在 TCP 保持长连接的过程中，客户端与服务端之间如果长时间没有交互的话，无法发现对方是否已经掉线。为了确保客户端与服务端是否都还正常工作，客户端和服务端需要定期发送心跳包来维护连接。readerIdleTime：读超时时限，当在指定时间间隔内没有从 Channel 读取到数据时，会触发一个 READER_IDLE 的 IdleStateEvent 事件。
netty之客户端定时发心跳数据包
zsj777的专栏
06-10 1690
服务端在一段时间内没有收到客户端的数据，这个现象产生的原因可以分为以下两种。 1.连接假死。 2.非假死状态下确实没有发送数据。 我们只需要排除第二种可能，那么连接自然就是假死的。要排查第二种情况，我们可以在客户端定期发送数据包到服务端，通常这个数据包被称为心跳数据包。我们定义一个Handler，定期发送心跳数据包给服务端。客户端发送心跳数据给服务端 HeartBeatTimerHandler.java ctx.executor()方法返回的是当前Channel绑定的NIO线程。NIO线程有一个sc
简单的Java实现Netty进行通信
严阵以待的专栏
05-16 799
使用Java搭建一个简单的Netty通信例子 看过dubbo源码的同学应该都清楚，使用dubbo协议的底层通信是使用的netty进行交互，而最近看了dubbo的Netty部分后，自己写了个简单的Netty通信例子。 本文源地址：实现Netty进行通信 准备 工程截图 模块详解 rpc-common rpc-common作为各个模块都需使用的模块，工程中出现的是一些通信时请求的参数以及返回的参数，还有一些序列化的工具。 rpc-client rpc-client中目前只是单单的一个
网络I/o编程模型12 netty实现tcp服务通讯（含EventLoop实现调度）
健康平安的活着的专栏
05-28 372
一 netyy实现tcp通讯 1.1 案例需求描述 1.netty服务端可以监听6666端口，客户端向此服务器进行发送信息。例如“hello，netty服务器....”; 2.服务端收到信息对客户端进行回复信息，例如“hello，客户端发的消息已经收到.....” ......
看看好不好用，使用 Netty+SpringBoot 打造的 TCP 长连接通讯方案
2301_76936922的博客
04-27 497
希望我们可以一起学习进步，共同推动物联网技术的发展。是从构造函数传入的，而不是在客户端中创建的，因为当客户端数量非常多时，每个客户端都创建自己的线程组会极大的消耗服务器资源，因此我们在实际使用中是按业务去创建统一的线程组给该业务下的所有客户端共同使用的，线程组的大小需要根据业务需求灵活配置。当消费者接收到某设备发送的消息后，将判断缓存中是否存在该设备与服务端的连接，如果存在并且通道活跃则使用该通道发送消息，如果不存在则创建通道并在通道激活后立即发送消息，当客户端收到来自服务端的消息时进行响应的业务处理。
Netty之——如何实现长链接
fulong0406的博客
06-14 2535
一个简单的长连接demo分为以下几个步骤： 创建连接（Channel） 发心跳包 发消息，并通知其他用户 一段时间没收到心跳包或者用户主动关闭之后关闭连接 如何保存已创建的Channel 这里我们是将Channel放在一个Map中，以Channel.hashCode()作为key 其实这样做有一个劣势，就是不适合水平扩展，每个机器都有一个连接数的上线，如果需要实现多用户实时在线，对机器的数量要求会很高，在这里我们不多做讨论，不同的业务场景，设计方案也是不同的，可以在长连接方案和客户端...
netty连接池技术实例
04-08
Netty连接池技术是一种优化网络连接的方法，可以提高网络连接的复用率和效率。下面是一个使用Netty连接池技术的代码示例： ``` EventLoopGroup group = new NioEventLoopGroup(); Bootstrap bootstrap = new ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值