Java网络编程实战：TCP/UDP Socket通信详解与高并发服务器设计

socket(套接字)

在网络协议中，应用层是和程序员直接相关的，涉及到的网络通信协议也大多是程序员自定制的。

而在操作系统中提供了一组API：socket api（传输层给应用层提供的），socket相当于网卡的遥控器，我们可以通过这组api来间接操作网卡。

socket主要提供了两套，一个是TCP的，另一个是UDP，这两个核心协议差别很大，编写的时候风格不同，因此socket api提供了两套。

TCP和UDP差别

TCP:有连接，可靠传输，面向字节流，全双工
UDP:无连接，不可靠传输，面向数据报，全双工

• 有连接 & 无连接： 对于TCP来说，TCP协议保存了对端的信息，如果A和B进行通信，A保存B的信息，B也保存A的信息，彼此都知道谁是和它建立联系的。而UDP就不会存储彼此的信息。

• 可靠传输 & 不可靠传输： 在网络中，数据非常容易出现丢包的情况，因为光信号和电信号可能会收到外界的干扰，本来传输的数据被修改了，这样乱的数据会被丢弃掉。而可靠传输并不是保证数据包100%到达，而是尽可能的提高传输成功率，如果丢包了，也可以感知到，而可靠传输的代价就是效率降低~不可靠传输，只是把数据发送出去了，其他的不管了。

• 面向字节流 & 面向数据报： TCP读写数据时是以字节为单位的，长度是任意的，可能会出现“粘包”问题。UPD读写数据时以一个数据报为单位，一次必须是一整个不能是半个，严格收到长度的限制，因此不会出现“粘包”问题。

• 双全工 & 半全工： 一个通信链路层如果支持双向通信则称为双全工，如果只支持单向通信（仅能读或者写）则称之为半全工

粘包（TCP Stickiness）是指 TCP 协议在传输数据时，多个数据包被接收方当作一个包接收，导致数据解析错误的现象。主要发生在 基于流的传输协议（如 TCP），而 UDP 不会粘包，因为 UDP 是面向消息的协议，每个数据包都有明确的边界。

UDP编程

方法

DatagramSocket是JAVA为UPD提供的实现类。

构造方法：

核心方法：

上述我们讲到UDP是以数据报为一个单位进行读写的，而在JAVA中DatagramPacket类表示一个完整的UDP数据报。

构造方法：

核心方法：

使用

构造数据报

DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);

1. 第一个参数：创建一个长度为1024字节的字节数组
   这个数组将作为数据包的缓冲区，用于存储接收到的网络数据
2. 第二个参数：1024
   指定缓冲区的大小（这里是1024字节）
   表示这个数据包最多能接收1024字节的数据

看到这里不知道你是否和我一样好奇，这里为什么要这样设计呢？？？这里的数值反正都一样，直接传入第一个参数不就可以获得第二个参数吗。

• 当接收长度 < 缓冲区长度时 即使数据包大于1024字节，也只会填充缓冲区的前1024字节,可以限制接收数据量，防止缓冲区溢出
• 当接收长度 > 缓冲区长度时 会抛出IllegalArgumentException异常

推荐做法：使接收长度等于缓冲区长度
特殊场景：当只需要接收部分数据时可以使用不一致设置

接受数据报

DatagramSocket socket =  new DatagramSocket(9090);
//存储字节大小为1024字节数组。
DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);
//接收数据
socket.receive(packet);
//将有效部分转化成字符串
String receive = new String(packet.getData(), 0, packet.getLength());
System.out.println("收到消息：" + receive);

getLength()方法是获取DatagramPacket 的length属性，也就是在初始时设置的1024，但是length在接受到数据报后会被改变，变成实际接收到的字节长度。

发送数据报

DatagramSocket socket =  new DatagramSocket(9090);
//存储字节大小为1024字节数组。
DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);
//接收数据
socket.receive(packet);
String respose  = "你好呀";
DatagramPacket resposePacket = new DatagramPacket(respose.getBytes(), respose.getBytes().length, packet.getSocketAddress());
socket.send(resposePacket);

