JavaEE初阶：网络编程套接字

一、网络编程基础

1、为什么需要网络编程

与本地打开视频文件类似，只是视频文件这个资源的来源是网络。
相比本地资源来说，网络提供了更为丰富的网络资源：
所谓的网络资源，其实就是在网络中可以获取的各种数据资源。
而所有的网络资源，都是通过网络编程来进行数据传输的。

2、什么是网络编程

网络编程，指网络上的主机，通过不同的进程，以编程的方式实现网络通信（或称为网络数据传输）。

进程具有隔离性（每个进程都有自己独立的虚拟地址空间）.
进程间通信，借助一个每个进程都能访问到的公共区域，完成数据交换.

网络编程，也就是一种进程 间通信的方式，借助的公共区域就是 网卡.（当下最主流的方式）

3、网络编程中的基本概念

① 发送端和接收端

发送端：数据的发送方进程，称为发送端。发送端主机即网络通信中的源主机。
接收端：数据的接收方进程，称为接收端。接收端主机即网络通信中的目的主机。
收发端：发送端和接收端两端，也简称为收发端。

注意：发送端和接收端只是相对的，只是一次网络数据传输产生数据流向后的概念。

② 请求和相应

请求：客户端给服务器发送的数据.
响应：服务器给客户端返回的数据.

③ 客户端和服务端

客户端：主动发送网络数据的一方.
服务器：被动接受网络数据的一方.

④ 常见的客户端服务端模型

1. 一问一答（最常见的方式，比如：浏览网页）
   客户端给服务器发一个请求
   服务器给客户端返回一个响应
2. 多问一答（更少见一些，比如：上传文件）
   客户端给服务器发多个请求
   服务器给客户端返回一个响应
3. 一问多答（不多不少，比如：下载文件）
   客户端给服务器发一个请求
   服务器给客户端返回多个响应
4. 多问多答（比如：远程控制，有些串流）
   客户端给服务器发多个请求
   服务器给客户端返回多个响应

二、Socket套接字

1、概念

Socket套接字，是由系统提供用于网络通信的技术，是基于TCP/IP协议的网络通信的基本操作单元。基于Socket套接字的网络程序开发就是网络编程。

2、分类

Socket套接字主要针对传输层协议划分为如下三类：
流套接字（TCP）、数据报套接字（UDP）、原始套接字.

① 流套接字（TCP）

TCP，即Transmission Control Protocol（传输控制协议），传输层协议。

TCP 特点：

• 有连接（打电话：先建立连接，然后再通信）
• 可靠传输（数据对方是否收到，发送方能够感知）
• 面向字节流
• 全双工（双向通信，一个管道，能 A->B，B->A 同时进行）

对于字节流来说，可以简单的理解为，传输数据是基于IO流，流式数据的特征就是在IO流没有关闭的情况下，是无边界的数据，可以多次发送，也可以分开多次接收。

② 数据报套接字（UDP）

UDP，即User Datagram Protocol（用户数据报协议），传输层协议。

UDP 特点：

• 无连接（发微信：不必建立连接，直接通信即可）
• 不可靠传输（数据对方是否收到，发送方无法感知）
• 面向数据报
• 全双工（单向通信，一个管道，同一时刻，要么 A->B，要么 B->A，不能同时进行）

对于数据报来说，可以简单的理解为，传输数据是一块一块的，发送一块数据假如100个字节，必须一次发送，接收也必须一次接收100个字节，而不能分100次，每次接收1个字节。

③ 原始套接字

原始套接字用于自定义传输层协议，用于读写内核没有处理的IP协议数据。
我们不学习原始套接字，简单了解即可。

三、UDP数据报套接字编程

1、DatagramSocket API

DatagramSocket：socke类，本质上相当于是一个 “文件”，在系统中，还有一种特殊的 socket 文件，对应到网卡设备.
构造一个 DatagramSocket 对象，就相当于是打开了一个 内核中的 socket 文件.

DatagramSocket 构造方法：

DatagramSocket 方法：

2、DatagramPacket API

DatagramPacket：表示一个 UDP 数据报，UDP 是面向数据报的协议，传输数据，就是以 DatagramPacket 为基本单位.

DatagramPacket 构造方法：

DatagramPacket 方法：

3、InetSocketAddress API

InetSocketAddress：IP 地址 + 端口号.

InetSocketAddress （ SocketAddress 的子类 ）构造方法：

4、示例一：一发一收（无响应）

① UDP服务端

package network;

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

