TCP长连接+心跳包

最新推荐文章于 2024-07-30 08:15:00 发布
最新推荐文章于 2024-07-30 08:15:00 发布
阅读量384 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdndouniwan/article/details/85858277
版权 
import android.os.Bundle;
import android.text.TextUtils;
import android.text.method.ScrollingMovementMethod;
import android.util.Log;
import com.ysl.socket.broad.SockeBroadcastReceiver;
import com.ysl.socket.interfaces.SocketCallback;

import android.app.Activity;
import android.content.IntentFilter;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.Toast;

public class MainActivity extends Activity {
   
   public static String str = "first message...";
   private SockeBroadcastReceiver mHeartBeatBroadCast;
   private TextView txtMsg;  
   private Button send;  
   private EditText etMsg;  
   private String content;  
   
   @Override
   protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_socket);  
      socketTest();
   }
   
   @Override
   protected void onResume()
   {
      super.onResume();
      IntentFilter mIntentFilter = new IntentFilter();
      mIntentFilter.addAction(SockeBroadcastReceiver.HEART_BEAT_ACTION);
      mIntentFilter.addAction(SockeBroadcastReceiver.MESSAGE_ACTION);
      registerReceiver(mHeartBeatBroadCast, mIntentFilter);
   }
   
   @Override
   protected void onDestroy()
   {
      super.onDestroy();
      unregisterReceiver(mHeartBeatBroadCast);
   }
   
   //***socke测试 start*****************
   private void socketTest(){
        txtMsg = (TextView) findViewById(R.id.txt1);  
        txtMsg.setMovementMethod(ScrollingMovementMethod.getInstance());  //滚动条
        
        send = (Button) findViewById(R.id.send);  
        etMsg = (EditText) findViewById(R.id.ed1);  
        send.setOnClickListener(new OnClickListener() {  
            @Override  
            public void onClick(View v) {  
                content = etMsg.getText().toString();
                content = "FE0099CF010A01005243FE";
                if (TextUtils.isEmpty(content)){
               Toast.makeText(MainActivity.this, "消息不能为空", Toast.LENGTH_SHORT).show();
                 return;
              }
                boolean sendState = mHeartBeatBroadCast.sendMsg(content);
                if (sendState){
               Toast.makeText(MainActivity.this, "SendSuccess", Toast.LENGTH_SHORT).show();
               setMessages("客户端发送消息："+content);
//                 etMsg.setText("");
            }else{
               Toast.makeText(MainActivity.this, "SendFail", Toast.LENGTH_SHORT).show();
            }
            }  
        });
        
        mHeartBeatBroadCast = new SockeBroadcastReceiver(this);
      setMessages("正在连接到服务器(" + mHeartBeatBroadCast.HOST + ":" + mHeartBeatBroadCast.PORT  +  ")...");
      mHeartBeatBroadCast.setSocketCallback(new SocketCallback()
      {
         @Override
         public void connected()
         {
            Log.i("ysl", "服务器连接了...");
            runOnUiThread(new Runnable()
            {
               @Override
               public void run()
               {
                  setMessages("已连接到服务器...");
               }
            });
         }  
         @Override
         public void disConnected(){
            Log.i("ysl", "服务器断开了...");
            runOnUiThread(new Runnable()
            {
               @Override
               public void run()
               {
                  setMessages("服务器断开，自动重连中...");
               }
            });
            mHeartBeatBroadCast.initSocket();
         }
         @Override
         public void receiveMessage(String message)
         {
            Log.i("ysl", "收到新消息:" + message);
            setMessages("JAVA服务端: " + message);
         }
      });
   }
   
   /**
    * 设置TextView文本
    * @param message
    */
   public void setMessages(String message){
      txtMsg.append(message + "\n");
//    txtMsg.setText(txtMsg.getText().toString() + "\n" + message);
      int offset = txtMsg.getLineCount() * txtMsg.getLineHeight();
      if(offset > txtMsg.getHeight()){
         txtMsg.scrollTo(0,offset-txtMsg.getHeight());
      }
   }
}

 

 

 

 


/**
 * 模拟服务器  可直接运行

 */
public class AndroidService
{
   
   public static void main(String[] args) throws IOException
   {
      ServerSocket serivce = new ServerSocket(6000);
//    System.out.println("服务器已运行...");
      System.out.print("服务器已经运行======");
        while (true) {  
            //等待客户端连接  
            Socket socket = serivce.accept();  
            new Thread(new AndroidRunable(socket)).start();  
        } 
   }
}

 