在这里我们将信息重新发回源地址，那么怎么知道对方的ip呢？我们接收到的数据报里面含有对方的源端口以及源ip地址，那么此时对方的源地址就是我们的目的地址，而我们的getSocketAddress()方法恰好可以返回一个带有端口以及ip地址的类。

除此之外，还要注意我们的respose.getBytes().length，这里不能使用respose.length，因为字符的长度不等于字节的长度！

简单服务器实现

如果你理解了上述的代码，那么你就可以完成一个简单的回显服务器啦~
所谓回显服务器就是你的询问是什么，回答的就是什么…

一个服务器程序通常的流程：

1. 读取请求并解析
2. 根据请求，计算响应。（服务器最关键的部分）
3. 返回响应

服务端代码：

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
import java.util.Scanner;

public class UdpechoServer {
    //服务端
    DatagramSocket socket = null;
    public UdpechoServer (int port) throws SocketException {
        socket = new DatagramSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动了");
        while (true) {
            //存储字节大小为1024字节数组。
            DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);
            //接收数据
            socket.receive(packet);
            //将有效部分转化成字符串
            String receive = new String(packet.getData(), 0, packet.getLength());
            System.out.println("收到消息：" + receive);
            //根据输入回复
            String respose = poss(receive);
            //构建响应的数据报。并且传入目的端口和地址
            DatagramPacket resposePacket = new DatagramPacket(respose.getBytes(), respose.getBytes().length
                    , packet.getSocketAddress());

            socket.send(resposePacket);
            //打印日志
            System.out.printf("[%s:%d] req:%s resp:%s\n", packet.getAddress(), packet.getPort(), receive, respose);
        }

    }

    //处理请求的函数，根据需要进行调整;
    private String poss(String receive) {
        return receive;
    }

    public static void main(String[] args) throws IOException {
        UdpechoServer udpechoServer = new UdpechoServer(9090);
        udpechoServer.start();
    }
}

关键点解析：

1. 使用while(ture)是否会出现忙等问题？

当调用 socket.receive() 时，如果内核的 接收缓冲区（Receive Buffer) 中没有数据，应用程序的线程会被操作系统挂起（进入阻塞状态），并添加到该 Socket 的等待队列中。此时线程不会占用 CPU。。

2. 服务端的端口号如何设置？

服务端的端口号一般设置为一个固定值，这样服务端相当于一个固定的商户，而不是流动的小摊，客户可以根据这个地址一直找到你，如果你的地址一直在变化，客户怎么找到你？你总不能一直让客户去找你吧？

3. DatagramSocket 既然有close方法，是否需要关闭？

是否需要关闭需要考虑它的生命周期是怎样的，服务器一般是7*24小时的运行的，只要你开着它你就需要保持DatagramSocket 的开启状态，而如果你的服务器关闭了，进程结束时自然会关闭所有的资源，无需手动结束。

客户端代码：

import java.io.IOException;
import java.net.*;
import java.util.Scanner;

public class UdpEchoClient {
    //udp不会保存对方的ip和端口号，因此需要额外进行保存
    private DatagramSocket socket = null;
    private String ServerAdress = null;
    private  int ServerPort;
    public UdpEchoClient(String adress, int port) throws SocketException {
        this.ServerPort = port;
        this.ServerAdress = adress;
        //客户端的端口号随机生成一个空闲的就行。
        socket = new DatagramSocket();
    }
    public void start() throws IOException {
        while (true) {
            Scanner sc = new Scanner(System.in);
            System.out.print("请输入：");
            String input = sc.nextLine();
            //getByName是一个特殊的构造方法
            DatagramPacket packet = new DatagramPacket(input.getBytes(), input.getBytes().length,InetAddress.getByName(ServerAdress), ServerPort);
            socket.send(packet);
            //等待回复
            System.out.println("等待回复中...");
            DatagramPacket respose = new DatagramPacket(new byte[1024], 1024);
            socket.receive(respose);
            String s = new String(respose.getData(), 0, respose.getLength());
            System.out.println("回复：" + s);
        }
    }

    public static void main(String[] args) throws IOException {
        UdpEchoClient client = new UdpEchoClient("127.0.0.1", 9090);
        client.start();
    }
}

关键解析：

1. 客户端如何设置端口号以及ip地址？

