netty长连接实例

最新推荐文章于 2024-07-26 12:03:37 发布
最新推荐文章于 2024-07-26 12:03:37 发布
阅读量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-leanring:netty长连接复用的demo
05-18
netty-leanring netty长连接复用的demo
netty 实现长连接
04-30
9. **实例代码**：通常会包含如何配置和启动一个支持长连接的Netty服务器，以及客户端如何连接和发送数据的示例代码。 由于没有具体的博客内容，以上是基于常见情况的分析。实际的博客可能会详细解释这些概念，并...
ESXi安装【真机和虚拟机】（超详细）
最新发布
五指山的网络员
07-26 5634
ESXi（Elastic Sky X Integrated）是VMware公司开发的一种裸机虚拟化管理程序，允许用户在单一物理服务器上运行多个虚拟机（VM）。它直接安装在服务器硬件上，而不是操作系统之上，从而提高了性能和效率。ESXi的关键特性和管理方法。
Netty框架（一）组件介绍及实例实现长连接
Husky
07-08 854
目录一、Netty组件介绍1.Handler2.EventLoopGroup3.Bootstrap4.Channel二、Netty实战实现长连接1.服务器端代码实现2.客户端代码实现 一、Netty组件介绍 1.Handler 2.EventLoopGroup 3.Bootstrap 4.Channel 二、Netty实战实现长连接 1.服务器端代码实现 2.客户端代码实现 ...
Netty--长连接实例
百世经纶的博客
10-01 502
netty长连接---待更新
netty 长连接 demo
许佳佳的博客
07-20 1035
概要 近期接触netty长连接方面，实现简单demo记录，主要实现以下内容： 使用HashMap存储Channel，保证需要的时候可以根据key获取到。 被HashMap存储的长连接实现心跳机制。 demo中是以id为key存储在HashMap中，解析内容用到了Gson。 为了让demo更容易理解，没有实现粘包分包的逻辑，一旦发生会有问题。 对粘包和分包有兴趣的可以看下笔者的另一篇文章：So...
netty5长连接.自动重连
09-28
在“netty5长连接.自动重连”这个主题中，我们将深入探讨 Netty 如何实现长连接以及自动重连的机制。 首先，让我们理解什么是长连接。在传统的 TCP/IP 协议中，每次通信都需要建立一次连接（三次握手），完成数据...
netty:netty 实例
06-13
这个实例很可能是 Netty 框架的一个源码仓库，名为 "netty-master"，通常包含了 Netty 的核心组件、示例代码、测试用例以及相关的文档。 在深入探讨 Netty 的知识点之前，先来理解一下什么是框架。框架是一种半成品...
netty并发服务器实例代码
09-28
在描述中提到的"netty并发服务器实例代码"，意味着这个压缩包可能包含了使用Netty框架搭建的一个服务器端应用的源码。通常，这样的服务器会处理大量的并发连接，并且能够高效地处理来自客户端的请求。Netty的非阻塞I...
Spring+Netty+WebSocket实例
12-06
Netty提供了对WebSocket协议的全面支持，允许开发者直接在Netty服务器上处理WebSocket连接，提高了性能和灵活性。 在实际项目中，Spring与Netty的结合可以发挥各自的优势。Spring负责业务逻辑和路由控制，而Netty...
Netty4长连接（服务端+客户端）
06-02
Netty4长连接、断开重连、心跳检测、Msgpack编码解码 http://blog.csdn.net/giousa/article/details/72846303#t2
Netty实现长连接通讯-连接协议为了简单json封装
09-27
Netty实现长连接通讯,连接协议为了简单json封装,如果需要协议变化可以自己封装，有问题可以联系邮箱：lmjlimj@foxmail.com
Netty4 学习笔记之二:客户端与服务端心跳 demo
虚无境的博客
10-08 6462
前言 在上一篇Netty demo 中，了解了Netty中的客户端和服务端之间的通信。这篇则介绍Netty中的心跳。 之前在Mina 中心跳的使用是通过继承 KeepAliveMessageFactory 心跳工厂类而实现的。而在Netty中，提供IdleStateHandler 类，可以实现对三种心跳的检测，分别是readerIdleTime、writerIdleTime和allIdleTi...
Netty系列之实现长连接(九)
热门推荐
yuliantao的专栏
09-10 1万+
转：https://blog.csdn.net/qq_18603599/article/details/80810566 前面几个章节算是从头到尾把和netty的相关知识进行了详细的介绍,也做了相关的总结,但是关于netty如何在实践中去使用还没有提及到,今天就谈一下这方面的内容,netty大家都知道被适用于网络通信这块,所以很多RPC框架都有他的身影,而实际中使用netty都需要用到的是'长连...
Netty整合Socket客户端长链接
qq_39912230的博客
11-11 1171
创建客户端连接 import com.alibaba.fastjson.JSONObject; import com.lianfu.smartparking.controller.ThreadServerSocket; import io.netty.bootstrap.Bootstrap; import io.netty.channel.*; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.Sock
Netty WebSocket长连接
hn_lzh2014的博客
03-24 166
【代码】Netty WebSocket长连接。
[Netty实践] 心跳检测
Staba的博客
12-24 2551
心跳检测是用于保障服务端与客户端之间通信连接状态的实时监控。客户端不断向服务端发送心跳包（心跳包就是一组数据，自行定义，能够进行区分就好）。服务端在一定时间范围内能够正常接收客户端心跳包的话，就认为连接正常活跃；如果服务端在一定时间内没有接收到客户端心跳包的话，就认为连接出现中断或异常，那么就可以进行连接断开、释放资源等操作，从而保证节省服务端连接资源。
Netty网络框架学习笔记-8(WebSocket实现服务器和客户端长连接)
志豪的博客
06-20 1557
netty简单实现webSocket
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、付费专栏及课程。

余额充值