装饰模式

装饰模式详解

装饰模式（Decorator Pattern）是一种结构型设计模式，它允许在不改变对象自身的情况下，动态地给一个对象添加一些额外的职责。装饰模式提供了一种灵活的替代方案来扩展功能，通常用于遵循开闭原则（对扩展开放，对修改关闭）。

主要组成部分

组件接口（Component）：
- 定义一个对象接口，可以给这些对象动态地添加职责。
具体组件（ConcreteComponent）：
- 实现了组件接口的具体对象，装饰者将对其进行装饰。
装饰者（Decorator）：
- 也是实现了组件接口的抽象类，持有一个组件对象的引用，并定义了与组件接口一致的接口。
具体装饰者（ConcreteDecorator）：
- 继承自装饰者，负责给具体组件添加额外的职责。

工作原理

装饰模式通过将一个对象嵌套在另一个对象中来实现功能的扩展。具体步骤如下：

创建一个实现了组件接口的具体组件。
创建一个装饰者类，持有对具体组件的引用。
在装饰者中实现组件接口的方法，并在其中调用具体组件的方法，同时添加额外的功能。
可以通过多个装饰者层叠使用，以实现更复杂的功能组合。

示例

以下是一个简单的示例，展示了如何使用装饰模式来扩展一个文本的功能：

// 组件接口
interface Text {
    String getContent();
}

// 具体组件
class PlainText implements Text {
    private String content;

    public PlainText(String content) {
        this.content = content;
    }

    public String getContent() {
        return content;
    }
}

// 装饰者
abstract class TextDecorator implements Text {
    protected Text text;

    public TextDecorator(Text text) {
        this.text = text;
    }

    public String getContent() {
        return text.getContent();
    }
}

// 具体装饰者
class BoldDecorator extends TextDecorator {
    public BoldDecorator(Text text) {
        super(text);
    }

    public String getContent() {
        return "<b>" + super.getContent() + "</b>";
    }
}

class ItalicDecorator extends TextDecorator {
    public ItalicDecorator(Text text) {
        super(text);
    }

    public String getContent() {
        return "<i>" + super.getContent() + "</i>";
    }
}

// 示例用法
public class Main {
    public static void main(String[] args) {
        Text text = new PlainText("Hello, world!");
        Text boldText = new BoldDecorator(text);
        Text boldItalicText = new ItalicDecorator(boldText);

        System.out.println(boldItalicText.getContent());
    }
}

优点

灵活性：可以在运行时动态添加或删除装饰。
遵循开闭原则：可以通过添加新的装饰者来扩展功能，而不需要修改现有代码。
组合性：可以通过组合多个装饰者来实现复杂的功能。

缺点

复杂性：使用装饰模式可能会导致代码结构变得复杂，尤其是当装饰者层次较多时。
调试困难：由于装饰者的嵌套，调试可能会变得更加困难。

适用场景

当需要在不改变对象结构的情况下，给对象添加额外的功能时。
当需要动态地组合多个功能时。
当希望使用多个小类来实现功能的扩展，而不是使用一个大类时。

装饰模式是一种强大的设计模式，可以帮助开发者以灵活和可扩展的方式管理对象的功能。

网络编程

IP地址

IP地址（Internet Protocol Address）是用于在网络上唯一标识主机或设备的地址。IP地址分为IPv4和IPv6两种版本，IPv4地址由32位二进制数表示，通常以点分十进制表示，如192.168.1.1；IPv6地址由128位二进制数表示，通常以冒号分隔的八组十六进制数表示，如2001:0db8:85a3:0000:0000:8a2e:0370:7334。

IP地址组成

网络地址：标识网络的部分，用于在网络中路由数据包。
主机地址：标识网络中的主机或设备。

详解网络协议

TCP（Transmission Control Protocol）

TCP（传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层协议。TCP通过三次握手建立连接，提供数据传输的可靠性和有序性，以及拥塞控制和流量控制等机制。TCP适用于对数据传输的可靠性要求较高的场景，如文件传输、网页访问等。

UDP（User Datagram Protocol）

UDP（用户数据报协议）是一种无连接的、不可靠的传输层协议。UDP不保证数据传输的可靠性和有序性，也不提供拥塞控制和流量控制等机制，但具有传输速度快的优点。UDP适用于对实时性要求较高、数据丢失可以容忍的场景，如音频、视频流传输等。

