Java——网络编程套接字

目录

一、网络编程基础

1.1 为什么需要网络编程？——丰富的网络资源

二、什么是网络编程?

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

3.2 请求和响应

 3.3 客户端和服务端

 常见的客户端服务端模型

四、Socket套接字

五、通信模型

5.1 Java数据报套接字通信模型

5.2 Java流套接字通信模型

 Socket编程注意事项

5.3 UDP数据报套接字编程

 示例一：

示例二：

---

一、网络编程基础

1.1 为什么需要网络编程？——丰富的网络资源

用户在浏览器中，打开在线视频网站，如优酷看视频，实质是通过网络，获取到网络上的一个视频资源。

与本地打开视频文件类似，只是视频文件这个资源的来源是网络。

相比本地资源来说，网络提供了更为丰富的网络资源：

所谓的网络资源，其实就是在网络中可以获取的各种数据资源。

而所有的网络资源，都是通过网络编程来进行数据传输的。

二、什么是网络编程?

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

当然，我们只要满足 进程 不同就行；所以即便是同一个主机，只要是不同进程，基于网络来传输数据， 也属于网络编程。

特殊的，对于开发来说，在条件有限的情况下，一般也都是在一个主机中运行多个进程来完成网络编程。

但是，我们一定要明确，我们的目的是提供网络上不同主机，基于网络来传输数据资源：

• 进程A：编程来获取网络资源
• 进程B：编程来提供网络资源

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

3.1  发送端和接收端

在一次网络数据传输时：

发送端 ：数据的 发送方进程 ，称为发送端。发送端主机即网络通信中的源主机。

接收端 ：数据的 接收方进程 ，称为接收端。接收端主机即网络通信中的目的主机。

收发端 ：发送端和接收端两端，也简称为收发端。

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

3.2 请求和响应

一般来说，获取一个网络资源，涉及到两次网络数据传输：

• 第一次：请求数据的发送
• 第二次：响应数据的发送。

好比在快餐店点一份炒饭：

先要发起请求：点一份炒饭，再有快餐店提供的对应响应：提供一份炒饭

 3.3 客户端和服务端

服务端 ：在常见的网络数据传输场景下，把 提供服务 的一方进程，称为服务端，可以提供对外服务。

客户端 ： 获取服务 的一方进程，称为客户端。

对于服务来说，一般是提供：

• 客户端获取服务资源
• 客户端保存资源在服务端

好比在银行办事：

银行提供存款服务：用户（客户端）保存资源（现金）在银行（服务端）

银行提供取款服务：用户（客户端）获取服务端资源（银行替用户保管的现金）

 常见的客户端服务端模型

最常见的场景，客户端是指给用户使用的程序，服务端是提供用户服务的程序：

1. 客户端先发送请求到服务端

2. 服务端根据请求数据，执行相应的业务处理

3. 服务端返回响应：发送业务处理结果

4. 客户端根据响应数据，展示处理结果（展示获取的资源，或提示保存资源的处理结果）

四、Socket套接字

概念

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

基于Socket套接字的网络程序开发就是网络编程。

分类

Socket 套接字主要针对传输层协议划分为如下三类：

4.1  流套接字 ：使用传输层 TCP 协议

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

以下为 TCP 的特点（细节后续再学习）：

• 有连接
• 可靠传输
• 面向字节流
• 有接收缓冲区，也有发送缓冲区
• 大小不限

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

4.2. 数据报套接字 ：使用传输层 UDP 协议

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

以下为 UDP 的特点（细节后续再学习）：

• 无连接
• 不可靠传输
• 面向数据报
• 有接收缓冲区，无发送缓冲区
• 大小受限：一次最多传输64k

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

4.3 原始套接字

原始套接字用于自定义传输层协议，用于读写内核没有处理的 IP 协议数据。

我们不学习原始套接字，简单了解即可。

五、通信模型

5.1 Java数据报套接字通信模型

对于 UDP 协议来说，具有无连接，面向数据报的特征，即每次都是没有建立连接，并且一次发送全部数据报，一次接收全部的数据报。

java 中使用 UDP 协议通信，主要基于 DatagramSocket 类来创建数据报套接字，并使用

DatagramPacket 作为发送或接收的 UDP 数据报。对于一次发送及接收 UDP 数据报的流程如下：

 

以上只是一次发送端的 UDP 数据报发送，及接收端的数据报接收，并没有返回的数据。也就是只有请求，没有响应。对于一个服务端来说，重要的是提供多个客户端的请求处理及响应，流程如下：

 

5.2 Java流套接字通信模型

 Socket编程注意事项

 

1. 客户端和服务端：开发时，经常是基于一个主机开启两个进程作为客户端和服务端，但真实的场

景，一般都是不同主机。

2. 注意目的 IP 和目的端口号，标识了一次数据传输时要发送数据的终点主机和进程

3. Socket 编程我们是使用流套接字和数据报套接字，基于传输层的 TCP 或 UDP 协议，但应用层协议，

