mina 心跳机制

最新推荐文章于 2023-03-13 15:09:16 发布
最新推荐文章于 2023-03-13 15:09:16 发布
阅读量710 收藏 1
点赞数
分类专栏： 服务器

mina 心跳机制

  • 博客分类：
  • mina
 

 MINA自带了对心跳协议的支持，可以对心跳做出细致的配置，本文在次基础上实现了server端对client端的心跳检测。

在开始之前先简单介绍下keepAlive的机制：

首先，需要搞清楚TCP keepalive是干什么用的。从名字理解就能够知道，keepalive就是用来检测一个tcp connection是否还连接正常。当一个tcp connection建立好之后，如果双方都不发送数据的话，tcp协议本身是不会发送其它的任何数据的，也就是说，在一个idle的connection上，两个socket之间不产生任何的数据交换。从另一个方面讲，当一个connection建立之后，链接双方可以长时间的不发送任何数据，比如几天，几星期甚至几个月，但该connection仍然存在。

所以，这就可能出现一个问题。举例来说，server和client建立了一个connection，server负责接收client的request。当connection建立好之后，client由于某种原因机器停机了。但server端并不知道，所以server就会一直监听着这个connection，但其实这个connection已经失效了。

keepalive就是为这样的场景准备的。当把一个socket设置成了keepalive，那么这个socket空闲一段时间后，它就会向对方发送数据来确认对方仍然存在。放在上面的例子中，如果client停机了，那么server所发送的keepalive数据就不会有response，这样server就能够确认client完蛋了（至少从表面上看是这样）。

 

具体的源代码如下：

 Server.java

 

 

