MENU
  1. ホーム
  2. Java
  3. Javaでのカスタムオブジェクトのシリアライズとデシリアライズ方法を徹底解説

Javaでのカスタムオブジェクトのシリアライズとデシリアライズ方法を徹底解説

Java

Javaでのシリアライズとデシリアライズは、オブジェクトの状態を保存し、後で再利用するための重要なプロセスです。特にカスタムオブジェクトの場合、標準のシリアライズでは対応できない複雑な要件が生じることがあります。これに対処するためには、シリアライズとデシリアライズの基本を理解し、カスタム実装を行うスキルが必要です。本記事では、Javaでのカスタムオブジェクトのシリアライズとデシリアライズの基本概念から応用までを詳細に解説し、実際のプロジェクトでの活用方法を紹介します。

目次

シリアライズとデシリアライズの基本概念

シリアライズとは、Javaオブジェクトの状態をバイトストリームに変換し、ファイルやデータベースなどの外部記憶装置に保存するプロセスを指します。一方、デシリアライズは、そのバイトストリームから元のオブジェクトを復元するプロセスです。この技術により、プログラム間でデータをやり取りしたり、永続的に保存したりすることが可能になります。

利点と用途

シリアライズとデシリアライズは、データの永続化やリモート通信でのオブジェクトのやり取り、キャッシュ機能の実装などに広く利用されます。特に、分散システムやネットワークアプリケーションにおいて、オブジェクトを簡単に送受信するための手段として非常に有用です。

制約と注意点

シリアライズ可能なオブジェクトは、Serializableインターフェースを実装する必要がありますが、全てのオブジェクトがシリアライズ可能ではありません。また、シリアライズされたデータは、元のクラスが変更された場合に復元できない可能性があり、バージョン管理の重要性が強調されます。

シリアライズの仕組み

シリアライズは、Javaオブジェクトの状態をバイトストリームに変換するプロセスです。このプロセスを利用することで、オブジェクトをファイルやデータベースに保存したり、ネットワークを介して送信することができます。Javaの標準ライブラリは、シリアライズのためのシンプルで強力なメカニズムを提供しており、特定の条件を満たすオブジェクトであれば、容易にシリアライズを行えます。

標準的なシリアライズプロセス

Javaでシリアライズを行うためには、対象のクラスがSerializableインターフェースを実装している必要があります。このインターフェースはマーカーインターフェースであり、特定のメソッドを要求するものではありません。シリアライズの際には、ObjectOutputStreamクラスを使用して、オブジェクトをバイトストリームに変換します。次に、ストリームをFileOutputStreamなどに接続して、ファイルやネットワークソケットに書き出します。

シリアライズのプロセスの流れ

  1. オブジェクトを生成し、ObjectOutputStreamを介してシリアライズ対象のオブジェクトをバイトストリームに変換。
  2. 変換されたバイトストリームを外部ストレージ（例：ファイル、データベース）に保存。
  3. 必要なときにバイトストリームをデシリアライズし、元のオブジェクトを復元。