也需要考虑，这块我们在后续来说明如何设计应用层协议。

4. 关于端口被占用的问题

如果一个进程 A 已经绑定了一个端口，再启动一个进程 B 绑定该端口，就会报错，这种情况也叫端

口被占用。对于 java 进程来说，端口被占用的常见报错信息如下：

 

此时需要检查进程B绑定的是哪个端口，再查看该端口被哪个进程占用。以下为通过端口号查进程的方式：

• 在cmd输入 netstat -ano | findstr 端口号 ，则可以显示对应进程的pid。如以下命令显

    示了 8888 进程的 pid

• 在任务管理器中，通过pid查找进程

 解决端口被占用的问题：

• 如果占用端口的进程A不需要运行，就可以关闭A后，再启动需要绑定该端口的进程B
• 如果需要运行A进程，则可以修改进程B的绑定端口，换为其他没有使用的端口。

5.3 UDP数据报套接字编程

DatagramSocket API

DatagramSocket 是 UDP Socket ，用于发送和接收 UDP 数据报。

DatagramSocket 构造方法：

 DatagramSocket 方法：

 DatagramPacket API

DatagramPacket 是 UDP Socket 发送和接收的数据报。

DatagramPacket 构造方法：

 DatagramPacket 方法：

 构造UDP发送的数据报时，需要传入 SocketAddress ，该对象可以使用 InetSocketAddress 来创

建。

InetSocketAddress API

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

 

示例一：

实现一个基于TCP的回显服务

客户端：

mport 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对象
    private Socket clientSocket;

    /**
     * 初始化客户端的Socket
     *
     * @param serverIp 服务器IP地址
     * @param serverPort 服务器的端口号
     * @throws IOException
     */
    public TCPEchoClient (String serverIp, int serverPort) throws IOException {
        this.clientSocket = new Socket(serverIp, serverPort);
    }

    public void start () throws IOException {
        System.out.println("客户端已启动...");
        // 获取Socket中的输入输出流
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()) {
            // 循环处理用户的输入
            while (true) {
                System.out.println("->");
                // 接收用户的输入内容
                Scanner requestScanner = new Scanner(System.in);
                String request = requestScanner.nextLine();
                // 发送用户的请求
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(request);
                // 强制刷新缓冲区
                printWriter.flush();
                // 接收服务器的响应
                Scanner responseScanner = new Scanner(inputStream);
                // 获取响应数据
                String response = responseScanner.nextLine();
                // 打印响应内容
                System.out.println("接收到服务器的响应：" + response);

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            clientSocket.close();
        }
    }

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

服务端：

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ProtocolException;
import java.net.ServerSocket;
import java.net.Socket;
import java.text.MessageFormat;
import java.util.Scanner;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 基于TCP的服务器程序

 * @Date 2023-05-23
 */
public class TCPEchoServer {
    // 声明一个用于服务端的Socket对象
    private ServerSocket server;

    /**
     * 通过指定端口号实例化服务
     *
     * @param port 端口号
     * @throws IOException
     */
    public TCPEchoServer(int port) throws IOException {
        if (port < 1025 || port > 65535) {
            throw new RuntimeException("端口号要在 1025 ~ 65535之间.");
        }
        // 实例化ServerSocket并指定端口号
        this.server = new ServerSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动成功...");
        // 创建一个线程池
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(3, 10, 1, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(10));
        // 循环接收客户端的连接
        while (true) {
            Socket clientSocket = server.accept();
            // 每接收到一个新连接请求，就创建一个新的子线程
//            Thread thread = new Thread(() -> {
//                // 处理Socket中的数据
//                try {
//                    processConnections(clientSocket);
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            });
//            // 启动线程
//            thread.start();

            // 提交任务到线程池中
            poolExecutor.submit(() -> {
                try {
                    processConnections(clientSocket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });

        }
    }

    // 处理数据
    private void processConnections(Socket clientSocket) throws IOException {
        // 打印日志
        String clientInfo = MessageFormat.format("[{0}:{1}] 客户端已上线", clientSocket.getInetAddress(),
                clientSocket.getPort());
        System.out.println(clientInfo);
        // 处理数据之前要获取一下输入输出流
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()) {
            // 循环处理用户的请求
            while (true) {
                // 通过Scanner读取用户请求中的数据
                Scanner requestScanner = new Scanner(inputStream);
                if (!requestScanner.hasNextLine()) {
                    // 日志
                    clientInfo = MessageFormat.format("[{0}:{1}] 客户端已下线.", clientSocket.getInetAddress(),
                            clientSocket.getPort());
                    System.out.println(clientInfo);
                    break;
                }
                // 获取真实的用户请求数据
                String request = requestScanner.nextLine();
                // 根据请求计算响应
                String response = process(request);
                // 把响应写回客户端
                PrintWriter printWriter = new PrintWriter(outputStream);
                // 写入输出流
                printWriter.println(response);
                // 强制刷新缓冲区
                printWriter.flush();
                // 打印日志
                clientInfo = MessageFormat.format("[{0}:{1}], request: {2}, response: {3}",
                        clientSocket.getInetAddress(), clientSocket.getPort(), request, response);
                System.out.println(clientInfo);

            }


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            clientSocket.close();
        }

    }

    private String process(String request) {
        System.out.println("收到新消息："  + request);
        Scanner scanner = new Scanner(System.in);
        String response = scanner.nextLine();
        return response;
    }

    public static void main(String[] args) throws IOException {
        TCPEchoServer server = new TCPEchoServer(9999);
        server.start();
    }
}

