【Socket】Java Socket编程基础及深刻讲解

时间 2019-11-11

标签 Socket java socket 编程基础深刻讲解栏目系统网络繁體版

原文原文链接

　　Socket是Java网络编程的基础，了解仍是有好处的，html

　　这篇文章主要讲解Socket的基础编程。Socket用在哪呢，主要用在进程间，网络间通讯。本篇比较长，特别作了个目录：java

1、Socket通讯基本示例程序员

2、消息通讯优化算法

3、服务端优化编程

4、Socket的其它知识数组

5、关于Socket的理解缓存

1、Socket通讯基本示例

　　这种模式是基础，必须掌握，后期对Socket的优化都是在这个基础上的，也是为之后学习NIO作铺垫。安全

package yiwangzhibujian.onlysend;

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

public class SocketServer {
  public static void main(String[] args) throws Exception {
    // 监听指定的端口
    int port = 55533;
    ServerSocket server = new ServerSocket(port);
    
    // server将一直等待链接的到来
    System.out.println("server将一直等待链接的到来");
    Socket socket = server.accept();
    // 创建好链接后，从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();
    server.close();
  }
}

　　服务端监听一个端口，等待链接的到来。服务器

package yiwangzhibujian.onlysend;

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

public class SocketClient {
  public static void main(String args[]) throws Exception {
    // 要链接的服务端IP地址和端口
    String host = "127.0.0.1"; 
    int port = 55533;
    // 与服务端创建链接
    Socket socket = new Socket(host, port);
    // 创建链接后得到输出流
    OutputStream outputStream = socket.getOutputStream();
    String message="你好  yiwangzhibujian";
    socket.getOutputStream().write(message.getBytes("UTF-8"));
    outputStream.close();
    socket.close();
  }
}

　　客户端经过ip和端口，链接到指定的server，而后经过Socket得到输出流，并向其输出内容，服务器会得到消息。最终服务端控制台打印以下：网络

server将一直等待链接的到来
get message from client: 你好  yiwangzhibujian

　　经过这个例子应该掌握并了解：

Socket服务端和客户端的基本编程
传输编码统一指定，防止乱码

　　这个例子作为学习的基本例子，实际开发中会有各类变形，好比客户端在发送完消息后，须要服务端进行处理并返回，以下。

2、消息通讯优化

2.1 双向通讯，发送消息并接受消息

　　这个也是作为Socket编程的基本，应该掌握，例子以下：

package yiwangzhibujian.waitreceive;

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

public class SocketServer {
  public static void main(String[] args) throws Exception {
    // 监听指定的端口
    int port = 55533;
    ServerSocket server = new ServerSocket(port);
    
    // server将一直等待链接的到来
    System.out.println("server将一直等待链接的到来");
    Socket socket = server.accept();
    // 创建好链接后，从socket中获取输入流，并创建缓冲区进行读取
    InputStream inputStream = socket.getInputStream();
    byte[] bytes = new byte[1024];
    int len;
    StringBuilder sb = new StringBuilder();
    //只有当客户端关闭它的输出流的时候，服务端才能取得结尾的-1
    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);

