javaUDP逐步实现多线程发送和接收消息

一、UDP实现发送消息

1. 发送端

   //不需要连接服务器
   public class UdpClientDemo1 {
       public static void main(String[] args) throws Exception{
           //1.建立一个Socket
           DatagramSocket socket = new DatagramSocket();
   
           //2.建个包
           String msg = "你好啊，服务器！";
   
           InetAddress localhost = InetAddress.getByName("localhost");
           int port = 9000;
           //数据，数据的长度起始，要发送给谁
   
           DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);
   
           //3.发送包
           socket.send(packet);
   
           //4.关闭流
           socket.close();
       }
   }
   
   

2. 接收端

   public class UdpServerDemo1 {
       public static void main(String[] args) throws Exception {
           //开发端口
           DatagramSocket socket = new DatagramSocket(9000);
           //接收数据包
           byte[] buffer = new byte[1024];
           DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);//接收
   
           socket.receive(packet);
   
           System.out.println(packet.getAddress().getHostAddress());
           System.out.println(new String(packet.getData(),0,packet.getLength()));
           //关闭连接
           socket.close();
       }
   }
   

二、UDP实现聊天

1. 循环发送消息

   public class UdpSenderDemo1 {
       public static void main(String[] args) throws Exception {
   
           DatagramSocket socket = new DatagramSocket(8888);
   
           //准备数据：控制台读取System.in
           BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
   
           while(true) {
               String data = reader.readLine();
               byte[] datas = data.getBytes();
               DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress("localhost", 6666));
   
               socket.send(packet);
               if(data.equals("bye")){
                   break;
               }
           }
           socket.close();
       }
   }
   
   

2. 循环接收消息

   public class UdpReceiveDemo1 {
       public static void main(String[] args) throws Exception {
           DatagramSocket socket = new DatagramSocket(6666);
   
           while(true) {
               //准备接收包裹
               byte[] container = new byte[1024];
               DatagramPacket packet = new DatagramPacket(container, 0, container.length);
               socket.receive(packet); //阻塞式接收包裹
   
               //断开连接
               byte[] data = packet.getData();
               String receiveData = new String(data, 0, data.length);
   
               System.out.println(receiveData);
               if(receiveData.equals("bye")){
                   break;
               }
           }
           socket.close();
       }
   }
   

三、UDP多线程在线聊天

1. 在线聊天：两人都可以是发送方，也都可以是接收方

2. 发送端

   public class TalkSend implements Runnable {
   
       DatagramSocket socket = null;
       BufferedReader reader = null;
   
       private int fromPort;
       private String toIP;
       private int toPort;
   
       public TalkSend(int fromPort, String toIP, int toPort) {
           this.fromPort = fromPort;
           this.toIP = toIP;
           this.toPort = toPort;
   
           try {
               socket = new DatagramSocket(fromPort);
               reader = new BufferedReader(new InputStreamReader(System.in));
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   
       @Override
       public void run() {
   
           //准备数据：控制台读取System.in
   
           while(true) {
               try {
                   String  data = reader.readLine();
                   byte[] datas = data.getBytes();
                   DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress(this.toIP, this.toPort));
   
                   socket.send(packet);
                   if(data.equals("bye")){
                       break;
                   }
   
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
           socket.close();
       }
   }
   

3. 接收端

   public class TalkReceive implements Runnable{
       DatagramSocket socket = null;
   
       private int port;
       private String msgFrom;
   
       public TalkReceive(int port,String msgFrom) {
           this.port = port;
           this.msgFrom = msgFrom;
           try {
               socket = new DatagramSocket(port);
           } catch (SocketException e) {
               e.printStackTrace();
           }
       }
   
       @Override
       public void run() {
   
           while(true) {
               try {
                   //准备接收包裹
                   byte[] container = new byte[1024];
                   DatagramPacket packet = new DatagramPacket(container, 0, container.length);
                   socket.receive(packet); //阻塞式接收包裹
   
                   //断开连接
                   byte[] data = packet.getData();
                   String receiveData = new String(data, 0, data.length);
   
                   System.out.println(msgFrom+"："+receiveData);
   
                   if(receiveData.equals("bye")){
                       break;
                   }
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
           socket.close();
       }
   }
   
   

4. 学生端测试

   public class TalkStudent {
       public static void main(String[] args) {
           //开启两个线程：发送和接收
           new Thread(new TalkSend(7777,"localhost",9999)).start();
           new Thread(new TalkReceive(8888,"老师")).start();
       }
   }
   

5. 老师端测试

   public class TalkTeacher {
       public static void main(String[] args) {
           new Thread(new TalkSend(5555,"localhost",8888)).start();
           new Thread(new TalkReceive(9999,"学生")).start();
       }
   }
   

6. 测试结果