示例二：

实现一个基于UDP的回显服务：

客户端：

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

/**
 * @Date 2023-05-20
 */
public class UDPEchoClient {
    // 定义一个用于客户端的DatagramSocket
    private DatagramSocket client;
    // 定义服务器的IP地址
    private String serverIp;
    // 定义服务器的端口号
    private int port;
    private SocketAddress address;

    /**
     * 构造方法,指定服务器的Ip地址和端口号
     *
     * @param serverIp 服务器IP
     * @param port 端口号
     */
    public UDPEchoClient (String serverIp, int port) throws SocketException {
        this.client = new DatagramSocket();
        this.serverIp = serverIp;
        this.port = port;
        this.address = new InetSocketAddress(serverIp, port);
    }

    public void start () throws IOException {
        System.out.println("客户端已启动.");
        // 循环接收用户的输入
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.println("->");
            // 接收用户输入
            String request = scanner.next();
            // 1. 把请求内容包装成DatagramPacket
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(StandardCharsets.UTF_8),
                    request.getBytes().length, address);
            // 2. 发送数据
            client.send(requestPacket);
            // 3. 接收响应
            DatagramPacket responsePacket = new DatagramPacket(new byte[1024], 1024);
            // 4. 在receive方法中填充响应数据
            client.receive(responsePacket);
            // 5. 解析响应数据
            String response = new String(responsePacket.getData(), 0, responsePacket.getLength(), "UTF-8");
            // 6. 打印日志
            System.out.printf("request: %s, response: %s.\n", request, response);
        }
    }

    public static void main(String[] args) throws IOException {
        UDPEchoClient client = new UDPEchoClient("127.0.0.1", 9999);
        // 启动服务
        client.start();
    }

}

服务端：

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.nio.charset.StandardCharsets;

/**
 * UDP 回显服务器
 *
 * @Date 2023-05-20
 */
public class UDPEchoServer {
    // 定义一个用于服务器端的DatagramSocket
    private DatagramSocket server;

    /**
     * 构造方法，完成服务器的初始化
     * @param port 端口号
     */
    public UDPEchoServer (int port) throws Exception {
        if (port > 65535 || port < 1024) {
            throw new Exception("端口号必须在1024 ~ 65535之间");
        }
        // 初始化服务器端的UDP服务
        this.server = new DatagramSocket(port);
    }

    /**
     * 对外提供服务
     */
    public void start () throws IOException {
        System.out.println("服务器已启动....");
        // 循环接收用户的请求
        while (true) {
            // 1. 创建一个用于接收请求数据的DatagramPacket
            DatagramPacket requestPacket = new DatagramPacket(new byte[1024], 1024);
            // 2. 接收请求, 把真实的内容填充到requestPacket
            server.receive(requestPacket);
            // 3. 从requestPacket获取数据
            String request = new String(requestPacket.getData(), 0, requestPacket.getLength(), "UTF-8");
            // 4. 根据请求获取响应
            String response = processor (request);
            // 5. 把响应封装到DatagramPacket
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(StandardCharsets.UTF_8),
                    response.getBytes().length, requestPacket.getSocketAddress());
            // 6. 发送数据
            server.send(responsePacket);
            // 7. 打印日志
            System.out.printf("[%s:%d] request: %s, response: %s.\n", requestPacket.getAddress().toString(),
                    requestPacket.getPort(), request, response);
        }

    }

    public String processor(String request) {
        return request;
    }

    public static void main(String[] args) throws Exception {
        // 初始化服务器
        UDPEchoServer server = new UDPEchoServer(9999);
        // 启动服务
        server.start();
    }

}

简单的字典功能

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

/**
 * @Date 2023-05-20
 */
public class UDPDictServer extends UDPEchoServer{
    private Map<String, String> map = new HashMap<>();
    /**
     * 构造方法，完成服务器的初始化
     *
     * @param port 端口号
     */
    public UDPDictServer(int port) throws Exception {
        super(port);
        // 初始化字典内容
        map.put("dog", "小狗");
        map.put("cat", "小猫");
        map.put("pig", "小猪");
        map.put("tiger", "大老虎");
        map.put("veryGood", "牛P");
    }

    @Override
    public String processor(String request) {
        return map.getOrDefault(request, "查无此词");
    }

    public static void main(String[] args) throws Exception {
        UDPDictServer server = new UDPDictServer(9999);
        server.start();
    }
}