    OutputStream outputStream = socket.getOutputStream();
    outputStream.write("Hello Client,I get the message.".getBytes("UTF-8"));

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

　　与以前server的不一样在于，当读取完客户端的消息后，打开输出流，将指定消息发送回客户端，客户端程序为：

package yiwangzhibujian.waitreceive;

import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class SocketClient {
  public static void main(String args[]) throws Exception {
    // 要链接的服务端IP地址和端口
    String host = "127.0.0.1";
    int port = 55533;
    // 与服务端创建链接
    Socket socket = new Socket(host, port);
    // 创建链接后得到输出流
    OutputStream outputStream = socket.getOutputStream();
    String message = "你好  yiwangzhibujian";
    socket.getOutputStream().write(message.getBytes("UTF-8"));
    //经过shutdownOutput高速服务器已经发送完数据，后续只能接受数据
    socket.shutdownOutput();
    
    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 server: " + sb);
    
    inputStream.close();
    outputStream.close();
    socket.close();
  }
}

　　客户端也有相应的变化，在发送完消息时，调用关闭输出流方法，而后打开输出流，等候服务端的消息。

2.2 使用场景

　　这个模式的使用场景通常用在，客户端发送命令给服务器，而后服务器相应指定的命令，若是只是客户端发送消息给服务器，而后让服务器返回收到消息的消息，这就有点过度了，这就是彻底不相信Socket的传输安全性，要知道它的底层但是TCP，若是没有发送到服务器端是会抛异常的，这点彻底不用担忧。

2.3 如何告知对方已发送完命令

　　其实这个问题仍是比较重要的，正常来讲，客户端打开一个输出流，若是不作约定，也不关闭它，那么服务端永远不知道客户端是否发送完消息，那么服务端会一直等待下去，直到读取超时。因此怎么告知服务端已经发送完消息就显得特别重要。

2.3.1 经过Socket关闭

　　这个是第一章介绍的方式，当Socket关闭的时候，服务端就会收到响应的关闭信号，那么服务端也就知道流已经关闭了，这个时候读取操做完成，就能够继续后续工做。

　　可是这种方式有一些缺点

客户端Socket关闭后，将不能接受服务端发送的消息，也不能再次发送消息
若是客户端想再次发送消息，须要重现建立Socket链接

2.3.2 经过Socket关闭输出流的方式

　　这种方式调用的方法是：

socket.shutdownOutput();

　　而不是（outputStream为发送消息到服务端打开的输出流）：

outputStream.close();

　　若是关闭了输出流，那么相应的Socket也将关闭，和直接关闭Socket一个性质。

　　调用Socket的shutdownOutput()方法，底层会告知服务端我这边已经写完了，那么服务端收到消息后，就能知道已经读取完消息，若是服务端有要返回给客户的消息那么就能够经过服务端的输出流发送给客户端，若是没有，直接关闭Socket。

　　这种方式经过关闭客户端的输出流，告知服务端已经写完了，虽然能够读到服务端发送的消息，可是仍是有一点点缺点：

不能再次发送消息给服务端，若是再次发送，须要从新创建Socket链接

　　这个缺点，在访问频率比较高的状况下将是一个须要优化的地方。

2.3.3 经过约定符号

　　这种方式的用法，就是双方约定一个字符或者一个短语，来当作消息发送完成的标识，一般这么作就须要改造读取方法。

　　假如约定单端的一行为end，表明发送完成，例以下面的消息，end则表明消息发送完成：

hello yiwangzhibujian
end

　　那么服务端响应的读取操做须要进行以下改造：

Socket socket = server.accept();
// 创建好链接后，从socket中获取输入流，并创建缓冲区进行读取
BufferedReader read=new BufferedReader(new InputStreamReader(socket.getInputStream(),"UTF-8"));
String line;
StringBuilder sb = new StringBuilder();
while ((line = read.readLine()) != null && "end".equals(line)) {
  //注意指定编码格式，发送方和接收方必定要统一，建议使用UTF-8
  sb.append(line);
}

　　能够看见，服务端不只判断是否读到了流的末尾，还判断了是否读到了约定的末尾。

　　这么作的优缺点以下：

优势：不须要关闭流，当发送完一条命令（消息）后能够再次发送新的命令（消息）
缺点：须要额外的约定结束标志，太简单的容易出如今要发送的消息中，误被结束，太复杂的很差处理，还占带宽

　　通过了这么多的优化仍是有缺点，难道就没有完美的解决方案吗，答案是有的，看接下来的内容。

2.3.4 经过指定长度

　　若是你了解一点class文件的结构（后续会写，敬请期待），那么你就会佩服这么设计方式，也就是说咱们能够在此找灵感，就是咱们能够先指定后续命令的长度，而后读取指定长度的内容作为客户端发送的消息。

　　如今首要的问题就是用几个字节指定长度呢，咱们能够算一算：

1个字节：最大256，表示256B
2个字节：最大65536，表示64K
3个字节：最大16777216，表示16M
4个字节：最大4294967296，表示4G
依次类推

　　这个时候是否是很纠结，最大的固然是最保险的，可是真的有必要选择最大的吗，其实若是你稍微了解一点UTF-8的编码方式（字符编码后续会写，敬请期待），那么你就应该能想到为何必定要固定表示长度字节的长度呢，咱们可使用变长方式来表示长度的表示，好比：

第一个字节首位为0：即0XXXXXXX，表示长度就一个字节，最大128，表示128B
第一个字节首位为110，那么附带后面一个字节表示长度：即110XXXXX 10XXXXXX，最大2048，表示2K
第一个字节首位为1110，那么附带后面二个字节表示长度：即110XXXXX 10XXXXXX 10XXXXXX，最大131072，表示128K
依次类推

　　上面提到的这种用法适合高富帅的程序员使用，通常呢，若是用做命名发送，两个字节就够了，若是还不放心4个字节基本就能知足你的全部要求，下面的例子咱们将采用2个字节表示长度，目的只是给你一种思路，让你知道有这种方式来获取消息的结尾：

　　服务端程序：

package yiwangzhibujian.waitreceive2;

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

public class SocketServer {
  public static void main(String[] args) throws Exception {
    // 监听指定的端口
    int port = 55533;
    ServerSocket server = new ServerSocket(port);

    // server将一直等待链接的到来
    System.out.println("server将一直等待链接的到来");
    Socket socket = server.accept();
    // 创建好链接后，从socket中获取输入流，并创建缓冲区进行读取
    InputStream inputStream = socket.getInputStream();
    byte[] bytes;
    // 由于能够复用Socket且能判断长度，因此能够一个Socket用到底
    while (true) {
      // 首先读取两个字节表示的长度
      int first = inputStream.read();
      //若是读取的值为-1 说明到了流的末尾，Socket已经被关闭了，此时将不能再去读取
      if(first==-1){
        break;
      }
      int second = inputStream.read();
      int length = (first << 8) + second;
      // 而后构造一个指定长的byte数组
      bytes = new byte[length];
      // 而后读取指定长度的消息便可
      inputStream.read(bytes);
      System.out.println("get message from client: " + new String(bytes, "UTF-8"));
    }
    inputStream.close();
    socket.close();
    server.close();
  }
}

　　此处的读取步骤为，先读取两个字节的长度，而后读取消息，客户端为：

package yiwangzhibujian.waitreceive2;

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

public class SocketClient {
  public static void main(String args[]) throws Exception {
    // 要链接的服务端IP地址和端口
    String host = "127.0.0.1";
    int port = 55533;
    // 与服务端创建链接
    Socket socket = new Socket(host, port);
    // 创建链接后得到输出流
    OutputStream outputStream = socket.getOutputStream();
    String message = "你好  yiwangzhibujian";
    //首先须要计算得知消息的长度
    byte[] sendBytes = message.getBytes("UTF-8");
    //而后将消息的长度优先发送出去
    outputStream.write(sendBytes.length >>8);
    outputStream.write(sendBytes.length);
    //而后将消息再次发送出去
    outputStream.write(sendBytes);
    outputStream.flush();
    //==========此处重复发送一次，实际项目中为多个命名，此处只为展现用法
    message = "第二条消息";
    sendBytes = message.getBytes("UTF-8");
    outputStream.write(sendBytes.length >>8);
    outputStream.write(sendBytes.length);
    outputStream.write(sendBytes);
    outputStream.flush();
    //==========此处重复发送一次，实际项目中为多个命名，此处只为展现用法
    message = "the third message!";
    sendBytes = message.getBytes("UTF-8");
    outputStream.write(sendBytes.length >>8);
    outputStream.write(sendBytes.length);
    outputStream.write(sendBytes);    
    
    outputStream.close();
    socket.close();
  }
}

　　客户端要多作的是，在发送消息以前先把消息的长度发送过去。

　　这种事先约定好长度的作法解决了以前提到的种种问题，Redis的Java客户端Jedis就是用这种方式实现的这种方式的缺点：

暂时还没发现

　　固然若是是须要服务器返回结果，那么也依然使用这种方式，服务端也是先发送结果的长度，而后客户端进行读取。固然如今流行的就是，长度+类型+数据模式的传输方式。

3、服务端优化

3.1 服务端并发处理能力

　　在上面的例子中，服务端仅仅只是接受了一个Socket请求，并处理了它，而后就结束了，可是在实际开发中，一个Socket服务每每须要服务大量的Socket请求，那么就不能再服务完一个Socket的时候就关闭了，这时候能够采用循环接受请求并处理的逻辑：

package yiwangzhibujian.multiserver;

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

public class SocketServer {
  public static void main(String args[]) throws IOException {
    // 监听指定的端口
    int port = 55533;
    ServerSocket server = new ServerSocket(port);
    // server将一直等待链接的到来
    System.out.println("server将一直等待链接的到来");
    
    while(true){
      Socket socket = server.accept();
      // 创建好链接后，从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();
    }
    
  }
}

　　这种通常也是新手写法，可是可以循环处理多个Socket请求，不过当一个请求的处理比较耗时的时候，后面的请求将被阻塞，因此通常都是用多线程的方式来处理Socket，即每有一个Socket请求的时候，就建立一个线程来处理它。

　　不过在实际生产中，建立的线程会交给线程池来处理，为了：

线程复用，建立线程耗时，回收线程慢
防止短期内高并发，指定线程池大小，超过数量将等待，方式短期建立大量线程致使资源耗尽，服务挂掉

package yiwangzhibujian.threadserver;

import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

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);
    }

  }
}

