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;
import java.net.SocketException;
/*
* 发送端
* 1.使用DatagramSocket 指定端口 创建发送端
* 2.准备将基本类型转成字节数组
* 3.封装成DatagramPacket包裹，需要指定目的地
* 4.发送包裹send(DatagramPacket p)
* 5.释放资源
*/
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.flush();
byte[] datas=baos.toByteArray(); //将字节流转为字节数组
//3.封装成DatagramPacket包裹，需要指定目的地
DatagramPacket packet
=new DatagramPacket(datas,0,datas.length,new InetSocketAddress("localhost",9999));
//4.发送包裹send(DatagramPacket p)
client.send(packet);
//5.释放资源
client.close();
}
}
package cn.jd.udp;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
/*
* 同一个协议下端口不允许冲突
* 基本类型:接收端
* 1.使用DatagramSocket 指定端口 创建接收端
* 2.准备容器 封装成DatagramPacket包裹
* 3.阻塞式接收包裹receive(DatagramPacket p)
* 4.分析数据 将字节数组还原成对应的类型
* byte[] getData()
* getLength()
* 5.释放资源
*/
public class UdpTypeServer {
public static void main(String[] args) throws Exception {
System.out.println("接收方启动中");
//1.使用DatagramSocket 指定端口 创建接收端
DatagramSocket server=new DatagramSocket(9999);
//2.准备容器 封装成DatagramPacket包裹
byte[] container=new byte[1024*60];//最多接收60K
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();
System.out.println(msg);
//5.释放资源
server.close();
}
}
package cn.jd.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.net.SocketException;
import java.util.Date;
/*
* 引用类型:发送端
* 1.使用DatagramSocket 指定端口 创建发送端
* 2.准备数据一定要转成字节数组
* 3.封装成DatagramPacket包裹，需要指定目的地
* 4.发送包裹send(DatagramPacket p)
* 5.释放资源
*/
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.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",9999));
//4.发送包裹send(DatagramPacket p)
client.send(packet);
//5.释放资源
client.close();
}
}
package cn.jd.udp;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ObjectInputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
import java.util.Date;
/*
* 同一个协议下端口不允许冲突
* 引用类型:接收端
* 1.使用DatagramSocket 指定端口 创建接收端
* 2.准备容器 封装成DatagramPacket包裹
* 3.阻塞式接收包裹receive(DatagramPacket p)
* 4.分析数据
* byte[] getData()
* getLength()
* 5.释放资源
*/
public class UdpObjServer {
public static void main(String[] args) throws Exception {
System.out.println("接收方启动中");
//1.使用DatagramSocket 指定端口 创建接收端
DatagramSocket server=new DatagramSocket(9999);
//2.准备容器 封装成DatagramPacket包裹
byte[] container=new byte[1024*60];//最多接收60K
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();
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());
}
// System.out.println(msg);
//5.释放资源
server.close();
}
}
package cn.jd.udp;
//写了一个javabean类 后期用来封装数据 transient
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 cn.jd.udp;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;
/*
* 文件上传:发送端
* 1.使用DatagramSocket 指定端口 创建发送端
* 2.准备数据一定要转成字节数组
* 3.封装成DatagramPacket包裹，需要指定目的地
* 4.发送包裹send(DatagramPacket p)
* 5.释放资源
*/
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/OIP.jpg");
//3.封装成DatagramPacket包裹，需要指定目的地
DatagramPacket packet
=new DatagramPacket(datas,0,datas.length,new InetSocketAddress("localhost",9999));
//4.发送包裹send(DatagramPacket p)
client.send(packet);
//5.释放资源
client.close();
}
}
package cn.jd.udp;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
/*
* 同一个协议下端口不允许冲突
* 文件存储:接收端
* 1.使用DatagramSocket 指定端口 创建接收端
* 2.准备容器 封装成DatagramPacket包裹
* 3.阻塞式接收包裹receive(DatagramPacket p)
* 4.分析数据
* byte[] getData()
* getLength()
* 5.释放资源
*/
public class UdpFileServer {
public static void main(String[] args) throws Exception {
System.out.println("接收方启动中");
//1.使用DatagramSocket 指定端口 创建接收端
DatagramSocket server=new DatagramSocket(9999);
//2.准备容器 封装成DatagramPacket包裹
byte[] container=new byte[1024*60];//最多接收60K
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.jpg");
//5.释放资源
server.close();
}
}
package cn.jd.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.字节数组写出到文件
* 先说第一个，我们开始讲第二个
*/
public class IOUtils {
// 图片读取到字节数组写一个方法,字节数组的目的地可以不用管
// 1.图片到程序 FileInputStream 2.程序到字节数组 ByteArrayOutputStream
public static byte[] fileToByteArray(String filePath) {
//先将图片以字节流的方式输入到程序中
File src = new File(filePath);
byte[] dest = null; //这个目的地可有可无
InputStream is=null;
try {
is = new FileInputStream(src);
} catch (FileNotFoundException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
ByteArrayOutputStream baos = new ByteArrayOutputStream();// 有新增方法不能发生多态
byte[] flush = new byte[1024 * 10];//定义了一个字节数组
int len = -1;
try {
while ((len = is.read(flush)) != -1) {//把文件写入到程序中了(这里是通过)
// String str=new String(flush,0,len);
// System.out.println(str);
baos.write(flush, 0, len); //从程序写出到字节数组中
}
baos.flush();
return baos.toByteArray(); //返回baos的字节数组
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
if (is != null) {
is.close();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return null; //这里记得写
}
// 字节数组写出到图片 需要字节数组的数据源,以及文件的路径
//1.字节数组读取到程序中(ByteArrayInputStream)2.程序写出到文件(FileOutputStream)
public static void byteArrayToFile(byte[] src, String filePath) {
File dest=new File(filePath);//输出图片的目的地，这里是文件写出的路径
ByteArrayInputStream is=new ByteArrayInputStream(src); //字节数组的流，先让它写到程序 src是数据源
OutputStream os=null;
try {
os=new FileOutputStream(dest);
byte[] flush=new byte[5];
int len=-1;
while((len=is.read(flush))!=-1){//这里是写入程序
os.write(flush,0,len);//这一步是将程序写入到文件 这里一定要记住文件流一定要释放
}
os.flush();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
try {
if(os!=null) {
os.close();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
