序列化和反序列化（八）——Externalizable接口

梦里梦外; 2022-02-15 14:49 269阅读 0赞

**       Externalizable****接口：**该接口继承自 Serializable接口，Externalizable接口定义了两个抽象方法：writeExternal()与readExternal()，通过这些方法指定序列化哪些属性不序列化哪些属性。注意：实现Externalizable接口的类可以不设置serialVersionUID常量，但必须要求序列化前后的两个类完全相同，为了编程更显灵活，推荐设置serialVersionUID常量。

示例：

import java.io.Externalizable;
    import java.io.IOException;
    import java.io.ObjectInput;
    import java.io.ObjectOutput;
    
    public class UserInfo implements Externalizable {
    
    	private int age;
    	private String name;
    
    	public int getAge() {
    		return age;
    	}
    
    	public void setAge(int age) {
    		this.age = age;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	@Override
    	public void writeExternal(ObjectOutput out) throws IOException {
    		out.writeObject(name);
    		out.writeInt(age);
    	}
    
    	@Override
    	public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
    		name = (String) in.readObject();
    		age = in.readInt();
    	}
    
    	@Override
    	public String toString() {
    		return "name='" + name + '\'' + ", age=" + age;
    	}
    }

import java.io.*;
    
    public class Test {
    	
    	/**
    	 * 序列化
    	 * 
    	 * @author GaoHuanjie
    	 */
    	public static void serialize(){
    		UserInfo userInfo = new UserInfo();
    		userInfo.setAge(23);
    		userInfo.setName("Tom");
    		System.out.println(userInfo);
    		ObjectOutput objectOutput = null;
    		try {
    			objectOutput = new ObjectOutputStream(new FileOutputStream("D:\\user_info.ser"));
    			objectOutput.writeObject(userInfo);
    			objectOutput.flush();
    		} catch (IOException e) {
    			e.printStackTrace();
    		} finally {
    			if (objectOutput!=null) {
    				try {
    					objectOutput.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    
    	/**
    	 * 反序列化
    	 * 
    	 * @author GaoHuanjie
    	 */
    	public static void deserialize(){
    		ObjectInput objectInput = null;
    		try {
    			objectInput = new ObjectInputStream(new FileInputStream("D:\\user_info.ser"));
    			UserInfo userInfo = (UserInfo) objectInput.readObject();
    			System.out.println(userInfo);
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			if (objectInput!=null) {
    				try {
    					objectInput.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				} 
    			}
    		}
    	}
    
    	public static void main(String[] args) {
    		serialize();//序列化
    		deserialize();//反序列化
    	}
    }

Serializable接口与Externalizable接口区别：

1、Serializable反序列化时不会调用默认构造方法，而Externalizable反序列化时会调用默认构造器方法；

2、Serializable反序列化时构造方法可以是任意访问权限的控制符，而Externalizable反序列化时只能是public；

3、Serializable序列化时，static或transient修饰的属性不会被序列化，而Externalizable序列化时只能通过writeExternal()和readExternal()方法指定序列化哪些属性不序列化哪些属性，不能使用transient修饰符；