　　使用线程池的方式，算是一种成熟的方式。能够应用在生产中。

3.2 服务端其余属性

　　ServerSocket有如下3个属性。

SO_TIMEOUT：表示等待客户链接的超时时间。通常不设置，会持续等待。
SO_REUSEADDR：表示是否容许重用服务器所绑定的地址。通常不设置，经个人测试不必，下面会进行详解。
SO_RCVBUF：表示接收数据的缓冲区的大小。通常不设置，用系统默认就能够了。

　　具体详细的解释能够参照下面。

3.3 性能再次提高

　　当如今的性能还不能知足需求的时候，就须要考虑使用NIO，这不是本篇的内容，后续会贴出。

4、Socket的其它知识

　　其实若是常常看有关网络编程的源码的话，就会发现Socket仍是有不少设置的，能够学着用，可是仍是要有一些基本的了解比较好。下面就对Socket的Java API中涉及到的进行简单讲解。首先呢Socket有哪些能够设置的选项，其实在SocketOptions接口中已经都列出来了：

int TCP_NODELAY = 0x0001：对此链接禁用 Nagle 算法。
int SO_BINDADDR = 0x000F：此选项为 TCP 或 UDP 套接字在 IP 地址头中设置服务类型或流量类字段。
int SO_REUSEADDR = 0x04：设置套接字的 SO_REUSEADDR。
int SO_BROADCAST = 0x0020：此选项启用和禁用发送广播消息的处理能力。
int IP_MULTICAST_IF = 0x10：设置用于发送多播包的传出接口。
int IP_MULTICAST_IF2 = 0x1f：设置用于发送多播包的传出接口。
int IP_MULTICAST_LOOP = 0x12：此选项启用或禁用多播数据报的本地回送。
int IP_TOS = 0x3：此选项为 TCP 或 UDP 套接字在 IP 地址头中设置服务类型或流量类字段。
int SO_LINGER = 0x0080：指定关闭时逗留的超时值。
int SO_TIMEOUT = 0x1006：设置阻塞 Socket 操做的超时值： ServerSocket.accept(); SocketInputStream.read(); DatagramSocket.receive(); 选项必须在进入阻塞操做前设置才能生效。
int SO_SNDBUF = 0x1001：设置传出网络 I/O 的平台所使用的基础缓冲区大小的提示。
int SO_RCVBUF = 0x1002：设置传入网络 I/O 的平台所使用基础缓冲区的大小的提示。
int SO_KEEPALIVE = 0x0008：为 TCP 套接字设置 keepalive 选项时
int SO_OOBINLINE = 0x1003：置 OOBINLINE 选项时，在套接字上接收的全部 TCP 紧急数据都将经过套接字输入流接收。

