基于TCP的安卓客户端开发

一.Socket通信简介

　　Android与服务器的通信方式主要有两种，一是Http通信，一是Socket通信。两者的最大差异在于，http连接使用的是“请求—响应方式”，即在请求时建立连接通道，当客户端向服务器发送请求后，服务器端才能向客户端返回数据。而Socket通信则是在双方建立起连接后就可以直接进行数据的传输，在连接时可实现信息的主动推送，而不需要每次由客户端向服务器发送请求。 那么，什么是socket？Socket又称套接字，在程序内部提供了与外界通信的端口，即端口通信。通过建立socket连接，可为通信双方的数据传输传提供通道。socket的主要特点有数据丢失率低，使用简单且易于移植。

• 什么是Socket？

　　是一种抽象层，应用程序通过它来发送和接收数据，使用Socket可以将应用程序添加到网络中，与处于同一网络中的其他应用程序进行通信。简单来说，Socket提供了程序内部与外界通信的端口并为通信双方的提供了数据传输通道。

• Socket的分类

　　根据不同的的底层协议，Socket的实现是多样化的。本指南中只介绍TCP/IP协议族的内容，在这个协议族当中主要的Socket类型为流套接字（streamsocket）和数据报套接字(datagramsocket)。流套接字将TCP作为其端对端协议，提供了一个可信赖的字节流服务。数据报套接字使用UDP协议，提供数据打包发送服务。 下面，我们来认识一下这两种Socket类型的基本实现模型。

二.Socket基本通信模型

• TCP通信模型

• UDP通信模型

三.Socket基本实现原理

• 基于TCP协议的Socket

　　服务器端首先声明一个ServerSocket对象并且指定端口号，然后调用Serversocket的accept（）方法接收客户端的数据。accept（）方法在没有数据进行接收的处于堵塞状态。（Socketsocket=serversocket.accept()）,一旦接收到数据，通过inputstream读取接收的数据。
　　客户端创建一个Socket对象，指定服务器端的ip地址和端口号（Socketsocket=newSocket("172.168.10.108",8080);）,通过inputstream读取数据，获取服务器发出的数据（OutputStreamoutputstream=socket.getOutputStream()），最后将要发送的数据写入到outputstream即可进行TCP协议的socket数据传输。

• 基于UDP协议的数据传输

　　服务器端首先创建一个DatagramSocket对象，并且指点监听的端口。接下来创建一个空的DatagramSocket对象用于接收数据（bytedata[]=newbyte[1024;]DatagramSocketpacket=newDatagramSocket（data，data.length））,使用DatagramSocket的receive方法接收客户端发送的数据，receive（）与serversocket的accepet（）类似，在没有数据进行接收的处于堵塞状态。
　　客户端也创建个DatagramSocket对象，并且指点监听的端口。接下来创建一个InetAddress对象，这个对象类似与一个网络的发送地址（InetAddressserveraddress=InetAddress.getByName（"172.168.1.120"））.定义要发送的一个字符串，创建一个DatagramPacket对象，并制定要讲这个数据报包发送到网络的那个地址以及端口号，最后使用DatagramSocket的对象的send（）发送数据。*（Stringstr="hello";bytedata[]=str.getByte();DatagramPacketpacket=new DatagramPacket(data,data.length,serveraddress,4567);socket.send(packet);）

注：以上通信原理内容非笔者总结，引于此目的在于“实践在即，理论先行”

四.权限申明

 1     <!--允许应用程序改变网络状态-->
     <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/>

     <!--允许应用程序改变WIFI连接状态-->
     <uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/>

     <!--允许应用程序访问有关的网络信息-->
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>

     <!--允许应用程序访问WIFI网卡的网络信息-->
     <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>

     <!--允许应用程序完全使用网络-->
     <uses-permission android:name="android.permission.INTERNET"/>

五.布局文件

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

     <LinearLayout
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
         android:layout_marginLeft="10dp"
         android:layout_marginRight="10dp"
         >
         <TextView
             android:layout_width="0dp"
             android:layout_height="match_parent"
             android:layout_weight="1"
             android:layout_marginTop="12dp"
             android:layout_gravity="center"
             android:text="IP:"
             android:textSize="20dp"/>
         <EditText
             android:id="@+id/IPEditText"
             android:layout_width="0dp"
             android:layout_height="match_parent"
             android:gravity="center"
             android:layout_weight="4"
             android:text="223.3.200.4"
             android:textSize="20dp"
             />
         <TextView
             android:layout_width="0dp"
             android:layout_height="match_parent"
             android:layout_weight="2"
             android:layout_marginTop="12dp"
             android:layout_gravity="center"
             android:text="Port:"
             android:textSize="20dp"/>
         <EditText
             android:id="@+id/PortEditText"
             android:layout_width="0dp"
             android:layout_height="match_parent"
             android:gravity="center"
             android:layout_weight="2"
             android:text="8086"
             android:textSize="20dp"
             />
         <Button
             android:id="@+id/ConnectButton"
             android:layout_width="0dp"
             android:layout_height="match_parent"
             android:layout_weight="1"
             android:text="连接"/>

     </LinearLayout>
     <LinearLayout
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
         android:layout_marginLeft="10dp"
         android:layout_marginRight="10dp"

         >
         <EditText
             android:id="@+id/MessagetoSendEditText"
             android:layout_width="0dp"
             android:layout_height="match_parent"
             android:layout_weight="3"
             android:text="Data from Client"/>
         <Button
             android:id="@+id/SendButton"
             android:layout_width="0dp"
             android:layout_height="wrap_content"
             android:layout_weight="1"
             android:text="发送"/>
     </LinearLayout>
     <LinearLayout
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
         android:layout_marginLeft="10dp"
         android:layout_marginRight="10dp"
         >
         <TextView
             android:id="@+id/DisplayTextView"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
             android:layout_marginTop="10dp"
             android:hint="Display area:"
             android:textSize="20dp"/>
     </LinearLayout>

 </LinearLayout>

