Android（java）学习笔记80：UDP协议发送数据

1. UDP协议发送数据：我们总是先运行接收端，再运行发送端
发送端：

 package cn.itcast_02;
 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetAddress;
 /*
  * UDP协议发送数据：
  * A:创建发送端Socket对象
  * B:创建数据，并把数据打包
  * C:调用Socket对象的发送方法发送数据包
  * D:释放资源
  */
 public class SendDemo {
     public static void main(String[] args) throws IOException {
         // 创建发送端Socket对象
         // DatagramSocket()
         DatagramSocket ds = new DatagramSocket();
         // 创建数据，并把数据打包
         // DatagramPacket(byte[] buf, int length, InetAddress address, int port)
         // 创建数据
         byte[] bys = "hello,udp,我来了".getBytes();//转码
         // 长度
         int length = bys.length;
         // IP地址对象
         InetAddress address = InetAddress.getByName("192.168.12.92");
         // 端口
         int port = 10086;
         DatagramPacket dp = new DatagramPacket(bys, length, address, port);
         // 调用Socket对象的发送方法发送数据包
         // public void send(DatagramPacket p)
         ds.send(dp);
         // 释放资源
         ds.close();
     }
 }

接收端：

 package cn.itcast_02;
 
 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetAddress;
 
 /*
 9  * UDP协议接收数据：
10  * A:创建接收端Socket对象
11  * B:创建一个数据包(接收容器)
12  * C:调用Socket对象的接收方法接收数据
13  * D:解析数据包，并显示在控制台
14  * E:释放资源
  */
 public class ReceiveDemo {
     public static void main(String[] args) throws IOException {
18         // 创建接收端Socket对象
19         // DatagramSocket(int port)
         DatagramSocket ds = new DatagramSocket(10086);
 
22         // 创建一个数据包(接收容器)
23         // DatagramPacket(byte[] buf, int length)
         byte[] bys = new byte[1024];
         int length = bys.length;
         DatagramPacket dp = new DatagramPacket(bys, length);
 
28         // 调用Socket对象的接收方法接收数据
29         // public void receive(DatagramPacket p)
         ds.receive(dp); // 阻塞式

32         // 解析数据包，并显示在控制台
33         // 获取对方的ip
         // public InetAddress getAddress()
         InetAddress address = dp.getAddress();
         String ip = address.getHostAddress();
         // public byte[] getData():获取数据缓冲区
         // public int getLength():获取数据的实际长度
         byte[] bys2 = dp.getData();
         int len = dp.getLength();
         String s = new String(bys2, 0, len);
         System.out.println(ip + "传递的数据是:" + s);
 
44         // 释放资源
         ds.close();
     }
 }

这里ds.close():

Java的内存回收机制，也是要等到资源达到一定限度才开始回收，也是有生命周期的。用close（）可以及时回收资源，更加高效.使用close()后就可以及时释放资源，不必非等到最后资源占用完了才开始痛苦的回收过程，而且从良好的编程习惯来说，创建了对象，就应该考虑到用完后就要释放内存资源，要养成一个良好的编程习惯。

这里首先我们是运行接收端，因为如果不先运行接收端，先运行发送端的话，数据也不会接收到。但是与此同时，如果先运行接收端，可是没有接收到数据，不可能解析数据和显示数据，所以：先运行接收端，后运行发送端，同时我们也定义接收端为阻塞式，（也就是等待数据发送过来）。

UDP发送数据和接收数据图解：

UDP发送数据和接收数据代码的优化：

UDP协议发送数据：我们总是先运行接收端，再运行发送端
发送端：

 package cn.itcast_03;
 
 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetAddress;
 
 public class SendDemo {
     public static void main(String[] args) throws IOException {
         // 创建发送端的Socket对象
         DatagramSocket ds = new DatagramSocket();
 
         // 创建数据并打包
         byte[] bys = "helloworld".getBytes();
         DatagramPacket dp = new DatagramPacket(bys, bys.length,
                 InetAddress.getByName("192.168.12.92"), 12345);
 
         // 发送数据
         ds.send(dp);
 
         // 释放资源
         ds.close();
     }
 }

接收端：

 package cn.itcast_03;
 
 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 
 7 /*
 8  * 多次启动接收端：
 9  *         java.net.BindException: Address already in use: Cannot bind
10  *         端口被占用。
11  */
 public class ReceiveDemo {
     public static void main(String[] args) throws IOException {
         // 创建接收端的Socket对象
         DatagramSocket ds = new DatagramSocket(12345);
 
         // 创建一个包裹
         byte[] bys = new byte[1024];
         DatagramPacket dp = new DatagramPacket(bys, bys.length);
 
         // 接收数据
         ds.receive(dp);
 
         // 解析数据
         String ip = dp.getAddress().getHostAddress();
         String s = new String(dp.getData(), 0, dp.getLength());
         System.out.println("from " + ip + " data is : " + s);
 
         // 释放资源
         ds.close();
     }
 }

