网络编程

发表于 分类于 本文字数： 6.1k
TCP、UDP协议的基本实现

TCP

客户端发送消息

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
try {
    Socket socket = new Socket("localhost", 7171);

    // 与客户端通信的输出流
    OutputStream outputStream = socket.getOutputStream();
    // 编码转换
    OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputStream, StandardCharsets.UTF_8);
    // 字符缓冲流包装
    BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter);

    // 读取键盘输入的消息
    Scanner scanner = new Scanner(System.in);

    while (true) {
        String text = scanner.nextLine();
        // 逐行输入
        bufferedWriter.write(text);
        bufferedWriter.newLine();
        bufferedWriter.flush();

        if ("exit".equals(text))
            break;
    }

    socket.close();
} catch (IOException e) {
    throw new RuntimeException(e);
}

服务端接收消息

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
try {
    // 在服务端创建套接字
    ServerSocket serverSocket = new ServerSocket(7171);
    System.out.println("等待客户端连接");
    // 等待客户端连接
    Socket socket = serverSocket.accept();
    System.out.println("客户端连接成功");

    // 获取来自客户端的输入流
    InputStream inputStream = socket.getInputStream();
    // 编码转换
    InputStreamReader inputStreamReader = new InputStreamReader(inputStream, StandardCharsets.UTF_8);
    // 字符缓冲流包装
    BufferedReader bufferedReader = new BufferedReader(inputStreamReader);

    while (true) {
        // 逐行读取
        String text = bufferedReader.readLine();
        System.out.println("收到客户端消息: " + text);

        if ("exit".equals(text))
            break;
    }

    serverSocket.close();
} catch (IOException e) {
    throw new RuntimeException(e);
}

UDP

单播

发送消息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
try {
    // 目标端口号
    int port = 3000;

    // 消息内容
    String text = "hello";
    byte[] bytes = text.getBytes(StandardCharsets.UTF_8);

    // 消息目标地址
    InetAddress inetAddress = InetAddress.getByName("192.168.110.116");
    // 封装要发送的数据
    DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length, inetAddress, port);

    // 负责传递数据报的套接字（自动绑定到本机随机可用端口）
    DatagramSocket datagramSocket = new DatagramSocket();
    // 发送数据报
    datagramSocket.send(datagramPacket);

    // 释放
    datagramSocket.close();
} catch (IOException e) {
    throw new RuntimeException(e);
}

接收消息

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
try {
    // 接收数据报的端口号
    int port = 3000;

    // 数据报缓冲区
    byte[] buffer = new byte[1024];
    // 封装接收的数据
    DatagramPacket datagramPacket = new DatagramPacket(buffer, buffer.length);

    // 负责传递数据报的套接字
    DatagramSocket datagramSocket = new DatagramSocket(port);
    // 接收数据报
    datagramSocket.receive(datagramPacket);

    // 接收到的数据报，经测试data数组其实就是buffer数组的引用
    byte[] data = datagramPacket.getData();
    // 数据报长度
    int length = datagramPacket.getLength();
    // 偏移量
    int offset = datagramPacket.getOffset();
    // 发送端的地址
    InetAddress address = datagramPacket.getAddress();
    // 发送端发送数据报使用的端口
    int packetPort = datagramPacket.getPort();

    // 收到的消息
    String message = new String(data, offset, length);

    // 释放
    datagramSocket.close();

    // 输出接收到的消息
    System.out.println("message = " + message + " - address = " + address);
} catch (IOException e) {
    throw new RuntimeException(e);
}

组播

组播要求发送和所有接收的主机在同一网段，因此只适用于局域网内通信。组播地址是D类IP地址的一个子集，专门用于支持一对多的网络通信。D类IP地址的范围是从224.0.0.0到239.255.255.255

发送组播消息

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
try {
    // 定义多播组的目标端口号
    int port = 3000;

    // 准备要发送的文本消息
    String text = "hello";
    // 将文本转换为字节数组
    byte[] data = text.getBytes(StandardCharsets.UTF_8);

    // 获取多播组地址对象（224.0.0.1是本地网络多播保留地址）
    InetAddress inetAddress = InetAddress.getByName("224.0.0.1");

    // 创建数据报包对象，封装要发送的数据和目标信息
    // 参数说明：数据内容 | 数据长度 | 目标地址 | 目标端口
    DatagramPacket datagramPacket = new DatagramPacket(data, data.length, inetAddress, port);

    // 创建多播Socket对象（自动绑定到本机随机可用端口）
    MulticastSocket multicastSocket = new MulticastSocket();

    // 发送数据报到多播组（所有加入该组的设备都会收到）
    multicastSocket.send(datagramPacket);

    // 关闭Socket释放系统资源
    multicastSocket.close();
} catch (IOException e) {
    throw new RuntimeException(e);
}

