Android心跳包(一)——心跳实现

关注

原创最新推荐文章于 2026-05-21 14:01:01 发布 7.3k 阅读 AI 写同款· GEO 优化 ›

分享一种Android端IM即时通讯智能心跳算法对于IM或实时消息推送技术来说，客户端的心跳算法几乎是必备品，尤其当前复杂的移动网络环境下，网络心跳保活算法的优劣更是决定了您的APP即时数据收发的实时性和用户体验，非常地关键。为什么TCP连接需要心跳？因为运营商有一个NAT超时：因为IP v4的IP量有限，运营商分配给手机终端的IP是运营商内网的IP，手机要连接Internet，就需要通过运营商的网关做一个网络地址转换(Network Address Translation，NAT)。简单的说运营商的网关需要维护一个外网IP、端口到内网IP、端口的对应阅读详情

长连接

测试服务器：
Socket基本上都这么一个流程。

public class Test {

    private static final int PORT = 1234;  

    private static final int BUFFER_SIZE = 1024; 

    public static void main(String[] args) {
        ServerSocket ss;
        try {
            ss = new ServerSocket(PORT);
            Socket s = ss.accept();
            byte[] recData = null;  
            InputStream in = s.getInputStream();  
            OutputStream out = s.getOutputStream();  
            while(true) {  
                recData = new byte[BUFFER_SIZE];  
                int r = in.read(recData);  
                //int r = in.read(recData);  
                if(r>-1) {  
                    String data = new String(recData);  
                    if(data.trim().equals("over")) {  
                        s.close();  
                    }  
                    System.out.println("读取到客户端发送的来数据："+data);  
                    out.write("这是服务端发给客户端的数据：".getBytes());  
                    out.write(recData);  
                }else {  
                    System.out.println("数据读取完毕！");  
                    s.close();  
                    System.exit(0);  
                    //ss.close();  
                }  
            }  

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}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

这个就是读客户端传过来的数据。
客户端我写在了android上，一个click事件：

    public void test(View v) {
        new Thread(new Runnable() {

            @Override
            public void run() {
                try {
                    Socket s = new Socket(serv,port);
                    PrintWriter out = new PrintWriter(s.getOutputStream());
                    while (true) {
                        Thread.sleep(5000);
                        String msg = "me";
                        out.println(msg);
                        out.flush();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }               
            }
        }).start();
    }1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

启动Server后，效果如下，每5秒钟会收到客户端发的消息：
这里写图片描述

这个就是长连接，如果不关掉服务器，会一直接收某个客户端的消息。

短连接

服务器代码：

public class Test {

    private static final int PORT = 1234;  

    private static final int BUFFER_SIZE = 1024; 

    public static void main(String[] args) {
        ServerSocket ss;
        try {
            ss = new ServerSocket(PORT);
            Socket s = ss.accept();
            //主要是这一句
            s.setSoTimeout(2000);
            byte[] recData = null;  
            InputStream in = s.getInputStream();  
            OutputStream out = s.getOutputStream();  
            while(true) {  
                recData = new byte[BUFFER_SIZE];  
                int r = in.read(recData);  
                //int r = in.read(recData);  
                if(r>-1) {  
                    String data = new String(recData);  
                    if(data.trim().equals("over")) {  
                        s.close();  
                    }  
                    System.out.println("读取到客户端发送的来数据："+data);  
                    out.write("这是服务端发给客户端的数据：".getBytes());  
                    out.write(recData);  
                }else {  
                    System.out.println("数据读取完毕！");  
                    s.close();  
                    System.exit(0);  
                    //ss.close();  
                }  
            }  

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}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

客户端代码：

    public void test(View v) {
        new Thread(new Runnable() {

            @Override
            public void run() {
                try {
                    Socket s = new Socket(serv,port);
                    PrintWriter out = new PrintWriter(s.getOutputStream());
                    while(true){
                        String msg = "me";
                        out.println(msg);
                        out.flush();
                        Thread.sleep(3000);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }               
            }
        }).start();
    }1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

可以看到，客户端是3秒发一次消息，而服务器设置的是2秒超时。所以只能接收到一次消息，然后就关闭了socket。
这里写图片描述
如果不想报错，就把服务器的while(true)循环放到Socket s = ss.accept();外面。意思是，为每个客户端分配的连接时长是2秒，超过以后就中断这个socket，除非重新建立连接。

心跳包

长连接占用系统资源，但是短连接会造成连接中断。所以综合这两种情况，提出一个心跳包的概念。就是给服务器设置超时，比如上面的2秒，然后客户端发空的消息，或约定好的字符串格式，当然间隔时长需要在超时以内（比如这里就需要在2秒以内）来给服务器保证这个连接（即这个socket）不被销毁。

服务器代码：

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;


public class Test {

    private static final int PORT = 1234;  

    private static final int BUFFER_SIZE = 1024; 

    public static void main(String[] args) {
        ServerSocket ss = null;
        try {
            ss = new ServerSocket(PORT);
            Socket s = ss.accept();
            s.setSoTimeout(2000);
            byte[] recData = null;  
            InputStream in = s.getInputStream();  
            OutputStream out = s.getOutputStream();  
            while(true) {  
                recData = new byte[BUFFER_SIZE];  
                int r = in.read(recData);  
                //int r = in.read(recData);  
                if(r>-1) {  
                    String data = new String(recData);  
                    if(data.trim().equals("over")) {  
                        s.close();  
                    }  
                    System.out.println("读取到客户端发送的来数据："+data);  
                    out.write("这是服务端发给客户端的数据：".getBytes());  
                    out.write(recData);  
                }else {  
                    System.out.println("数据读取完毕！");  
                    s.close();  
                    System.exit(0);  
                    //ss.close();  
                }  
            }  

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
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

客户端代码：

public void test(View v) {
        new Thread(new Runnable() {

            @Override
            public void run() {
                try {
                    Socket s = new Socket(serv,port);
                    PrintWriter out = new PrintWriter(s.getOutputStream());
                    while(true){
                        String msg = "me";
                        out.println(msg);
                        out.flush();
                        //这里改成1秒了
                        Thread.sleep(1000);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }               
            }
        }).start();
    }1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24