　　上面只是简单介绍了下（来源Java API），下面有对其中的某些的详细讲解，没讲到的后续若是用到会补上。

4.1 客户端绑定端口

　　服务端绑定端口是能够理解的，由于要监听指定的端口，可是客户端为何要绑定端口，说实话我以为这么作的人有点2，或许有的网络安全策略配置了端口访出，使用户只能使用指定的端口，那么这样的配置也是挺2的，直接说就能够不要留面子。

　　固然首先要理解的是，若是没有指定端口的话，Socket会自动选取一个能够用的端口，不用瞎操心的。

　　可是你非得指定一个端口也是能够的，作法以下，这时候就不能用Socket的构造方法了，要一步一步来：

// 要链接的服务端IP地址和端口
String host = "localhost"; 
int port = 55533;
// 与服务端创建链接
Socket socket = new Socket();
socket.bind(new InetSocketAddress(55534));
socket.connect(new InetSocketAddress(host, port));

　　这样作就能够了，可是当这个程序执行完成之后，再次执行就会报，端口占用异常：

java.net.BindException: Address already in use: connect

　　明明上一个Socket已经关闭了，为何再次使用还会说已经被占用了呢？若是你是用netstat 命令来查看端口的使用状况：

netstat -n|findstr "55533"
TCP 127.0.0.1:55534 127.0.0.1:55533 TIME_WAIT