接收组播消息

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
try {
    // 设置多播通信的端口号（接收端需与发送端使用相同端口）
    int port = 3000;

    // 创建接收缓冲区
    byte[] buffer = new byte[1024];

    // 创建数据报包对象，用于接收传入的数据
    // 参数说明：存储容器 | 最大接收长度
    DatagramPacket datagramPacket = new DatagramPacket(buffer, buffer.length);

    // 获取多播组地址（224.0.0.1是本地网络控制多播地址）
    InetAddress inetAddress = InetAddress.getByName("224.0.0.1");

    // 创建多播Socket并绑定到指定端口
    MulticastSocket multicastSocket = new MulticastSocket(port);

    // 将Socket加入多播组
    multicastSocket.joinGroup(inetAddress);

    // 阻塞等待接收数据报
    // 接收成功后，数据将填充到datagramPacket中
    multicastSocket.receive(datagramPacket);

    // 获取数据字节数组（与buffer是同一个数组的引用）
    byte[] packetData = datagramPacket.getData();
    // 获取实际接收的数据长度（可能小于buffer长度）
    int length = datagramPacket.getLength();
    // 获取数据在数组中的起始偏移量（通常为0）
    int offset = datagramPacket.getOffset();
    // 获取发送方地址（可用于响应或日志记录）
    InetAddress address = datagramPacket.getAddress();
    // 获取发送方源端口号（动态分配的客户端端口）
    int packetPort = datagramPacket.getPort();

    // 将字节数据转换为字符串
    String message = new String(packetData, offset, length);

    System.out.println("Received: " + message);

    // 关闭Socket释放资源
    multicastSocket.close();
} catch (IOException e) {
    throw new RuntimeException(e);
}

广播

发送广播消息需要设置广播权限，其实代码和单播差不太多。广播要求发送和所有接收的主机在同一网段，典型地址为255.255.255.255

发送广播消息

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
try {
    // 目标端口号
    int post = 3000;

    // 消息内容
    String text = "hello";
    byte[] data = text.getBytes(StandardCharsets.UTF_8);

    // 广播地址
    InetAddress inetAddress = InetAddress.getByName("255.255.255.255");
    // 封装要发送的数据
    DatagramPacket datagramPacket = new DatagramPacket(data, data.length, inetAddress, post);

    // 负责传递数据报的套接字（自动绑定到本机随机可用端口）
    DatagramSocket datagramSocket = new DatagramSocket();
    // 设置广播权限
    datagramSocket.setBroadcast(true);

    // 发送广播
    datagramSocket.send(datagramPacket);

    datagramSocket.close();
} catch (IOException e) {
    throw new RuntimeException(e);
}

接收广播消息

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
try {
    // 接收数据报的端口号
    int port = 3000;

    // 数据报缓冲区
    byte[] buffer = new byte[1024];
    // 封装接收的数据
    DatagramPacket datagramPacket = new DatagramPacket(buffer, buffer.length);

    // 负责传递数据报的套接字
    DatagramSocket datagramSocket = new DatagramSocket(port);
    // 接收数据报
    datagramSocket.receive(datagramPacket);

    // 接收到的数据报，经测试data数组其实就是buffer数组的引用
    byte[] data = datagramPacket.getData();
    // 数据报长度
    int length = datagramPacket.getLength();
    // 偏移量
    int offset = datagramPacket.getOffset();
    // 发送端的地址
    InetAddress address = datagramPacket.getAddress();
    // 发送端使用的端口
    int packetPort = datagramPacket.getPort();

    // 收到的消息
    String message = new String(data, offset, length);

    // 释放
    datagramSocket.close();

    // 输出接收到的消息
    System.out.println("message = " + message + " - address = " + address);
} catch (IOException e) {
    throw new RuntimeException(e);
}