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();
}
} }
执行效果图如下：