Java代码 复制代码  收藏代码
  1. import java.io.IOException;   
  2. import java.net.InetSocketAddress;   
  3. import java.nio.charset.Charset;   
  4.   
  5. import org.apache.mina.core.service.IoAcceptor;   
  6. import org.apache.mina.core.session.IdleStatus;   
  7. import org.apache.mina.core.session.IoSession;   
  8. import org.apache.mina.filter.codec.ProtocolCodecFilter;   
  9. import org.apache.mina.filter.keepalive.KeepAliveFilter;   
  10. import org.apache.mina.filter.keepalive.KeepAliveMessageFactory;   
  11. import org.apache.mina.filter.logging.LoggingFilter;   
  12. import org.apache.mina.transport.socket.nio.NioSocketAcceptor;   
  13. import org.slf4j.Logger;   
  14. import org.slf4j.LoggerFactory;   
  15.   
  16. public class Server {   
  17.   
  18.     private static final int PORT = 9123;   
  19.     /** 30秒后超时 */  
  20.     private static final int IDELTIMEOUT = 30;   
  21.     /** 15秒发送一次心跳包 */  
  22.     private static final int HEARTBEATRATE = 15;   
  23.     /** 心跳包内容 */  
  24.     private static final String HEARTBEATREQUEST = "0x11";   
  25.     private static final String HEARTBEATRESPONSE = "0x12";   
  26.     private static final Logger LOG = LoggerFactory.getLogger(Server.class);   
  27.   
  28.     public static void main(String[] args) throws IOException {   
  29.         IoAcceptor acceptor = new NioSocketAcceptor();   
  30.         acceptor.getSessionConfig().setReadBufferSize(1024);   
  31.         acceptor.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE,   
  32.                 IDELTIMEOUT);   
  33.            
  34.         acceptor.getFilterChain().addLast("logger", new LoggingFilter());   
  35.         acceptor.getFilterChain().addLast(   
  36.                 "codec",   
  37.                 new ProtocolCodecFilter(new TextLineCodecFactory()));   
  38.   
  39.         KeepAliveMessageFactory heartBeatFactory = new KeepAliveMessageFactoryImpl();   
  40.         //下面注释掉的是自定义Handler方式   
  41. //      KeepAliveRequestTimeoutHandler heartBeatHandler = new    
  42. //                              KeepAliveRequestTimeoutHandlerImpl();   
  43. //      KeepAliveFilter heartBeat = new KeepAliveFilter(heartBeatFactory,   
  44. //              IdleStatus.BOTH_IDLE, heartBeatHandler);   
  45.            
  46.         KeepAliveFilter heartBeat = new KeepAliveFilter(heartBeatFactory,   
  47.                 IdleStatus.BOTH_IDLE);   
  48.   
  49.         //设置是否forward到下一个filter   
  50.         heartBeat.setForwardEvent(true);   
  51.         //设置心跳频率   
  52.         heartBeat.setRequestInterval(HEARTBEATRATE);   
  53.   
  54.         acceptor.getFilterChain().addLast("heartbeat", heartBeat);   
  55.   
  56.         acceptor.setHandler(new MyIoHandler());   
  57.         acceptor.bind(new InetSocketAddress(PORT));   
  58.         System.out.println("Server started on port： " + PORT);   
  59.     }   
  60.   
  61.     /**  
  62.      * @ClassName KeepAliveMessageFactoryImpl  
  63.      * @Description 内部类，实现KeepAliveMessageFactory（心跳工厂）  
  64.      * @author cruise  
  65.      *  
  66.      */  
  67.     private static class KeepAliveMessageFactoryImpl implements  
  68.             KeepAliveMessageFactory {   
  69.   
  70.         @Override  
  71.         public boolean isRequest(IoSession session, Object message) {   
  72.             LOG.info("请求心跳包信息: " + message);   
  73.             if (message.equals(HEARTBEATREQUEST))   
  74.                 return true;   
  75.             return false;   
  76.         }   
  77.   
  78.         @Override  
  79.         public boolean isResponse(IoSession session, Object message) {   
  80. //          LOG.info("响应心跳包信息: " + message);   
  81. //          if(message.equals(HEARTBEATRESPONSE))   
  82. //              return true;   
  83.             return false;   
  84.         }   
  85.   
  86.         @Override  
  87.         public Object getRequest(IoSession session) {   
  88.             LOG.info("请求预设信息: " + HEARTBEATREQUEST);   
  89.             /** 返回预设语句 */  
  90.             return HEARTBEATREQUEST;   
  91.         }   
  92.   
  93.         @Override  
  94.         public Object getResponse(IoSession session, Object request) {   
  95.             LOG.info("响应预设信息: " + HEARTBEATRESPONSE);   
  96.             /** 返回预设语句 */  
  97.             return HEARTBEATRESPONSE;   
  98. //          return null;   
  99.         }   
  100.   
  101.     }   
  102.        
  103.     /**  
  104.      * 对应上面的注释  
  105.      * KeepAliveFilter(heartBeatFactory,IdleStatus.BOTH_IDLE,heartBeatHandler)  
  106.      * 心跳超时处理  
  107.      * KeepAliveFilter 在没有收到心跳消息的响应时，会报告给的KeepAliveRequestTimeoutHandler。  
  108.      * 默认的处理是 KeepAliveRequestTimeoutHandler.CLOSE  
  109.      * （即如果不给handler参数，则会使用默认的从而Close这个Session）  
  110.      * @author cruise  
  111.      *  
  112.      */  
  113.   
  114. //  private static class KeepAliveRequestTimeoutHandlerImpl implements   
  115. //          KeepAliveRequestTimeoutHandler {   
  116. //   
  117. //     
  118. //      @Override   
  119. //      public void keepAliveRequestTimedOut(KeepAliveFilter filter,   
  120. //              IoSession session) throws Exception {   
  121. //          Server.LOG.info("心跳超时！");   
  122. //      }   
  123. //   
  124. //  }   
  125. }  
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.keepalive.KeepAliveFilter;
import org.apache.mina.filter.keepalive.KeepAliveMessageFactory;
import org.apache.mina.filter.logging.LoggingFilter;
import org.apache.mina.transport.socket.nio.NioSocketAcceptor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Server {

	private static final int PORT = 9123;
	/** 30秒后超时 */
	private static final int IDELTIMEOUT = 30;
	/** 15秒发送一次心跳包 */
	private static final int HEARTBEATRATE = 15;
	/** 心跳包内容 */
	private static final String HEARTBEATREQUEST = "0x11";
	private static final String HEARTBEATRESPONSE = "0x12";
	private static final Logger LOG = LoggerFactory.getLogger(Server.class);

	public static void main(String[] args) throws IOException {
		IoAcceptor acceptor = new NioSocketAcceptor();
		acceptor.getSessionConfig().setReadBufferSize(1024);
		acceptor.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE,
				IDELTIMEOUT);
		
		acceptor.getFilterChain().addLast("logger", new LoggingFilter());
		acceptor.getFilterChain().addLast(
				"codec",
				new ProtocolCodecFilter(new TextLineCodecFactory()));

		KeepAliveMessageFactory heartBeatFactory = new KeepAliveMessageFactoryImpl();
		//下面注释掉的是自定义Handler方式
//		KeepAliveRequestTimeoutHandler heartBeatHandler = new 
//								KeepAliveRequestTimeoutHandlerImpl();
//		KeepAliveFilter heartBeat = new KeepAliveFilter(heartBeatFactory,
//				IdleStatus.BOTH_IDLE, heartBeatHandler);
		
		KeepAliveFilter heartBeat = new KeepAliveFilter(heartBeatFactory,
				IdleStatus.BOTH_IDLE);

		//设置是否forward到下一个filter
		heartBeat.setForwardEvent(true);
		//设置心跳频率
		heartBeat.setRequestInterval(HEARTBEATRATE);

		acceptor.getFilterChain().addLast("heartbeat", heartBeat);

		acceptor.setHandler(new MyIoHandler());
		acceptor.bind(new InetSocketAddress(PORT));
		System.out.println("Server started on port： " + PORT);
	}

	/**
	 * @ClassName KeepAliveMessageFactoryImpl
	 * @Description 内部类，实现KeepAliveMessageFactory（心跳工厂）
	 * @author cruise
	 *
	 */
	private static class KeepAliveMessageFactoryImpl implements
			KeepAliveMessageFactory {

		@Override
		public boolean isRequest(IoSession session, Object message) {
			LOG.info("请求心跳包信息: " + message);
			if (message.equals(HEARTBEATREQUEST))
				return true;
			return false;
		}

		@Override
		public boolean isResponse(IoSession session, Object message) {
//			LOG.info("响应心跳包信息: " + message);
//			if(message.equals(HEARTBEATRESPONSE))
//				return true;
			return false;
		}

		@Override
		public Object getRequest(IoSession session) {
			LOG.info("请求预设信息: " + HEARTBEATREQUEST);
			/** 返回预设语句 */
			return HEARTBEATREQUEST;
		}

		@Override
		public Object getResponse(IoSession session, Object request) {
			LOG.info("响应预设信息: " + HEARTBEATRESPONSE);
			/** 返回预设语句 */
			return HEARTBEATRESPONSE;
//			return null;
		}

	}
	
	/**
	 * 对应上面的注释
	 * KeepAliveFilter(heartBeatFactory,IdleStatus.BOTH_IDLE,heartBeatHandler)
	 * 心跳超时处理
	 * KeepAliveFilter 在没有收到心跳消息的响应时，会报告给的KeepAliveRequestTimeoutHandler。
	 * 默认的处理是 KeepAliveRequestTimeoutHandler.CLOSE
	 * （即如果不给handler参数，则会使用默认的从而Close这个Session）
	 * @author cruise
	 *
	 */

