Java基础--网络编程之UDP

凌风博客原创作品。转载请注明出处：

UDP

1.将数据及源和目的封装成数据包中，不需要建立连接
2.每个数据包的大小限制在64K内
3.因无连接，是不可靠协议
4.不需要建立连接，速度快


举例：聊天，视频共享


--------------------------
TCP
1.建立连接，形成传输数据的通道
2.在连接中进行大数据量传输
3.通过三次握手完成连接，是可靠协议

4.必须建立连接，效率会稍低

[java]  view plain copy

1. import java.net.*;  
2. class IPDemo_1  
3. {  
4.     public static void main(String[] args) throws Exception  
5.     {  
6.         InetAddress i = InetAddress.getLocalHost();  
7.         System.out.println(i.toString());  
8.         System.out.println("address:"+i.getHostAddress());  
9.         System.out.println("name:"+i.getHostName())l  
10.   
11.   
12.   
13.         //在给定主机名的情况下确定主机的 IP 地址  
14.         InetAddress ia = InetAddress.getByName("www.baidu.com");  
15.           
16.         System.out.println("address:"+ia.getHostAddress());  
17.         System.out.println("name:"+ia.getHostName());  
18.           
19.           
20.     }  
21. }  

需求:通过UDP传输方式，将一段文字数据发送出去


定义一个UDP的发送端
思路：
1.建立udpsocket服务
2.提供数据，并将数据封装到数据包中
3.通过socket服务的发送功能，将数据包发出去。
4.关闭资源

[java]  view plain copy

1. import java.net.*;  
2. class UDPSend  
3. {  
4.     public static void main(String[] args) throws Exception  
5.     {  
6.         //1.创建UDP服务，通过DatagramSocket对象  
7.         DatagramSocket ds = new DatagramSocket(8888);  //指定发送端口  
8.   
9.         //2.确定数据，并封装成数据包 DatagramPacket(byte[] buf, int length, InetAddress address, int port)   
10.         byte[] buf = "UDP ge men lai le ".getBytes();  
11.         DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.102"),10000);  
12.   
13.         //3.通过socket服务，将已有的数据包发送出去，通过send方法  
14.         ds.send(dp);  
15.   
16.         //4.关闭资源  
17.         ds.close();  
18.     }  
19. }  

需求：
定义一个应用程序，用于接收UDP 协议传输的数据并处理的


定义UDP的接收端
思路：
1.定义UDPsocket服务，通常会监听一个端口，其实就是给这个接收网络应用程序定义数字标识。
  方便于明确哪些数据过来该应用程序可以处理。
2.定义一个数据包，因为要存储接收到的字节数据
  因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。
3.通过socket服务的receive方法将收到的数据存入已定义好的数据包中
4.通过数据包对象的特有功能，将这些不同的数据取出，打印在控制台上。
5.关闭资源

[java]  view plain copy

1. class UDPRece  
2. {  
3.     public static void main(String[] args) throws Exception  
4.     {  
5.         //1.创建UDP socket，建立端点  
6.         DatagramSocket ds = new DatagramSocket(10000); //指定接收端口  
7.           
8.         while (true)//无限接收数据  
9.         {  
10.         //2.定义数据包，用于存储数据  
11.         byte[] buf = new byte[1024];  
12.         DatagramPacket dp = new DatagramPacket(buf,buf.length);  
13.   
14.         //3.通过服务的receive方法将收到数据存入数据包中，  
15.         ds.receive(dp);  //阻塞式方法  
16.   
17.         //4.通过数据包的方法获取其中的数据  
18.         String ip = dp.getAddress().getHostAddress();//接收IP  
19.   
20.         String data = new String(dp.getData(),0,dp.getLength());//接收数据的有效长度  
21.   
22.         int port = dp.getPort();  //接收发送端的端口号  
23.   
24.         System.out.println(ip+"..."+data+"..."+port);  
25.         }  
26.         //5.关闭资源  
27.         ds.close();  
28.   
29.   
30.     }  
31. }  

练习

[java]  view plain copy

