发送端:
package com.lzy.udp;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
public class UdpClient {
public static void main(String[] args) throws Exception {
System.out.println("发送方启动中。。。");
//1.使用DatagramSocket指定端口 创建发送端
DatagramSocket client=new DatagramSocket(9999);
//2.准备数据 一定转成字节数组
String data="好好学习天天向上";
byte[] datas=data.getBytes();
//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.lzy.udp;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class UdpServer {
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[] datas=packet.getData();
int len=packet.getLength();
System.out.println(new String(datas,0,len));
//5.释放资源
server.close();
}
}
上传文件
基本类型接收端
package com.lzy.udp;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
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[] 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.lzy.udp;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
/**
* 基本类型: 发送端
* 1、使用DatagramSocket 指定端口 创建发送端
* 2、将基本类型 转成字节数组
* 3、 封装成DatagramPacket 包裹,需要指定目的地
* 4、发送包裹send(DatagramPacket p) *
* 5、释放资源
* @author
*
*/
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
public class UdpTypeClient {
public static void main(String[] args) throws Exception {
System.out.println("发送方启动中。。。");
//1.使用DatagramSocket指定端口 创建发送端
DatagramSocket client=new DatagramSocket(9999);
//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.lzy.udp;
/**
* 引用类型: 发送端
* 1、使用DatagramSocket 指定端口 创建发送端
* 2、将基本类型 转成字节数组
* 3、 封装成DatagramPacket 包裹,需要指定目的地
* 4、发送包裹send(DatagramPacket p) *
* 5、释放资源
*
*
*/
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;
public class UdpObjClient {
public static void main(String[] args) throws Exception {
System.out.println("发送方启动中。。。");
//1.使用DatagramSocket指定端口 创建发送端
DatagramSocket client=new DatagramSocket(9999);
//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.lzy.udp;
/**
* 引用类型: 接收端
* Address already in use: Cannot bind 同一个协议下端口不允许冲突
* 1、使用DatagramSocket 指定端口 创建接收端
* 2、准备容器 封装成DatagramPacket 包裹
* 3、阻塞式接收包裹receive(DatagramPacket p)
* 4、分析数据 将字节数组还原为对应的类型
* byte[] getData()
* getLength()
* 5、释放资源
* @author 裴新 QQ:3401997271
*
*/
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ObjectInputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.util.Date;
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[] 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();
}
}
这里需要再加一个Employee类
package com.lzy.udp;
public class Employee implements java.io.Serializable{
private transient String name; //该数据不需要序列化
private double salary;
public Employee() {
}
public Employee(String name, double salary) {
this.name = name;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
文件上传:发送端
package com.lzy.udp;
/**
* 文件上传: 发送端
* 1、使用DatagramSocket 指定端口 创建发送端
* 2、将基本类型 转成字节数组
* 3、 封装成DatagramPacket 包裹,需要指定目的地
* 4、发送包裹send(DatagramPacket p) *
* 5、释放资源
*
*
*/
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
public class UdpFileClient {
public static void main(String[] args) throws Exception {
System.out.println("发送方启动中。。。");
//1.使用DatagramSocket指定端口 创建发送端
DatagramSocket client=new DatagramSocket(9999);
//2.准备数据 一定转成字节数组
byte[] datas =IOUtils.fileToByteArray("D:/workspace02/Net_study02/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.lzy.udp;
/**
* 文件存储: 接收端
* Address already in use: Cannot bind 同一个协议下端口不允许冲突
* 1、使用DatagramSocket 指定端口 创建接收端
* 2、准备容器 封装成DatagramPacket 包裹
* 3、阻塞式接收包裹receive(DatagramPacket p)
* 4、分析数据 将字节数组还原为对应的类型
* byte[] getData()
* getLength()
* 5、释放资源
*
*
*/
import java.net.DatagramPacket;
import java.net.DatagramSocket;
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[] datas=packet.getData();
int len=packet.getLength();
IOUtils.byteArrayToFile(datas, "src/copy.png");
System.out.println(new String(datas,0,len));
//5.释放资源
server.close();
}
}
添加IOUtils类
package com.lzy.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) {
}
}
}
}