1.计算机网络

IP

• 定义与作用 ：IP 地址是在网络中用于标识设备的数字标签，它允许网络中的设备之间相互定位和通信。每一个设备在特定网络环境下都有一个唯一的 IP 地址，以此来确定其在网络中的位置。

• 分类 ：常见的 IP 地址分为 IPv4 和 IPv6。

• IPv4 地址是一个 32 位的二进制数，通常被分为 4 个字节，表示为十进制形式，如 192.168.1.1。

• 由于 IPv4 地址数量有限，逐渐出现了 IPv6 地址， 它是128 位的二进制数，通常表示为 8 组 16 进制数，如 2001:0db8:85a3:0000:0000:8a2e:0370:7334。

端口

• 定义与作用 ：端口是操作系统中的一个抽象概念，用于区分同一设备上运行的不同程序。在 TCP/IP 协议族中，端口号是一个 16 位的数字，范围从 0 到 65535。当数据到达设备后，系统会根据端口号将数据转发给对应的程序进行处理。

• 分类 ：端口可以分为三大类。

• 一类是熟知端口（0 - 1023），这些端口通常被系统服务所使用，如 HTTP 协议使用 80 端口，HTTPS 协议使用 443 端口等。

• 另一类是注册端口（1024 - 49151），这些端口可以被用户进程或应用程序使用，但需要在相关机构进行注册。

• 还有一类是动态和 / 或私有端口（49152 - 65535），这些端口可以自由使用，通常用于临时会话或应用程序内部通信。

TCP/UDP 传输协议

• TCP 协议

  • 特点 ：TCP（Transmission Control Protocol，传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议。它在正式通信之前需要建立连接，如同打电话之前先拨号建立通话线路一样。在数据传输过程中，TCP 通过三次握手建立连接，确保双方都准备好数据进行传输。并且它采用流量控制、拥塞控制等机制，能够有效避免网络拥塞和数据丢失。

  • 应用场景 ：适用于对数据准确性要求高、数据传输量较大的场景，如文件传输、邮件传输、网页浏览等。

• UDP 协议

  • 特点 ：UDP（User Datagram Protocol，用户数据报协议）是一种无连接的传输层协议。它不建立连接就直接发送数据，数据传输就像是直接投递一封信，不考虑对方是否准备好接收。UDP 不保证的数据可靠传输，数据可能会丢失、重复或乱序到达。不过，UDP 的传输速度相对较快，因为它不需要进行繁琐的连接建立和维护过程。

  • 应用场景 ：适用于对实时性要求高、对数据丢失不太敏感的场景，如视频直播、在线游戏、实时语音通信等。

服务器与客户端

• 服务器

  • 定义与作用 ：服务器是网络环境中的高性能计算机或设备，它运行特定的服务器软件，为客户端提供各种服务和资源。

  • 工作原理 ：服务器通常会一直保持监听状态，等待客户端的连接请求。当收到请求后，服务器会根据请求的内容和协议进行相应的处理，并将处理结果返回给客户端。为了确保能够同时处理多个客户端的请求，服务器通常会采用多线程、多进程或异步 IO 等技术。

• 客户端

  • 定义与作用 ：客户端是用户直接使用并与服务器进行交互的设备或软件。它向服务器发送请求，并接收服务器返回的响应。

  • 工作原理 ：客户端一般需要知道服务器的 IP 地址和端口号，通过建立与服务器的连接，按照特定的协议格式发送请求消息。在接收到服务器的响应后，客户端会对响应进行解析和处理，以实现用户期望的功能。

IO 模型

