Preskočiť na hlavný obsah

Java Serialization

Have you ever use serialization? Why and when is serialization required? Serialization is the process of storing an object's full state to a sequence of bytes. By deserializing the object you rebuild those bytes into a original object.


The Java Serialization API provides not only the interfaces and utilities to handle this process. Enterprise applications have distributed components in current systems. If you want to make inter-component or inter-system comunication, serialization shoul be the right choice for comparision to XML transfer.

How to make the objects of some class to be serializable? To serialize an object, you need to ensure that the class of the object implements the java.io.Serializable interface. The Serializable interface declares no methods at all. It tells the serialization mechanism that the class can be serialized.

class Entity implements java.io.Serializable {
  int someAttribute;
}

Serialization is done by calling the writeObject() method of the java.io.ObjectOutputStream class. The object's restoration occurs with the in.readObject() method call. This method call reads in the raw bytes that we previously saved and creates a live fresh object, an exact replica of the original object.
public static void main(String args[]) throws IOException {
  FileOutputStream fos = new FileOutputStream("a.out");
  ObjectOutputStream os = new ObjectOutputStream(fos);
  os.writeObject(new Entity());
  os.close();

  FileInputStream fis = new FileInputStream("temp.out");
  ObjectInputStream in = new ObjectInputStream(fis);
  Entity entity = (Entity) in.readObject();
  System.out.println(entity);
}

This is a basic knowledge of how to serialize an object. But how does the process exactly work? In general the serialization algorithm does the following:
  • writes out the metadata of the class associated with an object instance
  • recursively writes out the description of the superclass until it finds java.lang.Object
  • Once it finishes writing the metadata information, then starts with the actual attributes associated with the instance, but this time, it starts from the topmost superclass
  • recursively writes the data associated with the instance, starting from the least superclass to the most-derived class

Obľúbené príspevky z tohto blogu

mysql 5.0 upgrade to 5.1

The 5.1 series of MySQLwas unmasked for the gentoo portage. When upgrading from an older major version (including 5.0), you will be required to rebuild everything linked to the libmysqlclient.so.15 and libmysqlclient_r.so.15. You can do this by installing app-portage/gentoolkit and running: # revdep-rebuild --library libmysqlclient.so.15 # revdep-rebuild --library libmysqlclient_r.so.15 If you use the Portage 2.2 series, you may also use: # emerge @preserved-rebuild The official upgrade documentation is available here: http://dev.mysql.com/doc/refman/5.1/en/upgrading.html Note that existing databases may need converting as well, again including those upgrading from 5.0 to 5.1.

JDK 8

The goal of this Project is to to produce an open-source reference implementation of the Java SE 8 Platform, to be defined by JSR 337 in the Java Community Process. This Project is sponsored by the Build Group. History and status JDK 8 as presently conceived is the second part of Plan B. The proposed release-driver features are the Lambda and Jigsaw Projects. Additional features will be included, but they must fit into the schedule required for the release drivers. Now that work on JDK 7 is winding down, the next couple of months will be devoted to planning JDK 8 in detail. The proposed JEP Process will be a key part of this effort. Details on how Committers can participate in that process will be available shortly. Plan A: JDK 7 (as currently defined) Mid 2012 Plan B: JDK 7 (minus Lambda, Jigsaw, and part of Coin) Mid 2011 JDK 8 (Lambda, Jigsaw, the rest of Coin, ++) Late 2012