package cn.lxq.net;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;

/*
 * 发送端
 * 1. 使用DatagramSocket 指定端口 创建接收端
 * 2.准备数据一定要转化成字节数组
 * 3.封装成DatagramPacket 目的地 ip+端口
 * 4.发送数据send（）；
 * 5.释放数据
 */
public class UdpTalkServer implements Runnable{

    private DatagramSocket sender;
    
    private String LoIP;
    
    private int rePort;
    
    private BufferedReader reader;
    
    public UdpTalkServer(int port,String LoIP,int rePort){
        try {
            this.sender=new DatagramSocket(port);
            this.LoIP=LoIP;
            this.rePort=rePort;
            this.reader=new BufferedReader(new InputStreamReader(System.in));
        } catch (SocketException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    @Override
    public void run() {
        while(true)
        {
            String str;
        try {
             //* 2.准备数据一定要转化成字节数组
            str=reader.readLine();
            byte[] datas=str.getBytes();
             //* 3.封装成DatagramPacket 目的地 ip+端口
            DatagramPacket packet=new DatagramPacket(datas, 0,datas.length,new InetSocketAddress(this.LoIP, this.rePort));
             //* 4.发送数据send（）；
            sender.send(packet);
            
            //发送bye 退出线程
            if(str.equals("bye"))
            {
                break;
            }
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
      }    
        sender.close();
    }
}

 1 package cn.lxq.net;
 2 
 3 import java.io.IOException;
 4 import java.net.DatagramPacket;
 5 import java.net.DatagramSocket;
 6 import java.net.SocketException;
 7 
 8 /*
 9  * 接收端
10  * 1. 使用DatagramSocket 指定端口 创建接收端
11  * 2.准备容器 封装成DatagramPacket包裹
12  * 3.阻塞式接受包裹receive（）；
13  * 4.分析数据
14  * 5.释放数据
15  */
16 public class UdpTalkClient implements Runnable{
17     
18     private  DatagramSocket receiver;
19     
20     public UdpTalkClient(int port){
21         try {
22             this.receiver=new DatagramSocket(port);
23         } catch (SocketException e) {
24             // TODO Auto-generated catch block
25             e.printStackTrace();
26         }
27     }
28 
29     @Override
30     public void run() {
31         while(true)
32         {
33               //* 2.准备容器 封装成DatagramPacket包裹
34               byte[] container=new byte[1024*60];
35               DatagramPacket packet=new DatagramPacket(container, 0,container.length);
36           try {
37             
38              //* 3.阻塞式接受包裹receive（）；
39             receiver.receive(packet);
40              //* 4.分析数据
41               byte[] datas=packet.getData();
42               int len=packet.getLength();
43               String str=new String(datas,0,len);
44               System.out.println(str);
45               if(str.equals("bye"))
46               {
47                   break;
48               }
49         } catch (IOException e) {
50             // TODO Auto-generated catch block
51             e.printStackTrace();
52         }
53        }
54          //* 5.释放数据
55          receiver.close();
56     }
57 }

 1 package cn.lxq.net;
 2 /*
 3  * 
 4  */
 5 public class TalkTeacher {
 6 
 7     public static void main(String[] args) {
 8            new Thread(new UdpTalkServer(6666, "localhost", 8888)).start();//发送
 9            
10            
11            new Thread(new UdpTalkClient(5555)).start();//接受
12     }
13 
14 }

package cn.lxq.net;

public class TalkStudent {

    public static void main(String[] args) {
         
           new Thread(new UdpTalkClient(8888)).start();//接收
           
           new Thread(new UdpTalkServer(9999, "localhost", 5555)).start();//发送
    }

}