一、序列化
序列化定义：序列化是将对象状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化，它将流转换为对象。这两个过程结合起来，可以轻松地存储和传输数据。
目的：
二、Java序列化
一个对象能够序列化的前提是实现Serializable接口。Serializable接口没有方法，更像是个标记。有了这个标记的Class就能被序列化机制处理。如下：
class myPoint implements Serializable{
}
JAVA反序列化不会调用任何构造器
序列化的控制：Externalizable。读写都交给你
void writeExternal(ObjectOutput out) throws IOException;
void readExternal(ObjectInput in) throws IOException,ClassNotFoundException;
public class Point implements Externalizable {
private int a;
private int b;
public Point(int a, int b) {
this.a = a;
this.b = b;
}
public Point() {
}
public String toString() {
return a + " , " + b;
}
public void writeExternal(ObjectOutput out) throws IOException {
out.write(a);
out.write(b);
}
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
a = in.read();
b = in.read();
}
public static void main(String[] args) throws IOException,
ClassNotFoundException {
String file = "d://1.txt";
Point p = new Point(1, 2);
System.out.println(p);
FileOutputStream fos = new FileOutputStream(file);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(p);
FileInputStream fis = new FileInputStream(file);
ObjectInputStream ois = new ObjectInputStream(fis);
Point pp = (Point) ois.readObject();
System.out.println(pp);
}
}
三、序列化的问题
在effective Java中列举出了java序列化要注意的一些问题：
1.谨慎地设计实现Serializable接口
2.保护性地编写 readObject()方法，因为readObject()是构建实例的入口。
不保护可能出现 构建了不满足要求的 实例
3.考虑自定义的序列化形式
public class StringList implements Serializable {
private transient int size = 0;
private transient Entity head = null;
public final void add(String str) {
// ...
}
private static class Entity {
String data;
Entity next;
Entity previous;
}
private void writeObject(ObjectOutputStream s) throws IOException {
s.defaultWriteObject();
s.write(size);
for (Entity e = head; e != null; e = e.next) {
s.writeObject(e.data);
}
}
private void readObject(ObjectInputStream s) throws IOException,
ClassNotFoundException {
s.defaultReadObject();
int num = s.read();
for (int i = 0; i < num; i++) {
this.add((String) s.readObject());
}
}
}
四、序列化代理模式
序列化机制提供的钩子函数有：
writeReplace writeObject readObject readResolve
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.util.Date;
public final class Period implements Serializable {
private static final long serialVersionUID = 100L;
private final Date start;
private final Date end;
public Period(Date start, Date end) {
this.start = new Date(start.getTime());
this.end = new Date(end.getTime());
if (this.start.compareTo(this.end) > 0) {
throw new IllegalArgumentException(start + " after " + end);
}
}
public Date start() {
return new Date(start.getTime());
}
public Date end() {
return new Date(end.getTime());
}
public String toString() {
return start + " - " + end;
}
// 不给
private Object writeReplace() {
return new SerializationProxy(this);
}
private void readObject(ObjectInputStream stream)
throws InvalidObjectException {
throw new InvalidObjectException("proxy request");
}
private static class SerializationProxy implements Serializable {
private final Date start;
private final Date end;
SerializationProxy(Period p) {
this.start = p.start;
this.end = p.end;
}
private Object readResolve() {
return new Period(start, end);
}
private static final long serialVersionUID = 1000L;
}
}
五、序列化算法
感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
