Java_网络编程_UDP编程基本步骤（操作引用数据类型）

package cn.UDP;

import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.util.Date;

/**
 * UDP基本步骤
 * 引用类型接收端
 * 1.使用DatagramSocket创建接收端，指定端口
 * 2.准备容器，封装成DatagramPacket包裹
 * 3.阻塞式接受包裹receive(DatagramPacket p)
 * 4.分析数据 getData() 将字节数组转换为相应的类型数据 
 * 5.释放资源
 * @author Chill Lyn
 *
 */
public class UDPServerObj {
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		System.out.println("server:");
//		1.使用DatagramSocket创建接收端，指定端口
		DatagramSocket server = new DatagramSocket(8090);
//		2.准备容器，封装成DatagramPacket包裹
		byte[] container = new byte[1024 * 60];
		DatagramPacket packet = new DatagramPacket(container, container.length);
//		3.阻塞式接受包裹receive(DatagramPacket p)
		server.receive(packet);
//		4.分析数据 getData() 将字节数组转换为相应的基本类型数据 
		byte[] datas = packet.getData();
		// 反序列化：读取
		ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(new ByteArrayInputStream(datas)));
		// 顺序与写出顺序一致
		boolean flag = ois.readBoolean();
		char ch = ois.readChar();
		int i = ois.readInt();
		String str = ois.readUTF();
		Object str2 = ois.readObject();
		Object drink = ois.readObject();
		Object date = ois.readObject();

		if (str2 instanceof String) {
			String strObj = (String) str2;
			System.out.println(strObj);
		}

		if (drink instanceof Drink) {
			Drink drinkObj = (Drink) drink;
			System.out.println(drinkObj.getName() + "-->" + drinkObj.getPrice() + "-->" + drinkObj.getCost());
		}

		if (date instanceof Date) {
			Date dateObj = (Date) date;
			System.out.println(dateObj);
		}
		System.out.println(ch);
//		5.释放资源
		server.close();
	}
}

package cn.UDP;

import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.util.Date;

/**
 * UDP基本步骤
 * 引用类型数据：发送端
 * 1.使用DatagramSocket创建发送端，指定端口
 * 2.将数据，转成字节数组
 * 3.封装成DatagramPacket包裹，指定目的地
 * 4.发送包裹send(DatagramPacket p)
 * 5.释放资源
 * @author Chill Lyn
 *
 */
public class UDPClientObj {
	public static void main(String[] args) throws IOException {
		System.out.println("client:");
//		1.使用DatagramSocket创建发送端，指定端口
		DatagramSocket client = new DatagramSocket(8080);
//		2.将数据转成字节数组
		// 序列化：写出
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(baos));
		// 操作数据类型+数据
		oos.writeBoolean(false);
		oos.writeChar('a');
		oos.writeInt(0);
		oos.writeUTF("我爱你");
		oos.writeObject("我还爱你");
		oos.writeObject(new Drink("Cola", 3, 2));
		oos.writeObject(new Date());
		oos.flush();
		byte[] datas = baos.toByteArray();
//		3.封装成DatagramPacket包裹，指定目的地
		DatagramPacket packet = new DatagramPacket(datas, datas.length, new InetSocketAddress("localhost", 8090));
//		4.发送包裹send(DatagramPacket p)
		client.send(packet);
//		5.释放资源
		client.close();
	}
}

package cn.UDP;

public class Drink implements java.io.Serializable {
	private String name;
	private double price;
	private transient double cost; // 该数据不需要序列化

	public Drink() {

	}

	public Drink(String name, double price, double cost) {
		super();
		this.name = name;
		this.price = price;
		this.cost = cost;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public double getPrice() {
		return price;
	}

	public void setPrice(double price) {
		this.price = price;
	}

	public double getCost() {
		return cost;
	}

	public void setCost(double cost) {
		this.cost = cost;
	}
}