**
 * 测试socket用的线程
 */
public class AndroidRunable implements Runnable
{

   Socket socket = null;
   String str = "ok";

   public AndroidRunable(Socket socket)
   {
      this.socket = socket;
   }

   @Override
   public void run()
   {
      // 向android客户端输出hello worild
      String line = null;
      InputStream input;
      OutputStream output;
      try
      {
         // 向客户端发送信息
         output = socket.getOutputStream();
         input = socket.getInputStream();
         byte[] buffer = new byte[1024 * 4];
         int length = 0;
//       output.write(str.getBytes("UTF-8"));
//       output.flush();
         // 半关闭socket
//       socket.shutdownOutput();
         //获取客户端发来的信息
         while (!socket.isClosed() && ((length = input.read(buffer)) != -1))
         {
            String message = null;
            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.GINGERBREAD) {
               message = new String(Arrays.copyOf(buffer, length)).trim();
            }
            System.out.print("服务器接收到的消息：\n" + message + "\n");
            if ("xt".equals(message))  //收到心跳
            {
               output.write("收到心跳".getBytes("UTF-8"));
               output.flush();
            }
         }
         // 关闭输入输出流
         output.close();
         input.close();
         socket.close();

      } catch (IOException e)
      {
         e.printStackTrace();
      }

   }
   /**
    * input-->string
    * @param in
    * @return
    * @throws IOException
    */
   public static String inputStream2String(InputStream in) throws IOException
   {
      StringBuffer out = new StringBuffer();
      byte[] b = new byte[4096];
      int n;
      while ((n = in.read(b)) != -1)
      {
         out.append(new String(b, 0, n));
      }
      return out.toString();
   }
}

 

 

/**
 * Socket长链接核心类
 * 1.定时与服务器心跳保持(时间可以自定义)
 * 2.断线自动重连
 * 3.连接成功、断开连接、收到消息回调处理
 * 4.消息发送状态获取(成功true or 失败false)
 * 5.注册广播
 */
public class SockeBroadcastReceiver extends BroadcastReceiver
{
   private static final String TAG = "ysl";
   /** 心跳检测时间 */
   private static final long HEART_BEAT_RATE = 3 * 1000;
   /** 主机IP地址 */
   public static final String HOST = "192.168.0.1";
// public static final String HOST = "101.200.191.35";

   /** 端口号 */
   public static final int PORT = 6000;
   /** 超时设置 **/
   public static final int SOCKET_TIME_OUT = 10 * 1000;
   /** 消息广播 */
   public static final String MESSAGE_ACTION = "com.ysl.message_ACTION";
   /** 心跳广播 */
   public static final String HEART_BEAT_ACTION = "com.ysl.heart_beat_ACTION";
   /** 线程池 **/
   private ExecutorService executorService = Executors.newFixedThreadPool(5);
   /** 为了节省开销：如果最后发送时间间隔不超过心跳时间则不发心跳 */
   private long sendTime = 0L;

   private ReadThread mReadThread;
   private MainActivity mMainActivity;
   private Socket socket;
   private boolean isConnected = true; //是否处于连接状态
   private SocketCallback callback; // 回调

   /**
    * 初始化
    * @param mMainActivity
    */
   public SockeBroadcastReceiver(MainActivity mMainActivity)
   {
      this.mMainActivity = mMainActivity;
      initSocket();
   }

   /**
    * 设置状态回调
    * @param callback
    */
   public void setSocketCallback(SocketCallback callback){
      this.callback = callback;
   }

   /**
    * 初始化Socake
    */
   public void initSocket()
   {
      executorService.execute(new Runnable()
      {
         @Override
         public void run()
         {
            try
            {
               socket = new Socket();
               SocketAddress socAddress = new InetSocketAddress(HOST,PORT);
               socket.connect(socAddress, SOCKET_TIME_OUT);
               if (callback != null)  //链接成功
               {  
                  isConnected = true;
                  callback.connected();
               }
               mReadThread = new ReadThread();
               mReadThread.start();
               mHandler.postDelayed(heartBeatRunnable, HEART_BEAT_RATE);// 初始化成功后，就准备发送心跳包
            } catch (UnknownHostException e)
            {
               if (callback != null)  //链接失败
               {  
                  isConnected = false;
                  callback.disConnected();
               }
               e.printStackTrace();
            } catch (IOException e)
            {
               if (callback != null)  //链接失败
               {  
                  isConnected = false;
                  callback.disConnected();
               }
               e.printStackTrace();
            }
         }
      });
      
   }