六.具体代码实现

 package com.example.john.androidsockettest_client;

 import android.os.Handler;
 import android.os.Message;
 import android.support.v7.app.AppCompatActivity;
 import android.os.Bundle;
 import android.view.View;
 import android.widget.Button;
 import android.widget.EditText;
 import android.widget.TextView;
 import android.widget.Toast;

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.net.InetSocketAddress;
 import java.net.Socket;
 import java.net.SocketTimeoutException;

 public class MainActivity extends AppCompatActivity {

     //Handler中的消息类型
     public static final int DEBUG = 0x00;
     public static final int RECEIVEDATAFROMSERVER = 0x01;
     public static final int SENDDATATOSERVER = 0x02;
     //线程
     Socket socket = null;               //成功建立一次连接后获得的套接字
     ConnectThread connectThread;       //当run方法执行完后，线程就会退出，故不需要主动关闭
     SendThread sendThread;             //发送线程,由send按键触发
     ReceiveThread receiveThread;       //接收线程，连接成功后一直运行
     //待发送的消息
     public String messagetoSend = "";
     //控件
     TextView displayTextView;             //显示接收、发送的数据及Debug信息
     Button sendButton;                    //发送按钮，点击触发发送线程
     Button connectButton;                //连接按钮，点击触发连接线程
     EditText messagetoSendEditText;
     EditText iPEditText;
     EditText portEditText;

     public Handler myHandler = new Handler() {
         @Override
         public void handleMessage(Message msg) {
             if (msg.what == RECEIVEDATAFROMSERVER) {
                 Bundle bundle = msg.getData();
                 displayTextView.append("Server:"+bundle.getString("string1")+"\n");
             }
             else if (msg.what == DEBUG) {
                 Bundle bundle = msg.getData();
                 displayTextView.append("Debug:"+bundle.getString("string1")+"\n");
             }
             else if (msg.what == SENDDATATOSERVER) {
                 Bundle bundle = msg.getData();
                 displayTextView.append("Client:"+bundle.getString("string1")+"\n");
             }
         }

     };
     //子线程更新UI
     public void SendMessagetoHandler(final int messageType , String string1toHandler){
         Message msg = new Message();
         msg.what = messageType;    //消息类型
         Bundle bundle = new Bundle();
         bundle.clear();
         bundle.putString("string1", string1toHandler); //向bundle中添加字符串
         msg.setData(bundle);
         myHandler.sendMessage(msg);
     }

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
         displayTextView = (TextView) findViewById(R.id.DisplayTextView);
         sendButton = (Button) findViewById(R.id.SendButton);
         messagetoSendEditText = (EditText) findViewById(R.id.MessagetoSendEditText);
         iPEditText = (EditText)findViewById(R.id.IPEditText);
         portEditText = (EditText)findViewById(R.id.PortEditText);
         connectButton = (Button)findViewById(R.id.ConnectButton);

         connectButton.setOnClickListener(new View.OnClickListener() {
             @Override
             public void onClick(View v) {
                 connectThread= new ConnectThread();
                 connectThread.start();
             }
         });
         sendButton.setOnClickListener(new View.OnClickListener() {

             @Override
             public void onClick(View v) {
                 messagetoSend = messagetoSendEditText.getText().toString();
                 //使用连接成功后得到的socket构造发送线程,每点击一次send按钮触发一次发送线程
                 sendThread = new SendThread(socket);
                 sendThread.start();
             }
         });
     }

     //********  连接线程  **********
     class ConnectThread extends Thread{
         @Override
         public void run() {
             try{
                 //连接服务器 并设置连接超时为1秒
                 socket = new Socket();
                 socket.connect(new InetSocketAddress(iPEditText.getText().toString(),
                         Integer.parseInt(portEditText.getText().toString())), 1000);
             }catch (SocketTimeoutException aa) {
                 //更新UI:连接失败
                 SendMessagetoHandler(DEBUG,"服务器连接失败！");
                 return;     //直接返回
             } catch (IOException e) {
                 e.printStackTrace();

             }
             //更新UI:连接成功
             SendMessagetoHandler(DEBUG,"服务器连接成功！");

             //打开接收线程
             receiveThread = new ReceiveThread(socket);
             receiveThread.start();
         }
     }
     //********  发送线程  **********
     class SendThread extends Thread{
         private Socket mSocket;
         //发送线程的构造函数，由连接线程传入套接字
         public SendThread(Socket socket) {mSocket = socket;}

         @Override
         public void run() {
             try{
                 OutputStream outputStream = mSocket.getOutputStream();
                 //向服务器发送信息
                 outputStream.write(messagetoSend.getBytes("gbk"));
                 outputStream.flush();
                 //更新UI:显示发送出的数据
                 SendMessagetoHandler(SENDDATATOSERVER,messagetoSend);
             }catch (IOException e) {
                 e.printStackTrace();
                 //更新UI：显示发送错误信息
                 SendMessagetoHandler(DEBUG,"发送失败！");
                 return;
             }
         }
     }

     //********  接收线程  **********
     class ReceiveThread extends Thread{

         private Socket mSocket;
         //接收线程的构造函数，由连接线程传入套接字
         public ReceiveThread(Socket socket){mSocket = socket;}

         @Override
         public void run() {
             while(true){               //连接成功后将一直运行
                 try {
                     BufferedReader bufferedReader;
                     String line = null;
                     String readBuffer="";
                     bufferedReader = new BufferedReader(new InputStreamReader(mSocket.getInputStream()));
                     while ((line = bufferedReader.readLine()) != null) {
                         readBuffer = line + readBuffer;
                         SendMessagetoHandler(RECEIVEDATAFROMSERVER,readBuffer);
                         readBuffer = "";
                     }
                     bufferedReader.close();
                 }catch (IOException e) {
                     e.printStackTrace();
                     //更新UI：显示发送错误信息
                     SendMessagetoHandler(DEBUG,"接收失败！");
                     return;
                 }
             }
         }
     }
 }

