【JavaEE】网络编程---TCP数据报套接字编程

一、TCP数据报套接字编程

1.1 ServerSocket API

ServerSocket 是创建TCP服务端Socket的API
ServerSocket 构造方法：

ServerSocket 方法：

1.2 Socket API

Socket 是客户端Socket，或服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。不管是客户端还是服务端Socket，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据的。
Socket 构造方法：

Socket 方法：

通过上述字节流对象进行数据传输：
从InputStream读数据就相当于从网卡接收
从OutputStream写数据就相当于从网卡发送

1.3 短连接和长连接

短连接：一次连接只有一个请求
长连接：一次连接有多个请求

1.4 示例一：回显服务器（echo server）

这里我们演示长连接：

1.4.1 Tcp服务器

package Tcp;

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

public class TcpEchoServer {
    //serverSocket是外场拉客的小哥,serverSocket有且只有一个
    //cilentSocket是内场服务的小姐姐，cilentSocket会给每个客户端分配一个
    private ServerSocket serverSocket = null;

    public TcpEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动！");
        while(true) {
            Socket cilentSocket = serverSocket.accept();
            processConnection(cilentSocket);  //连接后通过processConnection来处理连接
        }
    }

    //通过这个方法来处理一个连接:
    //1.读取请求
    //2.根据请求计算响应
    //3.把响应返回给客户端
    private void processConnection(Socket clientSocket) throws IOException {
        System.out.printf("[%s:%d] 客户端上线!\n", clientSocket.getInetAddress().toString(),
                clientSocket.getPort());  //提示客户端上线并打印IP地址和端口号
        //try()这种写法，允许括号中写多个流对象，中间使用“；”来分割
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()) {
            Scanner scanner = new Scanner(inputStream);  //为了读取请求方便，把字节流转为字符流
            PrintWriter printWriter = new PrintWriter(outputStream); //为了返回响应方便，把字节流转为字符流

            //我们读到哪里算是一个完整的请求呢；
            //此处做一个简单的约定：
            //每个请求是个字符串（文本数据），每个请求之间使用\n来分割,不要忘记响应也要这样约定

            while(true) {  //长连接：一次连接有多个请求
                //1.读取请求
                if (!scanner.hasNext()) {  //如果客户端关闭连接了，hasNext返回false,结束while循环
                    System.out.printf("[%s:%d] 客户端下线！\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());  //提示客户端下线并打印IP地址和端口号
                    break;
                }
                    //如果没有读完，直接使用scanner读取一段字符串
                String request = scanner.next();  //next会往后一直读直到读到空白符（空格、换行符、制表符、翻页符等）结束（不包含空白符）。此处尽量不要使用nextLine
                //2.根据请求计算响应
                String response = process(request);  //通过process方法来处理请求并返回响应
                //3.把响应返回给客户端(不要忘记响应里面也是要带上换行的，方便客户端区分从哪里到哪里是一个响应)
                printWriter.println(response);

                System.out.printf("[%s:%d] req:%s ; resp:%s \n",clientSocket.getInetAddress().toString(),
                        clientSocket.getPort(),request,response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            clientSocket.close();  //这里的cilentSocket只是给一个连接提供帮助，所以要及时释放
        }
    }

    private String process(String request) {
        return request;
    }

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

注意：如果没有客户端连接时，accept是会阻塞的

1.4.2 Tcp客户端

package Tcp;

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 {
    private Socket socket = null;
    private void TcpEchoServer(String serverIP, int port) throws IOException {
        //这个操作就相当于让客户端和服务端建立Tcp连接了
        socket = new Socket(serverIP,port);
    }

    public void start() throws IOException {
        Scanner scanner = new Scanner(System.in);
        try (InputStream inputStreamt = socket.getInputStream(); OutputStream outputStream = socket.getOutputStream()){
            PrintWriter printWriter = new PrintWriter(outputStream);
            Scanner scanner1 = new Scanner(inputStreamt);

            while (true) {
                //1.从键盘上读取用户输入的内容
                System.out.println("->");
                String request = scanner.next();
                //2.把输入的内容构造成请求并发送给服务器（对应服务器的接收）
                    //注意这里发送的请求带有换行
                printWriter.println(request);
                //3.从服务器读取相应内容
                String response = scanner1.next();
                //4.把响应结果显示在控制台上
                System.out.printf("req: %s; resp: %s\n", request, response);
            }
        }
    }

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

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

我们运行发现：


此时服务器已经启动且客户端也上线了，我们输入的请求为什么没有响应呢？
我们服务器这里的代码：



在这两个地方加上就可以正常运行了：


这样子我们的代码貌似没什么问题了
可是这里还有一个很严重的bug:咱们的服务器一次只能给一个客户端提供服务！！
在idea中默认只能启动一个客户端，我们需要稍微设置一下：

此时可以有两个客户端：

但是我们发现只有一个客户端上线了：

在第一个客户端输入正常，第二个没有任何响应：

当前服务器无法服务多个客户端！！！===》代码bug

怎么解决这个问题呢？

我们希望能够该客户端1提供循环服务的同时又能够循环的调用accept

我们对服务器代码的start函数做如下改变：

public void start() throws IOException {
        System.out.println("服务器启动！");
        while(true) {
            Socket cilentSocket = serverSocket.accept();
            // 如果直接调用, 该方法会影响这个循环的二次执行, 导致 accept 不及时了.
            // 创建新的线程, 用新线程来调用 processConnection
            // 每次来一个新的客户端都搞一个新的线程即可
            Thread t = new Thread(() -> {
                try {
                    processConnection(cilentSocket);  //连接后通过processConnection来处理连接
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            });
            t.start();
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

此时服务器便可同时处理多个客户端：