   @Override
   public void onReceive(Context context, Intent intent)
   {
      String action = intent.getAction();
      if (action.equals(MESSAGE_ACTION)){ // 消息广播
         String stringExtra = intent.getStringExtra("message");
//       Log.i(TAG, "收到服务器消息：" + stringExtra);
         if (callback != null)
         {
            callback.receiveMessage(stringExtra);
         }
      } else if (action.equals(HEART_BEAT_ACTION)){// 心跳广播
         Log.i("ysl", "收到服务器正常心跳。");
      }

   }

   /**
    * 发送心跳包
    */
   private Handler mHandler = new Handler();
   private Runnable heartBeatRunnable=new Runnable(){
      @Override 
      public void run(){
         if(System.currentTimeMillis()-sendTime>=HEART_BEAT_RATE){
//          boolean isSuccess=sendMsg("xt");// 可以随意与服务器定义好内容。。。
            boolean isSuccess=sendMsg("FE0099CF010B0114000031303038303030313135343630353238303296A1FE");// 可以随意与服务器定义好内容。。。

            if(!isSuccess){ // 如果发送不成功重连
               mHandler.removeCallbacks(heartBeatRunnable);
               mReadThread.release();
               releaseLastSocket(socket);
               if (callback != null)
               {
                  callback.disConnected();
               }
            }
         }
            mHandler.postDelayed(this,HEART_BEAT_RATE);
         }
      };

   /**
    * 发送消息
    * @param msg
    * @return
    */
   public boolean sendMsg(String msg)
   {
      if (null == socket){
         return false;
      }
      try
      {
         if (!socket.isClosed() && !socket.isOutputShutdown() && isConnected)
         {
            OutputStream os = socket.getOutputStream();
            String message = msg;
//          +"\r\n";
//          os.write(message.getBytes());
            os.write(toBytes(msg));

            os.flush();
            sendTime = System.currentTimeMillis();// 每次发送成功数据，就改一下最后成功发送的时间，节省心跳间隔时间
            Log.i(TAG, "发送成功的时间：" + sendTime);
         } else
         {
            return false;
         }
      } catch (IOException e)
      {
         e.printStackTrace();
         return false;
      }
      return true;
   }

   /**
    * 将16进制字符串转换为byte[]
    *  FE0099CF010A01005243FE
    * @param str
    * @return
    */
   public static byte[] toBytes(String str) {
      if(str == null || str.trim().equals("")) {
         return new byte[0];
      }

      byte[] bytes = new byte[str.length() / 2];
      for(int i = 0; i < str.length() / 2; i++) {
         String subStr = str.substring(i * 2, i * 2 + 2);
         bytes[i] = (byte) Integer.parseInt(subStr, 16);
      }

//        Log.e("tag1",BytesHexStrTranslate.bytesToHexFun1(bytes)+"");
//        Log.e("tag1111111", bytes + "");
      return bytes;
   }

   /**
    * 释放socket
    * @param mSocket
    */
   private void releaseLastSocket(Socket mSocket)
   {
      try
      {
         if (null != mSocket)
         {
            if (!mSocket.isClosed())
            {
               mSocket.close();
            }
            mSocket = null;
         }
      } catch (IOException e)
      {
         e.printStackTrace();
      }
   }

   /**
    * 接收消息
    */
   public class ReadThread extends Thread
   {
      private boolean isStart = true;
      public void release()
      {
         isStart = false;
         releaseLastSocket(socket);
      }