　　就会发现端口的使用状态为TIME_WAIT，说到这你须要有一点TCP链接的基本常识，建议看《》，这是其中的一点摘抄笔记，或许对理解有一些帮助。

　　简单来讲，当链接主动关闭后，端口状态变为TIME_WAIT，其余程序依然不能使用这个端口，防止服务端由于超时从新发送的确认链接断开对新链接的程序形成影响。

　　TIME_WAIT的时间通常有底层决定，通常是2分钟，还有1分钟和30秒的。

　　因此，客户端不要绑定端口，不要绑定端口，不要绑定端口。

4.2 读超时SO_TIMEOUT

　　读超时这个属性仍是比较重要的，当Socket优化到最后的时候，每每一个Socket链接会一直用下去，那么当一端由于异常致使链接没有关闭，另外一方是不该该持续等下去的，因此应该设置一个读取的超时时间，当超过指定的时间后，尚未读到数据，就假定这个链接无用，而后抛异常，捕获异常后关闭链接就能够了，调用方法为：

public void setSoTimeout(int timeout)
throws SocketException

　　timeout - 指定的以毫秒为单位的超时值。设置0为持续等待下去。建议根据网络环境和实际生产环境选择。

　　这个选项设置的值将对如下操做有影响：

ServerSocket.accept()
SocketInputStream.read()
DatagramSocket.receive()

4.3 设置链接超时

　　这个链接超时和上面说的读超时不同，读超时是在创建链接之后，读数据时使用的，而链接超时是在进行链接的时候，等待的时间。

4.4 判断Socket是否可用

　　当须要判断一个Socket是否可用的时候，不能简简单单判断是否为null，是否关闭，下面给出一个比较全面的判断Socket是否可用的表达式，这是根据Socket自身的一些状态进行判断的，它的状态有：

bound：是否绑定
closed：是否关闭
connected：是否链接
shutIn：是否关闭输入流
shutOut：是否关闭输出流

socket != null && socket.isBound() && !socket.isClosed() && socket.isConnected()&& !socket.isInputShutdown() && !socket.isOutputShutdown()

　　建议如此使用，但这只是第一步，保证Socket自身的状态是可用的，可是当链接正常建立后，上面的属性若是不调用本方相应的方法是不会改变的，也就是说若是网络断开、服务器主动断开，Java底层是不会检测到链接断开并改变Socket的状态，因此，真实的检测链接状态仍是得经过额外的手段，有两种方式。

4.4.1 自定义心跳包

　　双方须要约定，什么样的消息属于心跳包，什么样的消息属于正常消息，假设你看了上面的章节如今说就容易理解了，咱们定义前两个字节为消息的长度，那么咱们就能够定义第3个字节为消息的属性，能够指定一位为消息的类型，1为心跳，0为正常消息。那么要作的有以下：

客户端发送心跳包
服务端获取消息判断是不是心跳包，如果丢弃
当客户端发送心跳包失败时，就能够判定链接不可用

　　具体的编码再也不贴出，本身实现便可。

4.4.2 经过发送紧急数据

　　Socket自带一种模式，那就是发送紧急数据，这有一个前提，那就是服务端的OOBINLINE不能设置为true，它的默认值是false。

　　OOBINLINE的true和false影响了什么：

对客户端没有影响
对服务端，若是设置为true，那么服务端将会捕获紧急数据，这会对接收数据形成混淆，须要额外判断

　　发送紧急数据经过调用Socket的方法：

socket.sendUrgentData(0);