実装例

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Employee implements Serializable {
    private String name;
    private int id;

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

    public static void main(String[] args) {
        Employee emp = new Employee("John Doe", 12345);

        try (FileOutputStream fileOut = new FileOutputStream("employee.ser");
             ObjectOutputStream out = new ObjectOutputStream(fileOut)) {
            out.writeObject(emp);
            System.out.println("Serialized data is saved in employee.ser");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

このコード例では、Employeeオブジェクトがシリアライズされ、”employee.ser”というファイルに保存されます。

カスタムシリアライズの実装方法

標準のシリアライズでは、Javaのシリアライズエンジンが自動的にオブジェクトの状態をバイトストリームに変換しますが、場合によってはこのプロセスをカスタマイズする必要があります。たとえば、特定のフィールドをシリアライズしたくない場合や、特殊な変換が必要な場合には、カスタムシリアライズを実装します。

カスタムシリアライズの必要性

カスタムシリアライズが必要になるのは、以下のようなケースです：

  • セキュリティ上の理由で特定のフィールドを保存しないようにする場合
  • フィールドがシリアライズに適していないオブジェクトを持つ場合
  • シリアライズの際にデータの整形や暗号化を行いたい場合

`writeObject`メソッドの使用

カスタムシリアライズを実装するには、Serializableインターフェースを実装するクラスに、writeObjectメソッドをオーバーライドします。このメソッド内で、標準的なシリアライズ処理に加えて、特定のフィールドのシリアライズ処理をカスタマイズします。

例: カスタムシリアライズの実装

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.IOException;
import java.io.ObjectStreamException;
import java.io.Serializable;

public class Employee implements Serializable {
    private String name;
    private transient int id;  // シリアライズ対象外
    private String department;

    public Employee(String name, int id, String department) {
        this.name = name;
        this.id = id;
        this.department = department;
    }

    private void writeObject(ObjectOutputStream out) throws IOException {
        out.defaultWriteObject();  // 標準のシリアライズ
        out.writeInt(id);  // カスタムシリアライズ
    }

    public static void main(String[] args) {
        Employee emp = new Employee("John Doe", 12345, "Engineering");

        try (FileOutputStream fileOut = new FileOutputStream("employee_custom.ser");
             ObjectOutputStream out = new ObjectOutputStream(fileOut)) {
            out.writeObject(emp);
            System.out.println("Custom serialized data is saved in employee_custom.ser");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

この例では、EmployeeクラスでwriteObjectメソッドをオーバーライドしています。transientとしてマークされたidフィールドは通常のシリアライズでは無視されますが、このメソッドで特別に処理しています。

注意点

カスタムシリアライズを実装する際は、writeObjectメソッドで必ずdefaultWriteObjectを呼び出して、標準のシリアライズを実行してから追加のカスタム処理を行うようにすることが推奨されます。また、シリアライズの互換性やセキュリティに対して十分な配慮が必要です。

デシリアライズの仕組み

デシリアライズは、シリアライズされたバイトストリームからオブジェクトを再構築するプロセスです。このプロセスにより、保存されたオブジェクトの状態を復元し、プログラムで再利用できるようになります。Javaでは、デシリアライズはシリアライズと同様に簡単に実装できますが、特定のケースではカスタム処理が必要となることもあります。

標準的なデシリアライズプロセス

デシリアライズは、ObjectInputStreamクラスを使用して実行します。シリアライズされたバイトストリームをObjectInputStreamに渡すことで、元のオブジェクトが復元されます。この際、クラスはシリアライズされたときと同じ構造でなければならず、serialVersionUIDが一致する必要があります。

デシリアライズのプロセスの流れ

  1. バイトストリームをObjectInputStreamに入力。
  2. ObjectInputStreamを使用して、オブジェクトを読み込み、元のオブジェクトを復元。
  3. 必要に応じて、カスタムデシリアライズを実施してデータを処理。

実装例

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.io.Serializable;

public class Employee implements Serializable {
    private String name;
    private int id;
    private String department;

    public Employee(String name, int id, String department) {
        this.name = name;
        this.id = id;
        this.department = department;
    }

    public static void main(String[] args) {
        Employee emp = null;

        try (FileInputStream fileIn = new FileInputStream("employee_custom.ser");
             ObjectInputStream in = new ObjectInputStream(fileIn)) {
            emp = (Employee) in.readObject();
            System.out.println("Deserialized Employee...");
            System.out.println("Name: " + emp.name);
            System.out.println("ID: " + emp.id);
            System.out.println("Department: " + emp.department);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

このコード例では、以前にシリアライズされたEmployeeオブジェクトがデシリアライズされ、元の状態に復元されます。デシリアライズされたオブジェクトのフィールドにアクセスして、その値を確認することができます。

注意点

デシリアライズにおいて重要な点は、シリアライズされたバイトストリームが信頼できるものであるかを確認することです。不正なデータが含まれている場合、プログラムの予期しない動作やセキュリティリスクを引き起こす可能性があります。また、クラスのバージョンが一致しない場合、InvalidClassExceptionがスローされるため、serialVersionUIDの適切な管理が必要です。

カスタムデシリアライズの実装方法

カスタムデシリアライズは、標準のデシリアライズプロセスでは対応できない複雑な復元操作が必要な場合に実装します。Javaでは、readObjectメソッドをオーバーライドすることで、デシリアライズ時にカスタムロジックを実行できます。これにより、シリアライズされたデータを適切に処理し、オブジェクトを復元することが可能です。

`readObject`メソッドの使用

カスタムデシリアライズを実装するためには、対象のクラスにreadObjectメソッドをオーバーライドします。このメソッド内で、標準のデシリアライズ処理に加えて、カスタムロジックを追加できます。たとえば、データの検証や追加処理を行うことが可能です。

例: カスタムデシリアライズの実装

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.io.IOException;
import java.io.ObjectStreamException;
import java.io.Serializable;

public class Employee implements Serializable {
    private String name;
    private transient int id;  // シリアライズ対象外
    private String department;

    public Employee(String name, int id, String department) {
        this.name = name;
        this.id = id;
        this.department = department;
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        in.defaultReadObject();  // 標準のデシリアライズ
        this.id = in.readInt();  // カスタムデシリアライズ
    }

    public static void main(String[] args) {
        Employee emp = null;

        try (FileInputStream fileIn = new FileInputStream("employee_custom.ser");
             ObjectInputStream in = new ObjectInputStream(fileIn)) {
            emp = (Employee) in.readObject();
            System.out.println("Deserialized Employee...");
            System.out.println("Name: " + emp.name);
            System.out.println("ID: " + emp.id);
            System.out.println("Department: " + emp.department);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

このコード例では、readObjectメソッドをオーバーライドし、標準的なデシリアライズ処理の後に、idフィールドを再設定するカスタムデシリアライズ処理を行っています。transientとしてマークされたフィールドは通常シリアライズされませんが、このようにカスタムデシリアライズを行うことで、必要なデータを復元できます。

注意点

カスタムデシリアライズを実装する際には、データの整合性を保つために、シリアライズ時と同様の配慮が必要です。特に、readObjectメソッドでは例外処理を適切に行い、データの不整合や復元失敗によるエラーを回避することが重要です。また、デシリアライズされたオブジェクトが正しく初期化されるよう、すべてのフィールドが正しい値で復元されるように注意する必要があります。

シリアライズにおけるセキュリティ考慮事項

シリアライズとデシリアライズは便利な技術ですが、セキュリティに関するリスクも伴います。不正なデータの入力や攻撃によって、シリアライズされたオブジェクトの状態が悪用される可能性があります。そのため、シリアライズを使用する際には、セキュリティ上のベストプラクティスを守ることが重要です。

セキュリティリスクの概要

シリアライズされたオブジェクトは、バイトストリームとして保存されますが、このストリームを攻撃者が改ざんすることで、不正なデータやコードが注入されるリスクがあります。デシリアライズの際に、これらの不正なデータが実行されると、予期しない動作やシステムの脆弱性が露呈する可能性があります。

シリアライズにおけるセキュリティ対策

  1. クラスのホワイトリスト化: デシリアライズ可能なクラスを厳格に制限し、信頼できるクラスのみを許可する。
  2. serialVersionUIDの管理: クラスのバージョン管理を徹底し、異なるバージョン間でのデシリアライズを防ぐ。
  3. readObjectメソッドのカスタマイズ: デシリアライズ時に、入力データの検証やフィルタリングを行い、不正なデータを排除する。
  4. デシリアライズの制限: 可能な限り、デシリアライズを使わない設計を採用する。または、信頼できるデータのみをデシリアライズする。

クラスのホワイトリスト化の例

JavaのObjectInputStreamを拡張して、デシリアライズ可能なクラスをホワイトリストに基づいて制限することが可能です。

import java.io.ObjectInputStream;
import java.io.IOException;
import java.io.InputStream;

public class SafeObjectInputStream extends ObjectInputStream {

    public SafeObjectInputStream(InputStream in) throws IOException {
        super(in);
    }

    @Override
    protected Class<?> resolveClass(java.io.ObjectStreamClass desc)
            throws IOException, ClassNotFoundException {
        String className = desc.getName();
        if (!isAllowed(className)) {
            throw new ClassNotFoundException("Unauthorized deserialization attempt for class: " + className);
        }
        return super.resolveClass(desc);
    }

    private boolean isAllowed(String className) {
        // 許可されたクラスのリストをチェック
        return className.equals("com.example.Employee");
    }
}

この例では、SafeObjectInputStreamクラスを作成し、特定のクラスのみがデシリアライズされるように制限しています。このような手法により、意図しないクラスのデシリアライズを防ぐことができます。

データの検証とフィルタリング

デシリアライズする際には、入力データを厳密に検証し、期待される形式や値であることを確認することが重要です。たとえば、readObjectメソッド内でフィールドの値が正当かどうかをチェックし、不正なデータがデシリアライズされないようにすることが推奨されます。

まとめ

シリアライズとデシリアライズは強力なツールですが、適切なセキュリティ対策が必要不可欠です。クラスのホワイトリスト化や入力データの検証を行うことで、潜在的なセキュリティリスクを軽減し、システムの安全性を確保することができます。

シリアライズ対象外フィールドの指定方法

シリアライズの際、すべてのフィールドが必ずしもシリアライズされる必要はありません。特定のフィールドは、セキュリティ上の理由や一時的なデータであるため、シリアライズの対象外とすることが望ましい場合があります。Javaでは、transientキーワードを使って、これらのフィールドをシリアライズから除外することができます。

`transient`キーワードの使用

transientキーワードを使用することで、そのフィールドがシリアライズ対象外であることを明示的に指定できます。シリアライズのプロセス中、このフィールドの値はバイトストリームに書き込まれず、デシリアライズ後にはデフォルト値が設定されます。

例: `transient`の使用方法

import java.io.FileOutputStream;
import java.io.FileInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import java.io.Serializable;

public class Employee implements Serializable {
    private String name;
    private transient int id;  // シリアライズ対象外
    private String department;

    public Employee(String name, int id, String department) {
        this.name = name;
        this.id = id;
        this.department = department;
    }

    public static void main(String[] args) {
        Employee emp = new Employee("John Doe", 12345, "Engineering");

        try (FileOutputStream fileOut = new FileOutputStream("employee.ser");
             ObjectOutputStream out = new ObjectOutputStream(fileOut)) {
            out.writeObject(emp);
            System.out.println("Serialized data is saved in employee.ser");
        } catch (Exception e) {
            e.printStackTrace();
        }

        Employee deserializedEmp = null;
        try (FileInputStream fileIn = new FileInputStream("employee.ser");
             ObjectInputStream in = new ObjectInputStream(fileIn)) {
            deserializedEmp = (Employee) in.readObject();
            System.out.println("Deserialized Employee...");
            System.out.println("Name: " + deserializedEmp.name);
            System.out.println("ID: " + deserializedEmp.id);  // ID will be 0, the default value for int
            System.out.println("Department: " + deserializedEmp.department);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

このコードでは、idフィールドがtransientとしてマークされています。そのため、オブジェクトをシリアライズした際に、このフィールドの値は保存されません。デシリアライズ後、idフィールドの値は0（intのデフォルト値）にリセットされます。

シリアライズ対象外とする理由

  1. セキュリティ: パスワードや暗号鍵など、機密性の高い情報はシリアライズしないことで、セキュリティリスクを軽減します。
  2. 一時的なデータ: キャッシュや計算結果など、再生成可能なデータはシリアライズから除外することで、データの一貫性を保ちます。
  3. パフォーマンス: 不要なデータをシリアライズしないことで、バイトストリームのサイズを削減し、シリアライズおよびデシリアライズのパフォーマンスを向上させます。

カスタムデシリアライズとの併用

transientフィールドはデフォルトではシリアライズされませんが、必要に応じてwriteObjectやreadObjectメソッドを使用して、これらのフィールドをカスタム処理することも可能です。これにより、特定の条件下でのみフィールドをシリアライズする柔軟性を持たせることができます。

まとめ

transientキーワードは、シリアライズ対象外にするフィールドを指定するための便利なツールです。これにより、セキュリティ、パフォーマンス、データの一貫性を向上させることができます。また、カスタムデシリアライズと組み合わせることで、さらに柔軟なシリアライズ処理を実現することが可能です。

シリアライズ時のバージョン管理

シリアライズとデシリアライズのプロセスにおいて、クラスのバージョン管理は非常に重要です。クラスの構造が変更された場合、シリアライズされたデータとの互換性が失われる可能性があります。これを管理するために、JavaはserialVersionUIDというフィールドを使用します。

`serialVersionUID`の役割

serialVersionUIDは、シリアライズされたオブジェクトとクラス定義の間のバージョンの一貫性を保証するために使用される一意の識別子です。このフィールドがクラスに定義されていると、シリアライズとデシリアライズの際にクラスのバージョンが一致しているかを検証します。バージョンが一致しない場合、InvalidClassExceptionがスローされ、デシリアライズに失敗します。

`serialVersionUID`の定義方法

serialVersionUIDは、クラス内で以下のように定義します。このフィールドはstaticかつfinalであり、長整数（long）として指定されます。

import java.io.Serializable;

public class Employee implements Serializable {
    private static final long serialVersionUID = 1L;

    private String name;
    private int id;
    private String department;

    public Employee(String name, int id, String department) {
        this.name = name;
        this.id = id;
        this.department = department;
    }

    // その他のメソッドやフィールド
}

この例では、serialVersionUIDが1Lとして定義されています。クラスの構造に変更が加えられた場合、serialVersionUIDの値も変更し、互換性が保たれるようにする必要があります。

`serialVersionUID`の自動生成

Javaの統合開発環境（IDE）では、クラスの内容に基づいてserialVersionUIDを自動生成する機能が提供されています。たとえば、EclipseやIntelliJ IDEAでは、クラスのシリアライズ可能性を検出し、serialVersionUIDを自動生成して追加することが可能です。しかし、クラスの構造が変更されるたびに自動生成される値が異なるため、慎重に管理する必要があります。

バージョン管理の重要性

クラスのバージョン管理を適切に行わないと、デシリアライズの際に互換性問題が発生し、データの読み込みに失敗する可能性があります。これは、特にプロジェクトが進行中でクラスの構造が頻繁に変更される場合に重要です。serialVersionUIDを手動で管理し、クラスの変更に応じて適切に更新することで、シリアライズされたデータとの互換性を維持できます。

実際の運用での考慮事項

  • クラスタ間の互換性: 異なるバージョンのクラス間でオブジェクトをシリアライズする場合、互換性を維持するためにserialVersionUIDの管理が特に重要です。
  • レガシーシステムとの互換性: 古いシステムと新しいシステム間でデータの互換性を保つため、serialVersionUIDを適切に設定します。

まとめ

serialVersionUIDは、シリアライズとデシリアライズのプロセスにおけるクラスのバージョン管理に不可欠です。このフィールドを正しく管理することで、シリアライズされたデータとクラスのバージョン間での互換性を確保し、データの整合性を維持することができます。特に、クラス構造の変更が頻繁に発生するプロジェクトでは、慎重なserialVersionUIDの管理が求められます。

応用例: カスタムオブジェクトのシリアライズ

シリアライズとデシリアライズの基本的な概念を理解したところで、実際のプロジェクトでどのようにカスタムオブジェクトのシリアライズを実装できるかを具体的なコード例で紹介します。このセクションでは、複雑なオブジェクトのシリアライズと、それに伴うカスタム処理を実装する例を取り上げます。

カスタムオブジェクトのシリアライズの例

以下の例では、従業員（Employee）オブジェクトに加えて、プロジェクト（Project）という別のオブジェクトを含むシリアル化可能なクラスを作成します。この例では、従業員が複数のプロジェクトに参加している場合のシリアライズを考慮しています。

import java.io.FileOutputStream;
import java.io.FileInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.util.List;

class Project implements Serializable {
    private String projectName;
    private int projectId;

    public Project(String projectName, int projectId) {
        this.projectName = projectName;
        this.projectId = projectId;
    }

    @Override
    public String toString() {
        return "Project{" +
                "projectName='" + projectName + '\'' +
                ", projectId=" + projectId +
                '}';
    }
}

class Employee implements Serializable {
    private String name;
    private int id;
    private List<Project> projects;

    public Employee(String name, int id, List<Project> projects) {
        this.name = name;
        this.id = id;
        this.projects = projects;
    }

    private void writeObject(ObjectOutputStream out) throws IOException {
        out.defaultWriteObject(); // 標準のシリアライズ
        // カスタムシリアライズ処理（例: プロジェクトリストのシリアライズ）
        for (Project project : projects) {
            out.writeObject(project);
        }
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        in.defaultReadObject(); // 標準のデシリアライズ
        // カスタムデシリアライズ処理
        projects = (List<Project>) in.readObject();
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", projects=" + projects +
                '}';
    }
}

public class SerializationExample {
    public static void main(String[] args) {
        List<Project> projectList = List.of(
                new Project("AI Development", 101),
                new Project("Cloud Migration", 102)
        );

        Employee emp = new Employee("John Doe", 12345, projectList);

        // シリアライズ処理
        try (FileOutputStream fileOut = new FileOutputStream("employee_with_projects.ser");
             ObjectOutputStream out = new ObjectOutputStream(fileOut)) {
            out.writeObject(emp);
            System.out.println("Serialized data is saved in employee_with_projects.ser");
        } catch (Exception e) {
            e.printStackTrace();
        }

        // デシリアライズ処理
        Employee deserializedEmp = null;
        try (FileInputStream fileIn = new FileInputStream("employee_with_projects.ser");
             ObjectInputStream in = new ObjectInputStream(fileIn)) {
            deserializedEmp = (Employee) in.readObject();
            System.out.println("Deserialized Employee...");
            System.out.println(deserializedEmp);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

コード解説

この例では、Employeeクラスは複数のProjectオブジェクトを保持しており、これらをカスタムシリアライズおよびデシリアライズしています。writeObjectメソッドでは、defaultWriteObjectで標準的なフィールドをシリアライズした後、各プロジェクトをシリアライズします。同様に、readObjectメソッドではdefaultReadObjectで基本的なフィールドを復元し、その後プロジェクトリストを復元します。

シリアライズの実用的な応用

このようなカスタムシリアライズは、複雑なオブジェクトやデータ構造を扱う際に役立ちます。例えば、プロジェクト管理ツールや人事システムでは、従業員やプロジェクトの詳細を永続的に保存し、後で再利用する必要があります。この場合、シリアライズとデシリアライズを用いることで、システムの一貫性とデータの持続性を確保できます。

まとめ

カスタムオブジェクトのシリアライズは、標準のシリアライズプロセスを拡張し、複雑なデータ構造を効率的に保存および復元するための強力な手法です。特に、複数の関連オブジェクトを含むクラスや、特定のフィールドに対してカスタム処理が必要な場合に非常に有用です。この技術を活用することで、より柔軟で拡張性のあるJavaアプリケーションを構築することができます。

演習問題: シリアライズとデシリアライズの実装

シリアライズとデシリアライズの概念を深く理解するために、以下の演習問題に取り組んでみましょう。これらの問題を通じて、カスタムシリアライズとデシリアライズの実装方法を実際に手を動かして学ぶことができます。

演習1: 基本的なシリアライズとデシリアライズの実装

問題: 新しいクラスProductを作成し、次のフィールドを含めてください。

  • productName (String)
  • productId (int)
  • price (double)

このクラスをシリアライズ可能にし、オブジェクトのシリアライズとデシリアライズを行ってください。

ヒント:

  1. Serializableインターフェースを実装すること。
  2. シリアライズされたデータをファイルに保存し、その後デシリアライズして正しくオブジェクトが復元されることを確認してください。

解決策:

import java.io.*;

class Product implements Serializable {
    private String productName;
    private int productId;
    private double price;

    public Product(String productName, int productId, double price) {
        this.productName = productName;
        this.productId = productId;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Product{" +
                "productName='" + productName + '\'' +
                ", productId=" + productId +
                ", price=" + price +
                '}';
    }
}

public class ProductSerializationTest {
    public static void main(String[] args) {
        Product product = new Product("Laptop", 101, 1500.99);

        // シリアライズ
        try (FileOutputStream fileOut = new FileOutputStream("product.ser");
             ObjectOutputStream out = new ObjectOutputStream(fileOut)) {
            out.writeObject(product);
            System.out.println("Serialized product data is saved in product.ser");
        } catch (Exception e) {
            e.printStackTrace();
        }

        // デシリアライズ
        Product deserializedProduct = null;
        try (FileInputStream fileIn = new FileInputStream("product.ser");
             ObjectInputStream in = new ObjectInputStream(fileIn)) {
            deserializedProduct = (Product) in.readObject();
            System.out.println("Deserialized Product...");
            System.out.println(deserializedProduct);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

このプログラムを実行すると、Productオブジェクトがシリアライズされ、ファイルに保存された後、デシリアライズされて元のオブジェクトが復元されることが確認できます。

演習2: カスタムシリアライズの実装

問題: Userクラスを作成し、次のフィールドを含めてください。

  • username (String)
  • password (String – このフィールドはシリアライズから除外する)
  • email (String)

このクラスに対して、passwordフィールドをシリアライズ対象外とし、カスタムシリアライズとデシリアライズを実装してください。

ヒント:

  1. transientキーワードを使用してpasswordフィールドをシリアライズ対象外にします。
  2. writeObjectとreadObjectメソッドをオーバーライドし、usernameとemailをシリアライズしつつ、passwordをカスタム処理します。

解決策:

import java.io.*;

class User implements Serializable {
    private String username;
    private transient String password; // シリアライズ対象外
    private String email;

    public User(String username, String password, String email) {
        this.username = username;
        this.password = password;
        this.email = email;
    }

    private void writeObject(ObjectOutputStream out) throws IOException {
        out.defaultWriteObject(); // 標準のシリアライズ
        // カスタムシリアライズ（例: パスワードのハッシュ化）
        out.writeObject(encryptPassword(password));
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        in.defaultReadObject(); // 標準のデシリアライズ
        // カスタムデシリアライズ
        this.password = decryptPassword((String) in.readObject());
    }

    private String encryptPassword(String password) {
        // パスワードを暗号化する仮の処理（例: 逆順にする）
        return new StringBuilder(password).reverse().toString();
    }

    private String decryptPassword(String encryptedPassword) {
        // 暗号化されたパスワードを復号する仮の処理
        return new StringBuilder(encryptedPassword).reverse().toString();
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", email='" + email + '\'' +
                '}';
    }
}

public class UserSerializationTest {
    public static void main(String[] args) {
        User user = new User("johndoe", "password123", "johndoe@example.com");

        // シリアライズ
        try (FileOutputStream fileOut = new FileOutputStream("user.ser");
             ObjectOutputStream out = new ObjectOutputStream(fileOut)) {
            out.writeObject(user);
            System.out.println("Serialized user data is saved in user.ser");
        } catch (Exception e) {
            e.printStackTrace();
        }

        // デシリアライズ
        User deserializedUser = null;
        try (FileInputStream fileIn = new FileInputStream("user.ser");
             ObjectInputStream in = new ObjectInputStream(fileIn)) {
            deserializedUser = (User) in.readObject();
            System.out.println("Deserialized User...");
            System.out.println(deserializedUser);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

このプログラムでは、Userクラスのpasswordフィールドがシリアライズされず、代わりに暗号化されたパスワードをカスタムシリアライズしています。デシリアライズ時には、このフィールドが復号され、元の値に復元されます。

まとめ

これらの演習を通じて、シリアライズとデシリアライズの基本的な使用方法から、カスタム実装に至るまでの実践的なスキルを学ぶことができます。シリアライズに関する知識を深めることで、Javaのデータ管理や永続化における柔軟性を向上させることができるでしょう。

まとめ

本記事では、Javaにおけるシリアライズとデシリアライズの基礎から、カスタム実装の方法までを詳しく解説しました。シリアライズの仕組みやバージョン管理の重要性を理解し、セキュリティを考慮した実装方法、さらにはカスタムシリアライズの応用例を学ぶことで、シリアライズの強力な機能を効果的に活用できるようになります。これらの知識を実際のプロジェクトに応用することで、データの永続化やシステムの堅牢性を向上させることができるでしょう。

Java
java シリアライズ デシリアライズ

コメント

コメントする

目次