浅谈TCP协议在android中的使用

最新推荐文章于 2025-06-27 08:44:11 发布
原创 最新推荐文章于 2025-06-27 08:44:11 发布 · 2.9k 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#ServerSocket #Socket

本文详细介绍Android平台上使用TCP Socket实现客户端和服务端通信的过程。包括ServerSocket和Socket的基本使用方法，多线程下的通信处理，以及如何确保跨平台字符编码的一致性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

前言
手机作为移动设备，很受大家的青睐，因为它携带方便，可以随时随地上网聊天、玩游戏（如现在最火王者某某），这些都是在联网的情况进行的，如果手机不能上网的话，那么它就是没有用的铁疙瘩（某某奇葩也就不会为了某某果机割肾伤身了），因此网络对手机来说有着至关重要的作用。
由于JDK本身集成了TCP、UDP网路协议，那么Android 完全支持它；Android 也可以使用ServerSocket（服务端）、Socket（客户端），而ServerSocket、Socket是基于TCP/IP协议的网络通信；Android也可以使用DatagramSocket、DatagramPacket、MulticastSocket来建立基于UDP协议的网络通信；同时android也支持JDK提供URL、URLConnection；当然android还内置了HttpClient（这个自从android5.0以后需要自己添加Jar包），这样可以非常方便地发送HTTP请求，并获取HTTP响应；但是android并没有内置Web Service的支持，为了弥补这方面的不足， 需要使用第三方类库（KSOAP2）来调用WebService。
一 TCP协议
TCP/IP是一种可靠的网络通信协议，在通信的两端各需要建立一个Socket，从而在两端之间形成虚拟链路，两端的程序可以通过虚拟链路进行通信。如下：

IP协议负责将消息从一个主机传送到另一个主机，信息在传送的过程中被分割成几个小包。
TCP协议负责提供可靠并且无差错的通信服务，它也被称为一种端对端的协议，这是因为，它为两台计算机之间的连接起到重要的作用，当一台计算机需要与另一台计算机连接时， TCP协议会让它们建立一个连接：用于发送和接收数据的虚拟链路 。
TCP负责收集这些信息包，并将其按适当的次序排好传送，在接收端再将其正确地还原。TCP协议保证了数据包在传送中准确无误。 同时TCP使用重发机制 ：当一个通信实体发送一个信息给另一个通信实体后，需要收到另一个通信实体的确认信息，如果没有收到另一个通信实体的确认信息，则会再次重发刚才发送的信息。
综上所述，虽然IP和TCP这两个协议的功能不尽相同，也可以分开单独使用，但它们时在同一个时期作为一个协议来设计的，并且在功能上也是互补的。只有两者结合才能保证Internet在复杂的环境下正常的运行。凡是连接到Internet计算机，都必须安装和使用这两个协议。
二 ServerSocket创建TCP服务端
两个通信实体在进行通信，必须有服务端、客户端之分，而Java中建立服务端是使用ServerSocket，下面看一些它的方法：
ServerSocket(int port):构造函数，参数port是端口，有效值：0～65535。
ServerSocket(int port,int backlog):构造函数，增加一个用来改变连接队列长度的参数backlog。
ServerSocket(int port,int backlog,InetAddress localAddr):构造函数，参数localAddr指定本地IP地址，用于在本地存在过个IP地址的情况。
Socket accept():如果接受到一个客户端Socket的连接请求，该方法将会返回与连接客户端Socket对应的Socket；否则该方法将会一直处于等待状态，线程也被阻塞。
接下来看一个示例： 
 public static void main(String[] args) {
      System.out.print("开启服务!");
		try {
			//创建一个ServerSocket 对象实例，用来监听客户端Socket的连接状态，端口号为30000，IP为本机IP
			ServerSocket ss = new ServerSocket(30000);
			//无限循环，不断接收来自客户端Socket的请求，没有Socket请求时会进入阻塞状态。
			while(true){
				Socket  socket = ss.accept();
				//获取输出流，向Socket通道中写入数据
				OutputStream os = socket.getOutputStream();
				os.write("您好，恭喜您中奖了！".getBytes("utf-8"));
				//关闭通道
				os.close();
				socket.close();
			}
			
		} catch (IOException e) {
			e.printStackTrace();
		} 
	}
