1 述

• 即套接字，是一个对 TCP / IP体系机构的运输层(可基于TCP或者UDP协议)进行封装 的编程调用接口（API）
• 即通过Socket，我们才能在Andorid平台上通过 TCP/IP体系机构进行开发
• Socket不是一种协议，而是一个编程调用接口（API），Socket 作为应用层和传输层之间的桥梁

0281fc8e3250fc99bdc293c3666d998e.png

• 成对出现，一对套接字：
  每个套接字都是连接的一个端点，有相应的套接字地址。由一个IP地址与16位的整数端口组成.一个连接由两端的套接字地址唯一确定。叫套接字对。

Socket ={(IP地址1:PORT端口号)，(IP地址2:PORT端口号)}

2 原理

• Java.NET中为我们提供了使用 TCP、UDP 通信的两种 Socket：：
• 流套接字（streamsocket） ：基于 TCP协议，采用 流的方式 提供可靠的字节流服务
• 数据报套接字(datagramsocket)：基于 UDP协议，采用 数据报文 提供数据打包发送的服务

android端和服务器端的发送和接收大庭相径，只要端口号正确了，相互通信就没有问题，TCP使用的是流的方式发送，UDP是以包的形式发送。

• 具体原理图如下：

20130621185516921.jpg

2217296-ef48151595bca6a7.png

3 Socket 的基本操作有以下几部分：

1.连接远程机器
2.发送数据
3.接收数据
4.关闭连接
5.绑定端口
6.监听到达数据
7.在绑定的端口上接受来自远程机器的连接

4 Socket 与 Http 对比

• HTTP协议 属于 应用层，解决的是如何包装数据
• Socket属于传输层
• 由于二者不属于同一层面，所以本来是没有可比性的。但随着发展，默认的Http里封装了下面几层的使用，所以才会出现Socket & HTTP协议的对比：（主要是工作方式的不同）：

4.1 Http：采用 请求—响应 方式。

• 即建立网络连接后，当 客户端 向 服务器 发送请求后， 服务器端才能向客户端返回数据。
• 可理解为：是客户端有需要才进行通信

4.2 Socket：采用 服务器主动发送数据 的方式

• 即建立网络连接后，服务器可主动发送消息给客户端，而不需要由客户端向服务器发送请求
• 可理解为：是服务器端有需要才进行通信

5 使用步骤

• Socket可基于TCP或者UDP协议
• 所以下面的使用步骤 & 实例的Socket将基于TCP协议

// 步骤1：创建客户端 & 服务器的连接

    // 创建Socket对象 & 指定服务端的IP及端口号 
    Socket socket = new Socket("192.168.1.32", 1989);  

    // 判断客户端和服务器是否连接成功  
    socket.isConnected());


// 步骤2：客户端 & 服务器 通信
// 通信包括：客户端 接收服务器的数据 & 发送数据 到 服务器

    <-- 操作1：接收服务器的数据 -->

            // 步骤1：创建输入流对象InputStream
            InputStream is = socket.getInputStream() 

            // 步骤2：创建输入流读取器对象 并传入输入流对象
            // 该对象作用：获取服务器返回的数据
            InputStreamReader isr = new InputStreamReader(is);
            BufferedReader br = new BufferedReader(isr);

            // 步骤3：通过输入流读取器对象 接收服务器发送过来的数据
            br.readLine()；


    <-- 操作2：发送数据 到 服务器 -->                  

            // 步骤1：从Socket 获得输出流对象OutputStream
            // 该对象作用：发送数据
            OutputStream outputStream = socket.getOutputStream(); 

            // 步骤2：写入需要发送的数据到输出流对象中
            outputStream.write（（"Carson_Ho"+"\n"）.getBytes("utf-8")）；
            // 特别注意：数据的结尾加上换行符才可让服务器端的readline()停止阻塞

            // 步骤3：发送数据到服务端 
            outputStream.flush();  


// 步骤3：断开客户端 & 服务器 连接

             os.close();
            // 断开 客户端发送到服务器 的连接，即关闭输出流对象OutputStream

            br.close();
            // 断开 服务器发送到客户端 的连接，即关闭输入流读取器对象BufferedReader

            socket.close();
            // 最终关闭整个Socket连接

