Android心跳包(一)——心跳机制

转自：http://blog.csdn.net/rabbit_in_android/article/details/50119809

在写之前，我们首先了解一下为什么android维护长连接需要心跳机制，首先我们知道，维护任何一个长连接都需要心跳机制，客户端发送一个心跳给

服务器，服务器给客户端一个心跳应答，这样就形成客户端服务器的一次完整的握手，这个握手是让双方都知道他们之间的连接是没有断开，客户端是在线

的。如果超过一个时间的阈值，客户端没有收到服务器的应答，或者服务器没有收到客户端的心跳，那么对客户端来说则断开与服务器的连接重新建立一个

连接，对服务器来说只要断开这个连接即可。那么在智能手机上的长连接心跳和在Internet上的长连接心跳有什么不同的目的呢？原因就在于智能手机使用的

是移动无线网络，那么我们在讲长连接之前我们首先要了解无线移动网络的特点。

1.无线移动网络的特点：

        当一台智能手机连上移动网络时，其实并没有真正连接上Internet，运营商分配给手机的IP其实是运营商的内网IP，手机终端要连接上Internet还必须通过运营

商的网关进行IP地址的转换，这个网关简称为NAT(NetWork Address Translation)，简单来说就是手机终端连接Internet 其实就是移动内网IP，端口，外网IP之间

相互映射。相当于在手机终端在移动无线网络这堵墙上打个洞与外面的Internet相连。原理图如下：(来源网络)

        GGSN(GateWay GPRS Support Note 网关GPRS支持节点)模块就实现了NAT功能，由于大部分的移动无线网络运营商为了减少网关NAT映射表的负荷，如

果一个链路有一段时间没有通信时就会删除其对应表，造成链路中断，正是这种刻意缩短空闲连接的释放超时，原本是想节省信道资源的作用，没想到让互联网

的应用不得以远高于正常频率发送心跳来维护推送的长连接。这也是为什么会有之前的信令风暴，微信摇收费的传言，因为这类的应用发送心跳的频率是很短的，

既造成了信道资源的浪费，也造成了手机电量的快速消耗。

2.android系统的推送和IOS的推送有什么区别：

        首先我们必须知道，所有的推送功能必须有一个客户端和服务器的长连接，因为推送是由服务器主动向客户端发送消息，如果客户端和服务器之间不存在一个长连接那么服务器是无法来主动连接客户端的。因而推送功能都是基于长连接的基础是上的。

        IOS长连接是由系统来维护的，也就是说苹果的IOS系统在系统级别维护了一个客户端和苹果服务器的长链接，IOS上的所有应用上的推送都是先将消息推送到苹果的服务器然后将苹果服务器通过这个系统级别的长链接推送到手机终端上，这样的的几个好处为：1.在手机终端始终只要维护一个长连接即可，而且由于这个长链接是系统级别的不会出现被杀死而无法推送的情况。2.省电，不会出现每个应用都各自维护一个自己的长连接。3.安全，只有在苹果注册的开发者才能够进行推送，等等。

       android的长连接是由每个应用各自维护的，但是google也推出了和苹果技术架构相似的推送框架，C2DM,云端推送功能，但是由于google的服务器不在中国境内，其他的原因你懂的。所以导致这个推送无法使用，android的开发者不得不自己去维护一个长链接，于是每个应用如果都24小时在线，那么都得各自维护一个长连接，这种电量和流量的消耗是可想而知的。虽然国内也出现了各种推送平台，但是都无法达到只维护一个长连接这种消耗的级别。

3.推送的实现方式：

一：客户端不断的查询服务器，检索新内容，也就是所谓的pull 或者轮询方式

二：客户端和服务器之间维持一个TCP/IP长连接，服务器向客户端push

三：服务器又新内容时，发送一条类似短信的信令给客户端，客户端收到后从服务器中下载新内容，也就是SMS的推送方式

苹果的推送系统和googleC2DM推送系统其实都是在系统级别维护一个TCP/IP长连接，都是基于第二种的方式进行推送的。第三种方式由于运营商没有免费开放这种信令导致了这种推送在成本上是无法接受的，虽然这种推送的方式非常的稳定，高效和及时。

