【TCP和UDP通信】多发多收

TCP和UDP通信——多发多收

UDP通信

1.客户端可以反复发送数据

客户端实现步骤

（1）创建DatagramSocket对象（发送端对象）

（2）使用while死循环不断的接收用户的数据输入，如果用户输入”886”则退出程序

（3）使用DatagramSocket对象的send方法将数据包对象进行发送

（4）释放资源

public class UDPClient {
    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        DatagramSocket client = new DatagramSocket(); //使用随机端口

        while (true) {
            //发送的信息由键盘录入
            System.out.println("请输入聊天内容：");
            String info = sc.next();
            byte[] bytes = info.getBytes();
            DatagramPacket dp = new DatagramPacket(
                    bytes,
                    bytes.length,
                    InetAddress.getByName("127.0.0.1"),
                    20000
            );
            client.send(dp);

            //循环发送如果输入"886"退出
            if (info.contains("886")) {
                System.out.println("正在下线..");
                client.close();
                break;
            }
        }
    }
}
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

2.接收端可以反复接收数据

1.接受端可以反复接收数据

接收端实现步骤

（1）创建DatagramSocket对象并指定端口（接收端对象）

（2）创建DatagramSocket对象接收数据（数据包对象）

（3）使用DatagramSocket对象的receive方法传入DatagramPacket对象

（4）暂且不释放资源，使用while死循环不断的进行第3步

public class UDPServer {
    public static void main(String[] args) throws IOException {
        System.out.println("=== 聊天室 ===");
        DatagramSocket server = new DatagramSocket(20000);
        //循环接收
        while (true) {
            byte[] bytes = new byte[1024];
            DatagramPacket dp = new DatagramPacket(bytes, bytes.length);
            server.receive(dp);
            //展示数据
            System.out.println(new String(bytes,0, dp.getLength()));
            //DatagramPacket对象获取客户端其他信息
            System.out.println(dp.getAddress().getHostAddress() + "/" + dp.getPort());
            //不要关闭服务器Socket对象，否则只能接一次
            System.out.println("-------------------");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

TCP通信

1.客户端可以反复发送数据

实现步骤：

（1）客户端使用死循环，让用户不断输入消息

（2）服务端也使用死循环，控制服务端接收完消息，继续等到接收下一个消息

public class TCPClient {
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        Socket client = new Socket("127.0.0.1", 8888);
        OutputStream os = client.getOutputStream();
        DataOutputStream dos = new DataOutputStream(os);

        while (true) {
            System.out.println("请输入联调内容：");
            String info = sc.next();
            dos.writeUTF(info);
            dos.flush();
            //循环发送如果输入"886"退出
            if (info.contains("886")) {
                System.out.println("正在下线..");
                client.close();
                dos.close();
                break;
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2.接收端可以反复接收数据

public class TCPServer {
    public static void main(String[] args) throws Exception {
        System.out.println("=== 聊天室 ===");
        ServerSocket server = new ServerSocket(8888);
        Socket serverSocket = server.accept();
        InputStream is = serverSocket.getInputStream();
        DataInputStream dis = new DataInputStream(is);
        //循环接收
        while (true) {
            try {
                String info = dis.readUTF(); //有用户下线，会抛异常SocketException
                System.out.println(info);
            } catch (Exception e) {
                //有人下线则释放资源
                System.out.println(serverSocket.getRemoteSocketAddress() + "离线了");
                System.out.println("-----------------------");
                server.close();
                dis.close();
                break;
            }
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

TCP通信-支持与多个客户端同时通信（多线程）

如何实现服务端同时接收多个客户端的消息的？

• 主线程定义了循环负责接收客户端Socket管道连接
• 没接收到一个Socket通信管道后分配给一个独立的线程负责处理它

客户端：

public class TCPClient {
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        Socket client = new Socket("127.0.0.1", 8888);
        OutputStream os = client.getOutputStream();
        DataOutputStream dos = new DataOutputStream(os);
        while (true) {
            System.out.println("请输入联调内容：");
            String info = sc.next();
            dos.writeUTF(info);
            dos.flush();
            //循环发送如果输入"886"退出
            if (info.contains("886")) {
                System.out.println("正在下线..");
                client.close();
                dos.close();
                break;
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

任务类：封装本次连接的客户端要完成的逻辑

public class ServerThread implements Runnable {
    //serverSocket：本次连接的客户端的Socket对象
    private Socket serverSocket;
    public ServerThread(Socket serverSocket) {
        this.serverSocket = serverSocket;
    }
    @Override
    public void run() {
        try {
            //接收数据
            InputStream is = serverSocket.getInputStream();
            DataInputStream dis = new DataInputStream(is);
            //循环接收
            while (true) {
                try {
                    String info = dis.readUTF(); //有用户下线，会抛异常SocketException
                    System.out.println(info);
                } catch (Exception e) {
                    //有人下线则释放资源
                    System.out.println(serverSocket.getRemoteSocketAddress() + "离线了");
                    System.out.println("-----------------------");
                    serverSocket.close();
                    dis.close();
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
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

服务端：使用线程循环接收

package com.demo12_TCP多发多收_多线程实现;

// TODO: 能够完成TCP通信下服务端可以同时接收多个客户端的消息

import java.net.ServerSocket;
import java.net.Socket;

public class TCPServer {
    public static void main(String[] args) throws Exception {
        System.out.println("=== 聊天室 ===");
        ServerSocket server = new ServerSocket(8888);

        while (true) {
            Socket serverSocket = server.accept();
            //每当服务器监听到一个连接请求，获取serverSocket对象，开启一个线程处理任务
            new Thread(new ServerThread(serverSocket)).start();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19