　　采用多线程编程，输入IP地址和端口号后点击“连接”按钮开启ConnectThread,在该线程中执行对服务器的连接，由连接成功后的socket构造ReceiveThread并启动，在该线程中执行while(true){}循环持续监听输入流，并通过Handler异步消息处理机制更新主UI(Server：)。点击“发送”按钮，由socket构造SendThread并启动，向服务器端发送数据并更新主UI(Client：)。在子线程运行过程中，出现错误会向主UI呈递调试信息(Debug：)。以上即是该TCP客户端主要的编程思想。

七.Debug

• 关于readLine()

　　在写ReceiveThread线程代码块时，笔者最初读取输入流的写法如下：

　　

 while ((line = bufferedReader.readLine()) != null) {
                         readBuffer = line + readBuffer;
                         readBuffer = "";
                     }
 SendMessagetoHandler(RECEIVEDATAFROMSERVER,readBuffer);

　　结果在主UI一直没有看到消息更新（直到把服务器端口关闭，服务器之前发的数据才更新到UI），这就说明第5行代码根本没有实现，循环没有出来。后来将第5行代码放入while循环内部运行正常。

原因如下：

　　误以为readLine()是读取到没有数据时就返回null(因为其它read方法当读到没有数据时返回-1)，而实际上readLine()是一个阻塞函数，当没有数据读取时，就一直会阻塞在那，而不是返回null；因为readLine()阻塞后，第5行代码根本就不会执行到，所以在UI不会显示接收到的数据。要想执行到第5行，一个办法是发送完数据后就关掉流，这样readLine()结束阻塞状态，而能够得到正确的结果，但显然不能传一行就关一次数据流；另外一个办法是把第5行代码放到while循环体内。

　　readLine()只有在数据流发生异常或者另一端被close()掉时，才会返回null值。

　　如果不指定buffer大小，则readLine()使用的buffer有8192个字符。在达到buffer大小之前，只有遇到"/r"、"/n"、"/r/n"才会返回。

• 使用InputStream类中的read(b:byte[]):int函数

 　　　　　　　　　　　　//另一种读取方式 :+read(b:byte[]):int  从输入流中读取b.length个字节到
                     // 数组b中，并且返回实际读取的字节数。到流的最后返回-1
                     byte[] b = new byte[1024]; //每个数据包最大1024个字节
                     int length = 0;
                     while((length = mSocket.getInputStream().read(b)) != -1){  //在流产生时执行里面的代码
                         String r_msg = new String(b,0,length,ISO_ENCODE);
                         SendMessagetoHandler(RECEIVEDATAFROMSERVER,r_msg);
                         //SendMessagetoHandler(DEBUG,"length="+length);
                     }

　　这种方式不要求发送端在数据包后添加回车换行标志，所写即所发。

八.实际运行效果

如果这篇blog对您有所帮助，请留下您的一个赞，也欢迎留言讨论，笔者将在第一时间回复！