6 java 网络编程类介绍

6.1 InetAddress

InetAddress类用于标识网络上的硬件资源，标识互联网协议(IP)地址。

//获取本机的InetAddress实例
InetAddress address =InetAddress.getLocalHost();
//获取计算机名
address.getHostName();
//获取IP地址
address.getHostAddress();
//获取字节数组形式的IP地址,以点分隔的四部分
byte[] bytes = address.getAddress();

//获取其他主机的InetAddress实例
InetAddress address2 =InetAddress.getByName("其他主机名");
InetAddress address3 =InetAddress.getByName("IP地址");

6.2 URL

URL(Uniform Resource Locator)统一资源定位符，表示Internet上某一资源的地址，协议名：资源名称
1 基础使用

  URL myBlog =new URL("https://3dot141.cn");
  URL url =new URL(myBlog,"/blogs/33521.html?username=3dot141#test");//？表示参数，#表示锚点
  url.getProtocol();//获取协议
  url.getHost();//获取主机
  url.getPort();//如果没有指定端口号，根据协议不同使用默认端口。此时getPort()方法的返回值为 -1
  url.getPath();//获取文件路径
  url.getFile();//文件名，包括文件路径+参数
  url.getRef();//相对路径，就是锚点，即#号后面的内容
  url.getQuery();//查询字符串，即参数

读取网页内容

  //使用URL读取网页内容
  //创建一个URL实例
  URL url =new URL("http://www.baidu.com");
  InputStream is = url.openStream();//通过openStream方法获取资源的字节输入流
  InputStreamReader isr =newInputStreamReader(is,"UTF-8");//将字节输入流转换为字符输入流,如果不指定编码，中文可能会出现乱码
  BufferedReader br =newBufferedReader(isr);//为字符输入流添加缓冲，提高读取效率
  String data = br.readLine();//读取数据
  while(data!=null){
  System.out.println(data);//输出数据
  data = br.readerLine();
  }
  br.close();
  isr.colose();
  is.close();

6.3 Socket

看7

7 Socket 使用实例 基于TCP

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

7.1 服务器端

/**
 * 基于TCP协议的Socket通信，实现用户登录，服务端
*/
//1、创建一个服务器端Socket，即ServerSocket，指定绑定的端口，并监听此端口
ServerSocket serverSocket =newServerSocket(33521);//1024-65535的某个端口
//2、调用accept()方法开始监听，等待客户端的连接
Socket socket = serverSocket.accept();
//3、获取输入流，并读取客户端信息
InputStream is = socket.getInputStream();
InputStreamReader isr =newInputStreamReader(is);
BufferedReader br =newBufferedReader(isr);
String info =null;
while((info=br.readLine())!=null){
System.out.println("我是服务器，客户端说："+info)；
}
socket.shutdownInput();//关闭输入流

//4、获取输出流，响应客户端的请求
OutputStream os = socket.getOutputStream();
PrintWriter pw = new PrintWriter(os);
pw.write("欢迎您！");
pw.flush();


//5、关闭资源
pw.close();
os.close();
br.close();
isr.close();
is.close();
socket.close();
serverSocket.close();

7.2 客户端

//客户端
//1、创建客户端Socket，指定服务器地址和端口
Socket socket =newSocket("localhost",33521);
//2、获取输出流，向服务器端发送信息
OutputStream os = socket.getOutputStream();//字节输出流
PrintWriter pw =newPrintWriter(os);//将输出流包装成打印流
pw.write("用户名：3dot141；密码：hahah");
pw.flush();
socket.shutdownOutput();
//3、获取输入流，并读取服务器端的响应信息
InputStream is = socket.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(is));
String info = null;
while((info=br.readLine())!null){
 System.out.println("我是客户端，服务器说："+info);
}

//4、关闭资源
br.close();
is.close();
pw.close();
os.close();
socket.close();

7.3 多线程中的运用

服务器端创建ServerSocket，使用while(true)循环调用accept()等待客户端连接
客户端创建一个socket并请求和服务器端连接
服务器端接受请求，创建socket与该客户建立专线连接
建立连接的两个socket在一个单独的线程上对话
服务器端继续等待新的连接