      @SuppressLint("NewApi")
      @Override
      public void run()
      {
         if (null != socket && isConnected)
         {
            try
            {
               InputStream is = socket.getInputStream();
               byte[] buffer = new byte[1024 * 4];
               int length = 0;
               while (!socket.isClosed() && !socket.isInputShutdown() && isStart && ((length = is.read(buffer)) != -1))
               {
                  isConnected = true;
                  if (length > 0)
                  {
                     String message = new String(Arrays.copyOf(buffer, length)).trim();
                     // 收到服务器过来的消息，就通过Broadcast发送出去
                     if (message.equals("ok"))
                     {// 处理心跳回复
                        Intent intent = new Intent(HEART_BEAT_ACTION);
                        mMainActivity.sendBroadcast(intent);
                     } else
                     { // 其他消息回复
                        Intent intent = new Intent(MESSAGE_ACTION);
                        intent.putExtra("message", message);
                        mMainActivity.sendBroadcast(intent);
                     }
                  }
               }
               isConnected = false;
               if (callback != null)
               {
                  callback.disConnected();
               }
            } catch (IOException e)
            {
               isConnected = false;
               if (callback != null)
               {
                  callback.disConnected();
               }
               e.printStackTrace();
               Log.i("ysl", "已经断开IOException...");
            }
         }
      }
   }
}

 

 

public interface SocketCallback
{
   void connected();
   void disConnected();
   void receiveMessage(String message);
}

 

Demo 

https://download.csdn.net/download/csdndouniwan/10897812