如果想了解android中各种推送方式请参考这个链接：Android实现推送方式解决方案 这篇博客已经介绍的非常好了。

所谓的心跳包就是客户端定时放送简单的信息给服务器端，告诉它我还在而已。代码就是每隔几分钟发送一个固定信息给服务器端，服务器端回复一个固定信息。如果服务器端几分钟后没有收到客户端信息则视客户端断开。比如有些通信软件长时间不适用，要想知道它的状态是在线还是离线，就需要心跳包，定时发包收包。

    心跳包之所以叫心跳包是因为：它像心跳一样每隔固定时间发一次，以此来告诉服务器，这个客户端还活在。事实上这是为了保持长连接，至于这个包的内容，是没有什么特别规定的，不过一般都是很小的包，或者只包含包头的一个空包。

     在TCP机制里面，本身是存在有心跳包机制的，也就是TCP选项:SO_KEEPALIVE. 系统默认是设置的2小时的心跳频率。

Socket长连接+心跳检测：

http://blog.csdn.net/zh724738989/article/details/42007099

心跳包的机制，其实就是传统的长连接。或许有的人知道消息推送的机制，消息推送也是一种长连接 ，是将数据有服务器端推送到客户端这边从而改变传统的“拉”的请求方式。下面我来介绍一下安卓和客户端两个数据请求的方式

       1、push  这个也就是有服务器推送到客户端这边  现在有第三方技术 比如极光推送。

       2、pull   这种方式就是客户端向服务器发送请求数据（http请求）

一、首先服务器和客户端有一次“握手”

[javascript]  view plain  copy

1. public void connect()  
2.       {  
3.         LogUtil.e(TAG, "准备链接...");  
4.         InetAddress serverAddr;  
5.         try {  
6.             socket = new Socket(Config.Host, Config.SockectPort);  
7.             _connect = true;  
8.             mReceiveThread = new ReceiveThread();  
9.             receiveStop = false;  
10.             mReceiveThread.start();  
11.             LogUtil.e(TAG, "链接成功.");  
12.   
13.         } catch (Exception e) {  
14.             LogUtil.e(TAG, "链接出错." + e.getMessage().toString());  
15.             e.printStackTrace();  
16.         }  
17.     }  

二、下面就要开启一个线程  去不断读取服务器那边传过来的数据  采用Thread去实现

[javascript]  view plain  copy

