Android socket实现Tcp长连接

最新推荐文章于 2021-11-30 15:03:47 发布
最新推荐文章于 2021-11-30 15:03:47 发布
阅读量1.8w 收藏 50
点赞数 3
分类专栏： android开发 文章标签： tcp 长连接
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29634351/article/details/81458915
版权 
这个一个小功能，实现tcp链接，把手机当做服务器跟客户端的综合体，可以不需要外网服务器，只需要手机连接wifi即可

首先贴出Activity的代码跟布局

先上个图片
这里写图片描述

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".MainActivity">

   <Button
       android:id="@+id/btn_start_server"
       android:layout_width="match_parent"
       android:layout_marginTop="30dp"
       android:text="启动服务器"
       android:layout_height="wrap_content" />

    <Button
        android:id="@+id/btn_start_client"
        android:layout_width="match_parent"
        android:layout_marginTop="30dp"
        android:text="启动客户端"
        android:layout_height="wrap_content" />

    <Button
        android:id="@+id/btn_send_client"
        android:layout_width="match_parent"
        android:layout_marginTop="30dp"
        android:text="发送数据(123)给客户端"
        android:layout_height="wrap_content" />

    <Button
        android:id="@+id/btn_send_server"
        android:layout_width="match_parent"
        android:layout_marginTop="30dp"
        android:text="发送数据(321)给服务器"
        android:layout_height="wrap_content" />

    <Button
        android:id="@+id/tv_server"
        android:layout_width="match_parent"
        android:layout_marginTop="30dp"
        android:singleLine="true"
        android:text="服务器收到:"
        android:layout_height="wrap_content" />

    <Button
        android:id="@+id/tv_client"
        android:layout_width="match_parent"
        android:layout_marginTop="30dp"
        android:singleLine="true"
        android:text="客户端收到:"
        android:layout_height="wrap_content" />

</LinearLayout>

MainActivity


import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import com.example.administrator.dn_data_structure_01.bean.MessageClient;
import com.example.administrator.dn_data_structure_01.bean.MessageServer;

import org.greenrobot.eventbus.EventBus;
import org.greenrobot.eventbus.Subscribe;
import org.greenrobot.eventbus.ThreadMode;

import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.Enumeration;

public class MainActivity extends AppCompatActivity {

    Button btnStartServer;
    Button btnSrartClient;

    Button btnSendToServer;
    Button btnSendToClient;

    TextView tv_server;
    TextView tv_client;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);


        btnStartServer = findViewById(R.id.btn_start_server);
        btnSrartClient = findViewById(R.id.btn_start_client);
        btnSendToServer = findViewById(R.id.btn_send_server);
        btnSendToClient = findViewById(R.id.btn_send_client);
        tv_server = findViewById(R.id.tv_server);
        tv_client = findViewById(R.id.tv_client);

        btnStartServer.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //开启服务器
               TcpServer.startServer();
            }
        });

        btnSrartClient.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //连接服务器
                TcpClient.startClient( getIPAddress(getApplicationContext()) , 8080);
            }
        });

        btnSendToServer.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //发送数据给服务器
                TcpClient.sendTcpMessage("321");
            }
        });

        btnSendToClient.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //发送数据给客户端
                TcpServer.sendTcpMessage("321");
            }
        });

        Log.i("tcp" ,"ip地址:" + getIPAddress(this));

        //注册EventBus
        EventBus.getDefault().register(this);
    }

    @Subscribe(threadMode = ThreadMode.MAIN)
    //收到客户端的消息
    public void MessageClient(MessageClient messageEvent) {
        tv_client.setText("客户端收到:" +messageEvent.getMsg());
    }

    //收到服务器的消息
    @Subscribe(threadMode = ThreadMode.MAIN)
    public void MessageServer(MessageServer messageEvent) {
        tv_server.setText("服务器收到:" +messageEvent.getMsg());
    }


    public static String getIPAddress(Context context) {
        NetworkInfo info = ((ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE)).getActiveNetworkInfo();
        if (info != null && info.isConnected()) {
            if (info.getType() == ConnectivityManager.TYPE_MOBILE) {//当前使用2G/3G/4G网络
                try {
                    //Enumeration<NetworkInterface> en=NetworkInterface.getNetworkInterfaces();
                    for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements(); ) {
                        NetworkInterface intf = en.nextElement();
                        for (Enumeration<InetAddress> enumIpAddr = intf.getInetAddresses(); enumIpAddr.hasMoreElements(); ) {
                            InetAddress inetAddress = enumIpAddr.nextElement();
                            if (!inetAddress.isLoopbackAddress() && inetAddress instanceof Inet4Address) {
                                return inetAddress.getHostAddress();
                            }
                        }
                    }
                } catch (SocketException e) {
                    e.printStackTrace();
                }

            } else if (info.getType() == ConnectivityManager.TYPE_WIFI) {//当前使用无线网络
                WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
                WifiInfo wifiInfo = wifiManager.getConnectionInfo();
                String ipAddress = intIP2StringIP(wifiInfo.getIpAddress());//得到IPV4地址
                return ipAddress;
            }
        } else {
            //当前无网络连接,请在设置中打开网络
        }
        return null;
    }

    /**
     * 将得到的int类型的IP转换为String类型
     *
     * @param ip
     * @return
     */
    public static String intIP2StringIP(int ip) {
        return (ip & 0xFF) + "." +
                ((ip >> 8) & 0xFF) + "." +
                ((ip >> 16) & 0xFF) + "." +
                (ip >> 24 & 0xFF);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        EventBus.getDefault().unregister(this);
    }
}

