{"id":98,"date":"2023-04-03T05:30:24","date_gmt":"2023-04-03T05:30:24","guid":{"rendered":"https:\/\/www.w3computing.com\/articles\/?p=98"},"modified":"2023-08-23T16:22:33","modified_gmt":"2023-08-23T16:22:33","slug":"java-object-serialization-and-custom-serialization-techniques","status":"publish","type":"post","link":"https:\/\/www.w3computing.com\/articles\/java-object-serialization-and-custom-serialization-techniques\/","title":{"rendered":"Java Object Serialization and Custom Serialization Techniques"},"content":{"rendered":"\n

Java Object Serialization is a mechanism that allows developers to convert an object’s state into a byte stream, which can then be transmitted or stored. Once the object’s state is saved, it can be reconstructed later by deserializing the byte stream. This is particularly useful in cases where object data needs to be preserved across application restarts or sent over a network.<\/p>\n\n\n\n

In this article, we will delve into Java Object Serialization and Custom Serialization Techniques. The target audience is experienced developers who are looking to enhance their understanding of this topic and leverage its full potential.<\/p>\n\n\n\n

1. Overview of Java Object Serialization<\/h2>\n\n\n\n

Java Object Serialization is a built-in feature of the Java programming language that allows objects to be easily converted into a platform-independent byte stream. This byte stream can then be stored or transmitted and later deserialized back into an object. To make a Java object serializable, it must implement the Serializable interface, which is a marker interface with no methods:<\/p>\n\n\n

import<\/span> java.io.Serializable;\r\n\r\npublic<\/span> class<\/span> MyClass<\/span> implements<\/span> Serializable<\/span> <\/span>{\r\n    \/\/ Class implementation<\/span>\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
2. Advantages and Disadvantages of Java Object Serialization<\/h2>\n\n\n\n
Advantages:<\/strong><\/p>\n\n\n\n
    \n
  • Simplifies the process of storing and retrieving object data.<\/li>\n\n\n\n
  • Promotes data portability by allowing objects to be transmitted across different Java Virtual Machines (JVMs).<\/li>\n\n\n\n
  • Provides a flexible and customizable serialization mechanism.<\/li>\n<\/ul>\n\n\n\n
    Disadvantages<\/strong>:<\/p>\n\n\n\n
      \n
    • Can lead to performance overhead, as objects must be serialized and deserialized.<\/li>\n\n\n\n
    • May result in security vulnerabilities if not implemented carefully.<\/li>\n\n\n\n
    • Serialized data may become incompatible if a class’s structure changes, leading to potential deserialization issues.<\/li>\n<\/ul>\n\n\n\n
      3. Custom Serialization Techniques<\/h2>\n\n\n\n
      Java’s default serialization mechanism may not always meet the specific requirements of a project. In such cases, developers can implement custom serialization techniques, such as:<\/p>\n\n\n\n
      3.1. Implementing Externalizable<\/h3>\n\n\n\n
      The Externalizable interface extends Serializable and provides two methods, writeExternal()<\/strong><\/code> and readExternal()<\/code><\/strong>, which allow developers to take full control over the serialization process:<\/p>\n\n\n
      import<\/span> java.io.Externalizable;\r\nimport<\/span> java.io.ObjectInput;\r\nimport<\/span> java.io.ObjectOutput;\r\n\r\npublic<\/span> class<\/span> MyClass<\/span> implements<\/span> Externalizable<\/span> <\/span>{\r\n    \/\/ Class implementation<\/span>\r\n\r\n    @Override<\/span>\r\n    public<\/span> void<\/span> writeExternal<\/span>(ObjectOutput out)<\/span> <\/span>{\r\n        \/\/ Custom serialization logic<\/span>\r\n    }\r\n\r\n    @Override<\/span>\r\n    public<\/span> void<\/span> readExternal<\/span>(ObjectInput in)<\/span> <\/span>{\r\n        \/\/ Custom deserialization logic<\/span>\r\n    }\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
      3.2. Custom Serialization using readObject()<\/code> and writeObject()<\/code><\/h3>\n\n\n\n
      Developers can override the readObject()<\/strong><\/code> and writeObject()<\/strong><\/code> methods in their class to implement custom serialization logic:<\/p>\n\n\n
      import<\/span> java.io.IOException;\r\nimport<\/span> java.io.ObjectInputStream;\r\nimport<\/span> java.io.ObjectOutputStream;\r\nimport<\/span> java.io.Serializable;\r\n\r\npublic<\/span> class<\/span> MyClass<\/span> implements<\/span> Serializable<\/span> <\/span>{\r\n    \/\/ Class implementation<\/span>\r\n\r\n    private<\/span> void<\/span> writeObject<\/span>(ObjectOutputStream out)<\/span> throws<\/span> IOException <\/span>{\r\n        \/\/ Custom serialization logic<\/span>\r\n    }\r\n\r\n    private<\/span> void<\/span> readObject<\/span>(ObjectInputStream in)<\/span> throws<\/span> IOException, ClassNotFoundException <\/span>{\r\n        \/\/ Custom deserialization logic<\/span>\r\n    }\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
      3.3. Custom Serialization Proxies<\/h3>\n\n\n\n
      Serialization proxies provide a separate class responsible for the serialization and deserialization of an object. This can be useful when dealing with complex class hierarchies or when separating the serialization logic from the main class is desired:<\/p>\n\n\n
      import<\/span> java.io.InvalidObjectException;\r\nimport<\/span> java.io.ObjectInputStream;\r\nimport<\/span> java.io.Serializable;\r\nimport<\/span> java.io.ObjectStreamException;\r\n\r\npublic<\/span> class<\/span> MyClass<\/span> implements<\/span> Serializable<\/span> <\/span>{\r\n    \/\/ Class implementation<\/span>\r\n\r\n    private<\/span> Object writeReplace<\/span>()<\/span> <\/span>{\r\n        return<\/span> new<\/span> MyClassProxy(this<\/span>);\r\n    }\r\n\r\n    private<\/span> void<\/span> readObject<\/span>(ObjectInputStream stream)<\/span> throws<\/span> InvalidObjectException <\/span>{\r\n        throw<\/span> new<\/span> InvalidObjectException(\"Use serialization proxy instead\"<\/span>);\r\n    }\r\n\r\n    private<\/span> static<\/span> class<\/span> MyClassProxy<\/span> implements<\/span> Serializable<\/span> <\/span>{\r\n        \/\/ Custom serialization logic and data<\/span>\r\n\r\n        MyClassProxy(MyClass myClass) {\r\n            \/\/ Initialize proxy with data from myClass<\/span>\r\n        }\r\n\r\n        private<\/span> Object readResolve<\/span>()<\/span> <\/span>{\r\n            \/\/ Create and return a new MyClass object using the proxy data<\/span>\r\n        }\r\n    }\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
      4. Security Considerations in Java Serialization<\/h2>\n\n\n\n
      Serialization can introduce security risks if not properly implemented. To mitigate these risks, consider the following best practices:<\/p>\n\n\n\n
        \n
      • Limit the use of serialization to trusted data sources.<\/li>\n\n\n\n
      • Utilize the transient keyword for sensitive fields that should not be serialized.<\/li>\n\n\n\n
      • Validate input data during deserialization.<\/li>\n\n\n\n
      • Implement a custom serialization process for better control over data handling.<\/li>\n<\/ul>\n\n\n\n
        5. Alternatives to Java Serialization<\/h2>\n\n\n\n
        While Java’s built-in serialization mechanism is powerful, it may not be suitable for all use cases. Alternatives to consider include:<\/p>\n\n\n\n
          \n
        • JSON<\/strong>: JSON (JavaScript Object Notation) is a lightweight, human-readable data interchange format that can be used for serialization and deserialization of objects.<\/li>\n\n\n\n
        • XML<\/strong>: XML (eXtensible Markup Language) is a markup language that can represent structured data and is suitable for both human and machine readability.<\/li>\n\n\n\n
        • Protocol Buffers<\/strong>: Developed by Google, Protocol Buffers is a language- and platform-neutral mechanism for serializing structured data, offering high efficiency and strong backward and forward compatibility.<\/li>\n<\/ul>\n\n\n\n
          Exercise:<\/h2>\n\n\n\n
          Implement Custom Serialization for a Complex E-commerce Order Class<\/strong><\/p>\n\n\n\n
          Objective<\/strong>: To implement custom serialization for a complex E-commerce Order class using the writeObject()<\/code><\/strong> and readObject()<\/strong><\/code> methods.<\/p>\n\n\n\n
          Requirements:<\/strong><\/p>\n\n\n\n
            \n
          1. Create an Order class that implements the Serializable interface.\n
              \n
            • The class should have the following fields:<\/li>\n\n\n\n
            • orderID (String)<\/li>\n\n\n\n
            • customer (Customer)<\/li>\n\n\n\n
            • items (List)<\/li>\n\n\n\n
            • orderDate (LocalDate)<\/li>\n\n\n\n
            • shippingAddress (Address)<\/li>\n\n\n\n
            • billingAddress (Address)<\/li>\n\n\n\n
            • paymentMethod (PaymentMethod)<\/li>\n<\/ul>\n<\/li>\n\n\n\n
            • Implement custom serialization using the writeObject()<\/code><\/strong> and readObject()<\/strong><\/code> methods.<\/li>\n\n\n\n
            • Write a test program to serialize and deserialize instances of the Order class.<\/li>\n<\/ol>\n\n\n\n
              Instructions:<\/strong><\/p>\n\n\n\n
              Create a new Java project in your favorite IDE.<\/p>\n\n\n\n
              Define the supporting classes: Customer, Item, Address, and PaymentMethod.<\/p>\n\n\n
              import<\/span> java.io.Serializable;\r\n\r\npublic<\/span> class<\/span> Customer<\/span> implements<\/span> Serializable<\/span> <\/span>{\r\n    \/\/ Implementation of the Customer class<\/span>\r\n}\r\n\r\npublic<\/span> class<\/span> Item<\/span> implements<\/span> Serializable<\/span> <\/span>{\r\n    \/\/ Implementation of the Item class<\/span>\r\n}\r\n\r\npublic<\/span> class<\/span> Address<\/span> implements<\/span> Serializable<\/span> <\/span>{\r\n    \/\/ Implementation of the Address class<\/span>\r\n}\r\n\r\npublic<\/span> class<\/span> PaymentMethod<\/span> implements<\/span> Serializable<\/span> <\/span>{\r\n    \/\/ Implementation of the PaymentMethod class<\/span>\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
              Create a new class named “Order” and implement the Serializable interface:<\/p>\n\n\n
              import<\/span> java.io.Serializable;\r\nimport<\/span> java.time.LocalDate;\r\nimport<\/span> java.util.List;\r\n\r\npublic<\/span> class<\/span> Order<\/span> implements<\/span> Serializable<\/span> <\/span>{\r\n    private<\/span> String orderID;\r\n    private<\/span> Customer customer;\r\n    private<\/span> List<Item> items;\r\n    private<\/span> LocalDate orderDate;\r\n    private<\/span> Address shippingAddress;\r\n    private<\/span> Address billingAddress;\r\n    private<\/span> PaymentMethod paymentMethod;\r\n\r\n    public<\/span> Order<\/span>(String orderID, Customer customer, List<Item> items, LocalDate orderDate, Address shippingAddress, Address billingAddress, PaymentMethod paymentMethod)<\/span> <\/span>{\r\n        this<\/span>.orderID = orderID;\r\n        this<\/span>.customer = customer;\r\n        this<\/span>.items = items;\r\n        this<\/span>.orderDate = orderDate;\r\n        this<\/span>.shippingAddress = shippingAddress;\r\n        this<\/span>.billingAddress = billingAddress;\r\n        this<\/span>.paymentMethod = paymentMethod;\r\n    }\r\n\r\n    \/\/ Add getters and setters<\/span>\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
              Implement the writeObject()<\/code><\/strong> and readObject()<\/code><\/strong> methods for custom serialization:<\/p>\n\n\n
              import<\/span> java.io.IOException;\r\nimport<\/span> java.io.ObjectInputStream;\r\nimport<\/span> java.io.ObjectOutputStream;\r\n\r\n\/\/ ...<\/span>\r\n\r\nprivate<\/span> void<\/span> writeObject<\/span>(ObjectOutputStream out)<\/span> throws<\/span> IOException <\/span>{\r\n    out.writeObject(orderID);\r\n    out.writeObject(customer);\r\n    out.writeObject(items);\r\n    out.writeObject(orderDate.toString()); \/\/ Serialize as a String<\/span>\r\n    out.writeObject(shippingAddress);\r\n    out.writeObject(billingAddress);\r\n    out.writeObject(paymentMethod);\r\n}\r\n\r\nprivate<\/span> void<\/span> readObject<\/span>(ObjectInputStream in)<\/span> throws<\/span> IOException, ClassNotFoundException <\/span>{\r\n    orderID = (String) in.readObject();\r\n    customer = (Customer) in.readObject();\r\n    items = (List<Item>) in.readObject();\r\n    orderDate = LocalDate.parse((String) in.readObject()); \/\/ Deserialize from a String<\/span>\r\n    shippingAddress = (Address) in.readObject();\r\n    billingAddress = (Address) in.readObject();\r\n    paymentMethod = (PaymentMethod) in.readObject();\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
              Create a test program to serialize and deserialize instances of the Order class:<\/p>\n\n\n
              import<\/span> java.io.*;\r\nimport<\/span> java.time.LocalDate;\r\nimport<\/span> java.util.ArrayList;\r\nimport<\/span> java.util.List;\r\n\r\npublic<\/span> class<\/span> OrderTest<\/span> <\/span>{\r\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\r\n        \/\/ Create sample data<\/span>\r\n        Customer customer = new<\/span> Customer(\/* ... *\/<\/span>);\r\n        List<Item> items = new<\/span> ArrayList<>();\r\n        items.add(new<\/span> Item(\/* ... *\/<\/span>));\r\n        items.add(new<\/span> Item(\/* ... *\/<\/span>));\r\n        Address shippingAddress = new<\/span> Address(\/* ... *\/<\/span>);\r\n        Address billingAddress = new<\/span> Address(\/* ... *\/<\/span>);\r\n        PaymentMethod paymentMethod = new<\/span> PaymentMethod(\/* ... *\/<\/span>);\r\n\r\n        Order originalOrder = new<\/span> Order(\"ORD123\"<\/span>, customer, items, LocalDate.now(), shippingAddress, billingAddress, paymentMethod);\r\n\r\n        try<\/span> {\r\n            \/\/ Serialize the Order object<\/span>\r\n            FileOutputStream fileOut = new<\/span> FileOutputStream(\"order.ser\"<\/span>);\r\n            ObjectOutputStream out = new<\/span> ObjectOutputStream(fileOut);\r\n            out.writeObject(originalOrder);\r\n            out.close();\r\n            fileOut.close();\r\n\r\n            \/\/ Deserialize the Order object<\/span>\r\n            FileInputStream fileIn = new<\/span> FileInputStream(\"order.ser\"<\/span>);\r\n            ObjectInputStream in = new<\/span> ObjectInputStream(fileIn);\r\n            Order deserializedOrder = (Order) in.readObject();\r\n            in.close();\r\n            fileIn.close();\r\n\r\n            \/\/ Compare the original and deserialized orders<\/span>\r\n            System.out.println(\"Original order: \"<\/span> + originalOrder);\r\n            System.out.println(\"Deserialized order: \"<\/span> + deserializedOrder);\r\n        } catch<\/span> (IOException | ClassNotFoundException e) {\r\n            e.printStackTrace();\r\n        }\r\n    }\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
              Run the test program and observe the output to ensure that the original and deserialized Order instances have the same values for all fields. By completing this exercise, you will have successfully implemented custom serialization for a complex E-commerce Order class and tested the serialization and deserialization process.<\/p>\n\n\n\n
              Conclusion<\/h2>\n\n\n\n
              Java Object Serialization is a powerful feature that allows developers to easily store, transmit, and reconstruct object data. However, it is crucial to understand its limitations, security implications, and customization options. By implementing custom serialization techniques, developers can better tailor their solutions to specific requirements and enhance the security and efficiency of their applications. When Java’s built-in serialization is not suitable, alternatives like JSON, XML, or Protocol Buffers can provide viable solutions for different use cases.<\/p>\n","protected":false},"excerpt":{"rendered":"
              Java Object Serialization is a mechanism that allows developers to convert an object’s state into a byte stream, which can then be transmitted or stored. Once the object’s state is saved, it can be reconstructed later by deserializing the byte stream. This is particularly useful in cases where object data needs to be preserved across […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_genesis_hide_title":false,"_genesis_hide_breadcrumbs":false,"_genesis_hide_singular_image":false,"_genesis_hide_footer_widgets":false,"_genesis_custom_body_class":"","_genesis_custom_post_class":"","_genesis_layout":"","_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[5,4],"tags":[],"class_list":["post-98","post","type-post","status-publish","format-standard","category-java","category-programming-languages","entry"],"yoast_head":"\nJava Object Serialization and Custom Serialization Techniques<\/title>\n<meta name=\"description\" content=\"Java Object Serialization is a mechanism that allows developers to convert an object's state into a byte stream, which can then be transmitted\" \/>\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.w3computing.com\/articles\/java-object-serialization-and-custom-serialization-techniques\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Java Object Serialization and Custom Serialization Techniques\" \/>\n<meta property=\"og:description\" content=\"Java Object Serialization is a mechanism that allows developers to convert an object's state into a byte stream, which can then be transmitted\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.w3computing.com\/articles\/java-object-serialization-and-custom-serialization-techniques\/\" \/>\n<meta property=\"article:published_time\" content=\"2023-04-03T05:30:24+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-08-23T16:22:33+00:00\" \/>\n<meta name=\"author\" content=\"w3compadmin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"w3compadmin\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"6 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"TechArticle\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-object-serialization-and-custom-serialization-techniques\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-object-serialization-and-custom-serialization-techniques\\\/\"},\"author\":{\"name\":\"w3compadmin\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"headline\":\"Java Object Serialization and Custom Serialization Techniques\",\"datePublished\":\"2023-04-03T05:30:24+00:00\",\"dateModified\":\"2023-08-23T16:22:33+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-object-serialization-and-custom-serialization-techniques\\\/\"},\"wordCount\":766,\"commentCount\":0,\"articleSection\":[\"Java\",\"Programming Languages\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-object-serialization-and-custom-serialization-techniques\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-object-serialization-and-custom-serialization-techniques\\\/\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-object-serialization-and-custom-serialization-techniques\\\/\",\"name\":\"Java Object Serialization and Custom Serialization Techniques\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\"},\"datePublished\":\"2023-04-03T05:30:24+00:00\",\"dateModified\":\"2023-08-23T16:22:33+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"description\":\"Java Object Serialization is a mechanism that allows developers to convert an object's state into a byte stream, which can then be transmitted\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-object-serialization-and-custom-serialization-techniques\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-object-serialization-and-custom-serialization-techniques\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-object-serialization-and-custom-serialization-techniques\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Articles Home\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Programming Languages\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/programming-languages\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Java Object Serialization and Custom Serialization Techniques\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\",\"name\":\"Developer Articles Hub\",\"description\":\"\",\"alternateName\":\"Developer Articles\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\",\"name\":\"w3compadmin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"contentUrl\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"caption\":\"w3compadmin\"},\"sameAs\":[\"http:\\\/\\\/w3computing.com\\\/articles\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Java Object Serialization and Custom Serialization Techniques","description":"Java Object Serialization is a mechanism that allows developers to convert an object's state into a byte stream, which can then be transmitted","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.w3computing.com\/articles\/java-object-serialization-and-custom-serialization-techniques\/","og_locale":"en_US","og_type":"article","og_title":"Java Object Serialization and Custom Serialization Techniques","og_description":"Java Object Serialization is a mechanism that allows developers to convert an object's state into a byte stream, which can then be transmitted","og_url":"https:\/\/www.w3computing.com\/articles\/java-object-serialization-and-custom-serialization-techniques\/","article_published_time":"2023-04-03T05:30:24+00:00","article_modified_time":"2023-08-23T16:22:33+00:00","author":"w3compadmin","twitter_card":"summary_large_image","twitter_misc":{"Written by":"w3compadmin","Est. reading time":"6 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"TechArticle","@id":"https:\/\/www.w3computing.com\/articles\/java-object-serialization-and-custom-serialization-techniques\/#article","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/java-object-serialization-and-custom-serialization-techniques\/"},"author":{"name":"w3compadmin","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"headline":"Java Object Serialization and Custom Serialization Techniques","datePublished":"2023-04-03T05:30:24+00:00","dateModified":"2023-08-23T16:22:33+00:00","mainEntityOfPage":{"@id":"https:\/\/www.w3computing.com\/articles\/java-object-serialization-and-custom-serialization-techniques\/"},"wordCount":766,"commentCount":0,"articleSection":["Java","Programming Languages"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.w3computing.com\/articles\/java-object-serialization-and-custom-serialization-techniques\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.w3computing.com\/articles\/java-object-serialization-and-custom-serialization-techniques\/","url":"https:\/\/www.w3computing.com\/articles\/java-object-serialization-and-custom-serialization-techniques\/","name":"Java Object Serialization and Custom Serialization Techniques","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/#website"},"datePublished":"2023-04-03T05:30:24+00:00","dateModified":"2023-08-23T16:22:33+00:00","author":{"@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"description":"Java Object Serialization is a mechanism that allows developers to convert an object's state into a byte stream, which can then be transmitted","breadcrumb":{"@id":"https:\/\/www.w3computing.com\/articles\/java-object-serialization-and-custom-serialization-techniques\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.w3computing.com\/articles\/java-object-serialization-and-custom-serialization-techniques\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.w3computing.com\/articles\/java-object-serialization-and-custom-serialization-techniques\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Articles Home","item":"https:\/\/www.w3computing.com\/articles\/"},{"@type":"ListItem","position":2,"name":"Programming Languages","item":"https:\/\/www.w3computing.com\/articles\/programming-languages\/"},{"@type":"ListItem","position":3,"name":"Java Object Serialization and Custom Serialization Techniques"}]},{"@type":"WebSite","@id":"https:\/\/www.w3computing.com\/articles\/#website","url":"https:\/\/www.w3computing.com\/articles\/","name":"Developer Articles Hub","description":"","alternateName":"Developer Articles","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.w3computing.com\/articles\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561","name":"w3compadmin","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","url":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","contentUrl":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","caption":"w3compadmin"},"sameAs":["http:\/\/w3computing.com\/articles"]}]}},"featured_image_src":null,"featured_image_src_square":null,"author_info":{"display_name":"w3compadmin","author_link":"https:\/\/www.w3computing.com\/articles\/author\/w3compadmin\/"},"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/98","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/comments?post=98"}],"version-history":[{"count":3,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/98\/revisions"}],"predecessor-version":[{"id":105,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/98\/revisions\/105"}],"wp:attachment":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/media?parent=98"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/categories?post=98"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/tags?post=98"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}