mina 2 心跳包

最新推荐文章于 2021-02-13 17:54:40 发布
最新推荐文章于 2021-02-13 17:54:40 发布
阅读量120 收藏
点赞数
文章标签： java
原文链接：https://yq.aliyun.com/articles/70270
版权 

接收到心跳后先解码，先不调用经过messageReceived(）方法，先触发心跳接收发送类KeepAliveMessageFactoryImpl中的isRequest(）方法，当判断是心跳时，就会发一个心跳，不再调用messageReceived(），当判断不是心跳时，回调messageReceived(）方法，输出内容。


//服务器


import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.charset.Charset;




import org.apache.mina.core.service.IoAcceptor;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
import org.apache.mina.filter.keepalive.KeepAliveFilter;
import org.apache.mina.filter.keepalive.KeepAliveMessageFactory;
import org.apache.mina.filter.keepalive.KeepAliveRequestTimeoutHandler;
import org.apache.mina.filter.logging.LoggingFilter;
import org.apache.mina.transport.socket.SocketAcceptor;
import org.apache.mina.transport.socket.nio.NioSocketAcceptor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


import public_protocol.MsgProtocol;




import server.KeepAliveRequestTimeoutHandlerImpl;
import serverUntil.ServerInfo;




/**
 * 服务端启动
 * @author Lhy
 *
 */
public class ServerStart {
    //设置服务器的端口,从全局变量类中获取服务器端口
private static final int PORT =ServerInfo.getServerPort();
/** 30秒后超时 */
//private static final int IDELTIMEOUT = 15;
/** 15秒发送一次心跳包 */
private static final int HEARTBEATRATE = 5;
//心跳超时时间
private static final int RequestTimeout=15;






private static SocketAcceptor acceptor;


    private ServerStart() {}
    
    public static SocketAcceptor getAcceptor(){
    if(null==acceptor){
    // 创建非阻塞的server端的Socket连接
    acceptor = new NioSocketAcceptor();
    }
    return acceptor;
    }
public static boolean serverStart() {
IoAcceptor acceptor = getAcceptor();
//缓冲区大小
acceptor.getSessionConfig().setReadBufferSize(1024);

//添加日志过滤器
acceptor.getFilterChain().addLast("logger", new LoggingFilter());
//添加编码过滤器
acceptor.getFilterChain().addLast("codec",new ProtocolCodecFilter(new MsgProtocol()));
//心跳包类，用于接收和发送心跳
KeepAliveMessageFactory heartBeatFactory = new KeepAliveMessageFactoryImpl();
//心跳超时类
KeepAliveRequestTimeoutHandler heartBeatHandler = new KeepAliveRequestTimeoutHandlerImpl();
        //心跳超时过滤器，IdleStatus.BOTH_IDLE表示在此连接上的读写操作
KeepAliveFilter heartBeat = new KeepAliveFilter(heartBeatFactory,IdleStatus.BOTH_IDLE,heartBeatHandler);
//当设置为true时同时执行心跳判断和空闲判断的MyIoHandler类的sessionIdle()方法
//当为false时就不在调用sessionIdle()方法
heartBeat.setForwardEvent(false);
//设置多长时间发送一条心跳
heartBeat.setRequestInterval(HEARTBEATRATE);
//心跳超时时间，当超时后调用自己写的KeepAliveRequestTimeoutHandlerImpl类进行操作
heartBeat.setRequestTimeout(RequestTimeout);
//把心跳加入过滤器
acceptor.getFilterChain().addLast("heartbeat", heartBeat);
//设置，用于事件触发回调的类
acceptor.setHandler(new MyIoHandler());
try {
acceptor.bind(new InetSocketAddress(PORT));
return true;
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("Server started on port： " + PORT);
return false;
}

}



//客户端


package lhy.client;


import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.charset.Charset;


import lhy.client_util.ServerInfo;
import lhy.protocol.MsgProtocol;


import org.apache.mina.core.future.ConnectFuture;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
import org.apache.mina.filter.keepalive.KeepAliveFilter;
import org.apache.mina.filter.keepalive.KeepAliveMessageFactory;
import org.apache.mina.filter.keepalive.KeepAliveRequestTimeoutHandler;
import org.apache.mina.filter.logging.LoggingFilter;
import org.apache.mina.transport.socket.nio.NioSocketConnector;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;






/**
 * 客户端启动连接
 * @author Lhy
 *
 */


public class ClientStart {



private static IoSession is;
/** 30秒后超时 */
// private static final int IDELTIMEOUT = 15;
/** 15秒发送一次心跳包 */
private static final int HEARTBEATRATE = 15;
//心跳超时时间
private static final int RequestTimeout=15;


private static NioSocketConnector connector ;


public static NioSocketConnector getConnector(){
    if(null==connector){
    // 创建非阻塞的server端的Socket连接
    connector = new NioSocketConnector();
    }
    return connector;
    }

public static IoSession getIoSession(){
    return is;
}
public static boolean clientStart() {
//从全局变量类中获取服务器ip,port
 String serverIp=ServerInfo.getServerIp();
 int serverPort=ServerInfo.getServerPort();
System.out.println(serverIp+" "+serverPort);
NioSocketConnector connector = getConnector();
connector.getSessionConfig().setReadBufferSize(1024);


// connector.getFilterChain().addLast("logger", new LoggingFilter());
connector.getFilterChain().addLast("codec",new ProtocolCodecFilter(new MsgProtocol()));
KeepAliveMessageFactory heartBeatFactory = new KeepAliveMessageFactoryImpl();
KeepAliveRequestTimeoutHandler heartBeatHandler = new KeepAliveRequestTimeoutHandlerImpl();
        KeepAliveFilter heartBeat = new KeepAliveFilter(heartBeatFactory,IdleStatus.BOTH_IDLE,heartBeatHandler);
heartBeat.setRequestInterval(HEARTBEATRATE);
//心跳超时
heartBeat.setRequestTimeout(RequestTimeout);
connector.getFilterChain().addLast("heartbeat", heartBeat);
connector.setHandler(new MyIoHandler());
// connector.getSessionConfig().setBothIdleTime(IDELTIMEOUT);
// connector.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE,
// IDELTIMEOUT);
//设置连接超时时间
connector.setConnectTimeoutMillis(5000);
ConnectFuture cf = connector.connect(new InetSocketAddress(serverIp,serverPort));// 建立连接
cf.awaitUninterruptibly();// 等待连接创建完成
try {
is=cf.getSession();
//getIoSession().write(new String(XmlUtils.getXml().getBytes("UTF-8")));// 发送消息
} catch (Exception e) {
connector.getFilterChain().remove("codec");
connector.getFilterChain().remove("heartbeat");
System.out.println("连接超时");
return false;
}

return true;
}


/**
* @ClassName KeepAliveMessageFactoryImpl
* @Description 内部类，实现KeepAliveMessageFactory（心跳工厂）
* @author cruise
*
*/
//
// }
}

//心跳发送接收类
package server;




import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.keepalive.KeepAliveMessageFactory;


import server_domain.HeartReq102;
import server_domain.HeartRes101;
import server_domain.MsgPack;








/**
 * @see 发送心跳包的内容
 */
public class KeepAliveMessageFactoryImpl implements KeepAliveMessageFactory{

//心跳包内容
private static HeartReq102 hq=new HeartReq102();
private static HeartRes101 hs=new HeartRes101();
    private static final MsgPack HEARTBEATREQUEST = new MsgPack(hq.getCode(),hq.getData());
    private static final MsgPack HEARTBEATRESPONSE = new MsgPack(hs.getCode(),hs.getData());
    
/**
     * @see 返回给客户端的心跳包数据 return 返回结果才是客户端收到的心跳包数据
     * @author Herman.Xiong
     */
    @Override
    public boolean isRequest(IoSession session, Object message) {
    MsgPack msg=(MsgPack)message;
    
    if (msg.getMsgCode()==HEARTBEATREQUEST.getMsgCode())
    {
    //System.out.println("获得请求心跳"+message.toString());
    return true;
    }
       
    return false;
    }


    @Override
    public boolean isResponse(IoSession session, Object message) {
    
    MsgPack msg=(MsgPack)message;
    if(msg.getMsgCode()==HEARTBEATRESPONSE.getMsgCode())
    {
    //System.out.println("收到心跳响应"+message);
    return true;
    }
    return false;
    }


    @Override
    public Object getRequest(IoSession session) {
    
    //System.out.println("发送请求心跳"+HEARTBEATREQUEST);
    return HEARTBEATREQUEST;
    
    }


    @Override
    public Object getResponse(IoSession session, Object request) {
    
    //System.out.println("回复心跳"+HEARTBEATRESPONSE);
    return HEARTBEATRESPONSE;
//   return null;
    }


}




//事件触发类

package server;


import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;




import serverUntil.ClientRequestInfo;
import server_command.ServerCommandFactory;
import server_domain.MsgPack;


/**
 * 连接IoHeadler
 * @author Lhy
 *
 */


public class MyIoHandler extends IoHandlerAdapter{
private final static Logger log = LoggerFactory
.getLogger(MyIoHandler.class);


@Override
public void sessionOpened(IoSession session) throws Exception {

}


@Override
public void sessionClosed(IoSession session) throws Exception {
System.out.println("当前连接已经关闭"+session.getRemoteAddress());
//删除全局变量中的为sessionId的映射
ClientRequestInfo.deleteWithSessionId(session.getId());
System.out.println("保存的当前用于服务器定时刷新的映射为"+ClientRequestInfo.cReqInfo);

}


@Override
public void messageReceived(IoSession session, Object message)
throws Exception {
MsgPack msg=(MsgPack)message;
System.out.println("收到消息"+msg.toString());

int code=msg.getMsgCode();
String data=msg.getMsgPack();
ServerCommandFactory serverCmd=new ServerCommandFactory();
serverCmd.CodeToDo(session,code,data);





}

public void sessionCreated(IoSession session) throws Exception {
        System.out.println("创建一个新连接："+ session.getRemoteAddress()+"  id:  "+session.getId());
        //session.write("welcome to the chat room !");
    }

public void sessionIdle(IoSession session, IdleStatus status) throws Exception {
        System.out.println("当前连接处于空闲状态："+ session.getRemoteAddress()+ status);
       // session.close(true);
    }



}


weixin_34113237
关注
Mina心跳检测实现
_今我来思的博客
03-10 2854
上一篇文章讲了Mina的简单使用，这一篇将要讲讲怎么用Mina实现心跳检测。网上有很多相关的文章，但是我觉得比较难理解，自己折腾了好久才明白，所以想用我觉得容易理解的话总结一下。也给自己做个笔记。一、心跳机制    1.心跳机制有什么用？在TCP的长连接中，有可能两端有很长一段时间没有数据往来，理论上连接应该是一直保持的。但实际情况中，如果中间节点出现故障，连接断开（如防火墙，或者断网等），这时候...
基于MINA实现server端心跳检测（KeepAliveFilter）
cruise技术博客
10-30 1万+
MINA自带了对心跳协议的支持，可以对心跳做出细致的配置，本文在次基础上实现了server端对client端的心跳检测。 在开始之前先简单介绍下keepAlive的机制： 首先，需要搞清楚TCP keepalive是干什么用的。从名字理解就能够知道，keepalive就是用来检测一个tcp connection是否还连接正常。当一个tcp connection建立好之后，如果双方都不发送数据的
mina心跳包机制
05-26
项目包含有mina的服务端与客户端，客户端发送心跳包，服务端响应心跳包
【MINA】心跳机制
weixin_30690833的博客
08-10 100
列上两篇好文章 http://www.cnblogs.com/pricks/p/3832882.html http://blog.csdn.net/cruise_h/article/details/13756219 心跳要解决的问题：说白了就是监控无效的连接并断开，多次超时无反应就断开的方式处理 MINA自带了对心跳协议的支持，可以对心跳做出细致的配置，本文在次基础上实现了server端对...
mina中对心跳包的支持
iteye_11158的博客
07-13 165
在filter包下有个原生态支持，只需实现接口KeepAliveMessageFactory即可。 但是还是有些不算问题的问题，比如在运行时手动设置空闲时间限制，那么会和KeepAliveFilter相互干扰。   例子和源码相对简单，这里贴一个毫无意义的实现，以作参考。 public class KeepAliveTestServer { public static void mai...
java mina 心跳机制_【MINA】心跳机制
weixin_29070861的博客
02-13 285
列上两篇好文章http://www.cnblogs.com/pricks/p/3832882.htmlhttp://blog.csdn.net/cruise_h/article/details/13756219心跳要解决的问题：说白了就是监控无效的连接并断开，多次超时无反应就断开的方式处理MINA自带了对心跳协议的支持，可以对心跳做出细致的配置，本文在次基础上实现了server端对client端的...
JAVA 通信框架MINA(包含心跳)
02-11
Apache MINA 是一个开发高性能和高可伸缩性网络应用程序的网络应用框架。它提供了一个抽象的事件驱动的异步 API，可以使用 TCP/IP、UDP/IP、串口和虚拟机内部的管道等传输方式。Apache MINA 可以作为开发网络应用程序的一个良好基础。
mina连接 mina心跳连接 mina断线重连
04-19
Mina允许开发者自定义心跳包，通过发送无数据的包或者包含特定标识的数据包，来检查网络连接是否正常。心跳通常由客户端或服务端定期发起，如果在预定时间内未收到回应，则判断为连接异常，并可能触发断线重连流程。...
Mina开源框架 心跳机制详解
06-22
2. **发送心跳包**：到达心跳间隔后，客户端或服务器会发送一个心跳包给对方。心跳包可以是任何定制的二进制或文本数据，只要双方能识别并处理即可。 3. **接收和处理心跳包**：当接收到心跳包时，接收方会确认收到...
mina心跳包:客户端发送心跳包，服务端响应心跳包
rongrong_love_lc的专栏
05-26 3609
结果如下： 下载地址：稍后补上
spring心跳配置
04-24
spring心跳配置的，两种方式。 一种是以频率的方式 一种是以时间点的方式（）
Websocket 原理，使用方法，心跳包机制（你想要了解的知识点！）
longlong6682的博客
02-27 6710
一. Websocket原理 什么是webSocket？ webSocket是一种在单个TCP连接上进行全双工通信的协议 客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。 浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输 远古时期解决方案就是轮训：客户端以设定的时间间隔周期性地向服务端发送请求，频繁地查询是否有新的数据改动（浪费流...
mina 心跳包，断线重连的问题
sangsa的博客
05-21 1万+
mina自带了心跳包机制，我是每隔15秒发送一次心跳包，若30秒内没有收到，则认为超时。 网络连接的主题函数是： /** * 30秒后超时 */ private static final int IDELTIMEOUT = 30; /** * 15秒发送一次心跳包 */ private static final int HEAR
mina 心跳 时间间隔 失效 和 心包，断线重连的问题
04-17 1584
mina 心跳 时间间隔 失效重连的时候有时候 会导致 时间间隔 失效，重新设置了keepAliveFilter也不行，日志I/KeepAliveFilter: 间隔时间是1I/KeepAliveFilter: message sent5465-6041 msg= pingI/KeepAliveFilter: message write5465-6041I/KeepAliveFilter: 间隔时...
MINA之心跳协议运用
xianymo的专栏
11-28 2051
转自：http://my.oschina.net/yjwxh/blog/174633 摘要 心跳协议，对基于CS模式的系统开发来说是一种比较常见与有效的连接检测方式，最近在用MINA框架，原本自己写了一个心跳协议实现，后来突然发现MINA本身带有这样一个心跳实现，感于对框架的小小崇拜，在实践的同时研究了一下！ MINA TCP/IP SOCKET 心跳 MINA本身提供了一个
spring集成mina，包含心跳检测，实现服务端主动推送
热门推荐
旧时光她是个美人
07-14 2万+
服务端1.常规的spring工程集成nima时，pom.xml中需要加入如下配置： <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-jdk14</artifactId> <version>1.7.7</version> </dependency> <depen
MINA源码分析---心跳包过滤器KeepAliveFilter
佳颖的专栏
12-04 5209
1、源码中都加了注释了，用户所要做的就是定义自己的心跳包信息，以及判断拉收的信息是否是心跳包，封装心跳包信息 2、实现KeepAliveMessageFactory接口，必要时可以继承KeepAliveFilter类，扩展功能都是可以的，也可以定义自己的心跳过滤器 3、接口KeepAliveRequestTimeoutHandler中定义了几个处理获取心跳响应超时的处理，当然也可自己写处理函数
心跳包间隔多少时间合适_Spring Cloud Alibaba Nacos（心跳与选举）
weixin_39827589的博客
12-05 3394
通过阅读NACOS的源码，了解其心跳与选举机制。开始阅读此篇文章之前，建议先阅读如下两篇文章：Spring Cloud Alibaba Nacos（功能篇）Spring Cloud Alibaba Nacos（源码篇）一、心跳机制只有NACOS服务与所注册的Instance之间才会有直接的心跳维持机制，换言之，这是一种典型的集中式管理机制。服务实例发送心跳在client这一侧是心跳的发起源，进入N...
Apache Mina2教程：从入门到实践
Mina还有许多高级特性，如线程模型、心跳机制、事件模型等，可以根据需求进行深入学习和定制。此外，Mina社区活跃，有丰富的文档和示例代码可供参考。 Apache Mina提供了一整套工具和机制，帮助开发者快速构建高效...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值