然后直接上TcpClient类，此类用来开启客户端以及接受服务器消息的代码，然后通过EventBus3.0来实现线程中的通信

TcpClient：

import android.util.Log;

import com.example.administrator.dn_data_structure_01.bean.MessageClient;

import org.greenrobot.eventbus.EventBus;

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.net.Socket;

public class TcpClient {

    public static Socket socket;

    public static void startClient(final String address ,final int port){
        if (address == null){
            return;
        }
        if (socket == null) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Log.i("tcp", "启动客户端");
                        socket = new Socket(address, port);
                        Log.i("tcp", "客户端连接成功");
                        PrintWriter pw = new PrintWriter(socket.getOutputStream());

                        InputStream inputStream = socket.getInputStream();

                        byte[] buffer = new byte[1024];
                        int len = -1;
                        while ((len = inputStream.read(buffer)) != -1) {
                            String data = new String(buffer, 0, len);
                            Log.i("tcp", "收到服务器的数据---------------------------------------------:" + data);
                            EventBus.getDefault().post(new MessageClient(data));
                        }
                        Log.i("tcp", "客户端断开连接");
                        pw.close();

                    } catch (Exception EE) {
                        EE.printStackTrace();
                        Log.i("tcp", "客户端无法连接服务器");

                    }finally {
                        try {
                            socket.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        socket = null;
                    }
                }
            }).start();
        }
    }

    public static void sendTcpMessage(final String msg){
        if (socket != null && socket.isConnected()) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        socket.getOutputStream().write(msg.getBytes());
                        socket.getOutputStream().flush();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

接下来是服务器的类。用自己手机即当服务器又当客户端。
TcpServer：


import android.util.Log;

import com.example.administrator.dn_data_structure_01.bean.MessageServer;

import org.greenrobot.eventbus.EventBus;

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

public class TcpServer {
    private static ServerSocket serverSocket;
    private static Socket socket;

    public static void startServer(){
        if (serverSocket == null){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        serverSocket = new ServerSocket(8080);
                        Log.i("tcp" , "服务器等待连接中");
                        socket = serverSocket.accept();
                        Log.i("tcp" , "客户端连接上来了");
                        InputStream inputStream = socket.getInputStream();
                        byte[] buffer = new byte[1024];
                        int len = -1;
                        while ((len = inputStream.read(buffer)) != -1) {
                            String data = new String(buffer, 0, len);
                            Log.i("tcp" , "收到客户端的数据-----------------------------:" + data);
                            EventBus.getDefault().post(new MessageServer(data));
                        }
                    } catch (IOException e) {
                        e.printStackTrace();

                    }finally {
                        try {
                            socket.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        try {
                            serverSocket.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        socket = null;
                        serverSocket = null;
                    }
                }
            }).start();
        }
    }

    public static void sendTcpMessage(final String msg){
        if (socket != null && socket.isConnected()) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        socket.getOutputStream().write(msg.getBytes());
                        socket.getOutputStream().flush();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}


大功告成了，功能还是比较简单的。

最后再上个demo

