Java的Externalizable接口

最新推荐文章于 2021-05-19 21:49:10 发布

__KevinYzy__

最新推荐文章于 2021-05-19 21:49:10 发布

阅读量352

点赞数

本文链接：https://blog.csdn.net/huluwaaaa/article/details/102699788

版权

Java 专栏收录该内容

76 篇文章 0 订阅

订阅专栏

在理解Externalizable接口之前，你需要先理解什么是序列化。有关序列化可以读下这篇文章多了解一些。 Java提供了序列化的机制来把Java对象里持久化成一个有序的字节序列，这里面包括对象的数据及其类型，还有对象本身的类型信息。

Externalizable:
就如名字所说的，这个接口是用来将对象序列化具体化的。如果你想定制自己的序列化机制的话，它就派上用场了。它通过你自己编码的方式来完成对象的编解码。Externalizable接口继承了Serializable接口。如果你实现了这个接口你得重写下面的方法。

@Override
public void readExternal(ObjectInput arg0) throws IOException,

        ClassNotFoundException {

}

@Override
public void writeExternal(ObjectOutput arg0) throws IOException {

}

现在我们看下序列化是怎么进行的：发送方： JVM检查类是否实现了externalizable接口。如果实现了则使用writeExternal()方法来进行序列化。如果它没实现externalizable而实现了Serializable接口，就用ObjectOutputStream来进行对象的序列化。接收方：当对象被反序列化并且它实现了externalizable接口的话，就会用默认构造方法新建一个实例，然后调用它的readExternal方法。如果没有实现externalizable而实现了Serializable，就用ObjectOutputStream来进行对象的反序列化。我们还是从Java的序列化中用到过的那个例子讲起。在src->org.arpit.javapostsforlearning中新建一个Employee.java

package org.arpit.javapostsforlearning;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class Employee implements Externalizable{

int employeeId;
String employeeName;
String department;
String nationality;

public Employee()
{

}
public int getEmployeeId() {
return employeeId;
}
public void setEmployeeId(int employeeId) {
this.employeeId = employeeId;
}
public String getEmployeeName() {
return employeeName;
}
public void setEmployeeName(String employeeName) {
this.employeeName = employeeName;
}
public String getDepartment() {
return department;
}
public void setDepartment(String department) {
this.department = department;
}

public String getNationality() {
return nationality;
}
public void setNationality(String nationality) {
this.nationality = nationality;
}
@Override
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
employeeId=in.readInt();
employeeName=(String) in.readObject();

}
@Override
public void writeExternal(ObjectOutput out) throws IOException {

out.writeInt(employeeId);
out.writeObject(employeeName);
}
}
如果实现了externalizable就必须有一个无参的构造方法。在org.arpit.javapostsforlearning中新建一个ExternalizableMain.java。

package org.arpit.javapostsforlearning;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class ExternalizableMain {
/**

@author Arpit Mandliya
*/
public static void main(String[] args) {

Employee emp = new Employee();
emp.setEmployeeId(101);
emp.setEmployeeName(“Arpit”);
emp.setDepartment(“CS”);

//Serialize
try
{
FileOutputStream fileOut = new FileOutputStream(“employee.ser”);
ObjectOutputStream outStream = new ObjectOutputStream(fileOut);
outStream.writeObject(emp);
outStream.close();
fileOut.close();
}catch(IOException i)
{
i.printStackTrace();
}

//Deserialize
emp = null;
try
{
FileInputStream fileIn =new FileInputStream(“employee.ser”);
ObjectInputStream in = new ObjectInputStream(fileIn);
emp = (Employee) in.readObject();
in.close();
fileIn.close();
}catch(IOException i)
{
i.printStackTrace();
return;
}catch(ClassNotFoundException c)
{
System.out.println(“Employee class not found”);
c.printStackTrace();
return;
}
System.out.println(“Deserialized Employee…”);
System.out.println("Emp id: " + emp.getEmployeeId());
System.out.println("Name: " + emp.getEmployeeName());

}
}
运行：当你运行ExternalizableMain.java，你会得到这样的输出结果：

Deserialized Employee…
2Emp id: 101
3Name: Arpit
既然有了serializable，为什么还需要externalizable! 当你用serialize进行序列化时，除了所有字段，属于这个对象MAP的和成员变量能接触到的所有对象都会被序列化。比如：如果你Employee有个父类是person，那么它会序列化所有的父类直到Object类。同样的如果Employee有个address类型的成员变量，那么它会把整个address的整个对象集合也序列化进去。如果你想序列化的只有employeeId和employeeName的话，你会希望增加这么多额外开销吗？当你用serializable的话JVM会使用反射来进行序列化，这样会很慢。当使用serializable时，类的描述信息也会存储到流里，包括父类的描述信息，和类关联的成员变量的信息。这也是一个性能问题。

外部序列化里的继承
我们现在来看下继承是怎么影响到外部序列化的。这里会有几种情况比如父类有没有实现过externalizable接口。如果没有你应该如何处理，使得它能正常工作。我们来看个例子。我们创建一个Employee的父类叫做Person。

场景1：如果父类没有实现externalizable：如果父类没有实现externalizable，那么你得在实现externalizable的子类里序列化父类的字段。

package org.arpit.javapostsforlearning;
public class Person {

String name=“default”;
String nationality;

public Person()
{
System.out.println(“Person:Constructor”);
}

public Person(String name, String nationality) {
super();
this.name = name;
this.nationality = nationality;
}

public String getName() {
return name;
}

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

public String getNationality() {
return nationality;
}

public void setNationality(String nationality) {
this.nationality = nationality;
}

}
在org.arpit.javapostsforlearning中创建Employee。