　　发送数据任意便可，由于OOBINLINE为false的时候，服务端会丢弃掉紧急数据。

　　当发送紧急数据报错之后，咱们就会知道链接不通了。

4.4.3 真的须要判断链接断开吗

　　经过上面的两种方式已经能够判断出链接是否可用，而后咱们就能够进行后续操做，但是请你们认真考虑下面的问题：

发送心跳成功时确认链接可用，当再次发送消息时能保证链接还可用吗？即使中间的间隔很短
若是链接不可用了，你会怎么作？从新创建链接再次发送数据？仍是说单单只是记录日志？
若是你打算从新创建链接，那么发送心跳包的意义何在？为什么不在发送异常时再新建链接？

　　若是你认真考虑了上面的问题，那么你就会以为发送心跳包彻底是没有必要的操做，经过发送心跳包来判断链接是否可用是经过捕获异常来判断的。那么咱们彻底能够在发送消息报出IO异常的时候，在异常中从新发送一次便可，这两种方式的编码有什么不一样呢，下面写一写伪代码。

　　提早检测链接是否可用：

//有一个链接中的socket
Socket socket=...
//要发送的数据
String data="";
try{
    //发送心跳包或者紧急数据，来检测链接的可用性
}catch (Excetption e){
    //打印日志，并重连Socket
    socket=new Socket(host,port);
}
socket.write(data);

　　直接发送数据，出异常后从新链接再次发送：

//有一个链接中的socket
Socket socket=...
//要发送的数据
String data="";
try{
    socket.write(data);
}catch (Excetption e){
    //打印日志，并重连Socket
    socket=new Socket(host,port);
    socket.write(data);
}

　　经过比较能够发现两种方式的特色，如今简单介绍下：

两种方式都可实现链接断开从新链接并发送
提早检测，再每次发送消息的时候都要检测，影响效率，占用带宽

　　但愿你们认真考虑，作出本身的选择。

4.5 设置端口重用SO_REUSEADDR

　　首先，建立Socket时，默认是禁止的，设置true有什么做用呢，Java API中是这么介绍的：

关闭 TCP 链接时，该链接可能在关闭后的一段时间内保持超时状态（一般称为 TIME_WAIT 状态或 2MSL 等待状态）。对于使用已知套接字地址或端口的应用程序而言，若是存在处于超时状态的链接（包括地址和端口），可能不能将套接字绑定到所需的 SocketAddress 上。

使用 bind(SocketAddress) 绑定套接字前启用 SO_REUSEADDR 容许在上一个链接处于超时状态时绑定套接字。

　　通常是用在绑定端口的时候使用，可是通过个人测试建议以下：

服务端绑定端口后，关闭服务端，从新启动后不会提示端口占用
客户端绑定端口后，关闭，即使设置ReuseAddress为true，即使能绑定端口，链接的时候仍是会报端口占用异常

　　综上所述，不建议绑定端口，也不必设置ReuseAddress，固然ReuseAddress的底层仍是和硬件有关系的，或许在你的机器上测试结果和我不同，如果如此和平台相关性差别这么大配置更是不建议使用了。

4.6 设置关闭等待SO_LINGER

　　Java API的介绍是：启用/禁用具备指定逗留时间（以秒为单位）的 SO_LINGER。最大超时值是特定于平台的。该设置仅影响套接字关闭。

　　你们都是这么说的，当调用Socket的close方法后，没有发送的数据将再也不发送，设置这个值的话，Socket会等待指定的时间发送完数据包。说实话，通过我简单的测试，对于通常数据量来讲，几十K左右，即使直接关闭Socket的链接，服务端也是能够收到数据的。

　　因此对于通常应用不必设置这个值，当数据量发送过大抛出异常时，再来设置这个值也不晚。那么到达逗留超时值时，套接字将经过 TCP RST 强制性关闭。启用超时值为零的选项将当即强制关闭。若是指定的超时值大于 65,535，则其将被减小到 65,535。

4.7 设置发送延迟策略TCP_NODELAY