• 同步 IO 模型

  • 阻塞 IO ：阻在塞 IO 模型下，客户端调用 IO 操作后会一直阻塞，直到操作完成并返回结果。例如，在文件读取操作中，如果采用阻塞 IO，那么在读取文件内容的过程中，程序会暂停执行，等待文件读取完成才能继续向下执行。这种方式的缺点是资源利用率较低，因为线程或进程在等待 IO 完成期间无法进行其他工作。

  • 非阻塞 IO ：非阻塞 IO 模型与阻塞 IO 不同，它在调用 IO 操作时会立即返回，不会一直等待操作完成。但需要客户端不断轮询 IO 操作的状态，直到操作完成。例如，客户端发送一个非阻塞的网络请求后，会不断地询问操作系统这个请求是否完成，这种方式会增加 CPU 的负担，因为需要不断地进行轮询操作。

• 异步 IO 模型

  • 特点 ：异步 IO 模型是基于事件通知机制的。客户端发起 IO 操作后，会立即返回，操作系统会在 IO 操作完成时主动通知客户端。这样客户端可以在等待 IO 完成期间继续执行其他任务，提高了资源的利用率。例如，在网页浏览器中，当用户点击一个按钮触发一个异步请求时，浏览器可以继续响应用户的其他操作，如滚动页面等，而不会被这个请求所阻塞。

  • 优势 ：可以提高程序的并发能力和响应速度，特别适用于高并发的场景，如 Web 服务器处理大量客户端请求时，采用异步 IO 能够更有效地利用系统资源，提高服务器的性能。

通信架构模式

• C/S 架构（Client/Server 架构）

  • 特点 ：C/S 架构是一种基于请求 - 响应模式的架构。客户端负责与用户交互，将用户请求发送给服务器；服务器负责处理客户端请求，并将处理结果返回给客户端。这种架构需要在客户端安装专门的客户端软件，如银行的客户端应用程序、企业的内部办公软件等。

  • 优点 ：客户端软件可以提供丰富的用户界面和交互功能，能够对硬件资源进行充分利用，同时可以更好地控制数据的安全性和完整性。

  • 缺点 ：客户端软件的安装和维护成本较高，当需要进行软件升级时，需要对所有客户端进行更新。并且客户端对服务器的依赖性较强，服务器的性能和稳定性直接影响到整个系统的运行。

• B/S 架构（Browser/Server 架构）

  • 特点 ：B/S 架构是基于浏览器和服务器的架构。客户端只需要安装浏览器，通过浏览器访问服务器上的 Web 应用程序。服务器负责处理所有请求和业务逻辑，并返回相应的网页给客户端进行展示。例如，各种在线购物网站、社交媒体平台等都是基于 B/S 架构的。

  • 优点 ：客户端无需安装专门的软件，只要能够访问网络并打开浏览器即可使用。软件的升级和维护只需要在服务器端进行，降低了维护成本和复杂度。并且具有很好的兼容性和跨平台性，可以在不同的操作系统和设备上使用。

  • 缺点 ：相比 C/S 架构，B/S 架构下的网页应用在用户交互和界面体验方面可能会受到浏览器的限制。同时，服务器端的负载相对较大，需要处理大量的请求和业务逻辑。

2.核心API

Socket

• 定义与作用 ：Socket（套接字）是网络通信中的一种抽象概念，它是网络通信过程中的一个端点，用于实现不同设备之间的双向通信。通过 Socket，应用程序可以在网络中进行数据的发送和接收，就好像在设备之间建立了一条虚拟的通信管道。

• 使用流程 ：对于 TCP Socket，客户端先创建 Socket，然后连接到服务器的特定端口和 IP 地址；服务器端创建 Socket，绑定到本地的某个端口和 IP 地址，开始监听连接请求，接收客户端连接后，双方就可以通过 Socket 进行数据的读写操作。对于 UDP Socket，不需要建立连接，客户端和服务器端都可以直接发送和接收数据报。

ServerSocket

• 定义与作用 ：ServerSocket 是服务器端用于监听和接受客户端连接请求的套接字。它在服务器端等待客户端的连接，当客户端请求连接时，ServerSocket 会接受请求并创建一个新的 Socket 来与客户端进行通信，从而实现服务器与多个客户端的同时通信。

