Serialization in Java

-

Serialization in Java is a mechanism of converting the state of an object into a byte stream. This byte stream can be persisted into a file, transferred over a network, or stored in a database. The reverse process of recreating an object from the byte stream is known as Deserialization.

✨ Why Serialization?

  • To save the state of an object for later use (Persistence).
  • To send objects between JVMs (Distributed applications, RMI, Messaging).
  • To cache data temporarily.
  • To store objects in databases or files.

⚙️ How Serialization Works

Serialization is implemented using the java.io.Serializable interface. This is a marker interface (does not contain methods) that signals the JVM that the class can be serialized.

Basic Example:

import java.io.*;

class Student implements Serializable {
    int id;
    String name;

    Student(int id, String name) {
        this.id = id;
        this.name = name;
    }
}

public class SerializationDemo {
    public static void main(String[] args) throws Exception {
        Student s1 = new Student(101, "John Doe");

        // Serialization
        FileOutputStream fos = new FileOutputStream("student.ser");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(s1);
        oos.close();
        fos.close();

        System.out.println("Object has been serialized");

        // Deserialization
        FileInputStream fis = new FileInputStream("student.ser");
        ObjectInputStream ois = new ObjectInputStream(fis);
        Student s2 = (Student) ois.readObject();
        ois.close();
        fis.close();

        System.out.println("Deserialized Student: " + s2.id + ", " + s2.name);
    }
}

🔑 Important Keywords in Serialization

1. Transient Variables

A variable declared with the transient keyword is not serialized. During deserialization, it will be initialized with its default value (0 for int, null for objects, false for boolean). 

class Employee implements Serializable {
    String name;
    transient String password; // will not be serialized

    Employee(String name, String password) {
        this.name = name;
        this.password = password;
    }
}

2. Static Variables

Static variables are not serialized because they belong to the class, not an instance. During deserialization, they are initialized with the class value at runtime.

3. Final Variables

Final variables are included in serialization as their values. Declaring a final variable as transient is meaningless.

4. Transient vs Volatile

  • Transient: Excludes a field from serialization.
  • Volatile: Ensures threads read the most updated value (but does not affect serialization).

🆔 serialVersionUID

Every Serializable class has a unique identifier called serialVersionUID. It is used during deserialization to verify that the sender and receiver of a serialized object are compatible. If not declared manually, JVM generates one automatically (but may change if class structure changes). 

class Student implements Serializable {
    private static final long serialVersionUID = 1L;
    int id;
    String name;
}

Best Practice: Always declare serialVersionUID explicitly to avoid InvalidClassException.

📝 Custom Serialization

Sometimes we want more control over what gets serialized. We can override writeObject() and readObject() methods. 

class Account implements Serializable {
    String username;
    transient String password;

    private void writeObject(ObjectOutputStream oos) throws Exception {
        oos.defaultWriteObject();
        // custom encryption
        oos.writeObject("ENCRYPTED_" + password);
    }

    private void readObject(ObjectInputStream ois) throws Exception {
        ois.defaultReadObject();
        String encryptedPwd = (String) ois.readObject();
        password = encryptedPwd.replace("ENCRYPTED_", "");
    }
}

📦 Externalizable Interface

The Externalizable interface (extends Serializable) provides complete control over serialization. It has two methods: writeExternal() and readExternal(). 

import java.io.*;

class Person implements Externalizable {
    String name;
    int age;

    public Person() {} // mandatory no-arg constructor

    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(name);
        out.writeInt(age);
    }

    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        name = (String) in.readObject();
        age = in.readInt();
    }
}

This is useful when we want performance optimization or need to exclude/include fields manually.

✅ Advantages of Serialization

  • Object persistence (store objects in files or DBs).
  • Easy transfer of objects between JVMs.
  • Used in RMI, caching frameworks, HTTP session replication, etc.

⚠️ Limitations

  • Not all objects can be serialized (e.g., Thread, Socket).
  • Serialization can affect performance if objects are large.
  • Version mismatch may cause InvalidClassException.

📌 Real-World Use Cases

  • Saving game state.
  • Distributed systems (RMI, RPC, Messaging queues).
  • Caching frequently used objects.
  • Storing user sessions in web applications.

📚 References

Comments

Post a Comment

Popular posts from this blog

Spring Boot on AWS EC2: Upload to S3 Securely Using IAM Role

-
When running a Spring Boot application on AWS EC2 , the most common security mistake is hardcoding AWS access keys inside application.properties . This is unnecessary and risky. AWS already provides a secure mechanism: IAM Roles attached to EC2 . In this blog, you will learn how to upload and download files to Amazon S3 from Spring Boot running on EC2 without any access keys , using: Spring Profiles AWS SDK v2 Instance Metadata Service (IMDS) IAM Roles Why Access Keys Are a Bad Idea on EC2 Typical S3 setups use: Access key Secret key Region Bucket This works only for local development. It should NOT be used on EC2. Problems with access keys: Stored in config or code (high risk) Might leak through Git, logs, or screenshots Require manual rotation Not needed if app runs on EC2 AWS automatically manages temporary credentials using the EC2 Instance Profile (IAM Role) . Architecture: EC2 → IAM Role → S3 Spring Boot app r...
Read more

Java Streams Intermediate Operations Explained with Examples

-
Image
The Java Stream API lets you process collections in a fluent, declarative style. In this post, we’ll walk through the most useful intermediate operations with simple examples. Note: Examples below use Java 8 compatible collect(Collectors.toList()) . If you’re on Java 16+, you can replace it with toList() . 1) filter() — Select elements by a condition Keeps only elements that match the predicate. List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10); List<Integer> res = list.stream() .filter(num -> num % 2 != 0) // keep only odd numbers .collect(Collectors.toList()); System.out.println(res); // [1, 3, 5, 7, 9] 2) map() — Transform each element Applies a function to every element and returns a stream of results. List<String> strs = Arrays.asList("rama", "anjaneya", "krishna"); List<String> upper = strs.stream() .map(String::toUpperCase) .collect(Collectors.toList()); System.o...
Read more

ConcurrentHashMap vs Synchronized HashMap in Java

-
Image
Introduction In multi-threaded Java applications, managing shared data safely and efficiently is crucial. Two common approaches are using Synchronized HashMap (via Collections.synchronizedMap(...) ) and ConcurrentHashMap . While both aim to provide thread-safety, their implementations and performance characteristics differ significantly. This post explores these differences in detail. What is a Synchronized HashMap? Created by wrapping a regular HashMap using: Map<K, V> syncMap = Collections.synchronizedMap(new HashMap<>()); Enforces synchronization at the object level , meaning only one thread can access the map at any time (read or write). Supports null keys and values since it relies on HashMap behavior. Iterators are fail-fast , throwing ConcurrentModificationException if the map is modified while iterating. Simpler implementation, suitable when concurrency is low or performance is not cri...
Read more