注意：
上面的输出流 OutputStream 并没有装成PrintStream，然后直接输出，整个字符串，这是由于服务端程序运行于window主机上，当直接使用PrintStream输出整个字符串默认使用系统平台的字符编码GBK，而android是在Linux平台运行的，客户端在读取网络数据时，默认使用的UTF-8编码，这样势必引起乱码。所以为保证能够正确解析数据，要手动控制字符串的编码，强行指定使用UTF-8字符集进行编码。
三 Socket创建TCP客户端
先来看下socket的构造函数：
Socket(InetAddress/String remoteAddress,int port):参数remoteAddress指定远程主机的IP地址，port指定远程主机的端口，这里没有指定本地IP地址，本地端口，默认使用本机的IP地址，默认使用系统动态分配的端口。
Socket(InetAddress/String remoteAddress,int port,InetAddress localAddr, int localPort):增加参数localAddr指定本地Ip地址，localPort指定本地端口，这种情况使用本地主机有多个IP地址的情形。
再看其他重要的方法：
InputStream getInputStream():通过Socket对象实例获取输入流，让程序可以从Socket通道中获取数据。
OutputStream getOutputStream():通过Socket对象实例获取输出流，让程序可以往Socket通道中写入数据。
示例： 
 new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //建立连接到远程服务器的socket
                    Socket socket = new Socket("192.168.11.139",30000);
                    //=================或者==============
                    //创建Socket对象
                    Socket s = new Socket();
                    //连接远程服务
                    s.connect(new InetSocketAddress("192.168.11.139",30000));
                    //设置超时时间
                    socket.setSoTimeout(10000);
                    BufferedReader bufferedReader  = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                    //进行I／O 操作
                    final String result = bufferedReader.readLine();
                    if (!TextUtils.isEmpty(result)){
                        ServerSocketActivity.this.runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                txt_serverSocket.setText(result);
                            }
                        });
                    }
                    //关闭输入流、socket
                    bufferedReader.close();
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();
说明，到这里服务端、客户端通信的虚拟链路算是建立起来了，要实现通信客户端还要添加权限：
<uses-permission android :name= "android.permission.INTERNET" />
接下来先运行服务器，再运行客户端，那么客户端会收到字符串 "您好，恭喜您中奖了！" 。
四 加入多线程
在上面示例中已经简单的叙述了Socket的通信的过程，上面的示例中是一对一的关系，就是一个服务器对应一个客户端，那么在实际使用中却不是这样的，一个服务器需要服务多个对象（客户端），且可能需要与每个客户端保持长时间的通信，即服务端不断读取客户端的数据，并向客户端写入数据，而客户端也是如此。
当使用 readLine()方法读取数据，该方法成功返回之前，线程被阻塞，程序是无法进行下去 ，也就不能接受其他的Socket连接请求了，所以为了解决这个问题，服务端为每个Socket启动一个新的线程，该线程负责与客户端进行通信，这样就不影响服务器接受其他线程了。
服务端：
首先定义一个类继承Runnable（例如我的类名叫作ServerThread），通过构造函数把Socket对象实例传递来，这样就可以获取输入流、输出流了，如： 
	public ServerThread(Socket s) {
		this.s = s;
		if (null != s) {
			try {
				br = new BufferedReader(new InputStreamReader(s.getInputStream(),"utf-8"));
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
再者读取Socket中的数据如下： 
	/**
	 * 读取客户端数据
	 * @return
	 */
	public String readFromClient () {
		if(null != br) {
			try {
				String result = br.readLine();
				System.out.println("服务端读取：" +result);
				return result;
			} catch (IOException e) {
				System.out.println("读取失败！");
				//捕捉到异常，表明s 对应的客户端已经关闭
				MutiThreadServerSocket.socketList.remove(s);
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		return null;
	}
还可以把刚刚获取的数据转发给所有的客户端 
	String content = null;
		// TODO Auto-generated method stub
        while((content = readFromClient()) != null) {
        	   //MutiThreadServerSocket.socketList为ArrayList<Socket>类型用来记录每个客户端
        	   for(Socket s : MutiThreadServerSocket.socketList) {
        		   try {
					OutputStream os = s.getOutputStream();
					os.write(content.getBytes("utf-8"));
					os.flush();
//					os.close();
					System.out.println("服务端写入content：" + content);
				} catch (IOException e) {
					// TODO Auto-generated catch block
					System.out.println("服务端写入失败！");
					e.printStackTrace();
				}
        	   }
        }
最后就是服务程序： 
	//存储Socket对象 
    public static ArrayList<Socket> socketList = new ArrayList<>();
	public static void main(String[] args) {
		System.out.println("开启多线程服务!");
		try {
			ServerSocket ss = new ServerSocket(30010);
			while(true){
				Socket  socket = ss.accept();
			    socketList.add(socket);
			    //每当一个客户端连接之后，就启动一个线程
			    new Thread(new ServerThread(socket)).start();
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }
客户端：
首先定义一个类继承Runnable，如下： 
public class ClientThread implements Runnable {
    private Handler handler;
    private Socket socket;
    //输入流 读取服务端传送过来的消息
    private BufferedReader br;
    //输出流往服务器发送信息
    private static OutputStream outputStream;
    public static Handler  revHandler ;
    private InputStream inputStream;
    //计时器
    private Timer timer  = new Timer();

    public ClientThread(Handler handler) {
        this.handler = handler;
    }
    @Override
    public void run() {
        try {
            //192.168.11.139 为本地电脑的ip
            socket = new Socket("192.168.11.139",30010);
//            socket.setKeepAlive(true);
            inputStream = socket.getInputStream();
            br = new BufferedReader(new InputStreamReader(inputStream));
            outputStream = socket.getOutputStream();
            Log.e("进入循环线程：","-------------->");

            /**
             *
             * 开子线程读取数据，因为readLine()会导致阻塞
             * 对于socket，不能认为把某次写入到流中的数据读取完了就算流结尾了，
             * 但是socket流还存在，还可以继续往里面写入数据然后再读取。
             * 这时用BufferedReader封装socket的输入流，调用BufferedReader的readLine方法是不会返回null的
             * 所以在循环内如果不判断   content!=null && content.length() > 0  那么程序将会一直阻塞在这里(程序是因为readLine阻塞,并不是死循环)
             *
             */
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Log.e("开始读取：","1111");
                    String content  = null;
                    try {
                        while (((content = br.readLine()) != null) && (content.length() > 0)){
                            Log.e("读取====》",content);
                            //每当有消息时，及时通知主界面更新消息
                            Message  message  = new Message();
                            message.what = 0x123;
                            message.obj  = content;
                            handler.sendMessage(message);
                        }
                    } catch (IOException e) {
                        closeSocket();
                        e.printStackTrace();
                    }
                }
            }).start();
            Looper.prepare();
            revHandler = new Handler(){
                @Override
                public void handleMessage(Message msg) {
                    super.handleMessage(msg);
                    if (msg.what == 0x345){
                        try {
                            outputStream.write((msg.obj.toString() + "\r\n").getBytes("utf-8"));
                            Log.e("写入====》",msg.obj.toString());
                            outputStream.flush();
                        } catch (UnsupportedEncodingException e) {
                            closeSocket();
                            e.printStackTrace();
                        } catch (IOException e) {
                            closeSocket();
                            e.printStackTrace();
                        }
                    }
                }
            };
            //把当前的线程初始化为looper//，循环读取服务端发过来的消息
            Looper.loop();
        } catch (IOException e) {
            closeSocket();
            e.printStackTrace();
        }
    }


    /**
     * 关闭端口
     */
    private void  closeSocket(){
            try {
                if (null != inputStream){
                   inputStream.close();
                }
                if (null != outputStream){
                    outputStream.close();
                }
                if (null != br){
                    br.close();
                }
                if (null != socket){
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
    }
}
然后在主界面添加一个输入框和发送按钮，输入内容后，点击发送把内容发送给服务端，布局文件如下： 
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="com.ecric.http.socket.MultiThreadClientActivity">
    <LinearLayout
        android:orientation="horizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content">
        <EditText
            android:id="@+id/ed_multi_input"
            android:layout_width="0dp"
            android:layout_weight="3"
            android:layout_height="wrap_content" />
        <Button
            android:id="@+id/btn_send"
            android:text="发送"
            android:layout_width="0dp"
            android:layout_weight="1"
            android:layout_height="wrap_content" />
    </LinearLayout>
    <!--用来展示文本信息-->
    <TextView
        android:id="@+id/txt_show"
        android:text="展示文本信息："
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />
</LinearLayout>
最后就是客户端程序： 
@EActivity(R.layout.activity_multi_thread_client)
public class MultiThreadClientActivity extends AppCompatActivity {
    // 输入信息框
    @ViewById(R.id.ed_multi_input)
    EditText edInput;
    //展示信息
    @ViewById(R.id.txt_show)
    TextView txtShow;
    public Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            //如果消息来自于子线程
            if (msg.what == 0x123){
                txtShow.append("\n" + msg.obj.toString());
            }
        }
    };
    //客户端处理数据的线程
    private ClientThread clientThread;
    @AfterViews
    public void initData(){
        clientThread = new ClientThread(handler);
        new Thread(clientThread).start();
//        ClientBody clientBody = new ClientBody("192.168.11.139",30010,"1");
//        clientBody.start();
    }
    /**
     * 发送监听
     * @param view
     */
    @Click(R.id.btn_send)
    public void onClick(View view){
        //当用户按下发送按钮后，将用户输入的数据，封装成Message
        //然后发送给子线程的handle对象
        Message message  = new Message();
        message.what = 0x345;
        message.obj = edInput.getText().toString();
        clientThread.revHandler.sendMessage(message);
        edInput.setText("");
    }
}
说明在这个程序也没有处理多少，主要是启动ClientThread，及与输入操作，当用户点击“发送”按钮之后，程序将会吧输入的内容发送给ClientThread的revHandle，进而把内容写到Socket中，传送为服务端；同样从服务读取到内容时，将会把读取到的信息通过handle发送给UI线程，进而更新内容；还有一点要说说明下，上述代码我使用AndroidAnnotations注解框架，使代码看起来简单很多，不感兴趣的可以不管它，查看控件时，老老实实findViewById就可以了。
接下来先运行服务端，再运行客 户端，在输入框输入 QWERTY 点击发送，服务端打印结果：
开启多线程服务!
服务端读取：QWERTY
服务端写入content：QWERTY
客户端结果：

但在此过程中遇到一个问题：服务端可以很好的接受来自客户端数据，但为什么只有服务端进程关闭（或者说在服务端关闭socket）后，客户端才会收到服务端传送过来的数据呢？谁有解决之法、或知其原理务必指点一下小编。
参考文献：
《疯狂android讲义》









浅谈TCP和UDP协议
m0_67266787的博客
05-16 558
目录 TCP和UDP的区别 UDP 特点： 使用场景 UDP变形 QUIC协议 直播中的帧 嵌入式 TCP TCP三次握手 TCP四次挥手 TCP状态机 TCP和UDP的区别 我们大多数人的回答是，TCP是面向连接的，UDP是面向无连接的。 那么什么是面向连接，什么是面向无连接？，再互通之前，面向连接的协议会先建立连接，例如：TCP会三次握手， 而UDP不会。 所谓的建立连接，是为了在客户端和服务端维护连接，而建立一定的数据结构来维护双方交互的状态，用这样的数据结构来保证所谓的面
浅谈Android与C#之间的UDP/TCP那些事儿
qq_32680169的博客
06-01 844
Android客户端与C#客户端之间的UDP/TCP通信 对于从事网络编程的伙伴来说对UDP和TCP一定非常熟悉了，那么在跨语言中tcp传输数据需要注意些什么呢？ 首先我们来看看百度百科对UDP的解释： UDP 是User Datagram Protocol的简称， 中文名是用户数据报协议，是OSI（Open System Interconnection，开放式系统互联） 参考模型中一种无连接的传输层协议，UDP 为应用程序提供了一种无需建立连接就可以发送封装的 IP 数据包的方法。 再来看看百度百科对TC
Android端TCP通讯实现
04-17
TCP通讯的Android依赖库，Android Studio可直接集成，实现TCP通讯，默认发送心跳包断线自动重连，包含一个字节处理的工具类
Android中的TCP/IP协议，Socket，Http协议间的关系
u010618194的博客
03-16 4739
前提：本片文章的名字叫做"Android开发中的TCP/IP协议，Socket编程"，其实TCP/IP协议是一种网络协议，并不是在Android中才有的，也不只是在java中有，其他的开发语言中同样也可以使用TCP/IP协议进行网络编程。之所以这么说是因为在不久的以前，作者也是一个对于各种协议、什么socket编程、什么http等等完全没有概念，直到现在，我也还是在不断的学习，去尝试慢慢的理解它们
Android TCP Server 示例
最新发布
lph009的博客
06-27 155
本文介绍了在Android应用中实现TCP服务器的开发步骤。首先需要在AndroidManifest.xml中添加网络权限配置，然后引入ViewModel和协程相关库。核心实现包括：1)创建TcpServerViewModel管理服务器生命周期；2)TcpServerThread类负责监听端口和处理新连接；3)ClientHandler类处理客户端消息通信。系统采用多线程架构，支持同时管理多个客户端连接，并包含IP重复连接检测和自动清理机制。最后通过Compose界面调用ViewModel启动服务器。
Android Tcp操作
weixin_30535913的博客
08-19 177
Tcp是基于传输层的面向连接的可靠通讯协议，其优点是基于连接，使得服务端和客户端可以实现双向通信，且实时性高，在需要服务端主动向客户端推送数据的应用场景中，使用TCP协议是一种很好的方式。 初学Android，将Android中Tcp的使用方式记录一下，希望对新学Android开发的新同学有帮助，这里主要介绍TcpClient的使用，因为很少会用Android来建立TcpServer端。 这里...
浅谈Android应用开发之TCP协议
u013684964的博客
07-02 783
       Android设备能够使用互联网功能是因为系统底层实现了TCP/IP协议，可以使终端通过网络建立TCP连接。TCP协议是一个面向连接的传输控制协议，也就是说数据通信必须要建立在连接的基础上。建立一个TCP连接需要经过“三次握手”，通俗来讲就是：1.客户端向服务器发送一个含有同步序列号(SYN)的数据段给服务器，向服务器请求建立连接；2.服务器收到客户端的请求后，用一个带有确认应答(A...
Android中基于TCP协议的网络通信
华清远见 | 程序员的学习天堂
03-02 894
Android中基于TCP协议的网络通信
浅谈Android客户端与服务器的数据交互总结
08-25
在Android客户端与服务器的数据交互中，通常涉及到网络通信方式、数据传输格式以及API设计规范等多个方面。以下将详细阐述这些知识点。 首先，Android客户端与服务器的通信方式主要包括HTTP和Socket。HTTP通信是...
浅谈Hadoop在移动云计算中的应用.pdf
07-18
HDFS的数据通信基于TCP/IP协议进行。 在移动云计算中，Hadoop的移植和应用需要特别关注移动设备的性能限制。移动设备的计算资源、传感器和存储能力有限，而将这些资源通过网络连接可以创建一个分布式基础架构，从而...
浅谈TCP连接的创建和销毁过程
Ekmr的博客
05-24 982
1. 概述 本文主要讲述的内容主要包含以下部分 TCP的概念 连接的建立过程 连接的拆除过程 2. TCP协议 我们首先要明确一点，这里讨论的TCP协议并不是指TCP/IP协议簇，而是单指TCP协议，即Transmission Control Protocol，指传输控制协议，位于传输层（OSI七层模型的第四层，或是TCP/IP四层协议的第三层） 都应该清楚，传输层负责报文从进程到进程的传递，...
AndroidTCP
04-25
基于android开发实现TCP网络通信，语言JAVA，可在ARM9上运行。
TCP连接手机客端（安卓版）
08-10
tcp连接安卓端调试器，输入服务器地址连接tcp服务器i，可以进行数据传输
android tcpip
08-28
此资源，主要用于自己备份，下载请资源; android TCPIP ;server和 client都有，主要实现连接多个client； 4个点测试没有问题，多了没有测试
(Android)TCPDemo 下载
02-03
Android socket tcp应用，包含服务器和客户端，代码正常通过测试，学习使用，配合我的博客：http://blog.youkuaiyun.com/shankezh/article/details/51555455
android TCP/IP传输（客户端）
热门推荐
small5e4444的专栏
07-05 1万+
整了好久，查了好多文件才整的有点明白 http://download.youkuaiyun.com/detail/small5e4444/4412532 package com.bn.tcp; import java.io.BufferedReader; import java.io.InputStream; import java.io.InputStreamReader;
安卓开发学习之TCP通信
四国棋客
06-08 3570
背景这几天在学习安卓的进程间通信，而socket也可以实现这一功能，以可靠连接协议TCP为例，实现一个服务端和客户端的应答应用功能：客户端发消息，服务端把消息原样返回，如果收到小写over，退出步骤1、服务端，在Service的onCreate()里面，新建一个线程创建服务端的socket，并实现客户端的应答public class PeopleService extends Service { ...
Android 网络应用——基于TCP协议的Socket通信简要介绍
2401_85730841的博客
06-16 908
中能接收其他通信实体连接请求的是对象用于监听来自客户端的连接，如果没有连接，它将一直处于等待状态。包含一个监听来自客户端请求的方法。为了创建对象，：用指定的端口来创建一个。该端口应该有一个有效的端口整数值。：增加一个用来改变连接队列长度的参数。：在机器存在多个IP地址的情况下，通过这个参数来指定将绑定到指定的地址。在使用完毕后，应使用的()方法来关闭该。
安卓开发——tcp连接
qq_44937699的博客
07-18 1840
Android Studio使用的是java语言，换句话说，Android Studio相比于eclipse等软件，多的只是安卓端界面的设计，其相关功能的实现（比如登录、注册验证等），都是java实现的。因此，只要掌握了java语言的tcp连接方式，就可以完成Android Studio的TCP连接。 网上关于tcp连接的实现有很多文章，这里提供一个参考链接，就不再进行详述了。 这篇博客主要记录个人实现tcp连接中犯的两个错误： tcp连接需要使用socket，socket连接要使用子线程 在子线程中，不
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值