//	private static class KeepAliveRequestTimeoutHandlerImpl implements
//			KeepAliveRequestTimeoutHandler {
//
//	
//		@Override
//		public void keepAliveRequestTimedOut(KeepAliveFilter filter,
//				IoSession session) throws Exception {
//			Server.LOG.info("心跳超时！");
//		}
//
//	}
}

 

MyIoHandler.java

Java代码 复制代码  收藏代码
  1. import org.apache.mina.core.service.IoHandlerAdapter;   
  2. import org.apache.mina.core.session.IoSession;   
  3. import org.slf4j.Logger;   
  4. import org.slf4j.LoggerFactory;   
  5.   
  6.   
  7. public class MyIoHandler extends IoHandlerAdapter{   
  8.     private final static Logger log = LoggerFactory   
  9.             .getLogger(MyIoHandler.class);   
  10.   
  11.     @Override  
  12.     public void sessionOpened(IoSession session) throws Exception {   
  13.            
  14.     }   
  15.   
  16.     @Override  
  17.     public void sessionClosed(IoSession session) throws Exception {   
  18.            
  19.     }   
  20.   
  21.     @Override  
  22.     public void messageReceived(IoSession session, Object message)   
  23.             throws Exception {   
  24.         String ip = session.getRemoteAddress().toString();   
  25.         log.info("===> Message From " + ip + " : " + message);          
  26.     }   
  27.        
  28.        
  29.   
  30. }  
