UDP-基本步骤 &上传文件

发送端：

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) {
			}
		}
	}
}