package org.arpit.javapostsforlearning;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class Employee extends Person implements Externalizable{

int employeeId;
String department;

public Employee()
{

}
public Employee(int employeeId,String name,String department,String nationality)
{
super(name,nationality);
this.employeeId=employeeId;
this.department=department;
System.out.println(“Employee:Constructor”);
}

public int getEmployeeId() {
return employeeId;
}
public void setEmployeeId(int employeeId) {
this.employeeId = employeeId;
}

public String getDepartment() {
return department;
}
public void setDepartment(String department) {
this.department = department;
}

@Override
public void writeExternal(ObjectOutput out) throws IOException {

/since superclass does not implement externalizable, you need to serialize super class field in this class itself/
//superclass fields
out.writeObject(name);
out.writeObject(nationality);

// its own fields
out.writeInt(employeeId);
out.writeObject(department);
}

@Override
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
/since superclass does not implement externalizable, you need to deserialize super class field in this class itself/
//superclass fields
name=(String) in.readObject();
nationality=(String) in.readObject();

// its own fields
employeeId=in.readInt();
department=(String) in.readObject();

}
}
在org.arpit.javapostsforlearning新建ExternalizableMain。

public class ExternalizableMain {

/**

@author Arpit Mandliya
*/
public static void main(String[] args) {

//Serialize
Employee emp = new Employee(101,“Arpit”,“CS”,“Indian”);
System.out.println(“Before serializing”);
System.out.println("Emp id: " + emp.getEmployeeId());
System.out.println("Name: " + emp.getName());
System.out.println(“Department: " + emp.getDepartment());
System.out.println(“Nationality: " + emp.getNationality());
System.out.println(”************”);
System.out.println(“Serializing”);
try
{
FileOutputStream fileOut = new FileOutputStream(“employee.ser”);
ObjectOutputStream outStream = new ObjectOutputStream(fileOut);
outStream.writeObject(emp);
outStream.close();
fileOut.close();
}catch(IOException i)
{
i.printStackTrace();
}

//Deserialize
System.out.println("************");
System.out.println(“Deserializing”);
emp = null;
try
{
FileInputStream fileIn =new FileInputStream(“employee.ser”);
ObjectInputStream in = new ObjectInputStream(fileIn);
emp = (Employee) in.readObject();
in.close();
fileIn.close();
}catch(IOException i)
{
i.printStackTrace();
return;
}catch(ClassNotFoundException c)
{
System.out.println(“Employee class not found”);
c.printStackTrace();
return;
}
System.out.println(“After serializing”);
System.out.println("Emp id: " + emp.getEmployeeId());
System.out.println("Name: " + emp.getName());
System.out.println("Department: " + emp.getDepartment());
System.out.println("Nationality: " + emp.getNationality());
}
}
运行后结果如下：

Employee:Constructor
Before serializing
Emp id: 101
Name: Arpit
Department: CS
Nationality: Indian

Serializing

Deserializing
Person:Constructor
After serializing
Emp id: 101
Name: Arpit
Department: CS
Nationality: Indian
场景二：如果父类实现了Externalizable
如果父类实现了Externalizable，它也有相应的readExternal和writeExternal方法，它会用这些方法序列化自己的字段。 Person.java

package org.arpit.javapostsforlearning;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class Person implements Externalizable{

String name=“default”;
String nationality;

public Person()
{
System.out.println(“Person:Constructor”);
}

public Person(String name, String nationality) {
super();
this.name = name;
this.nationality = nationality;
}

public String getName() {
return name;
}

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

public String getNationality() {
return nationality;
}

public void setNationality(String nationality) {
this.nationality = nationality;
}

@Override
public void writeExternal(ObjectOutput out) throws IOException {

out.writeObject(name);
out.writeObject(nationality);
}

@Override
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
name=(String) in.readObject();
nationality=(String) in.readObject();

}

}
Employee.java:

package org.arpit.javapostsforlearning;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class Employee extends Person implements Externalizable{

int employeeId;
String department;

public Employee()
{

public int getEmployeeId() {
return employeeId;
}
public void setEmployeeId(int employeeId) {
this.employeeId = employeeId;
}

public String getDepartment() {
return department;
}
public void setDepartment(String department) {
this.department = department;
}

@Override
public void writeExternal(ObjectOutput out) throws IOException {

super.writeExternal(out);
out.writeInt(employeeId);
out.writeObject(department);
}

@Override
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {

super.readExternal(in);
employeeId=in.readInt();
department=(String) in.readObject();

}
}
ExternalizableMain.java:

public class ExternalizableMain {

/**

@author Arpit Mandliya
*/
public static void main(String[] args) {

Employee:Constructor
Before serializing
Emp id: 101
Name: Arpit
Department: CS
Nationality: Indian

Serializing

Deserializing
Person:Constructor
After serializing
Emp id: 101
Name: Arpit
Department: CS
Nationality: Indian
在这个例子中，由于Person类用自己的writeExternal和readExternal方法存储和恢复自己的字段，不用再子类中序列化父类的字段。不过如果你仔细观察下Employee 的writeExternal和readExternal方法，你会发现还是先调了下super.xxxx方法，这样说明实现externalizable的对象还得和父类协作才能序列化对象的状态。

Externalizable的缺点：
如果你修改了类的定义，你得对应的修改writeExternal和readExternal方法。就如示例中如示，子类对象必须和父类进行协作才能正确存储和恢复自己的状态。

原创文章转载请注明出处：Java的Externalizable接口

英文原文链接