2. 发送端数据来自于键盘录入的案例:（注意这里我们是如何更改上面的代码的）

发送端：

 package cn.itcast_04;
 
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetAddress;
 
10 /*
11  * 数据来自于键盘录入
12  * 键盘录入数据要自己控制录入结束。
13  */
 public class SendDemo {
     public static void main(String[] args) throws IOException {
         // 创建发送端的Socket对象
         DatagramSocket ds = new DatagramSocket();
 
19         // 封装键盘录入数据
20         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
         String line = null;
         while ((line = br.readLine()) != null) {
23             if ("886".equals(line)) { //键盘录入数据终止符定义为：886
24                 break;
25             }

             // 创建数据并打包
             byte[] bys = line.getBytes();
             // DatagramPacket dp = new DatagramPacket(bys, bys.length,
             // InetAddress.getByName("192.168.12.92"), 12345);//发送给特定的用户电脑
             DatagramPacket dp = new DatagramPacket(bys, bys.length,
                     InetAddress.getByName("192.168.12.255"), 12345);//发送给网内所有电脑

             // 发送数据
             ds.send(dp);
         }
 
         // 释放资源
         ds.close();
     }
 }

接收端：

 package cn.itcast_04;
 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 /*
  * 多次启动接收端：
  *         java.net.BindException: Address already in use: Cannot bind
  *         端口被占用。
  */
 public class ReceiveDemo {
     public static void main(String[] args) throws IOException {
         // 创建接收端的Socket对象
         DatagramSocket ds = new DatagramSocket(12345);
         while (true) {
             // 创建一个包裹
             byte[] bys = new byte[1024];
             DatagramPacket dp = new DatagramPacket(bys, bys.length);
             // 接收数据
             ds.receive(dp);
             // 解析数据
             String ip = dp.getAddress().getHostAddress();
             String s = new String(dp.getData(), 0, dp.getLength());
             System.out.println("from " + ip + " data is : " + s);
         }
         // 释放资源
32         // 接收端应该一直开着等待接收数据，是不需要关闭，就好比百度服务器是一直开着着，一样的，接收端好比服务器端
33         // ds.close();
     }
 }

这里我们知道如果这个程序要完成通信的话，我们就必须打开两个界面，一个发送端，一个接收端：

但是现实生活中我们都是在一个界面下发送和接收数据，例如如下的qq聊天界面：

于是我们这里引入对上面程序的进一步优化：这里就是利用多线程改进程序

 package cn.itcast_05;
 import java.io.IOException;
 import java.net.DatagramSocket;
 /*
  * 通过多线程改进刚才的聊天程序，这样我就可以实现在一个窗口发送和接收数据了
  */
 public class ChatRoom {
     public static void main(String[] args) throws IOException {
         DatagramSocket dsSend = new DatagramSocket();
         DatagramSocket dsReceive = new DatagramSocket(12306);
         SendThread st = new SendThread(dsSend);
         ReceiveThread rt = new ReceiveThread(dsReceive);
         Thread t1 = new Thread(st);
         Thread t2 = new Thread(rt);
         t1.start();
         t2.start();
     }
 }

 package cn.itcast_05;
 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 public class ReceiveThread implements Runnable {
     private DatagramSocket ds;
     public ReceiveThread(DatagramSocket ds) {
         this.ds = ds;
     }
     @Override
     public void run() {
         try {
             while (true) {
                 // 创建一个包裹
                 byte[] bys = new byte[1024];
                 DatagramPacket dp = new DatagramPacket(bys, bys.length);
                 // 接收数据
                 ds.receive(dp);
                 // 解析数据
                 String ip = dp.getAddress().getHostAddress();
                 String s = new String(dp.getData(), 0, dp.getLength());
                 System.out.println("from " + ip + " data is : " + s);
             }
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 }

 package cn.itcast_05;
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetAddress;
 public class SendThread implements Runnable {
     private DatagramSocket ds;
     public SendThread(DatagramSocket ds) {
         this.ds = ds;
     }
     @Override
     public void run() {
         try {
             // 封装键盘录入数据
             BufferedReader br = new BufferedReader(new InputStreamReader(
                     System.in));
             String line = null;
             while ((line = br.readLine()) != null) {
                 if ("886".equals(line)) {
                     break;
                 }
                 // 创建数据并打包
                 byte[] bys = line.getBytes();
                 // DatagramPacket dp = new DatagramPacket(bys, bys.length,
                 // InetAddress.getByName("192.168.12.92"), 12345);
                 DatagramPacket dp = new DatagramPacket(bys, bys.length,
                         InetAddress.getByName("192.168.12.255"), 12306);
                 // 发送数据
                 ds.send(dp);
             }
             // 释放资源
             ds.close();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 }

执行效果图如下：