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

最新推荐文章于 2024-05-09 19:34:30 发布
最新推荐文章于 2024-05-09 19:34:30 发布
阅读量6.8k 收藏 10
点赞数 3
分类专栏： Android项目功能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/github_27263697/article/details/78594165
版权

长连接

测试服务器： 
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

这样就保持了一个长连接。这个就可以看做心跳包。 
实际使用时比这个要复杂，但大概就是这个原理。

闲暇部落
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
android心跳包
鱼头小丸子的博客
02-07 566
心跳包就是在客户端和服务器间定时通知对方自己状态的一个自己定义的命令字，按照一定的时间间隔发送，类似于心跳，所以叫做心跳包。 主要作用是使客户端和服务器保持长时间的连接。 这里记录的是android客户端向服务端发送心跳包。 1.HeartbeatService 心跳包 public class HeartbeatService extends Service implements R
Android的socket长连接（心跳检测）
12-18
这是Android的socket长连接（心跳包），由于本人项目中需要用到长连接，所以先做了个demo，亲测是没有问题的。
android长连接心跳机制
热门推荐
rabbit_in_android的博客
11-30 2万+
在写之前，我们首先了解一下为什么android维护长连接需要心跳机制，首先我们知道，维护任何一个长连接都需要心跳机制，客户端发送一个心跳给 服务器，服务器给客户端一个心跳应答，这样就形成客户端服务器的一次完整的握手，这个握手是让双方都知道他们之间的连接是没有断开，客户端是在线 的。如果超过一个时间的阈值，客户端没有收到服务器的应答，或者服务器没有收到客户端的心跳，那么对客户端来说则断开
Android Socket通讯 之 心跳消息
晨曦
10-05 3883
不知道大家国庆节过的咋样，有没有学习呢？我是闲着没事就写点东西，本文篇幅较短，只是实现了心跳消息的处理，下面进入正文。
安卓 socket通信原理 心跳机制 面试必备
最新发布
2401_83816970的博客
05-09 310
为此，客户端的套接字必须首先描述它要连接的服务器的套接字，指出服务器端- - 套接字的地址和端口号，然后就向服务器端套接字提出连接请求。 连接确认：当服务器端套接字监听到或者说接收到客户端套接字的连接请求时，就响应客户端套接字的请求，建立一个新的线程，把服务器端套接字的描述发 给客户端，一旦客户端确认了此描述，双方就正式建立连接。而服务器端套接字继续处于监听状态，继续接收其他客户端套接字的连接请求。SOCKET 连接与 TCP创建 Socket 连接时，可以指定使用的传输层协议，Socket 可以支持不同的
Android service心跳实现的两种方式
ovejur的专栏
10-17 3185
这里简单介绍两种实现心跳的方式。 第一种，简单粗暴线程实现 new Thread(new Runnable() { @Override public void run() { while (true) { try { ...
TCP通信心跳包源码C语言实现
04-29
TCP通信心跳包源码C语言实现，基于Linux平台写的，可以整合到自己的代码中去。
Java心跳包功能TCP实现
11-07
Java心跳包功能的实现，tcp协议的，包含客户端和服务端
心跳包实现
04-27
C/S实操项目中很核心的一部分代码，可独立运行，希望能帮到大家
C#与Android进行Tcp通讯（心跳包；长连接，自动重连，发送失败时自动重发）
09-12
c#写tcpListener；Android写tcpClient 具有心跳包，长连接，自动重连，发送失败自动重发等功能 电脑与Android需要同属一个局域网 tcpListener设计成只能与一个tcpClient通信（当多个客户端接入时，会自动与前一个接入的客户端断开） tcpClient具有重连，长连接，与tcpListener进行心跳包通讯
Java心跳包功能实现
11-18
实现了心跳包的接收 和 发送功能 代码包含客户端和服务器端
安卓 socket通信原理 心跳机制 面试必备，app优化的内容及策略
03-21 389
*
Socket长连接Android端心跳机制实现
Dawish的专栏
07-25 1万+
前面用golang写的socket服务端请移步：http://blog.csdn.net/u010072711/article/details/760821761. 把socket链接和心跳功能都放在一个Service中，为什么要放在Service中？ 一般我们这种socket几乎是跟app的生命周期一样长，甚至更长。不管在不在Service中去完成操作，我们都得开异步线程，虽然Service并
【Android】Android心跳包详解
努力奋斗
09-27 7307
在做IM通信时，都会遇到这样一个概念：心跳包。又是一个比较抽象的概念，那么心跳包到底是什么呢？ 之前做的机房预定系统里，使用的Socket和服务器通信。长连接测试服务器： Socket基本上都这么一个流程。public class Test { private static final int PORT = 1234; private static final int BUFFE
android长连接 怎么处理心跳机制,C# 实现Scoket心跳机制的方法
weixin_29822105的博客
05-31 267
TCP网络长连接手机能够使用联网功能是因为手机底层实现了TCP/IP协议，可以使手机终端通过无线网络建立TCP连接。TCP协议可以对上层网络提供接口，使上层网络数据的传输建立在“无差别”的网络之上。建立起一个TCP连接需要经过“三次握手”：第一次握手：客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状态，等待服务器确认；第二次握手：服务器收到syn包，必须确认客户的SYN(ack=...
Android Socket连接（模拟心跳包，断线重连，发送数据等）
s2421458535的博客
05-31 3047
首页博客学院下载GitChatTinyMind论坛问答商城VIP活动招聘ITeyeCSTO写博客发Chat喻志强的博客耐心 细心 用心 传播正能量RSS订阅原Android Socket连接（模拟心跳包，断线重连，发送数据等）置顶2017年09月26日 14:29:13阅读数：2040这两天做了一个项目是app通过socket连接自动炒菜机，给炒菜机发指令，炒菜机接收到指令会执行相应的操作。（程序...
游戏服务器心跳包的作用
taitoubiyan1的专栏
12-25 6510
一 引 之前看代码没仔细,一直以为我们的心跳包就是为了防止socket自动断开连接 直到同事刚刚讲,这个超时是我们自己设置的啊....socket本身就是长连接 accept(Socket) -> Ref = prim_inet:async_recy(Socket, 5, 600) receive {ine
android心跳包示例
06-01
以下是一个使用新线程循环发送心跳包的示例代码： ```java public class HeartbeatThread extends Thread { private final String TAG = "HeartbeatThread"; private final int HEARTBEAT_INTERVAL = 5000; // 心跳包发送间隔，单位为毫秒 private boolean isRunning = false; // 标志位，用于控制线程运行状态 @Override public void run() { isRunning = true; while (isRunning) { try { // 发送心跳包 // ... Thread.sleep(HEARTBEAT_INTERVAL); // 线程休眠，等待下一次发送心跳包 } catch (InterruptedException e) { Log.e(TAG, "HeartbeatThread interrupted!"); e.printStackTrace(); } } } public void stopThread() { isRunning = false; } } ``` 在使用该线程时需要注意，在发送心跳包的同时，需要在主线程中处理接收到的心跳回包，以保证心跳功能的正常运行。可以使用Handler或者BroadcastReceiver来实现。 另外，需要注意线程的停止问题。在Activity或者Service销毁时，应该调用stopThread()方法来停止心跳线程，避免出现内存泄漏的情况。 ```java public class MainActivity extends AppCompatActivity { private HeartbeatThread mHeartbeatThread; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); mHeartbeatThread = new HeartbeatThread(); mHeartbeatThread.start(); } @Override protected void onDestroy() { super.onDestroy(); if (mHeartbeatThread != null) { mHeartbeatThread.stopThread(); mHeartbeatThread = null; } } } ``` 需要注意的是，该示例代码仅供参考，具体实现还需要根据具体的业务需求来进行调整。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值