此处的ip地址127.0.0.1是指向的本机，毕竟咱是在本地上部署的嘛~，因此服务器的ip地址就是本机。
客户端端口号不建议使用固定值，因为咱无法控制客户端的电脑，万一这个端口号被占用了呢？因此只需要随机找一个空闲的端口号即可。

2.这里的DatagramSocket 是否需要关闭？

按理说客户端的是需要关闭的，但是咱这里用的while(ture)，因此就没这个必要了。

运行结果
一定要先启动服务端再启动客户端！

TCP编程

方法

在JAVA中TCP协议使用ServerSocket创建一个服务端流套接字，并绑定到指定端口，作用：揽客，并把它交给Socket。

构造方法

核心方法

因为TCP协议是通过字节流进行读写的，因此在JAVA中有一个专门的类Socket来实现这个读写功能，但是和UDP不同的是他一次可能会接收到多个请求。

构造方法

核心方法

Socket和ServerSocket之间的关系

他们之间和UDP的关系不同，UDP的客户端和服务端都需要一个DatagramPacket来进行发送和接受数据。

而在TCP中，ServerSocket仅用于服务端的建立连接，发送和接受数据是通过Socket的字节流来进行的。

使用

接受信息

//服务端接受信息
ServerSocket Serversocket = new ServerSocket(9090);
Socket socket = Serversocket.accept();