肖旺银
关注
专栏目录
安卓tcp ip通讯
qq_41733851的博客
03-04 476
安卓tcp ip通讯
android 实现tcp 长连接
最新发布
weixin_29280657的博客
08-09 83
Android 实现 TCP 长连接 TCP（传输控制协议）是一种面向连接的、可靠的通信协议，广泛应用于网络数据传输。在 Android 开发中，TCP 长连接可以确保与服务器之间的持续沟通，有效地减少连接延迟和资源消耗。本文将介绍如何在 Android 中实现 TCP 长连接，并提供相应的代码示例。 1. TCP 长连接...
Android的socket长连接（心跳检测）
12-18
这是Android的socket长连接（心跳包），由于本人项目中需要用到长连接，所以先做了个demo，亲测是没有问题的。
android端 socket长连接 架构
weixin_34087301的博客
05-03 97
看过包建强的《App研发录》之后对其中的基础Activity类封装感到惊讶，一直想找一种方式去解决关于app中使用socket长连接问题，如何实现简易的封装来达到主活动中涉及socket相关的代码量少的效果。正常的实现socket的基本方式都是新建一个Socket服务，在活动中绑定服务和注册全局广播，通过绑定服务中的函数去发送数据，通过全局广播去接收数据。如果每个活动中都去写绑定服务和注册全局广播...
android socket长连接
tangweiguo0305的专栏
12-08 286
MinaSocket https://github.com/Jeromeer/MinaSocket
android 连接tcp连接,android – 使用Service的TCP连接
weixin_39535557的博客
05-27 624
我必须实现一个应用程序.此应用程序使用TCP / IP与服务器通信.我的应用程序必须向服务器请求位置.因为应用程序必须保持监听服务器请求,我认为使用IntentService.所以我实现它：public class Tasks extends IntentService{public final int SERVERPORT = 8100;private Socket socket;PrintWr...
android局域网 tcp链接,Android基于TCP的局域网聊天通信
weixin_29655399的博客
05-31 429
一、准备工作开发环境jdk1.8Eclipse Luna Service Release 1 (4.4.1)运行环境：华为荣耀6(Android4.4)、华为p9(Android7.0)实现功能：同一局域网下，两台设备进行tcp通信聊天。详情请参考博客：http://blog.csdn.net/VNanyesheshou/article/details/74896575二、程序实现工程截图： 2、...
Android socket实现Tcp长连接，断开自动重连
02-16
手写简化版tcp长链接的socket实现，主要功能有断开重连，以及收发读取解码解析，适用于需要用到长链接的原生开发。
Android用socket实现TCP通讯
10-29
总的来说，Android通过Socket实现TCP通信涉及到了网络编程的基本概念，包括套接字连接、数据流读写以及线程同步等问题。通过这样的实践，开发者可以更好地理解和运用网络通信技术，为开发更复杂的网络应用打下坚实...
Android Socket TCP
03-24
在Android上实现Socket TCP通信，我们需要了解以下几个关键知识点： 1. **环境准备**： - **Eclipse**：这是一个历史悠久的Java集成开发环境，虽然现在更多的开发者转向了Android Studio，但在本例中，服务器端...
android本地实现tcp连接
03-11
实现本地与服务器一个数据收发
Android基于socket的TCP通信
04-16
基于socket套接字的TCP通信，定时发送心跳包以保持长连接，使用守护线程来守护心跳线程，保证心跳线程持续工作。如果断开连接，启动重连接机制，随着重连接次数增加，连接时间拉长，如果重连接次数达到10次，认为网络已断开，放弃连接服务端。（待完善，客户端离线消息应该使用数据库保存，等网络重新建立连接，推送给服务端。）
Android TCP Socket通信实例Demo源码Apk下载
03-13
最近有个项目模块需要用到TCP Socket通讯，遇到了一个大坑，所以做了这个Demo。 本Demo主要实现了安卓(Android)TCP 客户端(Client)和服务器(Server)Demo的Socket通讯。以及对接硬件的项目数据在十六进制&&byte&&int的转换处理。 要注意BufferedReader的readLine()方法的阻塞问题： 读取socket输入流的时候很多代码都会这么写，一般也不会有什么问题，但是readLine()方法读取不到换行和回车时会阻塞！ String line = null; while ((line = br.readLine()) != null) { } 具体可以先查看博文：https://blog.csdn.net/daokedream/article/details/113918467，欢迎交流。
安卓 tcp socket长连接
ajiong314
12-04 1409
在Android开发中，经常会需要由服务端主动推送一些消息给客户端，最常见的做法就是用Tcp Socket保持长链接。为了简化这个过程，做了一个简单的依赖库来实现TCP Socket的client功能。 Doc 引入依赖 Step 1.先配置你的project的build.gradle allprojects {     repositories {         ···         m...
Android 网络应用——基于TCP协议的Socket通信简要介绍，flutter中文本框的长度
m0_64383081的博客
11-30 556
当本地主机只有一个IP地址时，使用第一个方法更为简单，如以下代码所示： //创建连接到10.34.87.82、30000端口的Socket Socket s=new Socket(“10.34.87.82”,30000);//这个ip地址是我本人的本机地址 //下面就可以使用Socket进行通信了… 当程序执行上面的代码时，该代码将会连接到指定的服务器，让服务器端ServerSocket的accept()方法向下执行，于是服务器端和客户端就产生一对互相连接的Socket了。 当客户端、服务器端产生了对应的S
android socket 长连接_原生Android网络通讯——TCP长连接
weixin_39786341的博客
11-22 503
要是努力有用的话，还要天才干什么？断剑重铸之日，其势归来之时！一.简介传输控制协议（TCP，Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议，和UDP同处五层模型的运输层，在网络层上，在应用层下，说来辛酸，当时被老师傅带进入TCP的坑，但是他没来得及把我带出来，原理理论放到以后再记录，这里就直接拉出来使用场景和代码，方便copy使用，...
Android开发TCP连接
Miss_min的博客
11-18 1725
一、添加依赖 compile ‘com.koushikdutta.async:androidasync:2.+’ 二、应用public class TCPHandle { public static long flowNumber=0; public static boolean isOnWebCall=false; public static final int
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值