public class ServerThread implements runnable{
//服务器线程处理
//和本线程相关的socket
Socket socket =null;
//
public ServerThread(Socket socket){
this.socket = socket;
}

publicvoid run(){
//服务器处理代码
}
}

//服务器代码
ServerSocket serverSocket =newServerSocket(33521);
Socket socket =null;
int count =0;//记录客户端的数量
while(true){
socket = serverScoket.accept();
ServerThread serverThread =new ServerThread(socket);
 serverThread.start();
 count++;
System.out.println("客户端连接的数量："+count);
}

8 Socket 使用实例 基于UDP

• 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);）

8.1 服务器端

//服务器端，实现基于UDP的用户登录
//1、创建服务器端DatagramSocket，指定端口
DatagramSocket socket =new datagramSocket(33521);
//2、创建数据报，用于接受客户端发送的数据
byte[] data =newbyte[1024];//
DatagramPacket packet =newDatagramPacket(data,data.length);
//3、接受客户端发送的数据
socket.receive(packet);//此方法在接受数据报之前会一致阻塞
//4、读取数据
String info =newString(data,o,data.length);
System.out.println("我是服务器，客户端告诉我"+info);


//=========================================================
//向客户端响应数据
//1、定义客户端的地址、端口号、数据
// 这里也可以自己设置
InetAddress address = packet.getAddress();
int port = packet.getPort();
byte[] data2 = "欢迎您！".geyBytes();
//2、创建数据报，包含响应的数据信息
DatagramPacket packet2 = new DatagramPacket(data2,data2.length,address,port);
//3、响应客户端
socket.send(packet2);
//4、关闭资源
socket.close();

8.2 客户端

//客户端
//1、定义服务器的地址、端口号、数据
InetAddress address =InetAddress.getByName("localhost");
int port =33521;
byte[] data ="用户名：3dot141;密码：hahah".getBytes();
//2、创建数据报，包含发送的数据信息
DatagramPacket packet = newDatagramPacket(data,data,length,address,port);
//3、创建DatagramSocket对象
DatagramSocket socket =newDatagramSocket();
//4、向服务器发送数据
socket.send(packet);


//接受服务器端响应数据
//======================================
//1、创建数据报，用于接受服务器端响应数据
byte[] data2 = new byte[1024];
DatagramPacket packet2 = new DatagramPacket(data2,data2.length);
//2、接受服务器响应的数据
socket.receive(packet2);
String raply = new String(data2,0,packet2.getLenth());
System.out.println("我是客户端，服务器说："+reply);
//4、关闭资源
socket.close();

9 android socket开发中可能遇到的坑

• 1. android网络请求需要放在工作线程中，socket通信也不例外；
• 2. 当socket长连接建立成功后，如果手机屏幕关闭，只要过很短的时间，android系统就会将socket服务挂起.果希望手机在熄屏后不将socket服务挂起，可以通过PowerManager设置电源模式，使cpu不进入节电模式，当然了，可以做个计时器，也别让cpu全马力输出太久嘛。
• 3. 客户端希望确认服务器端是否在运行，可以发送心跳包；
• 4. 如果客户端和服务器端需要双向确认对方是否存活，可以自定义一个易区分的字段，时时发送，在网络畅通的前提下，发送端如果发送失败，则接收端停止运行，接收端如果超过某个时间段之后依然无法接收到信息，则发送端停止运行；
• 5. socket通信，在发送数据时如果发送的数据被转化为byte后，长度超过1448时，发送的数据将被拆分，比方说，发送一个1500长数据，就会接收到2个包，包内携带的发送信息的长度分别为1448和52；
• 6. 为了解决socket的这种自动拆包问题，我们需要在发送的信息中写入所发送的信息的总长度，比如，首先我们可以将发送的第一位设置为“$”，它就表示数据的开头，接下来后四位用来存放数据的总长度，之后的部分用来存放发送数据，这样，接收端在接收到数据后就可以通过解析出数据的总长度来确认是否已经接收完全，如果不全再继续接收就可以了；