public class UDP_demo1_Server {
    private DatagramSocket socket = null;

    public UDP_demo1_Server(int port) throws SocketException {
        socket = new DatagramSocket(port);
    }

    // 启动服务器
    public void start() throws IOException {
        System.out.println("服务器启动！");
        while (true) {
            // 1. 读取客户端发来的请求.
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);

            System.out.println("---------------------------------------------------");
            System.out.println("等待接收UDP数据报...");

            socket.receive(requestPacket);

            // 2. 对请求进行解析，把 DatagramPacket 转成一个 String
            String request = new String(requestPacket.getData(), 0, requestPacket.getLength());

            System.out.printf("IP: %s\n",requestPacket.getAddress().getHostAddress());
            System.out.printf("端口号: %s\n",requestPacket.getPort());
            System.out.printf("req: %s\n",request);
        }
    }

    public static void main(String[] args) throws IOException {
        // 真正启动服务器
        UDP_demo1_Server server = new UDP_demo1_Server(8000);
        server.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

② UDP客户端

package network;

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

public class UDP_demo1_Client {
    private DatagramSocket socket = null;

    public UDP_demo1_Client() throws SocketException {
        socket = new DatagramSocket();
    }

    public void start() throws IOException {
        Scanner scanner = new Scanner(System.in);
        while (true) {
            // 1. 让客户端从控制台读取一个请求数据.
            System.out.print("> ");
            String request = scanner.next();

            // 2. 把这个字符串请求发送给服务器，构造 DatagramPacket
            //    构造的 Packet 既要包含 要传输的数据，又要包含把数据发到哪里
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,
                    InetAddress.getByName("127.0.0.1"), 8000);

            // 3. 把数据报发给服务器.
            socket.send(requestPacket);
        }
    }

    public static void main(String[] args) throws IOException {
        UDP_demo1_Client client = new UDP_demo1_Client();
        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

5、示例二：请求响应

① UDP服务端

package network;

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

public class UDPEchoServer {
    // 要想创建 UDP 服务器，首先要先打开一个 socket 文件.
    private DatagramSocket socket = null;

    public UDPEchoServer(int port) throws SocketException {
        // 绑定一个端口：把这个进程和一个端口号，关联起来
        // 一个操作系统上，有很多端口号：0~65535
        // 端口号相当于用来在网络上区分进程的身份标识符

        // 分配端口号的过程：
        // 1. 程序员手动绑定
        // socket = new DatagramSocket(port);
        // 2. 系统自动分配（系统自动分配一个闲置的端口）
        // socket = new DatagramSocket();

        // 一个端口，在通常情况下，是不能被同一个主机上的多个进程同时绑定的
        // 如果同时绑定，就会抛出 SocketException 异常.
        socket = new DatagramSocket(port);
    }

    // 启动服务器
    public void start() throws IOException {
        System.out.println("服务器启动！");
        while (true) {
            // 1. 读取客户端发来的请求.
            // receive 是尝试读取，不是说调用了就一定能读取到！
            // 如果客户端没有发来请求，receive 就会阻塞等待.
            // receive 的参数属于输出型参数
            // 调用 receive 之前，需要构造一个空的 DatagramPacket
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);
            socket.receive(requestPacket);

            // 2. 对请求进行解析，把 DatagramPacket 转成一个 String
            String request = new String(requestPacket.getData(), 0, requestPacket.getLength());

            // 3. 根据请求，处理相应
            String response = process(request);

            // 4. 把响应构造成 DatagramPacket 对象.
            //    构造响应对象，要搞清楚，对象要发给谁，谁发的请求，就把响应发给谁
            //    response.getBytes().length 表示字节数
            //    response..length           表示字符数
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(), response.getBytes().length,
                    requestPacket.getSocketAddress());

            // 5. 把这个 DatagramPacket 对象 返回给客户端.
            socket.send(responsePacket);
            System.out.printf("[%s:%d] req=%s; resp=%s\n", requestPacket.getAddress().toString(), requestPacket.getPort(),
                    request, response);
        }
    }

    // 通过这个方法，实现根据请求计算响应 这个过程
    // 由于是回显服务器，所以不涉及其他逻辑
    // 但是如果是其他服务器，就可以在 process 里，加上其他逻辑处理
    public String process(String req) {
        return req;
    }

    public static void main(String[] args) throws IOException {
        // 真正启动服务器
        // 端口号 0~65535 随便写，但是一般来说 1024 一下的端口，都是系统保留.
        UDPEchoServer server = new UDPEchoServer(8000);
        server.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

② UDP客户端

package network;

import java.io.IOException;
import java.net.*;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

public class UDPEchoClient {
    private DatagramSocket socket = null;

    public UDPEchoClient() throws SocketException {
        // 客户端的端口号，一般都是由操作系统自动分配的
        // 虽然手动指定也许，习惯上还是自动分配比较好

        // ①服务器，端口一般是手动指定的
        //   如果自动分配，客户端就不知道服务器的端口是什么了！
        // ②客户端，端口一般是自动分配的
        //   客户端程序是安装在用户的电脑上的，用户电脑当前运行哪些程序，是不可控的
        //   如果手动指定端口号，说不定这个端口就和其他程序冲突了，代码就无法运行了
        socket = new DatagramSocket();
    }

    public void start() throws IOException {
        Scanner scanner = new Scanner(System.in);
        while (true) {
            // 1. 让客户端从控制台读取一个请求数据.
            System.out.print("> ");
            String request = scanner.next();

            // 2. 把这个字符串请求发送给服务器，构造 DatagramPacket
            //    构造的 Packet 既要包含 要传输的数据，又要包含把数据发到哪里
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,
                    InetAddress.getByName("127.0.0.1"), 8000);

            // 3. 把数据报发给服务器.
            socket.send(requestPacket);

            // 4. 从服务器读取响应数据
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
            socket.receive(responsePacket);

            // 5. 把响应的数据获取出来，转成字符串
            String response = new String(responsePacket.getData(), 0, responsePacket.getLength());

            System.out.printf("req: %s; resp: %s\n", request, response);
        }
    }

    public static void main(String[] args) throws IOException {
        UDPEchoClient client = new UDPEchoClient();
        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
44
45
46
47
48
49
50
51
52
53

四、TCP流套接字编程

1、ServerSocket API

ServerSocket 是创建 TCP 服务端 Socket 的 API.
accept 没有参数，返回值是一个 Socket 对象， 功能是等待有客户端和服务器建立上连接.
accept 则会把这个连接获取到进程中，进一步的通过返回值的 Socket 对象来和客户端进行交互

ServerSocket 构造方法：

ServerSocket 方法：

2、Socket API

Socket 是客户端Socket，或服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。
不管是客户端还是服务端 Socket，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据的。
这里的传输数据，不是直接通过 Socket 对象，而是 Socket 内部包含了输入流 对象（接收）输出流 对象（发送）。

Socket 构造方法：

Socket 方法：

3、TCP中的长短连接

短连接：每次接收到数据并返回响应后，都关闭连接，即是短连接。也就是说，短连接只能一次收发数据。
长连接：不关闭连接，一直保持连接状态，双方不停的收发数据，即是长连接。也就是说，长连接可以多次收发数据。

4、示例一：一发一收（长连接）

① TCP服务端

package network;

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 Tcp_demo1_Server {
    private ServerSocket serverSocket = null;

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

    public void start() throws IOException {
        System.out.println("服务器启动！");
        while (true) {
            Socket clientSocket = serverSocket.accept();
            processConnect(clientSocket);
        }
    }

    private void processConnect(Socket clientSocket) throws IOException {
        System.out.printf("[%s:%d] 建立连接！\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()) {
            Scanner scanner = new Scanner(inputStream);
            PrintWriter printWriter = new PrintWriter(outputStream);

            while (true) {
                if (!scanner.hasNext()) {
                    // 连接断开，当客户端断开连接的时候，此时 hasNext 就会返回 false
                    System.out.printf("[%s:%d] 断开连接！\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
                    break;
                }
                // 1. 读取请求并解析
                String request = scanner.next();

                // 2. 返回字符串
                String response = process(request);

                System.out.printf("[%s:%d] req: %s！\n",
                        clientSocket.getInetAddress().toString(), clientSocket.getPort(),
                        request);
            }
        }finally {
            clientSocket.close();
        }
    }

    public String process(String req) {
        return req;
    }

    public static void main(String[] args) throws IOException {
        Tcp_demo1_Server server = new Tcp_demo1_Server(8000);
        server.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

② TCP客户端

package network;

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 Tcp_demo1_Client {
    private Socket socket = null;

    public Tcp_demo1_Client() throws IOException {
        socket = new Socket("127.0.0.1", 8000);
    }

    public void start() throws IOException {
        // 由于实现的是长连接，一个连接会处理 N 个请求和响应
        Scanner scanner = new Scanner(System.in);
        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()) {
            Scanner scannerNet = new Scanner(inputStream);
            PrintWriter printWriter = new PrintWriter(outputStream);
            while (true) {
                // 1. 从控制台读取用户的输入.
                System.out.print("> ");
                String request = scanner.next();

                // 2. 把请求发送到服务器
                printWriter.println(request);
                printWriter.flush();

                // 3. 把结果显示到界面上
                System.out.printf("req: %s\n", request);
            }
        }
    }

    public static void main(String[] args) throws IOException {
        Tcp_demo1_Client client = new Tcp_demo1_Client();
        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

5、示例二：请求响应（长连接）

① TCP服务端

package network;

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 {
    private ServerSocket serverSocket = null;

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

    public void start() throws IOException {
        System.out.println("服务器启动！");
        while (true) {
            // accept 进行的工作，是拉客
            // 对于操作系统来说，建立 TCP 连接，是内核的工作.
            // accept 是等连接建立好了，把这个连接拿到 应用程序 中.
            // 如果当前连接还没有建立，accept 就会阻塞
            Socket clientSocket = serverSocket.accept();

            // 不再直接调用了，而是创建一个新的线程，让新线程来调用
            // processConnect(clientSocket);
            Thread t=new Thread(()->{
                try {
                    processConnect(clientSocket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
            t.start();
        }
    }

    // 通过这个方法，给当前连上的客户端，提供服务！
    // 一个连接过来了，服务方式可能有两种
    // 1. 一个连接只进行一次数据交互（一个请求+一个响应） 短连接
    // 2. 一个连接进行多次数据交互（N个请求+N个响应）    长连接
    // 此处我们来写长连接的版本
    private void processConnect(Socket clientSocket) throws IOException {
        System.out.printf("[%s:%d] 建立连接！\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()) {
            Scanner scanner = new Scanner(inputStream);
            PrintWriter printWriter = new PrintWriter(outputStream);

            // 这里是长连接的写法，需要通过 循环 来获取到多次交互的情况
            while (true) {
                if (!scanner.hasNext()) {
                    // 连接断开，当客户端断开连接的时候，此时 hasNext 就会返回 false
                    System.out.printf("[%s:%d] 断开连接！\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
                    break;
                }
                // 1. 读取请求并解析
                String request = scanner.next();

                // 2. 根据请求计算响应
                String response = process(request);

                // 3. 把响应写回给客户端
                printWriter.println(response);
                //    刷新一下缓冲区，避免数据没有真的发出去
                printWriter.flush();

                System.out.printf("[%s:%d] req: %s; resp: %s！\n",
                        clientSocket.getInetAddress().toString(), clientSocket.getPort(),
                        request, response);
            }
        }finally {
            // 加在这里是更稳妥的做法
            // clientSocket 用完之后，要关闭，clientSocket 和 ServerSocket 不同
            // ServerSocket 的生命周期，是跟随整个程序的！
            // clientSocket 的生命周期，只是当前连接！
            // 如果不关闭，就会造成资源泄漏
            // ServerSocket 只有一个; clientSocket 会有无数个：每个客户端的连接都是一个！
            clientSocket.close();
        }
    }

    public String process(String req) {
        return req;
    }

    public static void main(String[] args) throws IOException {
        TcpEchoServer server = new TcpEchoServer(8000);
        server.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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

② TCP客户端

package network;

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

public class TcpEchoClient {
    private Socket socket = null;

    public TcpEchoClient() throws IOException {
        // new 这个对象，需要和服务器建立连接
        // 要想建立连接，就得知道服务器在哪里！！
        socket = new Socket("127.0.0.1", 8000);
    }

    public void start() throws IOException {
        // 由于实现的是长连接，一个连接会处理 N 个请求和响应
        Scanner scanner = new Scanner(System.in);
        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()) {
            Scanner scannerNet = new Scanner(inputStream);
            PrintWriter printWriter = new PrintWriter(outputStream);
            while (true) {
                // 1. 从控制台读取用户的输入.
                System.out.print("> ");
                String request = scanner.next();

                // 2. 把请求发送到服务器
                printWriter.println(request);
                printWriter.flush();

                // 3. 从服务器读取响应
                String response = scannerNet.next();

                // 4. 把结果显示到界面上
                System.out.printf("req: %s; resp: %s\n", request, response);
            }
        }
    }

    public static void main(String[] args) throws IOException {
        TcpEchoClient client = new TcpEchoClient();
        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
44
45