　　通常来讲当客户端想服务器发送数据的时候，会根据当前数据量来决定是否发送，若是数据量太小，那么系统将会根据Nagle 算法（暂时还没研究），来决定发送包的合并，也就是说发送会有延迟，这在有时候是致命的，好比说对实时性要求很高的消息发送，在线对战游戏等，即使数据量很小也要求当即发送，若是稍有延迟就会感受到卡顿，默认状况下Nagle 算法是开启的，因此若是不打算有延迟，最好关闭它。这样一旦有数据将会当即发送而不会写入缓冲区。

　　可是对延迟要求不是特别高下仍是可使用的，仍是能够提高网络传输效率的。

4.8 设置输出输出缓冲区大小SO_RCVBUF/SO_SNDBUF

SO_SNDBUF：发送缓冲
SO_RCVBUF：接收缓冲

　　默认都是8K，若是有须要能够修改，经过相应的set方法。不建议修改的过小，设置过小数据传输将过于频繁。太大了将会形成消息停留。

　　不过我对这个通过测试后有如下结论：

当数据填满缓冲区时，必定会发送
当数据没有填满缓冲区时也会发送，这个算法仍是上面说的Nagle 算法

4.9 设置保持链接存活SO_KEEPALIVE

　　虽说当设置链接链接的读超时为0，即无限等待时，Socket不会被主动关闭，可是总会有莫名其妙的软件来检测你的链接是否有数据发送，长时间没有数据传输的链接会被它们关闭掉。

　　所以经过设置这个选项为true，能够有以下效果：当2个小时（具体的实现而不一样）内在任意方向上都没有跨越套接字交换数据，则 TCP 会自动发送一个保持存活的消息到对面。将会有如下三种响应：

返回指望的ACK。那么不通知应用程序（由于一切正常），2 小时的不活动时间事后，TCP 将发送另外一个探头。
对面返回RST，代表对面挂了，可是又好了，Socket依然要关闭
没有响应，说明对面挂了，这时候关闭Socket

　　因此对于构建长时间链接的Socket仍是配置上SO_KEEPALIVE比较好。

4.10 异常：java.net.SocketException: Connection reset by peer

　　这个异常的含义是，我正在写数据的时候，你把链接给关闭了。这个异常在通常正常的编码是不会出现这个异常的，由于用户一般会判断是否读到流的末尾了，读到末尾才会进行关闭操做，若是出现这个异常，那就检查一下判断是否读到流的末尾逻辑是否正确。

5、关于Socket的理解

5.1 Socket和TCP/IP

　　最近在看《TCP/IP详解卷1：协议》，关于TCP/IP我以为讲解的很是详细，我作了点摘抄，能够大体看看，很是建议你们阅读下这本书。一般TCP/IP分为四层：

　　也就是说Socket其实是归属于应用层，使用的事运输层的TCP，使用SocketServer监听的端口，也是能够被Telnet链接的。能够看下面两行代码：

ServerSocket server = new ServerSocket(port);
Socket socket = server.accept();

　　在什么状况获取到这个Socket呢，经过理论加测试，结论是在三次握手操做后，系统才会将这个链接交给应用层，ServerSocket 才知道有一个链接过来了。那么系统当接收到一个TCP链接请求后，若是上层尚未接受它（假如SocketServer循环处理Socket，一次一个），那么系统将缓存这个链接请求，既然是缓存那么就是有限度的，书上介绍的是缓存3个，可是通过个人本机测试是50个，也就是说，系统将会为应用层的Socket缓存50和TCP链接（这是和系统底层有关系的），当超过指定数量后，系统将会拒绝链接。

　　假如缓存的TCP链接请求发送来数据，那么系统也会缓存这些数据，等待SocketServer得到这个链接的时候一并交给它，这个会在后期学习NIO进行详解。

　　换句话说，系统接收TCP链接请求放入缓存队列，而SocketServer从缓存队列获取Socket。

　　而上面例子中的为了让服务端知道发送完消息的，关闭输出流的操做：

socket.shutdownOutput();

　　实际上是对应着四次挥手的第一次：

　　也就是上面说的主动关闭，FIN_WAIT_1，这样服务端就能得知客户端发送完消息，此时服务端能够选择关闭链接，也能够选择发送数据后关闭链接：

　　这就是TCP所说的半关闭。其实不少知识都是想通的，多学点基础知识仍是有必要的。

5.2 Socket和RMI

　　RMI基础知识就很少介绍了（后续会写，敬请期待），如今假定你对RMI有所了解，那么通常就会对这两种技术有所比较。或者说在应用的时候就会想用那种技术比较好。