• 7. 发送数据过长时会有自动拆包的问题，当发送数据过短或者发送的数据之间时间间隔很短的时候，还会发生自动粘包的问题！自动粘包就是指本来是两个或者多个包中的数据同时合并到了一个包中，这时候，容易出现解析不全的情况。解决粘包问题同样可以使用上面提到的方法，只不过反过来了，当发现接收到的数据比通过首部一至五位计算出的长度要长时，可以通过截取的方法，分段计算；

• 8. socket在api19之前没有继承Closeable接口，如果大家是通过写一个关闭Closeable对象的工具类来关闭socket的话还是别用了，不然老版本的手机们只要一执行到关闭socket的语句时就会异常退出；

• 9. socket在通信的时候可能需要启动多个线程，可以考虑使用线程池，线程池操作多个线程到底是方便些，而且因线程长时间持有socket对象而产生内存溢出的情况会少很多，因为线程池可以集体关闭所有线程；

10 撸一波

10.1

try {
            LogUtil.d(TAG, " connecting  ip=%s , port = %d", ip, port);
            while (true) {
                try {
                    mSocket = new Socket();
                    mSocket.setKeepAlive(true);
                    mSocket.setSoTimeout(2 * 3 * 60 * 1000);//inputStream read 超时时间
                    mSocket.setTcpNoDelay(true);
                    mSocket.connect(new InetSocketAddress(ip, port));
                    if (mSocket.isConnected()) {
                        dataIS = new DataInputStream(mSocket.getInputStream());
                        dataOS = new DataOutputStream(mSocket.getOutputStream());
                        connectState = true;
                    }
                    this.mCallback.onConnect(this);
                    break;//connect sucess
                } catch (IOException e) {
                    mRetryPolicy.retry(e);
                    //间隔5秒，重连。
                    Thread.sleep(5000);
                    LogUtil.e(TAG, " connect IOException =%s , and retry count = %d", e.getMessage(), mRetryPolicy.getCurrentRetryCount());
                }
            }
        } catch (Exception e) {
            //重试后，仍然失败了。回调失败。
            connectState = false;
            e.printStackTrace();
            LogUtil.e(TAG, " connect IOException = " + e.getMessage());
            mCallback.onConnectFailed(e);
        }

10.2 接收消息

while (isConnected()) {
            try {
                int type = dataIS.readByte();//读取1位
                int length = dataIS.readChar();//读取2位标记第三段数据长度
                byte[] data = new byte[length];
                LogUtil.i(TAG, " receiveData connected receiveData type = %d, ", type);
                dataIS.readFully(data);
                mCallback.onReceive(type, data);
            } catch (SocketTimeoutException e) {
                LogUtil.e(TAG, " receiveData SocketTimeoutException = " + e.getMessage());
                e.printStackTrace();
                break;
            } catch (IOException e) {
                LogUtil.e(TAG, " receiveData IOException = " + e.getMessage());
                e.printStackTrace();
                break;//异常后，退出循环
            }
        }
        
        //通知异常，并重连。

10.3 发送消息

// 1.同步处理 2.异常或未连接状态下，则回调并通知重连
final byte[] bytes = {1,2,3,4,5}; //test data
synchronized (TcpClient.class) {
            if (isConnected()) {
                try {
                    byte type = 1;
                    dataOS.writeByte(type);
                    dataOS.writeChar(bytes.length);
                    dataOS.write(bytes);
                    dataOS.flush();
                    LogUtil.i(TAG, "send success msg : %s", Arrays.toString(bytes));
                } catch (final IOException e) {
                    callback.onFailed(e);
                    disConnect(true);
                    e.printStackTrace();
                }
            } else {
                callback.onFailed(new Exception("socket is not connected"));
                disConnect(true);
                LogUtil.i(TAG, "socket is not connected !");
            }
        }

10.4 断开连接