尼古拉斯.坦-全栈开发工程师
关注
理解TCP长连接（Keepalive）
chrisnotfound
04-27 6万+
TCP Keepalive的起源TCP协议中有长连接和短连接之分。短连接环境下，数据交互完毕后，主动释放连接；长连接的环境下，进行一次数据交互后，很长一段时间内无数据交互时，客户端可能意外断电、死机、崩溃、重启，还是中间路由网络无故断开，这些TCP连接并未来得及正常释放，那么，连接的另一方并不知道对端的情况，它会一直维护这个连接，长时间的积累会导致非常多的半打开连接，造成端系统资源的消耗和浪费，且...
Socket长连接+心跳包+发送读取
07-18
1. **TCP连接**：Socket基于传输层的TCP协议，提供可靠的双向通信。TCP保证了数据的顺序和完整性，通过三次握手建立连接，四次挥手断开连接。 2. **Socket对象**：在Java等语言中，Socket类代表一个网络连接，...
Delphi之TClientSocket和TServerSocket进行TCP长连接通讯使用KeepAlive自动发送心跳包检测断网
05-18
Delphi之TClientSocket和TServerSocket进行TCP长连接通讯，使用KeepALive自动发送心跳包检测断网，并实现断线重连，经测试可以及时检测到拔掉网线断网情况，具有较高的参考价值
关于TCP长连接心跳机制
hellmorning的博客
06-14 2500
TCP长连接心跳机制，以及使用C/C++实现
TCP/IP协议——心跳机制详解
最新发布
qq_3517289697的博客
07-30 682
心跳包之所以叫心跳包是因为：它像心跳一样每隔固定时间发一次，以此来告诉服务器，这个客户端还活着。事实上这是为了保持长连接，至于这个包的内容，是没有什么特别规定的，不过一般都是很小的包，或者只包含包头的一个空包。
基于socket的心跳长连接
cuishiying的专栏
08-12 683
案例：  心跳：  socket模拟网页的报文连接某个网站，创建tcp的socket后，当我socket.connect后，如果在5到7秒钟不socket.send，那么这个链接就失效了。 请问如何长时间的保持这个链接  这是在服务器端的设置的，客户端没法设置,可以发送心跳包。  socket.connect后，每3-4秒用socket.send发送一字节数据（内容随便），然后观查这个连接
闲说HeartBeat心跳包和TCP协议的KeepAlive机制
jnlovewwt1983的专栏
08-22 1648
很多应用层协议都有HeartBeat机制，通常是客户端每隔一小段时间向服务器发送一个数据包，通知服务器自己仍然在线，并传输一些可能必要的数据。使用心跳包的典型协议是IM，比如QQ/MSN/飞信等协议。 学过TCP/IP的同学应该都知道，传输层的两个主要协议是UDP和TCP，其中UDP是无连接的、面向packet的，而TCP协议是有连接、面向流的协议。 所以非常容易理解，使用UDP协议的
TCP长连接Socket心跳收发消息
01-05
3. 发送心跳包：客户端或服务器按照设定的间隔周期性发送心跳包。 4. 接收并回应心跳：接收方接收到心跳包后，立即返回一个心跳回应，表明连接正常。 5. 检测连接状态：若在预设时间内未收到回应，则判断连接可能已...
C# 实现 TCP服务端+客户端 带心跳机制.zip
12-31
心跳机制在TCP连接中扮演着关键角色，它定期发送小量数据包，确保连接的活跃状态，防止因网络问题导致的假死连接。 首先，我们来理解TCP服务端的实现。在C#中，我们可以使用System.Net.Sockets命名空间中的Tcp...
WinSock_TCP_keepalive.rar_Keepalive_tcp 心跳_心跳 C_心跳包 c+_心跳包机制
09-19
然而，TCP连接在长时间无数据交换时可能会出现“死锁”现象，即双方都认为对方仍然在线，但实际上可能已经因为各种原因（如网络故障、电源中断等）而断开。为了解决这个问题，引入了心跳机制和TCP的Keepalive特性。 ...
Android-Socket长连接通信心跳包消息回调Java服务端
08-13
本主题将深入探讨如何实现“Android-Socket长连接通信心跳包消息回调Java服务端”的技术细节。 首先，我们需要理解Socket通信的基本原理。Socket是网络编程中的一个概念，它为应用程序提供了一种在两台机器间建立...
C#与Android进行Tcp通讯（心跳包；长连接，自动重连，发送失败时自动重发）
09-12
c#写tcpListener；Android写tcpClient 具有心跳包，长连接，自动重连，发送失败自动重发等功能 电脑与Android需要同属一个局域网 tcpListener设计成只能与一个tcpClient通信（当多个客户端接入时，会自动与前一个接入的客户端断开） tcpClient具有重连，长连接，与tcpListener进行心跳包通讯
TCP心跳模块检测长连接
01-08
TCP服务器与客户端之间的心跳模块，开一个端口，连接的客户端每隔10秒发送心跳包，服务器收到则证明客户端还在，服务器每隔10秒检测客户接收心跳包。
tcp同步连接发消息心跳检测
05-08
tcp同步连接发消息心跳检测，只在本机测试，大神勿喷
node.js长连接开发实践
07-08
node.js长连接开发实践 来源 http://it.taocms.org/04/275.htm
nodeJs socketJs 搭建长连接(2) 项目应用整合
11-26
在博客中 http://blog.csdn.net/u014201191/article/details/50059017 有关的讲解案例再次,包中有两个chat和yowooa_chat,本案例请读取chat即可
长连接&短连接以及心跳包
linuxwln的博客
08-22 939
一、长连接与短连接 1、长连接: 指在一个TCP连接上可以连续发送多个数据包，         在TCP连接保持期间，如果没有数据包发送，需要双方发检测包以维持此连接;         一般需要自己做在线维持。  2、短连接: 指通信双方有数据交互时，就建立一个TCP连接，数据发送完成后，则断开此TCP连接;         一般银行都使用短连接。          它的优点是：管理起来比较简单，...
TCP心跳检测
m0_47984232的博客
08-27 9190
TCP心跳检测一.心跳机制2.为什么需要心跳检测3.心跳包发送技术4.两种技术的区别 一.心跳机制 客户端发起心跳：客户端每隔一段时间发送策略消息给Socket服务器，Socket服务器原路返回策略消息，如果客户端在设定时间内没有收到返回的消息，经重试机制后，判定Socket服务器已经down，关闭连接。 服务端发起的心跳：服务端实时记录每条Socket的IO操作时间，每隔一段时间获取所有Socket列表的快照，扫描每条Socket，如果该Socket的IO操作时间距当前时间已超出设定值，则判定客户端Dow
TCP长连接的连接池、容量控制与心跳保活
互联网架构师笔记
04-19 1820
想要简单，不追求高性能，使用短连接合适，这样我们就不需要操心连接状态的管理；想要追求性能，使用长连接，我们就需要担心各种问题：比如端对端连接的维护，连接的保活。
TCP长链接的心跳包内容
07-28
回答: TCP长连接的心跳包内容通常是一个特定的数据包，用于检测连接的存活状态和网络链路的通畅性。心跳包的内容可以是任意数据，通常是一个固定的标识符或者特定的数据格式。当被检测系统收到心跳包后，会进行回复以表示对方的存活。心跳包的发送和接收可以周期性地进行，以保持长连接的活跃状态。心跳包的具体内容可以根据实际需求和协议规定进行定义和设计。 #### 引用[.reference_title] - *1* *3* [TCP长连接，心跳机制介绍](https://blog.csdn.net/lzh824359508/article/details/115328250)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down1,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [tcp长连接、心跳包](https://blog.csdn.net/weixin_38054045/article/details/104257511)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值