import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IoSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


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 {
		
	}

	@Override
	public void messageReceived(IoSession session, Object message)
			throws Exception {
		String ip = session.getRemoteAddress().toString();
		log.info("===> Message From " + ip + " : " + message);		
	}
	
	

}

  

 

启动Server后，运行telnet客户端连接到Server端，便可以测试心跳；

测试结果如下图：

dyf20081124
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于MINA实现server端心跳检测（KeepAliveFilter）
cruise技术博客
10-30 1万+
MINA自带了对心跳协议的支持，可以对心跳做出细致的配置，本文在次基础上实现了server端对client端的心跳检测。 在开始之前先简单介绍下keepAlive的机制： 首先，需要搞清楚TCP keepalive是干什么用的。从名字理解就能够知道，keepalive就是用来检测一个tcp connection是否还连接正常。当一个tcp connection建立好之后，如果双方都不发送数据的
Mina服务端客户端心跳机制
hannuotayouxi的博客
12-01 2429
心跳： 1、自定义数据包，在业务逻辑里接收，客户端判断读写空闲，大于一个半的心跳之后，在空闲处理里将session关闭，注册的监听里断线重连 2、tcp的keepalive，服务端、客户端相互发确认心跳，设置好对应的心跳场景（服务端写空闲大于n秒后，每隔一个时间周期发送一个心跳1111，客户端读空闲大于n秒后，每隔一个时间周期发送一个心跳2222） 客户端设置超时时间，大于超时时间后，没有收到
mina 添加心跳包
rongrong_love_lc的专栏
05-08 2142
1.检测心跳包的关键代码如下:setKeepAliveRequestInterval(30);定时进入IoHandlerAdapter子类的sessionIdle(IoSession session, IdleStatus status)回调方法;/****************************************************************************
关于mina框架里产生too many open files的错误的解决办法
godghkj的专栏
11-25 1054
网上很多说法是增加修改可打开文件数  通过修改ulimit -n  这个命令来实现。 其实都是治标不治本的办法。 要解决这个问题，要从两个方面入手。 一个是设置session的超时状态。 比如设置读取闲置时间，根据自己的需求去设置，及时关闭掉觉得超时的session。 acceptor.getSessionConfig().setIdleTime(IdleStatus.READER_I
Netty学习（七）：心跳检测机制
最新发布
m0_49499183的博客
03-13 4159
所谓心跳, 即在TCP长连接中, 客户端和服务器之间定期发送的一种特殊的数据包, 通知对方自己还在线, 以确保TCP连接的有效性.心跳机制主要是客户端和服务端长时间连接时，客户端需要定时发送心跳包来保证自己是存活的，否则一个连接长时间没有作用就会浪费服务端的资源。
mina心跳包机制
05-26
mina心跳包机制是Apache Mina框架中的一个关键特性，它用于维持网络连接的活跃状态，确保数据能够在客户端和服务端之间顺畅地传输。Mina是一个高度可扩展的Java网络应用框架，广泛应用于各种分布式系统和网络服务，...
Mina开源框架 心跳机制详解
06-22
在Mina框架中，心跳机制扮演着至关重要的角色，它确保了网络连接的健康性和可靠性。心跳机制是网络通信中的一个基本概念，主要用来检测客户端与服务器之间的连接是否依然活跃，防止因网络延迟或数据包丢失导致的假死...
mina 心跳
02-24
"Mina心跳"是指在MINA框架中实现的一种机制，用于确保网络连接的活跃性和数据传输的可靠性。心跳在分布式系统、网络通信和实时应用程序中扮演着关键角色，因为它们可以检测并处理网络延迟、断开连接或其它通信问题。...
mina连接 mina心跳连接 mina断线重连
04-19
接下来，我们讨论"Mina心跳连接"。心跳机制是保持连接活性的重要手段，特别是在长连接中，防止因网络延迟或服务器无响应导致的假死状态。Mina允许开发者自定义心跳包，通过发送无数据的包或者包含特定标识的数据包，...
MINA 心跳协议Demo
05-09
MINA框架提供了心跳机制的内置支持，使得开发者可以轻松地在应用中集成这一功能。 在描述中，“使用MINA自带的心跳协议编写的心跳的Demo”表明这是一个演示如何在MINA中实现心跳检查的实际代码示例。通常，心跳协议...
Mina 解决请求后直接关闭连接 (解决too many open files)查询(netstat -a)
huangchao的专栏
11-24 2399
对于系统的TIME_WAIT过多，造成服务器的负载过高. 从程序的优化解决角度来说，在MINA那里有一个参数　setSoLinger(int i) 可以有很效地解决这个问题。 最后Mina的参数应该是这样的。覆盖IoHandlerAdapter的sessionCreated方法应该要这样设置参数。 Java代码 @Override       public void
Mina学习
weixin_34144848的博客
08-23 86
Apache MINA 2 是一个开发高性能和高可伸缩性网络应用程序的网络应用框架。它提供了一个抽象的事件驱动的异步 API，可以使用 TCP/IP、UDP/IP、串口和虚拟机内部的管道等传输方式。Apache MINA 2 可以作为开发网络应用程序的一个良好基础 优点: – 异步 – 无阻塞 – 事件驱动 – 支持TCP, UDP, APR, 串口… – ...
MINA的心跳filter的使用
chengzongjuan8489的博客
03-02 259
一、KeepAliveFilter 1、构造函数： KeepAliveFilter(KeepAliveMessageFactorymessageFactory,IdleStatusinterestedIdleStatus) KeepAliveFilter(KeepAl...
Mina心跳检测实现
_今我来思的博客
03-10 2841
上一篇文章讲了Mina的简单使用，这一篇将要讲讲怎么用Mina实现心跳检测。网上有很多相关的文章，但是我觉得比较难理解，自己折腾了好久才明白，所以想用我觉得容易理解的话总结一下。也给自己做个笔记。一、心跳机制    1.心跳机制有什么用？在TCP的长连接中，有可能两端有很长一段时间没有数据往来，理论上连接应该是一直保持的。但实际情况中，如果中间节点出现故障，连接断开（如防火墙，或者断网等），这时候...
从Mina源码看心跳超时机制
明光的博客
06-10 1416
首先明确一点，在Mina或者其他相似的框架中，心跳机制肯定都是和计时挂钩的，只要找到计时相关的代码，其实就离真正的心跳逻辑不远了。 Mina中的心跳超时其实都是指会话空闲，即在一定时间段内未接收或未发送消息的状态，此时会触发SessionIdle，也就是IoFilter中的方法。 找到计时的地方，就很好理解了： //AbstractPollingIoProcessor.java priva...
MINA源码分析---心跳包过滤器KeepAliveFilter
佳颖的专栏
12-04 5179
1、源码中都加了注释了，用户所要做的就是定义自己的心跳包信息，以及判断拉收的信息是否是心跳包，封装心跳包信息 2、实现KeepAliveMessageFactory接口，必要时可以继承KeepAliveFilter类，扩展功能都是可以的，也可以定义自己的心跳过滤器 3、接口KeepAliveRequestTimeoutHandler中定义了几个处理获取心跳响应超时的处理，当然也可自己写处理函数
Android使用mina传输数据以及发送心跳，有重连机制
wzx311的博客
07-02 644
在实验室写项目时，需要使用tcp的连接以及发送心跳给后台，还需接收后台给的数据，还可以给后台发送数据 1、先去写了很多的后台发送数据来我们去编解码 public class ByteArrayCodecFactory implements ProtocolCodecFactory { private ByteArrayDecoder decoder; private ByteArrayEncoder encoder; public ByteArrayCodecFactory(
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值