//关闭流
        closeInputStream(dataIS);
        closeOutputStream(dataOS);
        if (mSocket != null) {
            try {
                mSocket.shutdownInput();
                mSocket.shutdownOutput();
                mSocket.close();
                mSocket = null;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if (mCallback != null && needRec) {
            mCallback.onDisconnect();
        }
        mState = STATE_DISCONNECT;

10.5 进度灰色保活

由于项目中通信模块运行在独立的进程中，为避免进程被意外干掉，这里将其优先级提高已达到报活效果。

if (Build.VERSION.SDK_INT < 18) {//18以下，可直接设置为前台service
            startForeground(GRAY_SERVICE_ID, new Notification());
        } else if (Build.VERSION.SDK_INT <= 24) {
            Intent innerIntent = new Intent(this, GrayInnerService.class);
            startService(innerIntent);
            startForeground(GRAY_SERVICE_ID, new Notification());
        }

/**
     * 测试结果：API<=24可行。25/7.1.1版本，通知栏正常状态下看不到icon，但滑下来就看得到icon。
     * 给 API >= 18 的平台上用的灰色保活手段
     */
    public static class GrayInnerService extends Service {

        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
            startForeground(GRAY_SERVICE_ID, new Notification());
            stopSelf();
            return super.onStartCommand(intent, flags, startId);
        }

        @Nullable
        @Override
        public IBinder onBind(Intent intent) {
            return null;
        }

    }

代码中可以看出，启动一个相同id的前台GrayInnerService然后立即stopSelf，再以同样方式启动主service，这样运行起来的service就已经是达到前台服务优先级了，一般情况都杀不了它。

11 建立socket的基本流程

我们以linux操作系统提供的基本api为例

162e308be6b8173a.jpeg

11.1 最基本的Socket示范 单向通信

服务端

package com.marklux.socket.base;

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

/**
 * The very basic socket server that only listen one single message.
 */

public class BaseSocketServer {

    private ServerSocket server;
    private Socket socket;
    private int port;
    private InputStream inputStream;
    private static final int MAX_BUFFER_SIZE = 1024;

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public BaseSocketServer(int port) {
        this.port = port;
    }

    public void runServerSingle() throws IOException {
        this.server = new ServerSocket(this.port);

        System.out.println("base socket server started.");
        // the code will block here till the request come.
        this.socket = server.accept();

        this.inputStream = this.socket.getInputStream();

        byte[] readBytes = new byte[MAX_BUFFER_SIZE];

        int msgLen;
        StringBuilder stringBuilder = new StringBuilder();

        while ((msgLen = inputStream.read(readBytes)) != -1) {
            stringBuilder.append(new String(readBytes,0,msgLen,"UTF-8"));
        }

        System.out.println("get message from client: " + stringBuilder);

        inputStream.close();
        socket.close();
        server.close();
    }

    public static void main(String[] args) {
        BaseSocketServer bs = new BaseSocketServer(9799);
        try {
            bs.runServerSingle();
        }catch (IOException e) {
            e.printStackTrace();
        }

    }
}

客户端

package com.marklux.socket.base;

import java.io.IOException;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.Socket;

/**
 * The very basic socket client that only send one single message.
 */

public class BaseSocketClient {
    private String serverHost;
    private int serverPort;
    private Socket socket;
    private OutputStream outputStream;

    public BaseSocketClient(String host, int port) {
        this.serverHost = host;
        this.serverPort = port;
    }

    public void connetServer() throws IOException {
        this.socket = new Socket(this.serverHost, this.serverPort);
        this.outputStream = socket.getOutputStream();
        // why the output stream?
    }

    public void sendSingle(String message) throws IOException {
        try {
            this.outputStream.write(message.getBytes("UTF-8"));
        } catch (UnsupportedEncodingException e) {
            System.out.println(e.getMessage());
        }
        this.outputStream.close();
        this.socket.close();
    }

    public static void main(String[] args) {
        BaseSocketClient bc = new BaseSocketClient("127.0.0.1",9799);
        try {
            bc.connetServer();
            bc.sendSingle("Hi from mark.");
        }catch (IOException e) {
            e.printStackTrace();
        }
    }
}

先运行服务端，再运行客户端，就可以看到效果。

11.2 双向通信

服务端在收到客户端的消息后，将返回给客户端一个回执。
服务端

public void runServer() throws IOException {
        this.serverSocket = new ServerSocket(port);
        this.socket = serverSocket.accept();
        this.inputStream = socket.getInputStream();

        String message = new String(inputStream.readAllBytes(), "UTF-8");

        System.out.println("received message: " + message);

        this.socket.shutdownInput(); // 告诉客户端接收已经完毕，之后只能发送

        // write the receipt.

        this.outputStream = this.socket.getOutputStream();
        String receipt = "We received your message: " + message;
        outputStream.write(receipt.getBytes("UTF-8"));

        this.outputStream.close();
        this.socket.close();
    }

客户端

public void sendMessage(String message) throws IOException {
        this.socket = new Socket(host,port);
        this.outputStream = socket.getOutputStream();
        this.outputStream.write(message.getBytes("UTF-8"));
        this.socket.shutdownOutput(); // 告诉服务器，所有的发送动作已经结束，之后只能接收
        this.inputStream = socket.getInputStream();
        String receipt = new String(inputStream.readAllBytes(), "UTF-8");
        System.out.println("got receipt: " + receipt);
        this.inputStream.close();
        this.socket.close();
    }

• 注意这里我们在服务端接受到消息以及客户端发送消息后，分别调用了shutdownInput()和shutdownOutput()而不是直接close对应的stream，这是因为在关闭任何一个stream，都会直接导致socket的关闭，也就无法进行后面回执的发送了。
• 但是注意，调用shutdownInput()和shutdownOutput()之后，对应的流也会被关闭，不能再次向socket发送/写入了。

11.3 发送更多的消息：结束的界定

• 刚才的两个例子中，每次打开流，都只能进行一次写入/读取操作，结束后对应流被关闭，就无法再次写入/读取了。
• 在这种情况下，如果要发送两次消息，就不得不建立两个socket，既耗资源又麻烦。其实我们完全可以不关闭对应的流，只要分次写入消息就可以了。
• 但是这样的话，我们就必须面对另一个问题：如何判断一次消息发送的结束呢？

使用特殊符号
最简单的办法是使用一些特殊的符号来标记一次发送完成，服务端只要读到对应的符号就可以完成一次读取，然后进行相关的处理操作。
使用换行符\n来标记一次发送的结束，服务端每接收到一个消息，就打印一次，并且使用了Scanner来简化操作:
服务端

public void runServer() throws IOException {
        this.server = new ServerSocket(this.port);

        System.out.println("base socket server started.");

        this.socket = server.accept();
        // the code will block here till the request come.

        this.inputStream = this.socket.getInputStream();
        Scanner sc = new Scanner(this.inputStream);
        while (sc.hasNextLine()) {
            System.out.println("get info from client: " + sc.nextLine());
        } // 循环接收并输出消息内容
        this.inputStream.close();
        socket.close();
    }

客户端

public void connetServer() throws IOException {
        this.socket = new Socket(this.serverHost, this.serverPort);
        this.outputStream = socket.getOutputStream();
    }

public void send(String message) throws IOException {
        String sendMsg = message + "\n"; // we mark \n as a end of line.
        try {
            this.outputStream.write(sendMsg.getBytes("UTF-8"));
        } catch (UnsupportedEncodingException e) {
            System.out.println(e.getMessage());
        }
//        this.outputStream.close();
//        this.socket.shutdownOutput();
    }

 public static void main(String[] args) {
        CycleSocketClient cc = new CycleSocketClient("127.0.0.1", 9799);
        try {
            cc.connetServer();
            Scanner sc = new Scanner(System.in);
            while (sc.hasNext()) {
                String line = sc.nextLine();
                cc.send(line);
            }
        }catch (IOException e) {
            e.printStackTrace();
        }
    }

运行后效果是，客户端每输入一行文字按下回车后，服务端就会打印出对应的消息读取记录。
根据长度界定

• 回到原点，我们之所以不好定位消息什么时候结束，是因为我们不能够确定每次消息的长度。
• 那么其实可以先将消息的长度发送出去，当服务端知道消息的长度后，就能够完成一次消息的接收了。
• 总的来说，发送一次消息变成了两个步骤
• 1-发送消息的长度
• 2-发送消息
• 最后的问题就是，“发送消息的长度”这一步骤所发送的字节量必须是固定的，否则我们仍然会陷入僵局。
• 一般来说，我们可以使用固定的字节数来保存消息的长度，比如规定前2个字节就是消息的长度，不过这样我们能够传送的消息最大长度也就被固定死了，以2个字节为例，我们发送的消息最大长度不超过2^16个字节即64K。
• 如果你了解一些字符的编码，就会知道，其实我们可以使用变长的空间来储存消息的长度，比如：
  服务端

public void runServer() throws IOException {
        this.serverSocket = new ServerSocket(this.port);
        this.socket = serverSocket.accept();
        this.inputStream = socket.getInputStream();
        byte[] bytes;
        while (true) {
            // 先读第一个字节
            int first = inputStream.read();
            if (first == -1) {
                // 如果是-1，说明输入流已经被关闭了，也就不需要继续监听了
                this.socket.close();
                break;
            }
            // 读取第二个字节
            int second = inputStream.read();

            int length = (first << 8) + second; // 用位运算将两个字节拼起来成为真正的长度

            bytes = new byte[length]; // 构建指定长度的字节大小来储存消息即可

            inputStream.read(bytes);

            System.out.println("receive message: " + new String(bytes,"UTF-8"));
        }
    }

客户端

public void connetServer() throws IOException {
        this.socket = new Socket(host,port);
        this.outputStream = socket.getOutputStream();
    }

public void sendMessage(String message) throws IOException {
        // 首先要把message转换成bytes以便处理
        byte[] bytes = message.getBytes("UTF-8");
        // 接下来传输两个字节的长度，依然使用移位实现
        int length = bytes.length;
        this.outputStream.write(length >> 8); // write默认一次只传输一个字节
        this.outputStream.write(length);
        // 传输完长度后，再正式传送消息
        this.outputStream.write(bytes);
    }

public static void main(String[] args) {
        LengthSocketClient lc = new LengthSocketClient("127.0.0.1",9799);
        try {
            lc.connetServer();
            Scanner sc = new Scanner(System.in);
            while (sc.hasNextLine()) {
                lc.sendMessage(sc.nextLine());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

11.4 处理更多的连接：多线程

11.4.1 同时实现消息的发送与接收

• 在考虑服务端处理多连接之前，我们先考虑使用多线程改造一下原有的一对一对话实例。
• 在原有的例子中，消息的接收方并不能主动地向对方发送消息，换句话说我们并没有实现真正的互相对话，这主要是因为消息的发送和接收这两个动作并不能同时进行，因此我们需要使用两个线程，其中一个用于监听键盘输入并将其写入socket，另一个则负责监听socket并将接受到的消息显示。
• 出于简单考虑，我们直接让主线程负责键盘监听和消息发送，同时另外开启一个线程用于拉取消息并显示。
  消息拉取线程 ListenThread.java

public class ListenThread implements Runnable {
    private Socket socket;
    private InputStream inputStream;

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

    @Override
    public void run() throws RuntimeException{
        try {
            this.inputStream = socket.getInputStream();
        } catch (IOException e) {
            e.printStackTrace();
            throw new RuntimeException(e.getMessage());
        }

        while (true) {
            try {
                int first = this.inputStream.read();
                if (first == -1) {
                    // 输入流已经被关闭，无需继续读取
                    throw new RuntimeException("disconnected.");
                }
                int second = this.inputStream.read();
                int msgLength = (first<<8) + second;
                byte[] readBuffer = new byte[msgLength];
                this.inputStream.read(readBuffer);

                System.out.println("message from [" + socket.getInetAddress() + "]: " + new String(readBuffer,"UTF-8"));
            } catch (IOException e) {
                e.printStackTrace();
                throw new RuntimeException(e.getMessage());
            }
        }
    }
}

主线程，启动时由用户选择是作为server还是client:

public class ChatSocket {
    private String host;
    private int port;
    private Socket socket;
    private ServerSocket serverSocket;
    private OutputStream outputStream;

    // 以服务端形式启动，创建会话
    public void runAsServer(int port) throws IOException {
        this.serverSocket = new ServerSocket(port);
        System.out.println("[log] server started at port " + port);
        // 等待客户端的加入
        this.socket = serverSocket.accept();
        System.out.println("[log] successful connected with " + socket.getInetAddress());
        // 启动监听线程
        Thread listenThread = new Thread(new ListenThread(this.socket));
        listenThread.start();
        waitAndSend();
    }

    // 以客户端形式启动，加入会话
    public void runAsClient(String host, int port) throws IOException {
        this.socket = new Socket(host, port);
        System.out.println("[log] successful connected to server " + socket.getInetAddress());
        Thread listenThread = new Thread(new ListenThread(this.socket));
        listenThread.start();
        waitAndSend();
    }

    public void waitAndSend() throws IOException {
        this.outputStream = this.socket.getOutputStream();
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextLine()) {
            this.sendMessage(sc.nextLine());
        }
    }

    public void sendMessage(String message) throws IOException {
        byte[] msgBytes = message.getBytes("UTF-8");
        int length = msgBytes.length;
        outputStream.write(length>>8);
        outputStream.write(length);
        outputStream.write(msgBytes);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        ChatSocket chatSocket = new ChatSocket();
        System.out.println("select connect type: 1 for server and 2 for client");
        int type = Integer.parseInt(scanner.nextLine().toString());
        if (type == 1) {
            System.out.print("input server port: ");
            int port = scanner.nextInt();
            try {
                chatSocket.runAsServer(port);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }else if (type == 2) {
            System.out.print("input server host: ");
            String host = scanner.nextLine();
            System.out.print("input server port: ");
            int port = scanner.nextInt();
            try {
                chatSocket.runAsClient(host, port);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

11.4.1 使用线程池优化服务端并发能力

作为服务端，如果一次只跟一个客户端建立socket连接，未免显得太过浪费资源，因此我们完全可以让服务端和多个客户端建立多个socket。
那么既然要处理多个连接，就不得不面对并发问题了（当然，你也可以写循环轮流处理）。我们可以使用多线程来处理并发，不过线程的创建和销毁都会消耗大量的资源和时间，所以最好一步到位，用一个线程池来实现。
```java
public class SocketServer {
  public static void main(String args[]) throws Exception {
    // 监听指定的端口
    int port = 55533;
    ServerSocket server = new ServerSocket(port);
    // server将一直等待连接的到来
    System.out.println("server将一直等待连接的到来");

    //如果使用多线程，那就需要线程池，防止并发过高时创建过多线程耗尽资源
    ExecutorService threadPool = Executors.newFixedThreadPool(100);
    
    while (true) {
      Socket socket = server.accept();
      
      Runnable runnable=()->{
        try {
          // 建立好连接后，从socket中获取输入流，并建立缓冲区进行读取
          InputStream inputStream = socket.getInputStream();
          byte[] bytes = new byte[1024];
          int len;
          StringBuilder sb = new StringBuilder();
          while ((len = inputStream.read(bytes)) != -1) {
            // 注意指定编码格式，发送方和接收方一定要统一，建议使用UTF-8
            sb.append(new String(bytes, 0, len, "UTF-8"));
          }
          System.out.println("get message from client: " + sb);
          inputStream.close();
          socket.close();
        } catch (Exception e) {
          e.printStackTrace();
        }
      };
      threadPool.submit(runnable);
    }

  }
}

11.5 连接保活

• 当socket连接成功建立后，如果中途发生异常导致其中一方断开连接，此时另一方是无法发现的，只有在再次尝试发送/接收消息才会因为抛出异常而退出。
• 我们维持的socket连接，是一个长连接，但我们没有保证它的时效性，上一秒它可能还是可以用的，但是下一秒就不一定了。

11.5.1 使用心跳包

• 保证连接随时可用的最常见方法就是定时发送心跳包，来检测连接是否正常。这对于实时性要求很高的服务而言，还是非常重要的（比如消息推送）。
• 大体的方案如下：
• 1.双方约定好心跳包的格式，要能够区别于普通的消息。
• 2.客户端每隔一定时间，就向服务端发送一个心跳包
• 3.服务端每接收到心跳包时，将其抛弃
• 4.如果客户端的某个心跳包发送失败，就可以判断连接已经断开
• 5.如果对实时性要求很高，服务端也可以定时检查客户端发送心跳包的频率，如果超过一定时间没有发送可以认为连接已经断开

11.5.2 断开时重连

• 使用心跳包必然会增加带宽和性能的负担，对于普通的应用我们其实并没有必要使用这种方案，如果消息发送时抛出了连接异常，直接尝试重新连接就好了。
• 跟上面的方案对比，其实这个抛出异常的消息就充当了心跳包的角色。
• 总的来说，连接是否要保活，如何保活，需要根据具体的业务场景灵活地思考和定制。