try (InputStream inputStream = socket.getInputStream();
     OutputStream outputStream = socket.getOutputStream()) {
            //简化输入输出
            Scanner sc = new Scanner(inputStream);
            PrintWriter printWriter = new PrintWriter(outputStream);

            while (true) {
                if (!sc.hasNext()) {
                    break;
                }
                //获取输入
                String receive = sc.next();
                //处理数据
                String respose = "hello";
                //读写缓冲区
                printWriter.println(respose);
                //刷新缓冲区
                printWriter.flush();
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            socket.close();
        }

相比于UDP的发送与接收，TCP的流程要复杂的多。

讲解点1：读写数据

我们知道他们是通过字节流来进行读写的，因此我们在建立连接以后，只需要通过他们的输入输出流来进行操作，输入流是接受对方发送的数据，输出流是主动给对方发送数据。

此外我们不知道对方什么时候结束连接，因此需要我们使用while(ture)来一直进行判断。

讲解点2：try-resource-close

字节流使用完是需要进行关闭的，使用try()包裹内部的资源它在结束后会自动关闭，避免忘记手动关闭。

讲解点3：Scanner & PrintWriter

使用这两个类对输入输出流进行封装可以简化我们的读取操作，并且PrintWriter 的println方法在输出的时候还会帮我们加上\n，可以有效分割多次输入或输出的差别。

讲解点4：刷新缓冲区flush

当我们使用PrintWriter 的时候会出现一个问题，println仅仅是将数据发送了缓冲区内，并没有真正写入网卡中，这是因为JAVA在设计它的时候为了保证它的高效性，想让用户尽可能的多写入几次，再一起发送出去。

但是在这里它会造成我们的数据并没有实际发送出去，因此我们需要增添一个flush方法冲刷缓冲区到网卡中去。

讲解点5：长连接 & 短连接

所谓短连接就是一次连接只发送一次请求，长连接则是可以有多个请求，而TCP的连接明显是长连接的，建立一次连接客户端可以一直发送请求，直到对方断开连接。

发送信息

//需要传入地址和端口号
Socket socket = new Socket("127.0.0.1", 9090);
Scanner sc = new Scanner(System.in);
try (InputStream inputStream = socket.getInputStream();
     OutputStream outputStream = socket.getOutputStream()) {
    //简化输入输出
    Scanner scnet = new Scanner(inputStream);
    PrintWriter printWriter = new PrintWriter(outputStream);
    while (true) {
        String request = sc.next();
        //发送读入的数据
        printWriter.println(request);
        printWriter.flush();
        //返回的响应数据
        String respose = scnet.next();
        System.out.println(respose);
    }
} catch (IOException e) {
    throw new RuntimeException(e);
}

如果上一个理解了的话，这段代码应该不难理解，在这里的printWriter也是使用的println方法，这样可以约定双方的每一个请求以换行结束。

简单服务器实现

这里我们依然是一个回显服务器。

服务端代码：

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;

public class TcpEchoServer {
    ServerSocket Serversocket = null;

    TcpEchoServer (int port) throws IOException {
        Serversocket = new ServerSocket(port);
    }
    public void start() throws IOException {
        System.out.println("服务器启动了~");
        ExecutorService executorService = Executors.newCachedThreadPool();
        while (true) {
            Socket socket = Serversocket.accept();
            executorService.submit(()->{
                try {
                    processConnection(socket);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            });
        }
    }
    private void processConnection(Socket socket) throws IOException {
        System.out.printf("[%s:%d]客户端上线！\n", socket.getInetAddress(), socket.getPort());

        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()) {
            //简化输入输出
            Scanner sc = new Scanner(inputStream);
            PrintWriter printWriter = new PrintWriter(outputStream);

            while (true) {
                if (!sc.hasNext()) {
                    System.out.printf("[%s:%d]客户端下线！\n", socket.getInetAddress(), socket.getPort());
                    break;
                }
                //获取输入
                String receive = sc.next();
//                System.out.println("yes");
                //处理数据
                String respose = pross(receive);
                //读写缓冲区
                printWriter.println(respose);
                //刷新缓冲区
                printWriter.flush();
                //输出日志
                System.out.printf("[%s:%d] req:%s rep:%s\n",
                        socket.getInetAddress(), socket.getPort(), receive, respose);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            socket.close();
        }
    }
    private String pross(String receive) {
        return receive;
    }

    public static void main(String[] args) throws IOException {
        TcpEchoServer tcpEchoServer = new TcpEchoServer(9091);
        tcpEchoServer.start();
    }
}

客户端代码：

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class TcpEchoclient {
    Socket socket = null;

    public TcpEchoclient(String adress, int port) throws IOException {
        socket = new Socket(adress, port);
    }

    public void start() {
        //用户输入内容
        Scanner sc = new Scanner(System.in);
        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()) {
            //简化输入输出
            Scanner scnet = new Scanner(inputStream);
            PrintWriter printWriter = new PrintWriter(outputStream);
            while (true) {
                String request = sc.next();
                //发送读入的数据
                printWriter.println(request);
                printWriter.flush();
                //返回的响应数据
                String respose = scnet.next();
                System.out.println(respose);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) throws IOException {
        TcpEchoclient echoclient = new TcpEchoclient("127.0.0.1", 9091);
        echoclient.start();
    }
}

关键解析

1. 是否会出现忙等问题

这里的accept方法和UPD的类似，没有信息时也会进入阻塞等待。
而在另一个循环里面sc.hasNext()如果输入流中没有数据，但连接未关闭，hasNext() 也会阻塞（线程挂起），直到数据到达或流关闭。

2. 粘包问题

上述我们反复提到过TCP的这个问题，这里我们是通过println的换行符来对多个请求进行了分割。

除此之外，一点要记得关闭socket对象哦~

运行结果
运行顺序：先服务端再客户端。

多线程优化

通过这个代码不知道你有没有发现他并不支持多线程的操作？因为在服务端的代码里面它一次只能进行一次连接，只有这个连接断开的时候其他连接才有机会。

因此我们可以使用多线程的方法来解决这个问题：

public void start() throws IOException {
    System.out.println("服务器启动了~");
    while (true) {
        Socket socket = Serversocket.accept();
        Thread thread = new Thread(()->{
            try {
                processConnection(socket);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        });
        thread.start();
    }
}

使用多线程操作，每个客户端都独享一个线程。

但是每次都创建和销毁这个线程开销会比较大，因此我们可以在起基础上再使用线程池进行优化。

public void start() throws IOException {
    System.out.println("服务器启动了~");
    ExecutorService executorService = Executors.newCachedThreadPool();
    while (true) {
        Socket socket = Serversocket.accept();
        executorService.submit(()->{
            try {
                processConnection(socket);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        });
    }
}

如果客户端进一步增加达到1w或者100w，此时多线程/线程池，就会产生大量的线程，因此之后我们可以使用IO多路复用的方法来处理，感兴趣的可以自行了解。

感谢各位的观看Thanks♪(･ω･)ﾉ，创作不易，如果觉得有收获的话留个关注再走吧。