　　RMI全称：Remote Method Invocation－远程方法调用，经过名字其实就能对这种技术有个初步的了解。如今我就简单说说我对这两种技术的想法。

　　这个待写，等我写完RMI博客的时候补上，那时候会更细致的了解下。

5.3 DatagramSocket与Socket

　　这一段涉及到UDP，依然和上面同样，后续会补上。

5.4 拆包和黏包

　　使用Socket通讯的时候，或多或少都听过拆包和黏包，若是没听过而去贸然编程那么偶尔就会碰到一些莫名其妙的问题，全部有这方面的知识仍是比较重要的，至少知道怎么发生，怎么防范。

　　如今先简单说明下拆包和黏包的缘由：

拆包：当一次发送（Socket）的数据量过大，而底层（TCP/IP）不支持一次发送那么大的数据量，则会发生拆包现象。
黏包：当在短期内发送（Socket）不少数据量小的包时，底层（TCP/IP）会根据必定的算法（指Nagle）把一些包合做为一个包发送。

　　首先能够明确的是，大部分状况下咱们是不但愿发生拆包和黏包的（若是但愿发生，什么都去作便可），那么怎么去避免呢，下面进行详解？

5.4.1 黏包

　　首先咱们应该正确看待黏包，黏包其实是对网络通讯的一种优化，假如说上层只发送一个字节数据，而底层却发送了41个字节，其中20字节的I P首部、 20字节的T C P首部和1个字节的数据，并且发送完后还须要确认，这么作浪费了带宽，量大时还会形成网络拥堵。固然它仍是有必定的缺点的，就是由于它会合并一些包会致使数据不能当即发送出去，会形成延迟，若是能接受（通常延迟为200ms），那么仍是不建议关闭这种优化，若是由于黏包会形成业务上的错误，那么请改正你的服务端读取算法（协议），由于即使不发生黏包，在服务端缓存区也可能会合并起来一块儿提交给上层，推荐使用长度+类型+数据模式。

　　若是不但愿发生黏包，那么经过禁用TCP_NODELAY便可，Socket中也有相应的方法：

void setTcpNoDelay(boolean on)

　　经过设置为true便可防止在发送的时候黏包，可是当发送的速率大于读取的速率时，在服务端也会发生黏包，即因服务端读取过慢，致使它一次可能读取多个包。

5.4.2 拆包

　　这个问题应该引发重视，在TCP/IP详解中说过：最大报文段长度（MSS）表示TCP传往另外一端的最大块数据的长度。当一个链接创建时，链接的双方都要通告各自的 MSS。客户端会尽可能知足服务端的要求且不能大于服务端的MSS值，当没有协商时，会使用值536字节。虽然看起来MSS值越大越好，可是考虑到一些其余状况，这个值仍是不太好肯定，具体详见《TCP/IP详解卷1：协议》。

　　如何应对拆包，其实在上面2.3节已经介绍过了，那就是如何代表发送完一条消息了，对于已知数据长度的模式，能够构造相同大小的数组，循环读取，示例代码以下：

int length=1024;//这个是读取的到数据长度，现假定1024
byte[] data=new byte[1024];
int readLength=0;
while(readLength<length){
    int read = inputStream.read(data, readLength, length-readLength);
    readLength+=read;
}

　　这样当循环结束后，就能读取到完整的一条数据，而不须要考虑拆包了。

　　单单关于Java的Socket编程已经基本介绍完成了，固然还有更深层次的知识没有涉及到，后续若是能有接触也会写出来，但愿个人文章能帮助到有须要的人，若是有什么不对的地方请指出，禁止转载。

1. Java Socket编程基础及深入讲解
2. SOCKET基础讲解
3. java基础——Java Socket编程(一) Socket编程原理及基本概念
4. socket 编程基础
5. Socket编程基础
6. socket编程基础
7. 深刻了解php socket编程
8. 深刻理解Socket
9. Socket编程基础——Socket选项
10. Java Socket编程(一) Socket编程原理及基本概念
更多相关文章...
• Scala 基础语法 - Scala教程
• Kotlin 基础语法 - Kotlin 教程
• Flink 数据传输及反压详解
• Java 8 Stream 教程