{"id":43714,"date":"2015-09-18T21:51:22","date_gmt":"2015-09-18T18:51:22","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=43714"},"modified":"2023-12-06T12:17:00","modified_gmt":"2023-12-06T10:17:00","slug":"built-in-serialization-techniques","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2015\/09\/built-in-serialization-techniques.html","title":{"rendered":"Built-in Serialization techniques"},"content":{"rendered":"

This article is part of our Academy Course titled Advanced Java<\/a>.<\/p>\n

This course is designed to help you make the most effective use of Java. It discusses advanced topics, including object creation, concurrency, serialization, reflection and many more. It will guide you through your journey to Java mastery! Check it out here<\/a>!<\/em><\/p>\n

\n

Table Of Contents<\/h4>\n
\n
1. Introduction<\/a><\/dt>\n
2. Serializable interface<\/a><\/dt>\n
3. Externalizable interface<\/a><\/dt>\n
4. More about Serializable interface<\/a><\/dt>\n
5. Serializability and Remote Method Invocation (RMI)<\/a><\/dt>\n
6. JAXB<\/a><\/dt>\n
7. JSON-P<\/a><\/dt>\n
8. Cost of serialization<\/a><\/dt>\n
9. Beyond Java standard library and specifications<\/a><\/dt>\n
10. What\u2019s next<\/a><\/dt>\n
11. Download the Source code<\/a><\/dt>\n<\/dl>\n<\/div>\n

<\/a>1. Introduction<\/h2>\n

This part of the tutorial is going to be solely devoted to serialization<\/b>: the process of translating Java objects into a format that can be used to store and be reconstructed later in the same (or another) environment (http:\/\/en.wikipedia.org\/wiki\/Serialization<\/a>). Serialization<\/b> not only allows saving and loading Java objects to\/from the persistent storage, but is also a very important component of modern distributed systems communication.<\/p>\n

Serialization<\/b> is not easy, but effective serialization<\/b> is even harder. Besides the Java standard library, there are many serialization techniques and frameworks available: some of them are using compact binary representation, others put the readability on the first place. Although we are going to mention many alternatives along the way, our attention will be concentrated on the ones from Java standard library (and latest specifications): Serializable<\/code>, Externalizable<\/code>, Java Architecture for XML Binding (JAXB<\/b>, JSR-222<\/a>) and Java API for JSON Processing (JSON-P<\/b>, JSR-353<\/a>).<\/p>\n

<\/a>2. Serializable interface<\/h2>\n

Arguably, the easiest way in Java to mark the class as available for serialization is by implementing the java.io.Serializable<\/code> interface. For example:<\/p>\n

\npublic class SerializableExample implements Serializable {\n}\n\n<\/pre>\n
The serialization runtime associates with each serializable class a special version number, called a serial version UID<\/b>, which is used during deserialization<\/b> (the process opposite to serialization<\/b>) to make sure that the loaded classes for the serialized object are compatible. In case the compatibility has been compromised, the InvalidClassException<\/code> will be raised.<\/p>\n
A serializable class may introduce its own serial version UID<\/b> explicitly by declaring a field with name serialVersionUID<\/code> that must be static<\/code>, final<\/code>, and of type long<\/code>. For example:<\/p>\n
\n\npublic class SerializableExample implements Serializable {\n    private static final long serialVersionUID = 8894f47504319602864L;   \n}\n\n<\/pre>\n
However, if a serializable class does not explicitly declare a serialVersionUID<\/code> field, then the serialization runtime will generate a default serialVersionUID<\/code> field for that class. It is worth to know that it is strongly recommended by all classes implementing Serializable<\/code> to explicitly declare the serialVersionUID<\/code> field, because the default serialVersionUID<\/code> generation heavily relies on intrinsic class details and may vary depending on Java compiler implementation and its version. As such, to guarantee a consistent behavior, a serializable class must always declare an explicit serialVersionUID<\/code> field.<\/p>\n
Once the class becomes serializable (implements Serializable<\/code> and declares serialVersionUID<\/code>), it could be stored and retrieved using, for example,  ObjectOutputStream<\/code> \/ ObjectInputStream<\/code>:<\/p>\n
\nfinal Path storage = new File( \"object.ser\" ).toPath();\n\ntry( final ObjectOutputStream out = \n        new ObjectOutputStream( Files.newOutputStream( storage ) ) ) {\n    out.writeObject( new SerializableExample() );\n}\n\n<\/pre>\n
Once stored, it could be retrieved in a similar way, for example:<\/p>\n
\ntry( final ObjectInputStream in = \n        new ObjectInputStream( Files.newInputStream( storage ) ) ) {\n    final SerializableExample instance = ( SerializableExample )in.readObject();\n    \/\/ Some implementation here\n}\n\n<\/pre>\n
As we can see, the Serializable<\/code> interface does not provide a lot of control over what should be serialized and how (with exception of transient<\/code> keyword which marks the fields as non-serializable). Moreover, it limits the flexibility of changing the internal class representation as it could break the serialization \/ deserialization process. That is why another interface, Externalizable<\/code>, has been introduced.<\/p>\n
<\/a>3. Externalizable interface<\/h2>\n
In contrast to Serializable<\/code> interface, Externalizable<\/code> delegates to the class the responsibility of how it should be serialized and deserialized. It has only two methods and here is its declaration from the Java standard library:<\/p>\n
\npublic interface Externalizable extends java.io.Serializable {\n    void writeExternal(ObjectOutput out) throws IOException;\n    void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;\n}\n\n<\/pre>\n
In turn, every class which implements Externalizable<\/code> interface should provide the implementation of these two methods. Let us take a look on the example:<\/p>\n
\npublic class ExternalizableExample implements Externalizable {\n    private String str;\n    private int number;\n    private SerializableExample obj;\n        \n    @Override\n    public void readExternal(final ObjectInput in) \n            throws IOException, ClassNotFoundException {\n        setStr(in.readUTF());\n        setNumber(in.readInt());\n        setObj(( SerializableExample )in.readObject());\n    }\n    \n    @Override\n    public void writeExternal(final ObjectOutput out) \n            throws IOException {\n        out.writeUTF(getStr());\n        out.writeInt(getNumber());\n        out.writeObject(getObj());\n    }\n}\n\n<\/pre>\n
Similarly to the classes implementing Serializable<\/code>, the classes implementing Externalizable<\/code> could be stored and retrieved using, for example,  ObjectOutputStream<\/code> \/ ObjectInputStream<\/code>:
 
<\/div> <\/div><\/p>\n
\nfinal Path storage = new File( \"extobject.ser\" ).toPath();\n        \nfinal ExternalizableExample instance = new ExternalizableExample();\ninstance.setStr( \"Sample String\" );\ninstance.setNumber( 10 );\ninstance.setObj( new SerializableExample() );\n        \ntry( final ObjectOutputStream out = \n        new ObjectOutputStream( Files.newOutputStream( storage ) ) ) {\n    out.writeObject( instance );\n}\n        \ntry( final ObjectInputStream in = \n        new ObjectInputStream( Files.newInputStream( storage ) ) ) {\n    final ExternalizableExample obj = ( ExternalizableExample )in.readObject();\n    \/\/ Some implementation here\n}\n\n<\/pre>\n
The Externalizable<\/code> interface allows a fine-grained serialization \/ deserialization customization in the cases when the simpler approach with Serializable<\/code> interface does not work well.<\/p>\n
<\/a>4. More about Serializable interface<\/h2>\n
In the previous section we mentioned that the Serializable<\/code> interface does not provide a lot of control over what should be serialized and how. In fact, it is not completely true (at least when ObjectOutputStream<\/code> \/ ObjectInputStream<\/code> are used). There are some special methods which any serializable class can implement in order to control the default serialization and deserialization.<\/p>\n
\nprivate void writeObject(ObjectOutputStream out) throws IOException;\n\n<\/pre>\n
This method is responsible for writing the state of the object for its particular class so that the corresponding readObject<\/code> method can restore it (the default mechanism for saving the Object’s fields can be invoked by calling out.defaultWriteObject<\/code>).<\/p>\n
\nprivate void readObject(ObjectInputStream in) throws IOException,ClassNotFoundException;\n\n<\/pre>\n
This method is responsible for reading from the stream and restoring the state of the object (the default mechanism for restoring the Object’s fields can be invoked by calling in.defaultReadObject<\/code>). <\/p>\n
\nprivate void readObjectNoData() throws ObjectStreamException;\n\n<\/pre>\n
This method is responsible for initializing the state of the object in the case when the serialization stream does not list the given class as a superclass of the object being deserialized. <\/p>\n
\nObject writeReplace() throws ObjectStreamException;\n\n<\/pre>\n
This method is used when serializable classes need to designate an alternative object to be used when writing an object to the stream.<\/p>\n
\n\nObject readResolve() throws ObjectStreamException;\n\n<\/pre>\n
And lastly, this method is used when serializable classes need to designate a replacement when an instance of it is read from the stream.<\/p>\n
The default serialization mechanism (using Serializable<\/code> interface) could get really cumbersome in Java once you know the intrinsic implementation details and those special methods to use. More code you are writing to support serialization, more likely more bugs and vulnerabilities will show off. <\/p>\n
However, there is a way to reduce those risks by employing quite simple pattern named Serialization Proxy<\/b>, which is based on utilizing writeReplace<\/code> and readResolve<\/code> methods. The basic idea of this pattern is to introduce dedicated companion class for serialization (usually as private static<\/code> inner class), which complements the class required to be serialized. Let us take a look on this example:<\/p>\n
\npublic class SerializationProxyExample implements Serializable {\n    private static final long serialVersionUID = 6163321482548364831L;\n\n    private String str;\n    private int number;        \n    \n    public SerializationProxyExample( final String str, final int number) {\n        this.setStr(str);\n        this.setNumber(number);\n    }\n\n    private void readObject(ObjectInputStream stream) throws InvalidObjectException {\n        throw new InvalidObjectException( \"Serialization Proxy is expected\" );\n    }\n    \n    private Object writeReplace() {\n        return new SerializationProxy( this );\n    }\n    \n    \/\/ Setters and getters here\n}\n\n<\/pre>\n
When the instances of this class are being serialized, the class SerializationProxyExample<\/code> implementation provides the replacement object (instance of the SerializationProxy<\/code> class) instead. It means that instances of the SerializationProxyExample<\/code> class will never be serialized (and deserialized) directly. It also explains why the readObject<\/code> method raises an exception in case a deserialization attempt somehow happens. Now, let us take a look on the companion SerializationProxy<\/code> class:<\/p>\n
\nprivate static class SerializationProxy implements Serializable {\n    private static final long serialVersionUID = 8368440585226546959L;\n\n    private String str;\n    private int number;\n        \n    public SerializationProxy( final SerializationProxyExample instance ) {\n        this.str = instance.getStr();\n        this.number = instance.getNumber();\n    }\n        \n    private Object readResolve() {\n        return new SerializationProxyExample(str, number); \/\/ Uses public constructor\n    }\n}\n\n<\/pre>\n
In our somewhat simplified case, the SerializationProxy<\/code> class just duplicates all the fields of the SerializationProxyExample<\/code> (but it could be much complicated than that). Consequently, when the instances of this class are being deserialized, the readResolve<\/code> method is called and SerializationProxy<\/code> provides the replacement as well, this time in a shape of SerializationProxyExample<\/code> instance. As such, the SerializationProxy<\/code> class serves as a serialization proxy for SerializationProxyExample<\/code> class.<\/p>\n
<\/a>5. Serializability and Remote Method Invocation (RMI)<\/h2>\n
For quite some time, Java Remote Method Invocation (RMI<\/b>) was the only mechanism available for building distributed applications on Java platform. RMI<\/b> provides all the heavy lifting and makes it possible to transparently invoke the methods of remote Java objects from other JVMs on the same host or on different physical (or virtual) hosts. In the foundation of RMI<\/b> lays object serialization, which is used to marshal (serialize) and unmarshal (deserialize) method parameters.<\/p>\n
RMI<\/b> is still being used in many Java applications nowadays, but it lesser and lesser becomes a choice because of its complexity and communication restrictions (most of the firewalls do block RMI<\/b> ports). To get more details about RMI<\/b> please refer to official documentation<\/a>.<\/p>\n
<\/a>6. JAXB<\/h2>\n
Java Architecture for XML Binding, or just JAXB<\/b>, is probably the oldest alternative serialization mechanism available to Java developers. Underneath, it uses XML as the serialization format, provides a wide range of customization options and includes a lot of annotations which makes JAXB<\/b> very appealing and easy to use (annotations are covered in part 5<\/b> of the tutorial, How and when to use Enums and Annotations<\/a><\/b>). <\/p>\n
Let us take a look on a quite simplified example of the plain old Java class (POJO) annotated with JAXB<\/b> annotations:<\/p>\n
\nimport java.math.BigDecimal;\nimport javax.xml.bind.annotation.XmlAccessType;\nimport javax.xml.bind.annotation.XmlAccessorType;\nimport javax.xml.bind.annotation.XmlElement;\nimport javax.xml.bind.annotation.XmlRootElement;\n\n@XmlAccessorType( XmlAccessType.FIELD )\n@XmlRootElement( name = \"example\" )\npublic class JaxbExample {\n    @XmlElement(required = true) private String str;\n    @XmlElement(required = true) private BigDecimal number;\n    \n    \/\/ Setters and getters here\n}\n<\/pre>\n
To serialize the instance of this class into XML format using JAXB<\/b> infrastructure, the only thing needed is the instance of the marshaller (or serializer), for example:<\/p>\n
\nfinal JAXBContext context = JAXBContext.newInstance( JaxbExample.class );        \nfinal Marshaller marshaller = context.createMarshaller();\n     \nfinal JaxbExample example = new JaxbExample();\nexample.setStr( \"Some string\" );\nexample.setNumber( new BigDecimal( 12.33d, MathContext.DECIMAL64 ) );\n        \ntry( final StringWriter writer = new StringWriter() ) {\n    marshaller.marshal( example, writer );\n}\n<\/pre>\n
Here is the XML representation of the JaxbExample<\/code> class instance from the example above:<\/p>\n
\n<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n<example>\n    <str>Some string<\/str>\n    <number>12.33000000000000<\/number>\n<\/example>\n\n<\/pre>\n
Following the same principle, the instances of the class could be deserialized back from XML representation into the Java objects using the instance of the unmarshaller (or deserializer), for example:<\/p>\n
\nfinal JAXBContext context = JAXBContext.newInstance( JaxbExample.class );\n        \nfinal String xml = \"\" +\n    \"<?xml version=\\\\\"1.0\\\\\" encoding=\\\\\"UTF-8\\\\\" standalone=\\\\\"yes\\\\\"?>\" +\n    \"<example>\" +\n    \"    <str>Some string<\/str>\" +\n    \"    <number>12.33000000000000<\/number>\" +\n    \"<\/example>\";\n        \nfinal Unmarshaller unmarshaller = context.createUnmarshaller();\ntry( final StringReader reader = new StringReader( xml ) ) {\n    final JaxbExample example = ( JaxbExample )unmarshaller.unmarshal( reader );\n    \/\/ Some implementaion here\n}\n<\/pre>\n
As we can see, JAXB<\/b> is quite easy to use and the XML format is still quite popular choice nowadays. However, one of the fundamental pitfalls of XML is verbosity: quite often the necessary XML structural elements significantly surpass the effective data payload.
\n[ulp id=’w6F4W4SAMiyTapBF’]
\n <\/p>\n
<\/a>7. JSON-P<\/h2>\n
Since 2013, Java developers are able to use JSON<\/b> as the serialization format, by virtue of newly introduced Java API for JSON Processing (JSON-P<\/b>). <\/p>\n
As of now, JSON-P<\/b> is not a part of Java standard library although there are many discussions to include native JSON<\/b> support into the language in the upcoming Java 9<\/b> release (http:\/\/openjdk.java.net\/jeps\/198<\/a>). Nevertheless, it is there and available as part of Java JSON Processing Reference Implementation<\/b> (https:\/\/jsonp.java.net\/<\/a>). <\/p>\n
In contrast to JAXB<\/b>, there is nothing required to be added to the class to make it suitable for JSON<\/b> serialization, for example:<\/p>\n
\npublic class JsonExample {\n    private String str;\n    private BigDecimal number;\n    \/\/ Setters and getters here\n}\n<\/pre>\n
The serialization is not as transparent as with JAXB<\/b>, and requires a bit of code to be written for each class intended to be serialized into JSON<\/b>, for example:<\/p>\n
\nfinal JsonExample example = new JsonExample();\nexample.setStr( \"Some string\" );\nexample.setNumber( new BigDecimal( 12.33d, MathContext.DECIMAL64 ) );\n        \ntry( final StringWriter writer = new StringWriter() ) {\n    Json.createWriter(writer).write( \n        Json.createObjectBuilder()\n            .add(\"str\", example.getStr() )\n            .add(\"number\", example.getNumber() )\n            .build()\n        );\n}\n<\/pre>\n
And here is the JSON<\/b> representation of the JsonExample<\/code> class instance from the example above:<\/p>\n
\n{\n    \"str\":\"Some string\",\n    \"number\":12.33000000000000\n}\n\n<\/pre>\n
The deserialization process goes in the same vein:<\/p>\n
\nfinal String json = \"{\\\\\"str\\\\\":\\\\\"Some string\\\\\",\\\\\"number\\\\\":12.33000000000000}\";  \n      \ntry( final StringReader reader = new StringReader( json ) ) {\n    final JsonObject obj = Json.createReader( reader ).readObject();\n    final JsonExample example = new JsonExample();\n    example.setStr( obj.getString( \"str\" ) );\n    example.setNumber( obj.getJsonNumber( \"number\" ).bigDecimalValue() );\n}\n<\/pre>\n
It is fair to say that at the moment JSON<\/b> support in Java is pretty basic. Nonetheless it is a great thing to have and Java community is working on enriching the JSON<\/b> support by introducing Java API for JSON Binding<\/b> (JSON-B, JSR-367<\/a>). With this API the serialization and deserialization of the Java objects to\/from JSON<\/b> should be as transparent as JAXB<\/b> has.<\/p>\n
<\/a>8. Cost of serialization<\/h2>\n
It is very important to understand that though serialization \/ deserialization looks simple in Java, it is not free and depending on the data model and data access patterns may consume quite a lot of network bandwidth, memory and CPU resources. More to that, nevertheless Java has some kind of versioning support for the serializable classes (using serial version UID<\/b> as we have seen in the section Serializable interface<\/a>), it does make the development process much harder as developers are on their own to figure out how to manage data model evolution.<\/p>\n
To add another point, Java serialization does not work well outside of JVM world. It is a significant constraint for the modern distributed applications which are built using multiple programming languages and runtimes.<\/p>\n
That explains why many alternative serialization frameworks and solutions have emerged and became very popular choice in the Java ecosystem.<\/p>\n
<\/a>9. Beyond Java standard library and specifications<\/h2>\n
In this section we are going to look on alternative solutions for painless and effective Java serialization, starting from the Fast-serialization<\/b> project (http:\/\/ruedigermoeller.github.io\/fast-serialization\/<\/a>): the fast Java serialization drop in-replacement. The usage of Fast-serialization<\/b> is not much different from what Java standard library provides but it claims to be much faster and more effective.<\/p>\n
Another set of frameworks has a different take on the problem. They are based on structured data definition (or protocol) and serialize data into compact binary representation (the corresponding data model could be even generated from the definition). Aside from that, those frameworks are going far beyond just Java platform and can be used for cross-language \/ cross-platform serialization. The most known Java libraries in this space are Google Protocol Buffers<\/b> (https:\/\/developers.google.com\/protocol-buffers\/<\/a>), Apache Avro<\/b> (http:\/\/avro.apache.org\/<\/a>) and Apache Thrift<\/b> (https:\/\/thrift.apache.org\/<\/a>).<\/p>\n
<\/a>10. What\u2019s next<\/h2>\n
In this part of the tutorial we have discussed the built-in serialization techniques provided by the Java language and its runtime. We have seen how important serialization is today, when mostly every single application being built is a part of larger distributed system and needs to communicate with the rest of it (or with other external systems). In the next part of the tutorial we are going to talk about reflection and dynamic languages support in Java.<\/p>\n
<\/a>11. Download the Source code<\/h2>\n
You can dowload the source code of this course here: advanced-java-part-10<\/a><\/strong><\/p>\n","protected":false},"excerpt":{"rendered":"
This article is part of our Academy Course titled Advanced Java. This course is designed to help you make the most effective use of Java. It discusses advanced topics, including object creation, concurrency, serialization, reflection and many more. It will guide you through your journey to Java mastery! Check it out here! Table Of Contents …<\/p>\n","protected":false},"author":141,"featured_media":148,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[7],"tags":[343,88,580,557,65],"class_list":["post-43714","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-core-java","tag-annotations","tag-concurrency","tag-generics","tag-reflection","tag-serialization"],"yoast_head":"\nBuilt-in Serialization techniques - Java Code Geeks<\/title>\n<meta name=\"description\" content=\"This article is part of our Academy Course titled Advanced Java. This course is designed to help you make the most effective use of Java. It discusses\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.javacodegeeks.com\/2015\/09\/built-in-serialization-techniques.html\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Built-in Serialization techniques - Java Code Geeks\" \/>\n<meta property=\"og:description\" content=\"This article is part of our Academy Course titled Advanced Java. This course is designed to help you make the most effective use of Java. It discusses\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.javacodegeeks.com\/2015\/09\/built-in-serialization-techniques.html\" \/>\n<meta property=\"og:site_name\" content=\"Java Code Geeks\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/javacodegeeks\" \/>\n<meta property=\"article:published_time\" content=\"2015-09-18T18:51:22+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-12-06T10:17:00+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/java-logo.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"150\" \/>\n\t<meta property=\"og:image:height\" content=\"150\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Andrey Redko\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@javacodegeeks\" \/>\n<meta name=\"twitter:site\" content=\"@javacodegeeks\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Andrey Redko\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"9 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/built-in-serialization-techniques.html#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/built-in-serialization-techniques.html\"},\"author\":{\"name\":\"Andrey Redko\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#\\\/schema\\\/person\\\/771a6504862edc45322776832cbce413\"},\"headline\":\"Built-in Serialization techniques\",\"datePublished\":\"2015-09-18T18:51:22+00:00\",\"dateModified\":\"2023-12-06T10:17:00+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/built-in-serialization-techniques.html\"},\"wordCount\":1965,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/built-in-serialization-techniques.html#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2012\\\/10\\\/java-logo.jpg\",\"keywords\":[\"Annotations\",\"Concurrency\",\"Generics\",\"Reflection\",\"Serialization\"],\"articleSection\":[\"Core Java\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/built-in-serialization-techniques.html#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/built-in-serialization-techniques.html\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/built-in-serialization-techniques.html\",\"name\":\"Built-in Serialization techniques - Java Code Geeks\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/built-in-serialization-techniques.html#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/built-in-serialization-techniques.html#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2012\\\/10\\\/java-logo.jpg\",\"datePublished\":\"2015-09-18T18:51:22+00:00\",\"dateModified\":\"2023-12-06T10:17:00+00:00\",\"description\":\"This article is part of our Academy Course titled Advanced Java. This course is designed to help you make the most effective use of Java. It discusses\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/built-in-serialization-techniques.html#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/built-in-serialization-techniques.html\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/built-in-serialization-techniques.html#primaryimage\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2012\\\/10\\\/java-logo.jpg\",\"contentUrl\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2012\\\/10\\\/java-logo.jpg\",\"width\":150,\"height\":150},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2015\\\/09\\\/built-in-serialization-techniques.html#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/www.javacodegeeks.com\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Java\",\"item\":\"https:\\\/\\\/www.javacodegeeks.com\\\/category\\\/java\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Core Java\",\"item\":\"https:\\\/\\\/www.javacodegeeks.com\\\/category\\\/java\\\/core-java\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Built-in Serialization techniques\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#website\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/\",\"name\":\"Java Code Geeks\",\"description\":\"Java Developers Resource Center\",\"publisher\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#organization\"},\"alternateName\":\"JCG\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.javacodegeeks.com\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#organization\",\"name\":\"Exelixis Media P.C.\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2022\\\/06\\\/exelixis-logo.png\",\"contentUrl\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2022\\\/06\\\/exelixis-logo.png\",\"width\":864,\"height\":246,\"caption\":\"Exelixis Media P.C.\"},\"image\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/www.facebook.com\\\/javacodegeeks\",\"https:\\\/\\\/x.com\\\/javacodegeeks\"]},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#\\\/schema\\\/person\\\/771a6504862edc45322776832cbce413\",\"name\":\"Andrey Redko\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/16419ce8394173028eddaeb992859862bab50cfcf74589fa9bb9a3dd8bb27518?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/16419ce8394173028eddaeb992859862bab50cfcf74589fa9bb9a3dd8bb27518?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/16419ce8394173028eddaeb992859862bab50cfcf74589fa9bb9a3dd8bb27518?s=96&d=mm&r=g\",\"caption\":\"Andrey Redko\"},\"description\":\"Andriy is a well-grounded software developer with more then 12 years of practical experience using Java\\\/EE, C#\\\/.NET, C++, Groovy, Ruby, functional programming (Scala), databases (MySQL, PostgreSQL, Oracle) and NoSQL solutions (MongoDB, Redis).\",\"sameAs\":[\"http:\\\/\\\/aredko.blogspot.com\\\/\",\"http:\\\/\\\/ca.linkedin.com\\\/in\\\/aredko\"],\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/author\\\/andrey-redko\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Built-in Serialization techniques - Java Code Geeks","description":"This article is part of our Academy Course titled Advanced Java. This course is designed to help you make the most effective use of Java. It discusses","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.javacodegeeks.com\/2015\/09\/built-in-serialization-techniques.html","og_locale":"en_US","og_type":"article","og_title":"Built-in Serialization techniques - Java Code Geeks","og_description":"This article is part of our Academy Course titled Advanced Java. This course is designed to help you make the most effective use of Java. It discusses","og_url":"https:\/\/www.javacodegeeks.com\/2015\/09\/built-in-serialization-techniques.html","og_site_name":"Java Code Geeks","article_publisher":"https:\/\/www.facebook.com\/javacodegeeks","article_published_time":"2015-09-18T18:51:22+00:00","article_modified_time":"2023-12-06T10:17:00+00:00","og_image":[{"width":150,"height":150,"url":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/java-logo.jpg","type":"image\/jpeg"}],"author":"Andrey Redko","twitter_card":"summary_large_image","twitter_creator":"@javacodegeeks","twitter_site":"@javacodegeeks","twitter_misc":{"Written by":"Andrey Redko","Est. reading time":"9 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.javacodegeeks.com\/2015\/09\/built-in-serialization-techniques.html#article","isPartOf":{"@id":"https:\/\/www.javacodegeeks.com\/2015\/09\/built-in-serialization-techniques.html"},"author":{"name":"Andrey Redko","@id":"https:\/\/www.javacodegeeks.com\/#\/schema\/person\/771a6504862edc45322776832cbce413"},"headline":"Built-in Serialization techniques","datePublished":"2015-09-18T18:51:22+00:00","dateModified":"2023-12-06T10:17:00+00:00","mainEntityOfPage":{"@id":"https:\/\/www.javacodegeeks.com\/2015\/09\/built-in-serialization-techniques.html"},"wordCount":1965,"commentCount":0,"publisher":{"@id":"https:\/\/www.javacodegeeks.com\/#organization"},"image":{"@id":"https:\/\/www.javacodegeeks.com\/2015\/09\/built-in-serialization-techniques.html#primaryimage"},"thumbnailUrl":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/java-logo.jpg","keywords":["Annotations","Concurrency","Generics","Reflection","Serialization"],"articleSection":["Core Java"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.javacodegeeks.com\/2015\/09\/built-in-serialization-techniques.html#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.javacodegeeks.com\/2015\/09\/built-in-serialization-techniques.html","url":"https:\/\/www.javacodegeeks.com\/2015\/09\/built-in-serialization-techniques.html","name":"Built-in Serialization techniques - Java Code Geeks","isPartOf":{"@id":"https:\/\/www.javacodegeeks.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.javacodegeeks.com\/2015\/09\/built-in-serialization-techniques.html#primaryimage"},"image":{"@id":"https:\/\/www.javacodegeeks.com\/2015\/09\/built-in-serialization-techniques.html#primaryimage"},"thumbnailUrl":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/java-logo.jpg","datePublished":"2015-09-18T18:51:22+00:00","dateModified":"2023-12-06T10:17:00+00:00","description":"This article is part of our Academy Course titled Advanced Java. This course is designed to help you make the most effective use of Java. It discusses","breadcrumb":{"@id":"https:\/\/www.javacodegeeks.com\/2015\/09\/built-in-serialization-techniques.html#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.javacodegeeks.com\/2015\/09\/built-in-serialization-techniques.html"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.javacodegeeks.com\/2015\/09\/built-in-serialization-techniques.html#primaryimage","url":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/java-logo.jpg","contentUrl":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/java-logo.jpg","width":150,"height":150},{"@type":"BreadcrumbList","@id":"https:\/\/www.javacodegeeks.com\/2015\/09\/built-in-serialization-techniques.html#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.javacodegeeks.com\/"},{"@type":"ListItem","position":2,"name":"Java","item":"https:\/\/www.javacodegeeks.com\/category\/java"},{"@type":"ListItem","position":3,"name":"Core Java","item":"https:\/\/www.javacodegeeks.com\/category\/java\/core-java"},{"@type":"ListItem","position":4,"name":"Built-in Serialization techniques"}]},{"@type":"WebSite","@id":"https:\/\/www.javacodegeeks.com\/#website","url":"https:\/\/www.javacodegeeks.com\/","name":"Java Code Geeks","description":"Java Developers Resource Center","publisher":{"@id":"https:\/\/www.javacodegeeks.com\/#organization"},"alternateName":"JCG","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.javacodegeeks.com\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/www.javacodegeeks.com\/#organization","name":"Exelixis Media P.C.","url":"https:\/\/www.javacodegeeks.com\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.javacodegeeks.com\/#\/schema\/logo\/image\/","url":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2022\/06\/exelixis-logo.png","contentUrl":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2022\/06\/exelixis-logo.png","width":864,"height":246,"caption":"Exelixis Media P.C."},"image":{"@id":"https:\/\/www.javacodegeeks.com\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/javacodegeeks","https:\/\/x.com\/javacodegeeks"]},{"@type":"Person","@id":"https:\/\/www.javacodegeeks.com\/#\/schema\/person\/771a6504862edc45322776832cbce413","name":"Andrey Redko","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/16419ce8394173028eddaeb992859862bab50cfcf74589fa9bb9a3dd8bb27518?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/16419ce8394173028eddaeb992859862bab50cfcf74589fa9bb9a3dd8bb27518?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/16419ce8394173028eddaeb992859862bab50cfcf74589fa9bb9a3dd8bb27518?s=96&d=mm&r=g","caption":"Andrey Redko"},"description":"Andriy is a well-grounded software developer with more then 12 years of practical experience using Java\/EE, C#\/.NET, C++, Groovy, Ruby, functional programming (Scala), databases (MySQL, PostgreSQL, Oracle) and NoSQL solutions (MongoDB, Redis).","sameAs":["http:\/\/aredko.blogspot.com\/","http:\/\/ca.linkedin.com\/in\/aredko"],"url":"https:\/\/www.javacodegeeks.com\/author\/andrey-redko"}]}},"_links":{"self":[{"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/posts\/43714","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/users\/141"}],"replies":[{"embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/comments?post=43714"}],"version-history":[{"count":0,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/posts\/43714\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/media\/148"}],"wp:attachment":[{"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/media?parent=43714"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/categories?post=43714"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/tags?post=43714"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}