序列化的重要性：为何需要Serialization？能否不使用它存储数据？

Great question—this is something a lot of developers scratch their heads over when they first run into serialization. Let’s break this down clearly, with examples, to answer your core doubts.

First: What Exactly Is Serialization? #

At its simplest, serialization is the process of converting a complex object (like a User class instance with name, email, age fields) into a format that can be easily stored, transmitted, or reconstructed later. That format could be bytes, JSON, XML, or even a database-specific binary structure.

Can We Store Data Without Serialization? #

Absolutely! Serialization is a tool, not a requirement. You just have to handle the conversion manually. Let’s look at two common examples:

Example 1: Manual Database Insert (Java) #

Instead of serializing a User object into a byte stream and storing it as a BLOB, you can extract each field and insert them directly into a relational database table:

// A simple User class
public class User {
    private String name;
    private String email;
    private int age;
    
    // Getters and setters omitted
}

// Manual insertion without serialization
User myUser = new User("Alice", "alice@example.com", 30);
String sql = "INSERT INTO users (name, email, age) VALUES (?, ?, ?)";

try (Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
     PreparedStatement pstmt = conn.prepareStatement(sql)) {
    pstmt.setString(1, myUser.getName());
    pstmt.setString(2, myUser.getEmail());
    pstmt.setInt(3, myUser.getAge());
    pstmt.executeUpdate();
} catch (SQLException e) {
    e.printStackTrace();
}

Here, we’re not using serialization—we’re just mapping each object field to a database column directly.

Example 2: Python Dictionary to SQL #

In Python, you can convert an object to a dictionary and use that to build your SQL query:

class User:
    def __init__(self, name, email, age):
        self.name = name
        self.email = email
        self.age = age

my_user = User("Bob", "bob@example.com", 28)
user_data = {"name": my_user.name, "email": my_user.email, "age": my_user.age}

# Using psycopg2 to insert
import psycopg2
conn = psycopg2.connect("dbname=my_db user=postgres")
cur = conn.cursor()

cur.execute(
    "INSERT INTO users (name, email, age) VALUES (%(name)s, %(email)s, %(age)s)",
    user_data
)
conn.commit()
cur.close()
conn.close()

Again, no serialization needed—we’re handling the field-to-column mapping ourselves.

Then Why Do We Need Serialization? #

Serialization shines when:

• You need to store/transmit entire objects: If your object has nested fields (like a User with an Address object inside), manual mapping gets tedious fast. Serialization handles nested structures automatically.
• Cross-process or cross-language communication: If you’re sending an object from a Java backend to a Python microservice, serialization formats like JSON or Protobuf let both systems understand the data.
• Caching: Tools like Redis often store objects as serialized bytes—you don’t want to manually break down an object every time you cache it.
• ORM simplification: ORMs like Hibernate or SQLAlchemy use serialization under the hood to map objects to database records, saving you from writing repetitive SQL.

Example: Serialization for Nested Objects #

Suppose your User has a nested Address object:

public class Address {
    private String street;
    private String city;
}

public class User {
    private String name;
    private Address address;
}

Manual insertion would require extracting fields from both User and Address, but with serialization (like converting to JSON), you can store the entire object as a JSONB column in PostgreSQL:

ObjectMapper objectMapper = new ObjectMapper();
String userJson = objectMapper.writeValueAsString(myUser);

String sql = "INSERT INTO users (user_data) VALUES (?)";
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
    pstmt.setString(1, userJson);
    pstmt.executeUpdate();
}

This is way cleaner than mapping each nested field manually.

How Do Databases Store Data Without Our Serialization? #

Databases have their own internal serialization process. When you insert a row with name, email, and age, the database converts those values into its own binary format optimized for storage and retrieval. This is different from the serialization we do in code—databases handle low-level storage, while our code-level serialization is about converting objects to a format the database can accept (like JSON, bytes, or individual columns).

Summary #

• You don’t have to use serialization to store data—you can always map object fields to database columns manually.
• Serialization is a convenience tool that simplifies working with complex objects, cross-system communication, and caching.
• Databases do their own "serialization" under the hood, but that’s separate from the serialization we use in application code.

内容的提问来源于stack exchange，提问作者VasuDev