1. private class ReceiveThread extends Thread {  
2.         private byte[] buf;  
3.         private String str = null;  
4.   
5.         @Override  
6.         public void run() {  
7.             while (true) {  
8.                 try {  
9.                     // LogUtil.e(TAG, "监听中...:"+socket.isConnected());  
10.                     if (socket!=null && socket.isConnected()) {  
11.   
12.                         if (!socket.isInputShutdown()) {  
13.                             BufferedReader inStream = new BufferedReader(  
14.                                     new InputStreamReader(  
15.                                             socket.getInputStream()));  
16.                             String content = inStream.readLine();                              
17.                             if (content == null)  
18.                                 continue;  
19.                             LogUtil.e(TAG, "收到信息:" + content);  
20.                             LogUtil.e(TAG, "信息长度:"+content.length());  
21.                             if (!content.startsWith("CMD:"))  
22.                                 continue;  
23.                             int spacePos = content.indexOf(" ");  
24.                             if (spacePos == -1)  
25.                                 continue;  
26.                             String cmd = content.substring(4, spacePos);  
27. //                            String body = StringUtil.DecodeBase64(content  
28. //                                    .substring(spacePos));  
29.                             String body = content.substring(spacePos).trim();  
30.                             LogUtil.e(TAG, "收到信息(CMD):" + cmd);  
31.                             LogUtil.e(TAG, "收到信息(BODY):" + body);  
32.                             if (cmd.equals("LOGIN"))  
33.                            {  
34.                                 // 登录  
35.                                 ReceiveLogin(body);  
36.                                 continue;  
37.                             }  
38.                               if (cmd.equals("KEEPLIVE")) {  
39.                                 if (!body.equals("1")) {  
40.                                     Log.e(TAG, "心跳时检测到异常，重新登录!");  
41.                                     socket = null;  
42.                                     KeepAlive();  
43.                                 } else {  
44.                                     Date now = Calendar.getInstance().getTime();  
45.                                     lastKeepAliveOkTime = now;  
46.                                 }  
47.                                 continue;  
48.                             }  
49.                         }  
50.                     } else {  
51.                         if(socket!=null)  
52.                             LogUtil.e(TAG, "链接状态:" + socket.isConnected());  
53.                     }  
54.   
55.                 } catch (Exception e) {  
56.                     LogUtil.e(TAG, "监听出错:" + e.toString());  
57.                     e.printStackTrace();  
58.                 }  
59.             }  
60.         }  

三 、 Socket 是否断开了  断开了 需要重新去连接

[javascript]  view plain  copy

1. public void KeepAlive()  
2.         {  
3.         // 判断socket是否已断开,断开就重连  
4.         if (lastKeepAliveOkTime != null) {  
5.             LogUtil.e(  
6.                     TAG,  
7.                     "上次心跳成功时间:"  
8.                             + DateTimeUtil.dateFormat(lastKeepAliveOkTime,  
9.                                     "yyyy-MM-dd HH:mm:ss"));  
10.             Date now = Calendar.getInstance().getTime();  
11.             long between = (now.getTime() - lastKeepAliveOkTime.getTime());// 得到两者的毫秒数  
12.             if (between > 60 * 1000) {  
13.                 LogUtil.e(TAG, "心跳异常超过1分钟,重新连接:");  
14.                 lastKeepAliveOkTime = null;  
15.                 socket = null;  
16.             }  
17.   
18.         } else {  
19.             lastKeepAliveOkTime = Calendar.getInstance().getTime();  
20.         }  
21.   
22.         if (!checkIsAlive()) {  
23.             LogUtil.e(TAG, "链接已断开,重新连接.");  
24.             connect();  
25.             if (loginPara != null)  
26.                 Login(loginPara);  
27.         }  
28.   
29.     //此方法是检测是否连接  
30.       boolean checkIsAlive() {  
31.         if (socket == null)  
32.             return false;  
33.         try {  
34.             socket.sendUrgentData(0xFF);  
35.         } catch (IOException e) {  
36.             return false;  
37.         }  
38.         return true;  
39.   
40.     }  
41.    //然后发送数据的方法  
42.     public void sendmessage(String msg) {  
43.         if (!checkIsAlive())  
44.             return;  
45.         LogUtil.e(TAG, "准备发送消息:" + msg);  
46.         try {  
47.             if (socket != null && socket.isConnected()) {  
48.                 if (!socket.isOutputShutdown()) {  
49.                     PrintWriter outStream = new PrintWriter(new BufferedWriter(  
50.                             new OutputStreamWriter(socket.getOutputStream())),  
51.                             true);  
52.   
53.                     outStream.print(msg + (char) 13 + (char) 10);  
54.                     outStream.flush();  
55.                 }  
56.             }  
57.             LogUtil.e(TAG, "发送成功!");  
58.         } catch (Exception e) {  
59.             e.printStackTrace();  
60.         }  
61.     }  

最近做项目用到心跳轮询到主动到服务器取消息，为了做推送。坑了个爹的，极光百度推送限制多不能满足需求，只能自己写…手机主动到Service取数据，也就意味着你的手机要有一个服务，一直在后台运行，在特定的时间去服务器询问有没有消息，如果有消息则取回客户端。 
当然还可以用像什么XMPP（当然为了一个消息推送，动用那么大而又笨重的东西，很明显不明智），短信通知等等一下方式。

这里主要讲在android主动取数据： 
其实实现后台推送消息给客户端可以分为主动取，和主动推两种。

主动取：就是我们上面说的轮询服务器取消息。 
主动推：服务器推送消息给客户端，这里必须客户端和服务器保持长连接。 
两种形式各有利弊，“主动取”不能保证消息的实时性；“主动推”能保证消息的实时性，但是不能保证android端的这个链接不会被kill掉。

---

实现轮询

• 原理 
  其原理在于在android端的程序中，让一个SERVICE一直跑在后台，在规定时间之内调用服务器接口进行数据获取。

  这里的原理很简单，当然实现起来也不难；

  然后，这个类之中肯定要做网络了数据请求，所以我们在Service中建立一个线程（因为在android系统中网络请求属于长时间操作，不能放主线程，不然会导致异常），在线程中和服务器进行通信。

  最后，这个逻辑写完后，我们需要考虑一个问题，如何进行在规定时间内调用该服务器，当然可以用Thread+Handler(这个不是那么稳定),也可以使用AlamManager+Thread（比较稳定），因为我们需要其在后台一直运行，所以可以依靠系统的Alammanager这个类来实现，Alammanager是属于系统的一个闹钟提醒类，通过它我们能实现在规定间隔时间调用，并且也比较稳定，这个service被杀后会自己自动启动服务。

出于最近对im研究的兴趣，看到smack里有个30s发送一个空消息的线程，了解了下关于心跳包，keepalive的知识。 TCP的socket本身就是长连接的，那么为什么还要心跳包呢？

搜索到的资料解释如下：

一：内网机器如果不主动向外发起连接，外网机没法直连内网的，这也是内网机安全的原因之一吧，又因为路由器会把这个关系记录下来，但是过一段时间这个记录可能会丢失 ，所有每一个客户端每隔一定时间就会向服务器发送消息，以保证服务器可以随时找到你，这东西被称为心跳包。

二：理论上说，这个连接是一直保持连接的，但是实际情况中，如果中间节点出现什么故障是难以知道的。更要命的是，有的节点（防火墙）会自动把一定时间之内没有数据交互的连接给断掉。在这个时候，就需要我们的心跳包了，用于维持长连接，保活。在获知了断线之后，服务器逻辑可能需要做一些事情，比如断线后的数据清理呀，重新连接呀……当然，这个自然是要由逻辑层根据需求去做了。总的来说，心跳包主要也就是用于长连接的保活和断线处理。一般的应用下，判定时间在30-40秒比较不错。如果实在要求高，那就在6-9秒。

三：

如果不主动关闭socket的话，系统不会自动关闭的，除非当前进程挂掉了，操作系统把占用的socket回收了才会关闭。为什么需要心跳连接主要是判断当前连接是否是有效的、可被使用的。在实际应用中假设一段时间没有数据传输时候理论上说应该连接是没有问题的，但是网络复杂，中途出现问题也是常见的，网线被掐断了、对方进程挂掉了、频繁丢包等，这时候TCP连接是不可使用的，但是对于应用层并不知道，如果需知道网络情况则要很复杂的超时进行了解，TCP从底层就实现了这样的功能。
心跳机制是TCP在一段时间间隔后发送确定连接端是否还存在，如果存在的话就会回传一个包确定网络有效，如果心跳包有问题，则通知上层应用当前网络有问题了。
这取决于你的server端的超时配置， 每个socket连接都是长连接，它是一个相当占用系统资源的通信管道， 如果这个长连接什么事也没干硬是要占着资源，则server端可以选择关闭这个连接，以省下资源让更多的用户连接进来。
所以，即便客户端的是采用死循环while(true)方式连到服务端，对于特定的客户端和服务端类型来说也需要一定时间间隔的心跳（告诉服务端，我还活着，虽然我没干活也没说话，但别把我关了）。
记得以前开发手机游戏时，索爱有一款手机有强制要求，客户端如果超过三分钟无消息发向网络服务端，则会在客户端自动地强制把socket关断。因为socket长连接相对于手机这样资源少的设备来说是宝贵的资源。  (这个强制是指客户端系统自动关的，不是我们代码close的) 
这3个原因都是挺有道理。如果你有更好的解释欢迎交流啊。改天我做个程序测试一下不发心跳包和发心跳包的连接情况。