1. import java.io.*;  
2. import java.net.*;  
3. class UDPSend  
4. {  
5.     public static void main(String[] args) throws Exception  
6.     {  
7.         //1.创建UDP服务，通过DatagramSocket对象  
8.         DatagramSocket ds = new DatagramSocket(8888);  //指定发送端口  
9.           
10.         BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));  
11.   
12.         String line = null;  
13.         while ((line=bufr.readLine())!=null)  
14.         {  
15.             if("886".equals(line))  
16.                 break;  
17.             //2.确定数据，并封装成数据包 DatagramPacket(byte[] buf, int length, InetAddress address, int port)   
18.             byte[] buf = line.getBytes();  
19.             DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.102"),10000);  
20.             //3.通过socket服务，将已有的数据包发送出去，通过send方法  
21.             ds.send(dp);  
22.         }  
23.           
24.           
25.   
26.         //4.关闭资源  
27.         ds.close();  
28.     }  
29. }  
30.   
31.   
32.   
33. class UDPRece  
34. {  
35.     public static void main(String[] args) throws Exception  
36.     {  
37.         //1.创建UDP socket，建立端点  
38.         DatagramSocket ds = new DatagramSocket(10000); //指定接收端口  
39.           
40.         while (true)//无限接收数据  
41.         {  
42.         //2.定义数据包，用于存储数据  
43.         byte[] buf = new byte[1024];  
44.         DatagramPacket dp = new DatagramPacket(buf,buf.length);  
45.   
46.         //3.通过服务的receive方法将收到数据存入数据包中，  
47.         ds.receive(dp);  //阻塞式方法  
48.   
49.         //4.通过数据包的方法获取其中的数据  
50.         String ip = dp.getAddress().getHostAddress();//接收IP  
51.   
52.         String data = new String(dp.getData(),0,dp.getLength());//接收数据的有效长度  
53.   
54.         int port = dp.getPort();  //接收发送端的端口号  
55.   
56.         System.out.println(ip+"..."+data+"..."+port);  
57.         }  
58.         //5.关闭资源  
59.         //ds.close();  
60.   
61.   
62.     }  
63. }  

编写一个聊天程序。
有收数据的部分，和发数据的部分
这两部分需要同时执行
那就需要用到多线程技术
一个线程控制收，一个线程控制发。


因为收和发动作时不一致的，所以要定义两个run方法
而且这两个方法要封装到不同的类中

[java]  view plain copy

1. import java.net.*;  
2. import java.io.*;  
3. class Send implements Runnable  
4. {  
5.     private DatagramSocket ds;  
6.     public Send(DatagramSocket ds)  
7.     {  
8.         this.ds = ds;  
9.     }  
10.     public void run()  
11.     {  
12.         try  
13.         {  
14.             BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));  
15.   
16.             String line = null;  
17.             while ((line=bufr.readLine())!=null)  
18.             {  
19.                 if("886".equals(line))  
20.                     break;  
21.   
22.                 byte[] buf= line.getBytes();  
23.   
24.                 DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10002);  
25.   
26.                 ds.send(dp);  
27.             }  
28.         }  
29.         catch (Exception e)  
30.         {  
31.             throw new RuntimeException("发送端失败");  
32.         }  
33.     }  
34. }  
35.   
36. class Rece implements Runnable  
37. {  
38.     private DatagramSocket ds;  
39.     public Rece(DatagramSocket ds)  
40.     {  
41.         this.ds = ds;  
42.     }  
43.     public void run()  
44.     {  
45.         try  
46.         {  
47.             while (true)  
48.             {  
49.                 byte[] buf = new byte[1024];  
50.                 DatagramPacket dp = new DatagramPacket(buf,buf.length);  
51.   
52.                 ds.receive(dp);  
53.   
54.                 String ip = dp.getAddress().getHostAddress();  
55.   
56.                 String data = new String(dp.getData(),0,dp.getLength());  
57.   
58.                 System.out.println(ip+"::"+data);  
59.             }  
60.         }  
61.         catch (Exception e)  
62.         {  
63.             throw new RuntimeException("接收端失败");  
64.         }  
65.     }  
66. }  
67. class ChatDemo_4  
68. {  
69.     public static void main(String[] args) throws Exception  
70.     {  
71.         DatagramSocket sendSocket = new DatagramSocket();  
72.         DatagramSocket receSocket = new DatagramSocket(10002);  
73.   
74.         new Thread(new Send(sendSocket)).start();  
75.         new Thread(new Rece(receSocket)).start();  
76.   
77.     }  
78. }