• 工作原理 ：ServerSocket 绑定到本地的某个端口，然后开始监听该端口的连接请求。当客户端发送连接请求时，ServerSocket 会接受这个请求，并返回一个与客户端通信的 Socket 对象。服务器端可以通过这个 Socket 对象与客户端进行数据的读写操作，而 ServerSocket 则继续监听该端口，等待其他客户端的连接请求。

DNS 域名解析服务器

• 定义与作用 ：DNS（Domain Name System）域名解析服务器是用于将域名转换为 IP 地址的服务器。在互联网中，用户通常使用域名来访问网站，而计算机之间通信需要使用 IP 地址。DNS 服务器的作用就是将用户输入的域名解析为对应的 IP 地址，使得用户可以通过域名方便地访问网站。

• 工作原理 ：当用户在浏览器中输入一个域名时，浏览器会首先向本地 DNS 服务器发送域名解析请求。本地 DNS 服务器会先在自己的缓存中查找该域名对应的 IP 地址，如果找到则直接返回给浏览器；如果没有找到，本地 DNS 服务器会向根 DNS 服务器发送请求，根 DNS 服务器会根据域名的顶级域名（如.com、.net 等）返回相应的顶级域名服务器的地址，本地 DNS 服务器再向顶级域名服务器发送请求，顶级域名服务器会根据域名的二级域名返回相应的权威 DNS 服务器的地址，本地 DNS 服务器最后向权威 DNS 服务器发送请求，权威 DNS 服务器会返回该域名对应的 IP 地址，本地 DNS 服务器将这个 IP 地址缓存起来并返回给浏览器，浏览器就可以使用这个 IP 地址来访问网站了。

InputStream

• 定义与作用 ：InputStream 是 Java 中的一个输入流类，它用于从源读取字节数据。源可以是文件、网络连接、内存缓冲区等。InputStream 是所有字节输入流的父类，它提供了一组基本的方法用于读取数据，如 read() 方法用于读取单个字节，read(byte[] b) 方法用于将数据读入一个字节数组等。

• 常见子类与特点

  • FileInputStream ：用于从文件中读取数据。它可以打开一个文件进行读取，读取到文件末尾时返回 - 1 表示结束。

  • BufferedInputStream ：对其他输入流进行缓冲处理，提高读取效率。它通过内部维护一个缓冲区，减少对底层数据源的读取次数，从而提高读取速度。

  • ObjectInputStream ：用于读取 Java 对象序列化的数据。它可以将序列化的对象从输入流中还原为 Java 对象，前提是该对象的类实现了 Serializable 接口。

OutputStream

• 定义与作用 ：OutputStream 是 Java 中的一个输出流类，它用于将字节数据写入目标。目标可以是文件、网络连接、内存缓冲区等。OutputStream 是所有字节输出流的父类，它提供了一组基本的方法用于写入数据，如 write(int b) 方法用于写入单个字节，write(byte[] b) 方法用于将字节数组中的数据写入输出流等。

• 常见子类与特点

  • FileOutputStream ：用于将数据写入文件。它可以创建一个新文件或追加数据到现有文件中。

  • BufferedOutputStream ：对其他输出流进行缓冲处理，提高写入效率。它通过内部维护一个缓冲区，减少对底层数据目标的写入次数，从而提高写入速度。

  • ObjectOutputStream ：用于将 Java 对象序列化后写入输出流。它可以将 Java 对象转换为字节流序列，便于存储或传输，前提是该对象的类实现了 Serializable 接口。

3.代码

服务器端代码（MyChatServer）

服务器启动