在网络编程中，开发者可以根据实际需求选择使用TCP或UDP协议来进行数据通信，以满足不同场景下的需求。

详解 Socket

Socket（套接字）是计算机网络中用于实现网络通信的一种机制。它提供了一种标准的接口，使得应用程序能够通过网络进行数据的发送和接收，可以提供双向安全链接的通信服务。

Socket 的工作原理

Socket 基于客户端-服务器模型，其中客户端和服务器通过网络进行通信。Socket 的工作原理如下：

服务器创建一个 Socket，并绑定到一个特定的 IP 地址和端口上。
客户端创建一个 Socket，并连接到服务器的 IP 地址和端口。
服务器接受客户端的连接请求，并创建一个新的 Socket 与客户端进行通信。
客户端和服务器通过各自的 Socket 进行数据的发送和接收。
通信完成后，客户端和服务器关闭各自的 Socket。

Socket 的类型

Socket 可以分为两种类型：流式 Socket（Stream Socket）和数据报式 Socket（Datagram Socket）。

流式 Socket：基于 TCP 协议，提供可靠的、面向连接的通信。流式 Socket 提供了一个字节流接口，数据按照顺序传输，保证数据的可靠性和有序性。
数据报式 Socket：基于 UDP 协议，提供不可靠的、无连接的通信。数据报式 Socket 以数据报（Datagram）为单位进行传输，不保证数据的可靠性和有序性，但具有传输速度快的优点。

Java实现Socket通信

在Java中，可以使用Socket类和ServerSocket类来实现Socket通信。Socket类用于客户端，ServerSocket类用于服务器端。以下是实现Socket通信的基本过程：

客户端实现Socket通信：
- 创建一个Socket对象，指定服务器的IP地址和端口号。
- 通过Socket对象获取输入流和输出流，用于与服务器进行数据交换。
- 通过输出流向服务器发送数据。
- 通过输入流从服务器接收数据。
- 关闭Socket对象。
服务器端实现Socket通信：
- 创建一个ServerSocket对象，指定服务器监听的端口号。
- 调用ServerSocket的accept()方法接受客户端的连接，返回一个Socket对象。
- 通过Socket对象获取输入流和输出流，用于与客户端进行数据交换。
- 通过输出流向客户端发送数据。
- 通过输入流从客户端接收数据。
- 关闭Socket对象和ServerSocket对象。

常用方法

在Java中，Socket类和ServerSocket类提供了一些常用的方法来实现Socket通信，以下是其中一些常用方法：

Socket类常用方法：
- Socket(String host, int port): 创建一个Socket对象，连接到指定主机和端口。
- getInputStream(): 获取Socket的输入流，用于从Socket接收数据。
- getOutputStream(): 获取Socket的输出流，用于向Socket发送数据。
- close(): 关闭Socket连接。
ServerSocket类常用方法：
- ServerSocket(int port): 创建一个ServerSocket对象，监听指定端口。
- accept(): 接受客户端的连接，返回一个Socket对象。
- getInputStream(): 获取ServerSocket的输入流，用于从客户端接收数据。
- getOutputStream(): 获取ServerSocket的输出流，用于向客户端发送数据。
- close(): 关闭ServerSocket连接。

以下是使用Java实现客户端和服务端的Socket通信的示例代码：

// 服务端代码
import java.io.*;
import java.net.*;

