三个例子:基本类型、引用类型、文件
package com.sxt.udp;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
/**
* 基本类型: 发送端
* 1、使用DatagramSocket 指定端口 创建发送端
* 2、将基本类型 转成字节数组
* 3、 封装成DatagramPacket 包裹,需要指定目的地
* 4、发送包裹send(DatagramPacket p) *
* 5、释放资源
* @author
*
*/
public class UdpTypeClient {
public static void main(String[] args) throws Exception {
System.out.println("发送方启动中.....");
// 1、使用DatagramSocket 指定端口 创建发送端
DatagramSocket client =new DatagramSocket(8888);
//2、准备数据 一定转成字节数组
//写出
ByteArrayOutputStream baos =new ByteArrayOutputStream();
DataOutputStream dos =new DataOutputStream(new BufferedOutputStream(baos));
//操作数据类型 +数据
dos.writeUTF("编码辛酸泪");
dos.writeInt(18);
dos.writeBoolean(false);
dos.writeChar('a');
dos.flush();
byte[] datas =baos.toByteArray();
//3、 封装成DatagramPacket 包裹,需要指定目的地
DatagramPacket packet =new DatagramPacket(datas,0,datas.length,
new InetSocketAddress("localhost",6666));
//4、发送包裹send(DatagramPacket p) *
client.send(packet);
// 5、释放资源
client.close();
}
}
package com.sxt.udp;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
/**
* 基本类型: 接收端
* Address already in use: Cannot bind 同一个协议下端口不允许冲突
* 1、使用DatagramSocket 指定端口 创建接收端
* 2、准备容器 封装成DatagramPacket 包裹
* 3、阻塞式接收包裹receive(DatagramPacket p)
* 4、分析数据 将字节数组还原为对应的类型
* byte[] getData()
* getLength()
* 5、释放资源
* @author
*
*/
public class UdpTypeServer {
public static void main(String[] args) throws Exception {
System.out.println("接收方启动中.....");
// 1、使用DatagramSocket 指定端口 创建接收端
DatagramSocket server =new DatagramSocket(6666);
// 2、准备容器 封装成DatagramPacket 包裹
byte[] container =new byte[1024*60];
DatagramPacket packet = new DatagramPacket(container,0,container.length);
// 3、阻塞式接收包裹receive(DatagramPacket p)
server.receive(packet); //阻塞式
// 4、分析数据 将字节数组还原为对应的类型
// byte[] getData()
// getLength()
byte[] datas =packet.getData();
int len = packet.getLength();
DataInputStream dis =new DataInputStream(new BufferedInputStream(new ByteArrayInputStream(datas)));
//顺序与写出一致
String msg = dis.readUTF();
int age = dis.readInt();
boolean flag = dis.readBoolean();
char ch = dis.readChar();
System.out.println(msg+"-->"+flag);
// 5、释放资源
server.close();
}
}
package com.sxt.udp;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.util.Date;
/**
* 引用类型: 发送端
* 1、使用DatagramSocket 指定端口 创建发送端
* 2、将基本类型 转成字节数组
* 3、 封装成DatagramPacket 包裹,需要指定目的地
* 4、发送包裹send(DatagramPacket p) *
* 5、释放资源
* @author
*
*/
public class UdpObjClient {
public static void main(String[] args) throws Exception {
System.out.println("发送方启动中.....");
// 1、使用DatagramSocket 指定端口 创建发送端
DatagramSocket client =new DatagramSocket(8888);
//2、准备数据 一定转成字节数组
//写出
ByteArrayOutputStream baos =new ByteArrayOutputStream();
ObjectOutputStream oos =new ObjectOutputStream(new BufferedOutputStream(baos));
//操作数据类型 +数据
oos.writeUTF("编码辛酸泪");
oos.writeInt(18);
oos.writeBoolean(false);
oos.writeChar('a');
//对象
oos.writeObject("谁解其中味");
oos.writeObject(new Date());
Employee emp =new Employee("马云",400);
oos.writeObject(emp);
oos.flush();
byte[] datas =baos.toByteArray();
//3、 封装成DatagramPacket 包裹,需要指定目的地
DatagramPacket packet =new DatagramPacket(datas,0,datas.length,
new InetSocketAddress("localhost",6666));
//4、发送包裹send(DatagramPacket p) *
client.send(packet);
// 5、释放资源
client.close();
}
}
package com.sxt.udp;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ObjectInputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.util.Date;
/**
* 引用类型: 接收端
* Address already in use: Cannot bind 同一个协议下端口不允许冲突
* 1、使用DatagramSocket 指定端口 创建接收端
* 2、准备容器 封装成DatagramPacket 包裹
* 3、阻塞式接收包裹receive(DatagramPacket p)
* 4、分析数据 将字节数组还原为对应的类型
* byte[] getData()
* getLength()
* 5、释放资源
* @author
*
*/
public class UdpObjServer {
public static void main(String[] args) throws Exception {
System.out.println("接收方启动中.....");
// 1、使用DatagramSocket 指定端口 创建接收端
DatagramSocket server =new DatagramSocket(6666);
// 2、准备容器 封装成DatagramPacket 包裹
byte[] container =new byte[1024*60];
DatagramPacket packet = new DatagramPacket(container,0,container.length);
// 3、阻塞式接收包裹receive(DatagramPacket p)
server.receive(packet); //阻塞式
// 4、分析数据 将字节数组还原为对应的类型
// byte[] getData()
// getLength()
byte[] datas =packet.getData();
int len = packet.getLength();
//读取 -->反序列化
ObjectInputStream ois =new ObjectInputStream(new BufferedInputStream(new ByteArrayInputStream(datas)));
//顺序与写出一致
String msg = ois.readUTF();
int age = ois.readInt();
boolean flag = ois.readBoolean();
char ch = ois.readChar();
System.out.println(flag);
//对象的数据还原
Object str = ois.readObject();
Object date = ois.readObject();
Object employee = ois.readObject();
if(str instanceof String) {
String strObj = (String) str;
System.out.println(strObj);
}
if(date instanceof Date) {
Date dateObj = (Date) date;
System.out.println(dateObj);
}
if(employee instanceof Employee) {
Employee empObj = (Employee) employee;
System.out.println(empObj.getName()+"-->"+empObj.getSalary());
}
// 5、释放资源
server.close();
}
}
package com.sxt.udp;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
*1、 图片读取到字节数组
*2、 字节数组写出到文件
* @author
*
*/
public class IOUtils {
/**
* 1、图片读取到字节数组
* 1)、图片到程序 FileInputStream
* 2)、程序到字节数组 ByteArrayOutputStream
*/
public static byte[] fileToByteArray(String filePath) {
//1、创建源与目的地
File src = new File(filePath);
byte[] dest =null;
//2、选择流
InputStream is =null;
ByteArrayOutputStream baos =null;
try {
is =new FileInputStream(src);
baos = new ByteArrayOutputStream();
//3、操作 (分段读取)
byte[] flush = new byte[1024*10]; //缓冲容器
int len = -1; //接收长度
while((len=is.read(flush))!=-1) {
baos.write(flush,0,len); //写出到字节数组中
}
baos.flush();
return baos.toByteArray();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
//4、释放资源
try {
if(null!=is) {
is.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
return null;
}
/**
* 2、字节数组写出到图片
* 1)、字节数组到程序 ByteArrayInputStream
* 2)、程序到文件 FileOutputStream
*/
public static void byteArrayToFile(byte[] src,String filePath) {
//1、创建源
File dest = new File(filePath);
//2、选择流
InputStream is =null;
OutputStream os =null;
try {
is =new ByteArrayInputStream(src);
os = new FileOutputStream(dest);
//3、操作 (分段读取)
byte[] flush = new byte[5]; //缓冲容器
int len = -1; //接收长度
while((len=is.read(flush))!=-1) {
os.write(flush,0,len); //写出到文件
}
os.flush();
} catch (IOException e) {
e.printStackTrace();
}finally {
//4、释放资源
try {
if (null != os) {
os.close();
}
} catch (Exception e) {
}
}
}
}
package com.sxt.udp;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
/**
* 文件上传: 发送端
* 1、使用DatagramSocket 指定端口 创建发送端
* 2、将基本类型 转成字节数组
* 3、 封装成DatagramPacket 包裹,需要指定目的地
* 4、发送包裹send(DatagramPacket p) *
* 5、释放资源
* @author
*
*/
public class UdpFileClient {
public static void main(String[] args) throws Exception {
System.out.println("发送方启动中.....");
// 1、使用DatagramSocket 指定端口 创建发送端
DatagramSocket client =new DatagramSocket(8888);
//2、准备数据 一定转成字节数组
byte[] datas =IOUtils.fileToByteArray("src/logo.png");
//3、 封装成DatagramPacket 包裹,需要指定目的地
DatagramPacket packet =new DatagramPacket(datas,0,datas.length,
new InetSocketAddress("localhost",6666));
//4、发送包裹send(DatagramPacket p) *
client.send(packet);
// 5、释放资源
client.close();
}
}
package com.sxt.udp;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ObjectInputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.util.Date;
/**
* 文件存储: 接收端
* Address already in use: Cannot bind 同一个协议下端口不允许冲突
* 1、使用DatagramSocket 指定端口 创建接收端
* 2、准备容器 封装成DatagramPacket 包裹
* 3、阻塞式接收包裹receive(DatagramPacket p)
* 4、分析数据 将字节数组还原为对应的类型
* byte[] getData()
* getLength()
* 5、释放资源
* @author
*
*/
public class UdpFileServer {
public static void main(String[] args) throws Exception {
System.out.println("接收方启动中.....");
// 1、使用DatagramSocket 指定端口 创建接收端
DatagramSocket server =new DatagramSocket(6666);
// 2、准备容器 封装成DatagramPacket 包裹
byte[] container =new byte[1024*60];
DatagramPacket packet = new DatagramPacket(container,0,container.length);
// 3、阻塞式接收包裹receive(DatagramPacket p)
server.receive(packet); //阻塞式
// 4、分析数据 将字节数组还原为对应的类型
// byte[] getData()
// getLength()
byte[] datas =packet.getData();
int len = packet.getLength();
IOUtils.byteArrayToFile(datas, "src/copy.png");
// 5、释放资源
server.close();
}
}
注:通过这三个例子可以看到UDP里面还是操作字节数组,只不过这个字节数组需要跟我们的包裹打交道,封装成包裹,拆包;封包、拆包…封包的时候要知道地址。