public class MyChatServer {
    public static void main(String[] args) {
        try {
            // 创建服务器套接字，监听端口12000
            ServerSocket serverSocket = new ServerSocket(12000);
            System.out.println("服务器启动，等待客户端连接......");

• ServerSocket：用于监听特定端口的传入连接请求。

• serverSocket.accept()：阻塞等待客户端连接，直到有客户端连接时返回一个Socket对象。

处理客户端连接

            // 接受客户端连接
            Socket socket = serverSocket.accept();
            System.out.println("客户端已连接：" + socket.getInetAddress() + ":" + socket.getPort());

• socket.getInetAddress()：获取客户端的IP地址。

• socket.getPort()：获取客户端的端口号。

获取输入输出流

            // 获取输入输出流
            InputStream is = socket.getInputStream();
            OutputStream os = socket.getOutputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); // 从控制台读取消息
            BufferedReader serverIn = new BufferedReader(new InputStreamReader(is)); // 读取客户端消息

• socket.getInputStream()：获取输入流，用于读取客户端发送的数据。

• socket.getOutputStream()：获取输出流，用于向客户端发送数据。

• BufferedReader：用于从控制台或输入流读取文本数据。

通信循环

            System.out.println("等待客户端消息......");

            while (true) {
                // 读取客户端发送的消息
                int messageLength = is.read();  // 读取消息长度
                byte[] messageBuffer = new byte[messageLength];
                for (int i = 0; i < messageBuffer.length; i++) {
                    messageBuffer[i] = (byte) is.read();
                }
                String clientMessage = new String(messageBuffer);
                System.out.println("收到客户端消息：" + clientMessage);

                // 检查是否是退出命令
                if ("exit".equalsIgnoreCase(clientMessage)) {
                    System.out.println("客户端已断开连接");
                    break;
                }

                // 从控制台读取要发送给客户端的消息
                System.out.print("请输入要发送的消息：");
                String serverMessage = br.readLine();

                // 发送消息给客户端
                os.write(serverMessage.getBytes().length);  // 发送消息长度
                os.write(serverMessage.getBytes());  // 发送消息内容
                os.flush();

                // 检查是否是退出命令
                if ("exit".equalsIgnoreCase(serverMessage)) {
                    System.out.println("服务器将断开连接");
                    break;
                }
            }

• 服务器首先读取消息的长度，然后根据长度读取消息内容。

• 消息以字节数组的形式传输，然后转换为字符串。

• 如果收到"exit"消息，服务器将退出通信循环。

• 服务器从控制台读取消息，并将其发送给客户端。

• 消息发送前，先发送消息长度，以便客户端知道要读取多少字节。

关闭资源

            // 关闭资源
            br.close();
            os.close();
            is.close();
            socket.close();
            serverSocket.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

• 逐个关闭资源，确保没有资源泄漏。

完整代码

public class MyChatServer {
    public static void main(String[] args) {
        try {
            // 创建服务器套接字，监听端口12000
            ServerSocket serverSocket = new ServerSocket(12000);
            System.out.println("服务器启动，等待客户端连接......");

            // 接受客户端连接
            Socket socket = serverSocket.accept();
            System.out.println("客户端已连接：" + socket.getInetAddress() + ":" + socket.getPort());

            // 获取输入输出流
            InputStream is = socket.getInputStream();
            OutputStream os = socket.getOutputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); // 从控制台读取消息
            BufferedReader serverIn = new BufferedReader(new InputStreamReader(is)); // 读取客户端消息

            System.out.println("等待客户端消息......");

            while (true) {
                // 读取客户端发送的消息
                int messageLength = is.read();
                byte[] messageBuffer = new byte[messageLength];
                for (int i = 0; i < messageBuffer.length; i++) {
                    messageBuffer[i] = (byte) is.read();
                }
                String clientMessage = new String(messageBuffer);
                System.out.println("收到客户端消息：" + clientMessage);

                // 检查是否是退出命令
                if ("exit".equalsIgnoreCase(clientMessage)) {
                    System.out.println("客户端已断开连接");
                    break;
                }

                // 从控制台读取要发送给客户端的消息
                System.out.print("请输入要发送的消息：");
                String serverMessage = br.readLine();

                // 发送消息给客户端
                os.write(serverMessage.getBytes().length);
                os.write(serverMessage.getBytes());
                os.flush();

                // 检查是否是退出命令
                if ("exit".equalsIgnoreCase(serverMessage)) {
                    System.out.println("服务器将断开连接");
                    break;
                }
            }

            // 关闭资源
            br.close();
            os.close();
            is.close();
            socket.close();
            serverSocket.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端代码（ChatClient）

连接到服务器

public class ChatClient {
    public static void main(String[] args) {
        try {
            // 连接到服务器
            Socket socket = new Socket("127.0.0.1", 12000);
            System.out.println("客户端已连接到服务器");

• Socket：用于建立与服务器的连接。

• "127.0.0.1"：本地主机IP地址，表示客户端和服务器在同一台机器上。

• 12000：服务器监听的端口号。

获取输入输出流

            // 获取输入输出流
            InputStream is = socket.getInputStream();
            OutputStream os = socket.getOutputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); // 从控制台读取消息

• 客户端同样需要获取输入输出流，用于与服务器通信。

通信循环

            System.out.println("等待服务器消息......");

            while (true) {
                // 从控制台读取要发送的消息
                System.out.print("请输入要发送的消息：");
                String clientMessage = br.readLine();

                // 发送消息给服务器
                os.write(clientMessage.getBytes().length);  // 发送消息长度
                os.write(clientMessage.getBytes());  // 发送消息内容
                os.flush();

                // 检查是否是退出命令
                if ("exit".equalsIgnoreCase(clientMessage)) {
                    System.out.println("客户端将断开连接");
                    break;
                }

                // 读取服务器的响应消息
                int messageLength = is.read();  // 读取消息长度
                byte[] messageBuffer = new byte[messageLength];
                for (int i = 0; i < messageBuffer.length; i++) {
                    messageBuffer[i] = (byte) is.read();
                }
                String serverMessage = new String(messageBuffer);
                System.out.println("收到服务器消息：" + serverMessage);

                // 检查是否是退出命令
                if ("exit".equalsIgnoreCase(serverMessage)) {
                    System.out.println("服务器已断开连接");
                    break;
                }
            }

• 客户端的通信逻辑与服务器类似，先发送消息，然后等待服务器的响应。

• 如果收到"exit"消息，客户端将退出通信循环。

关闭资源

            // 关闭资源
            br.close();
            os.close();
            is.close();
            socket.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

完整代码

public class ChatClient {
    public static void main(String[] args) {
        try {
            // 连接到服务器
            Socket socket = new Socket("127.0.0.1", 12000);
            System.out.println("客户端已连接到服务器");

            // 获取输入输出流
            InputStream is = socket.getInputStream();
            OutputStream os = socket.getOutputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); // 从控制台读取消息

            System.out.println("等待服务器消息......");

            while (true) {
                // 从控制台读取要发送的消息
                System.out.print("请输入要发送的消息：");
                String clientMessage = br.readLine();

                // 发送消息给服务器
                os.write(clientMessage.getBytes().length);
                os.write(clientMessage.getBytes());
                os.flush();

                // 检查是否是退出命令
                if ("exit".equalsIgnoreCase(clientMessage)) {
                    System.out.println("客户端将断开连接");
                    break;
                }

                // 读取服务器的响应消息
                int messageLength = is.read();
                byte[] messageBuffer = new byte[messageLength];
                for (int i = 0; i < messageBuffer.length; i++) {
                    messageBuffer[i] = (byte) is.read();
                }
                String serverMessage = new String(messageBuffer);
                System.out.println("收到服务器消息：" + serverMessage);

                // 检查是否是退出命令
                if ("exit".equalsIgnoreCase(serverMessage)) {
                    System.out.println("服务器已断开连接");
                    break;
                }
            }

            // 关闭资源
            br.close();
            os.close();
            is.close();
            socket.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这个示例展示了一个基本的客户端-服务器Socket通信模型。服务器监听特定端口，客户端连接到该端口，双方可以通过输入输出流互相发送和接收消息。消息传输时，先发送消息长度，然后发送消息内容，这样可以确保接收方能够完整地读取消息。

效果展示