public class Server {
    public static void main(String[] args) {
        try {
            // 创建ServerSocket对象，指定端口号
            ServerSocket serverSocket = new ServerSocket(8888);
            
            System.out.println("等待客户端连接...");
            
            // 监听客户端的连接请求
            Socket clientSocket = serverSocket.accept();
            
            System.out.println("客户端已连接：" + clientSocket.getInetAddress().getHostAddress());
            
            // 创建输入流和输出流
            BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
            
            // 读取客户端发送的数据
            String message = in.readLine();
            System.out.println("客户端发送的消息：" + message);
            
            // 向客户端发送响应
            out.println("Hello, Client!");
            
            // 关闭流和Socket连接
            in.close();
            out.close();
            clientSocket.close();
            serverSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// 客户端代码
import java.io.*;
import java.net.*;

public class Client {
    public static void main(String[] args) {
        try {
            // 创建Socket对象，指定服务器的IP地址和端口号
            Socket socket = new Socket("localhost", 8888);
            
            // 创建输入流和输出流
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
            
            // 向服务器发送消息
            out.println("Hello, Server!");
            
            // 读取服务器的响应
            String response = in.readLine();
            System.out.println("服务器的响应：" + response);
            
            // 关闭流和Socket连接
            in.close();
            out.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上述示例中，服务端通过创建ServerSocket对象并指定端口号来监听客户端的连接请求。一旦有客户端连接成功，就会创建一个新的Socket对象与客户端进行通信。服务端通过输入流和输出流来接收和发送数据。

客户端通过创建Socket对象并指定服务器的IP地址和端口号来连接到服务端。客户端也通过输入流和输出流来接收和发送数据。

注意：在运行示例代码之前，需要先运行服务端代码，然后再运行客户端代码。

对象流

在Socket通信中，发送对象需要进行序列化和反序列化操作。序列化是将对象转换为字节流的过程，而反序列化是将字节流转换为对象的过程。Java中可以使用ObjectOutputStream和ObjectInputStream来实现对象的序列化和反序列化。

以下是使用Socket发送对象的基本步骤：

创建一个Socket对象，并指定服务器的IP地址和端口号。
创建一个ObjectOutputStream对象，并使用它的writeObject()方法将要发送的对象写入输出流。
创建一个ObjectInputStream对象，并使用它的readObject()方法从输入流中读取对象。
关闭输入流、输出流和Socket连接。

以下是一个示例代码，演示了如何使用Socket发送和接收对象：

// 服务端代码
import java.io.*;
import java.net.*;

public class Server {
    public static void main(String[] args) {
        try {
            // 创建ServerSocket对象，指定端口号
            ServerSocket serverSocket = new ServerSocket(8888);
            
            System.out.println("等待客户端连接...");
            
            // 监听客户端的连接请求
            Socket clientSocket = serverSocket.accept();
            
            System.out.println("客户端已连接：" + clientSocket.getInetAddress().getHostAddress());
            
            // 创建输入流和输出流
            ObjectInputStream in = new ObjectInputStream(clientSocket.getInputStream());
            ObjectOutputStream out = new ObjectOutputStream(clientSocket.getOutputStream());
            
            // 读取客户端发送的对象
            Object object = in.readObject();
            System.out.println("客户端发送的对象：" + object);
            
            // 向客户端发送响应对象
            out.writeObject("Hello, Client!");
            
            // 关闭流和Socket连接
            in.close();
            out.close();
            clientSocket.close();
            serverSocket.close();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

// 客户端代码
import java.io.*;
import java.net.*;

public class Client {
    public static void main(String[] args) {
        try {
            // 创建Socket对象，指定服务器的IP地址和端口号
            Socket socket = new Socket("localhost", 8888);
            
            // 创建输入流和输出流
            ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
            ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
            
            // 创建要发送的对象
            String message = "Hello, Server!";
            
            // 向服务器发送对象
            out.writeObject(message);
            
            // 读取服务器的响应对象
            Object response = in.readObject();
            System.out.println("服务器的响应：" + response);
            
            // 关闭流和Socket连接
            in.close();
            out.close();
            socket.close();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

在上述示例中，服务端和客户端都使用ObjectInputStream和ObjectOutputStream来进行对象的读写操作。服务端通过输入流读取客户端发送的对象，客户端通过输出流发送对象给服务端。注意，发送的对象需要实现Serializable接口，以便进行序列化和反序列化操作。

在实际开发中，可以根据需要自定义需要发送的对象，并在对象中实现Serializable接口。

序列化与反序列化

序列化

序列化是将对象转换为字节流的过程，使得对象可以在网络上传输或者持久化到磁盘中。在Java中，实现序列化的对象需要实现Serializable接口，该接口是一个标记接口，没有需要实现的方法。通过实现Serializable接口，对象的状态可以被保存并传输。

反序列化

反序列化是将字节流转换为对象的过程，将之前序列化的对象恢复为内存中的对象。在Java中，反序列化需要使用ObjectInputStream类来读取字节流并将其转换为对象。

示例代码

以下是一个简单的示例代码，演示了如何对一个自定义类进行序列化和反序列化：

import java.io.*;

// 自定义类实现Serializable接口
class Person implements Serializable {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class SerializationExample {
    public static void main(String[] args) {
        // 序列化对象到文件
        try (ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
            Person person = new Person("Alice", 30);
            outputStream.writeObject(person);
            System.out.println("对象序列化成功");
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 反序列化对象
        try (ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("person.ser"))) {
            Person person = (Person) inputStream.readObject();
            System.out.println("对象反序列化成功");
            System.out.println("反序列化的对象：" + person);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

在上述示例中，Person类实现了Serializable接口，使得对象可以被序列化。在main方法中，首先将一个Person对象序列化到文件person.ser中，然后再从文件中反序列化该对象并打印出来。

运行示例代码后，可以看到对象成功序列化和反序列化的输出结果。序列化和反序列化过程可以帮助在网络通信或数据持久化时传输和保存对象的状态。

使用多线程处理多客户端请求

在网络编程中，通常会遇到需要同时处理多个客户端请求的情况。为了有效处理多客户端请求，可以使用多线程来实现并发处理。下面是使用多线程处理多客户端请求的基本步骤：

创建服务器端Socket对象：首先需要创建一个ServerSocket对象，并指定服务器端口号。
监听客户端连接：通过ServerSocket的accept()方法监听客户端的连接请求，一旦有客户端连接成功，就会返回一个Socket对象。
为每个客户端请求创建一个线程：对于每个客户端连接，都需要创建一个新的线程来处理该客户端的请求。这样可以实现多个客户端请求的并发处理。
线程处理客户端请求：在线程中处理客户端的请求和响应，包括读取客户端发送的数据、处理数据、发送响应等操作。
关闭连接：在处理完客户端请求后，需要关闭与该客户端的连接。

下面是一个简单的示例代码，演示了如何使用多线程处理多客户端请求：

import java.io.*;
import java.net.*;

public class MultiThreadedServer {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(8888);
            System.out.println("服务器已启动，等待客户端连接...");

            while (true) {
                Socket clientSocket = serverSocket.accept();
                System.out.println("客户端已连接：" + clientSocket.getInetAddress().getHostAddress());

                // 为每个客户端连接创建一个新线程
                Thread clientThread = new Thread(new ClientHandler(clientSocket));
                clientThread.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    static class ClientHandler implements Runnable {
        private Socket clientSocket;

        public ClientHandler(Socket clientSocket) {
            this.clientSocket = clientSocket;
        }

        @Override
        public void run() {
            try {
                BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);

                String message = in.readLine();
                System.out.println("客户端发送的消息：" + message);

                // 模拟处理客户端请求
                String response = "Hello, Client!";
                out.println(response);

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

在上述示例中，MultiThreadedServer类创建了一个ServerSocket对象，并在一个无限循环中监听客户端连接。每当有客户端连接成功，就会创建一个新的线程ClientHandler来处理该客户端的请求。ClientHandler类实现了Runnable接口，其中的run()方法用于处理客户端请求和响应。

通过使用多线程处理多客户端请求，可以实现并发处理，提高服务器的性能和吞吐量。在实际开发中，可以根据需要对线程池、同步机制等进行进一步优化，以确保多线程处理多客户端请求的安全性和效率。

DatagramPacket 和 DatagramSocket

DatagramPacket

DatagramPacket 是 Java 中用于表示数据包的类，它包含了数据、数据的长度、发送方和接收方的地址信息等。DatagramPacket 可以用于在 UDP 协议下进行数据的发送和接收。

主要属性

数据：DatagramPacket 中包含的数据内容。
数据长度：数据的长度。
发送方地址和端口：发送方的 IP 地址和端口号。
接收方地址和端口：接收方的 IP 地址和端口号。

使用方法

构造方法：可以通过构造方法传入数据、数据长度、发送方地址和端口、接收方地址和端口等信息。
获取数据：通过 getData() 方法获取数据内容。
获取数据长度：通过 getLength() 方法获取数据长度。
获取发送方地址和端口：通过 getAddress() 和 getPort() 方法获取发送方的地址和端口。
获取接收方地址和端口：通过 getAddress() 和 getPort() 方法获取接收方的地址和端口。

DatagramPacket常用方法

构造方法
- DatagramPacket(byte[] buf, int length, InetAddress address, int port): 创建一个DatagramPacket对象，指定数据、数据长度、目标地址和端口。
- DatagramPacket(byte[] buf, int length): 创建一个DatagramPacket对象，指定数据和数据长度，用于接收数据。
获取方法
- getData(): 获取DatagramPacket中的数据。
- getLength(): 获取DatagramPacket中数据的长度。
- getAddress(): 获取DatagramPacket的目标地址。
- getPort(): 获取DatagramPacket的目标端口。
设置方法
- setData(byte[] buf): 设置DatagramPacket中的数据。
- setLength(int length): 设置DatagramPacket中数据的长度。
- setAddress(InetAddress address): 设置DatagramPacket的目标地址。
- setPort(int port): 设置DatagramPacket的目标端口。
其他方法
- setData(byte[] buf, int offset, int length): 设置DatagramPacket中的数据和数据长度，可以指定偏移量和长度。

DatagramPacket实例代码

以下是一个简单的Java示例代码，演示了如何使用DatagramPacket发送和接收数据：

import java.net.*;

public class DatagramExample {
    public static void main(String[] args) {
        try {
            // 创建DatagramSocket对象，指定端口号
            DatagramSocket socket = new DatagramSocket(8888);

            // 发送数据
            String message = "Hello, Datagram!";
            byte[] sendData = message.getBytes();
            InetAddress address = InetAddress.getByName("localhost");
            int port = 9999;
            DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, address, port);
            socket.send(sendPacket);
            System.out.println("Sent message: " + message);

            // 接收数据
            byte[] receiveData = new byte[1024];
            DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
            socket.receive(receivePacket);
            String receivedMessage = new String(receivePacket.getData(), 0, receivePacket.getLength());
            System.out.println("Received message: " + receivedMessage);

            // 关闭Socket连接
            socket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在上述示例中，首先创建了一个DatagramSocket对象，并指定端口号。然后通过DatagramPacket对象发送数据到指定的地址和端口，以及接收从指定地址和端口发送过来的数据。最后关闭了Socket连接。

这个示例展示了如何使用DatagramPacket的构造方法、发送和接收数据的方法。

DatagramSocket

DatagramSocket 是 Java 中用于实现 UDP 协议的套接字类，它可以用于发送和接收数据包。DatagramSocket 是基于无连接的、不可靠的数据传输方式，适用于对实时性要求较高、数据丢失可以容忍的场景。

主要功能

发送数据包：DatagramSocket 可以通过 send() 方法发送数据包。
接收数据包：DatagramSocket 可以通过 receive() 方法接收数据包。
绑定端口：可以通过 bind() 方法绑定端口。
关闭连接：可以通过 close() 方法关闭连接。

使用方法

创建 DatagramSocket：通过构造方法创建 DatagramSocket 对象。
发送数据包：通过 send() 方法发送数据包，需要传入 DatagramPacket 对象和目标地址信息。
接收数据包：通过 receive() 方法接收数据包，会返回一个 DatagramPacket 对象。
绑定端口：通过 bind() 方法绑定端口。
关闭连接：通过 close() 方法关闭连接。

在网络编程中，DatagramPacket 和 DatagramSocket 是实现 UDP 数据传输的重要类，通过它们可以实现 UDP 协议下的数据发送和接收操作。

DatagramSocket常用方法详解

DatagramSocket 类是 Java 中用于实现 UDP 协议的套接字类，提供了一些常用方法来实现 UDP 数据报的发送和接收。以下是 DatagramSocket 类的常用方法：

构造方法
- DatagramSocket(): 创建一个未绑定到任何本地地址和端口的 DatagramSocket 对象。
- DatagramSocket(int port): 创建一个绑定到指定端口的 DatagramSocket 对象。
发送数据报
- void send(DatagramPacket p): 发送指定的数据报。
接收数据报
- void receive(DatagramPacket p): 接收数据报，将接收到的数据存储在指定的数据报中。
关闭套接字
- void close(): 关闭 DatagramSocket 对象。
设置超时时间
- void setSoTimeout(int timeout): 设置接收数据超时时间，单位为毫秒。
绑定本地地址和端口
- void bind(SocketAddress addr): 将 DatagramSocket 绑定到指定的本地地址和端口。
获取本地端口
- int getLocalPort(): 获取 DatagramSocket 绑定的本地端口。

DatagramSocket实例代码示例

以下是一个简单的示例代码，演示了如何使用 DatagramSocket 类来实现 UDP 数据报的发送和接收：

服务端代码

import java.net.*;

public class UDPServer {
    public static void main(String[] args) {
        try {
            // 创建DatagramSocket对象，绑定到指定端口
            DatagramSocket serverSocket = new DatagramSocket(8888);
            
            byte[] receiveData = new byte[1024];
            
            // 创建DatagramPacket对象，用于接收数据
            DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
            
            System.out.println("等待客户端发送数据...");
            
            // 接收客户端发送的数据
            serverSocket.receive(receivePacket);
            
            String receivedMessage = new String(receivePacket.getData(), 0, receivePacket.getLength());
            System.out.println("客户端发送的数据：" + receivedMessage);
            
            // 向客户端发送响应数据
            InetAddress clientAddress = receivePacket.getAddress();
            int clientPort = receivePacket.getPort();
            String responseMessage = "Hello, Client!";
            byte[] sendData = responseMessage.getBytes();
            DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, clientAddress, clientPort);
            
            serverSocket.send(sendPacket);
            
            // 关闭DatagramSocket
            serverSocket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

客户端代码

import java.net.*;

public class UDPClient {
    public static void main(String[] args) {
        try {
            // 创建DatagramSocket对象
            DatagramSocket clientSocket = new DatagramSocket();
            
            InetAddress serverAddress = InetAddress.getByName("localhost");
            int serverPort = 8888;
            String message = "Hello, Server!";
            byte[] sendData = message.getBytes();
            
            // 创建DatagramPacket对象，用于发送数据
            DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, serverAddress, serverPort);
            
            // 发送数据到服务端
            clientSocket.send(sendPacket);
            
            byte[] receiveData = new byte[1024];
            
            // 创建DatagramPacket对象，用于接收服务端响应数据
            DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
            
            // 接收服务端响应数据
            clientSocket.receive(receivePacket);
            
            String responseMessage = new String(receivePacket.getData(), 0, receivePacket.getLength());
            System.out.println("服务端响应：" + responseMessage);
            
            // 关闭DatagramSocket
            clientSocket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在上述示例中，服务端通过 DatagramSocket 接收客户端发送的数据报，并向客户端发送响应数据报。客户端通过 DatagramSocket 向服务端发送数据报，并接收服务端的响应数据报。注意，在运行示例代码之前，需要先运行服务端代码，然后再运行客户端代码。

使用 DatagramSocket 实现 UDP 协议

在 Java 中，可以使用 DatagramSocket 和 DatagramPacket 类来实现 UDP（User Datagram Protocol）协议的通信。UDP 是一种无连接的、不可靠的传输层协议，适用于对实时性要求较高、数据丢失可以容忍的场景。

以下是使用 DatagramSocket 实现 UDP 协议通信的基本步骤：

创建一个 DatagramSocket 对象，指定本地端口号。
创建一个 DatagramPacket 对象，用于发送和接收数据。
发送数据时，将数据填充到 DatagramPacket 中，并使用 DatagramSocket 的 send() 方法发送。
接收数据时，创建一个空的 DatagramPacket，用于接收数据，并使用 DatagramSocket 的 receive() 方法接收数据。
关闭 DatagramSocket。

以下是一个简单的示例代码，演示了如何使用 DatagramSocket 实现 UDP 协议的通信：

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UDPServer {
    public static void main(String[] args) {
        try {
            // 创建 DatagramSocket 对象，指定端口号
            DatagramSocket serverSocket = new DatagramSocket(9876);

            byte[] receiveData = new byte[1024];

            // 创建空的 DatagramPacket 用于接收数据
            DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);

            System.out.println("等待客户端发送数据...");

            // 接收客户端发送的数据
            serverSocket.receive(receivePacket);

            String clientMessage = new String(receivePacket.getData(), 0, receivePacket.getLength());
            System.out.println("客户端发送的数据：" + clientMessage);

            // 获取客户端的地址和端口号
            InetAddress clientAddress = receivePacket.getAddress();
            int clientPort = receivePacket.getPort();

            // 发送响应数据给客户端
            String serverMessage = "Hello, Client!";
            byte[] sendData = serverMessage.getBytes();
            DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, clientAddress, clientPort);
            serverSocket.send(sendPacket);

            // 关闭 DatagramSocket
            serverSocket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UDPClient {
    public static void main(String[] args) {
        try {
            // 创建 DatagramSocket 对象
            DatagramSocket clientSocket = new DatagramSocket();

            // 定义服务器的地址和端口号
            InetAddress serverAddress = InetAddress.getByName("localhost");
            int serverPort = 9876;

            // 发送数据给服务器
            String message = "Hello, Server!";
            byte[] sendData = message.getBytes();
            DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, serverAddress, serverPort);
            clientSocket.send(sendPacket);

            byte[] receiveData = new byte[1024];

            // 创建空的 DatagramPacket 用于接收服务器的响应
            DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);

            // 接收服务器的响应
            clientSocket.receive(receivePacket);

            String serverResponse = new String(receivePacket.getData(), 0, receivePacket.getLength());
            System.out.println("服务器的响应：" + serverResponse);

            // 关闭 DatagramSocket
            clientSocket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在上述示例中，UDPServer 类作为服务器端，创建了一个 DatagramSocket 对象来监听指定端口，接收客户端发送的数据，并向客户端发送响应数据。UDPClient 类作为客户端，创建了一个 DatagramSocket 对象来发送数据给服务器，并接收服务器的响应数据。

在运行示例代码之前，先运行 UDPServer 类作为服务器端，然后再运行 UDPClient 类作为客户端。这样可以模拟 UDP 协议的通信过程。

通过 DatagramSocket 和 DatagramPacket 类，可以实现简单而高效的 UDP 协议通信。

InetAddress 和 URL

InetAddress

InetAddress 类表示互联网协议（IP）地址，它提供了一些方法来获取主机名、IP 地址等信息。InetAddress 类没有公共构造函数，而是通过静态方法来获取 InetAddress 实例。

常用方法

getByName(String host)：根据主机名获取 InetAddress 实例。
getHostAddress()：获取 IP 地址的字符串表示。
getHostName()：获取主机名。
getLocalHost()：获取本地主机的 InetAddress 实例。

URL

URL 类表示统一资源定位符，它用于标识互联网上的资源。URL 包含了协议、主机名、端口号、路径等信息。可以通过 URL 类来打开连接、读取数据等操作。

常用方法

openConnection()：打开 URL 的连接。
openStream()：打开 URL 的输入流。
getProtocol()：获取 URL 的协议。
getHost()：获取 URL 的主机名。
getPath()：获取 URL 的路径。

实例代码

使用 InetAddress 获取主机名和 IP 地址

import java.net.InetAddress;
import java.net.UnknownHostException;

public class InetAddressExample {
    public static void main(String[] args) {
        try {
            InetAddress address = InetAddress.getByName("www.google.com");
            System.out.println("Host Name: " + address.getHostName());
            System.out.println("IP Address: " + address.getHostAddress());
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}

使用 URL 打开连接并读取数据

import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class URLExample {
    public static void main(String[] args) {
        try {
            URL url = new URL("https://www.example.com");
            BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream()));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在上述示例中，第一个示例展示了如何使用 InetAddress 类获取指定主机名的 IP 地址。第二个示例展示了如何使用 URL 类打开连接并读取网页内容。

If you find the article useful, feel free to appreciate

Java基础（十一）

https://blog.mykele.asia/archives/javaji-chu-shi-yi

Author

kele

Published on

2024-09-10

Updated on

2024-09-12

License

CC BY 4.0

Java基础（十一）

装饰模式

装饰模式详解

主要组成部分

工作原理

示例

优点

缺点

适用场景

网络编程

IP地址

IP地址组成

详解网络协议

TCP（Transmission Control Protocol）

UDP（User Datagram Protocol）

详解 Socket

Socket 的工作原理

Socket 的类型

Java实现Socket通信

常用方法

对象流

序列化与反序列化

序列化

反序列化

示例代码

使用多线程处理多客户端请求

DatagramPacket 和 DatagramSocket

DatagramPacket

主要属性

使用方法

DatagramPacket常用方法

DatagramPacket实例代码

DatagramSocket

主要功能

使用方法

DatagramSocket常用方法详解

DatagramSocket实例代码示例

服务端代码

客户端代码

使用 DatagramSocket 实现 UDP 协议

InetAddress 和 URL

InetAddress

常用方法

URL

常用方法

实例代码

使用 InetAddress 获取主机名和 IP 地址

使用 URL 打开连接并读取数据

Author

Published on

Updated on

License

Comments