1、 对象流
java.io.ObjectOutputStream和ObjectInputSteam
对象流是一对高级流，在流连接中的作用是进行对象的序列化与反序列化。
对象序列化:将一个java对象按照其结构转换为一组字节的过程
对象反序列化:将一组字节还原为java对象(前提是这组字节是一个对象序列化得到的字节)
需要进行序列化的类必须实现接口:java.io.Serializable 实现序列化接口后最好主动定义序列化版本号这个常量。 这样一来对象序列化时就不会根据类的结构生成一个版本号,而是使用该固定值。 那么反序列化时，只要还原的对象和当前类的版本号一致就可以进行还原。
transient关键字可以修饰属性，用于在进行对象序列化时忽略不必要的属性，达到对象瘦身的目的
2、 java.io.ObjectInputStream对象输入流，继承自java.io.InputStream
- 常用构造器
ObjectInputStream(InputStream in)：创建一个对象输入流并连接到参数in这个输入流上。
- 常用方法
Object readObject()：进行对象反序列化，将读取的字节转换为一个对象并以Object形式返回(多态)。
如果读取的字节表示的不是一个java对象会抛出异常:java.io.ClassNotFoundException
3、 java.io.ObjectOutputStream对象输出流，继承自java.io.OutputStream
- 常用构造器
ObjectOutputStream(OutputStream out)：创建一个对象输出流并连接到参数out这个输出流上
- 常用方法
void writeObject(Object obj)：进行对象的序列化，将一个java对象序列化成一组字节后再通过连接的输出流将这组字节写出。
如果序列化的对象没有实现可序列化接口:java.io.Serializable就会抛出异常:java.io.NotSerializableException
4、 序列化接口java.io.Serrializable
该接口没有任何抽象方法，但是只有实现了该接口的类的实例才能进行序列化与反序列化。
实现了序列化接口的类建议显示的定义常量:static final long serialVersionUID = 1L;
可以为属性添加关键字transient，被该关键字修饰的属性在序列化是会被忽略，达到对象序列化瘦身的目的。
5、示例
- 类
import java.io.Serializable;
/**
* 订单类
* @author xiayimiaoyijiuyonggan
*序列化：将对象转换为二进制的字节序列过程，方便对象在网络里传输（不同的jvm之间进行对象传输）
*
*反序列化：将对象的二进制的字节序列，重新构建为目标对象的过程，可以在不jvm中获取原目标对象
*/
public class Order implements Serializable{
/**
* 序列号:
*
*/
private static final long serialVersionUID = -3977285738036192626L;
//订单号
private String orderNo;
//用户编号
private String usreId;
//
private String prodId;
//
private Double totalPrice;
//订单状态（0 1 2 3 4）
private Integer orderStatus;
//
private Integer payType;
private String remark;
public String getRemark() {
return remark;
}
public void setRemark(String remark) {
this.remark = remark;
}
public String getOrderNo() {
return orderNo;
}
public void setOrderNo(String orderNo) {
this.orderNo = orderNo;
}
public String getUsreId() {
return usreId;
}
public void setUsreId(String usreId) {
this.usreId = usreId;
}
public String getProdId() {
return prodId;
}
public void setProdId(String prodId) {
this.prodId = prodId;
}
public Double getTotalPrice() {
return totalPrice;
}
public void setTotalPrice(Double totalPrice) {
this.totalPrice = totalPrice;
}
public Integer getOrderStatus() {
return orderStatus;
}
public void setOrderStatus(Integer orderStatus) {
this.orderStatus = orderStatus;
}
public Integer getPayType() {
return payType;
}
public void setPayType(Integer payType) {
this.payType = payType;
}
@Override
public String toString() {
return "Order [orderNo=" + orderNo + ", usreId=" + usreId + ", prodId=" + prodId + ", totalPrice=" + totalPrice
+ ", orderStatus=" + orderStatus + ", payType=" + payType + ", remark=" + remark + "]";
}
}
- 操作
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class TestXlhOrder {
/**
* 订单对象序列化，写入文件
*/
public static void xlhOrder() {
//
Order xlhorder = new Order();
xlhorder.setOrderNo("KH10020230407165310");
xlhorder.setUsreId("U0001");
xlhorder.setProdId("P0002");
xlhorder.setTotalPrice(4488.0);
xlhorder.setPayType(1);
xlhorder.setOrderStatus(0);
xlhorder.setRemark("哈哈哈哈");
try (
//
ObjectOutputStream oost = new ObjectOutputStream
(new FileOutputStream("/Users/xiayimiaoyijiuyonggan/Projects/Kh100/order.txt"));
){
//
oost.writeObject(xlhorder);
oost.flush();
} catch (Exception e) {
// TODO: handle exception
}
System.out.println("写入成功！！");
}
/**
* 文件内容反序列化为订单对象
*/
public static void fxlhOrder() {
try (
//创建对象输入流，读取写入序列化对象文件
ObjectInputStream ois = new ObjectInputStream
(new FileInputStream("/Users/xiayimiaoyijiuyonggan/Projects/Kh100/order.txt"));
){
//
Order fxlhOrder =(Order) ois.readObject();
System.out.println(fxlhOrder);
} catch (Exception e) {
// TODO: handle exception
}
System.out.println("写出成功！！");
}
public static void main(String[] args) {
// 模拟:使用对象输出流将内存里创建的订单对象
xlhOrder();
fxlhOrder();
}
}
