So verwenden Sie Transient in Java

Transient ist in der Java-Sprache nicht so bekannt wie „class“, „synced“ und andere bekannte Schlüsselwörter und wird daher in einigen Interviewfragen auftauchen. In diesem Artikel erkläre ich Ihnen transient.

Verwendung von transient

F: Was kann das Schlüsselwort transient bewirken?

A: Wenn das Objekt serialisiert wird (die Bytesequenz wird in die Zieldatei geschrieben), verhindert transient, dass die mit diesem Schlüsselwort in der Instanz deklarierten Variablen beibehalten werden, wenn das Objekt deserialisiert wird (aus der Quelldatei). die Bytesequenz für die Rekonstruktion), solche Instanzvariablenwerte werden nicht beibehalten und wiederhergestellt. Wenn Sie beispielsweise ein Objekt deserialisieren, ist möglicherweise kein Datenstrom (z. B. eine Datei) vorhanden. Der Grund dafür ist, dass Ihr Objekt Variablen vom Typ java.io.InputStream enthält und die von diesen Variablen referenzierten Eingabeströme nicht vorhanden sein können während der Serialisierung geöffnet.

Einführung in die Verwendung von transient

F: Wie verwende ich transient?

A: Enthält den transienten Modifikator in der Instanzvariablendeklaration. Snippet 1 bietet eine kleine Demonstration.

java.io.DataInputStream importieren;
java.io.FileInputStream importieren;
java.io.FileOutputStream importieren;
java.io.InputStream importieren;
java.io importieren .IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

class ClassLib implements Serializable {
    private transient InputStream is;
    private int majorVer;
    private int minorVer;
    ClassLib(InputStream is) throws IOException {
        System.out.println("ClassLib(InputStream) called");
        this.is = is;
        DataInputStream dis;
        if (is instanceof DataInputStream)
            dis = (DataInputStream) is;
        else
            dis = new DataInputStream(is);
        if (dis.readInt() != 0xcafebabe)
            throw new IOException("not a .class file");
        minorVer = dis.readShort();
        majorVer = dis.readShort();
    }
    int getMajorVer() {
        return majorVer;
    }
    int getMinorVer() {
        return minorVer;
    }
    void showIS() {
        System.out.println(is);
    }
}
public class TransDemo {
    public static void main(String[] args) throws IOException {
        if (args.length != 1) {
            System.err.println("usage: java TransDemo classfile");
            return;
        }
        ClassLib cl = new ClassLib(new FileInputStream(args[0]));
        System.out.printf("Minor version number: %d%n", cl.getMinorVer());
        System.out.printf("Major version number: %d%n", cl.getMajorVer());
        cl.showIS();
        try (FileOutputStream fos = new FileOutputStream("x.ser");
                ObjectOutputStream oos = new ObjectOutputStream(fos)) {
            oos.writeObject(cl);
        }
        cl = null;
        try (FileInputStream fis = new FileInputStream("x.ser");
                ObjectInputStream ois = new ObjectInputStream(fis)) {
            System.out.println();
            cl = (ClassLib) ois.readObject();
            System.out.printf("Minor version number: %d%n", cl.getMinorVer());
            System.out.printf("Major version number: %d%n", cl.getMajorVer());
            cl.showIS();
        } catch (ClassNotFoundException cnfe) {
            System.err.println(cnfe.getMessage());
        }
    }
}

Fragment 1: ClassLib-Objekte serialisieren und deserialisieren

Die Klassen ClassLib und TransDemo werden in Fragment 1 deklariert. ClassLib ist eine Bibliothek, die Java-Klassendateien liest und die java.io.Serializable-Schnittstelle implementiert, damit diese Instanzen serialisiert und deserialisiert werden können. TransDemo ist eine Anwendungsklasse, die zum Serialisieren und Deserialisieren von ClassLib-Instanzen verwendet wird.

ClassLib deklariert seine Instanzvariablen als transient, da es einen Eingabestream bedeutungslos serialisieren kann (wie oben beschrieben). Wenn diese Variable nicht vorübergehend ist, wird beim Deserialisieren des Inhalts von x.ser tatsächlich eine java.io.NotSerializableException ausgelöst, da InputStream die Serializable-Schnittstelle nicht implementiert.

Kompilieren Sie Fragment 1: javac TransDemo.java; führen Sie die Anwendung mit einem Parameter TransDemo.class aus: java TransDemo TransDemo.class. Möglicherweise wird eine Ausgabe ähnlich der folgenden angezeigt:

ClassLib(InputStream) called
Minor version number: 0
Major version number: 51
java.io.FileInputStream@79f1e0e0
Minor version number: 0
Major version number: 51
null

Die obige Ausgabe zeigt, dass bei der Rekonstruktion des Objekts keine Konstruktormethode aufgerufen wird. Darüber hinaus wird davon ausgegangen, dass es standardmäßig null ist, im Gegensatz zu „majorVer“ und „minorVer“, die Werte haben, wenn das ClassLib-Objekt serialisiert wird.

Mitgliedsvariablen und Transient in einer Klasse

F: Kann Transient in Mitgliedsvariablen einer Klasse verwendet werden?

A: Die Antwort auf die Frage finden Sie in Fragment 2

public class TransDemo {
    public static void main(String[] args) throws IOException {
        Foo foo = new Foo();
        System.out.printf("w: %d%n", Foo.w);
        System.out.printf("x: %d%n", Foo.x);
        System.out.printf("y: %d%n", foo.y);
        System.out.printf("z: %d%n", foo.z);
        try (FileOutputStream fos = new FileOutputStream("x.ser");
                ObjectOutputStream oos = new ObjectOutputStream(fos)) {
            oos.writeObject(foo);
        }
        foo = null;
        try (FileInputStream fis = new FileInputStream("x.ser");
                ObjectInputStream ois = new ObjectInputStream(fis)) {
            System.out.println();
            foo = (Foo) ois.readObject();
            System.out.printf("w: %d%n", Foo.w);
            System.out.printf("x: %d%n", Foo.x);
            System.out.printf("y: %d%n", foo.y);
            System.out.printf("z: %d%n", foo.z);
        } catch (ClassNotFoundException cnfe) {
            System.err.println(cnfe.getMessage());
        }
    }
}

Fragment 2: Serialisieren und Deserialisieren von Foo-Objekten

Clip 2 ähnelt Clip 1 etwas. Der Unterschied besteht jedoch darin, dass das Foo-Objekt serialisiert und deserialisiert wird, nicht ClassLib. Darüber hinaus enthält Foo ein Variablenpaar, w und x, sowie Instanzvariablen y und z.

Kompilieren Sie Fragment 2 (javac TransDemo.java) und führen Sie die Anwendung (java TransDemo) aus. Sie können die folgende Ausgabe sehen:

w: 1
x: 2
y: 3
z: 4
w: 1
x: 2
y: 3
z: 0

Diese Ausgabe sagt uns, dass die Instanzvariable y serialisiert ist, z jedoch nicht, sie ist als transient markiert. Wenn Foo jedoch serialisiert wird, sagt es uns nicht, ob die Variablen w und x serialisiert und deserialisiert werden oder ob sie nur auf die normale Weise der Klasseninitialisierung initialisiert werden. Für die Antwort müssen wir uns den Inhalt von x.ser ansehen.

Das Folgende zeigt x.ser hexadezimal:

00000000 AC ED 00 05 73 72 00 03 46 6F 6F FC 7A 5D 82 1D ....sr..Foo.z]..
00000010 D2 9D 3F 02 00 01 49 00 01 79 78 70 00 00 00 03 ..?...I..yxp....

Dank des Artikels „Der Java-Serialisierungsalgorithmus enthüllt“ in JavaWorld haben wir festgestellt, dass die Ausgabe Bedeutung hat:

AC ED Serialisierungsprotokoll-Identifikation

00 05 Stream-Versionsnummer

73 bedeutet, dass es sich um ein neues Objekt handelt

72 bedeutet, dass es sich um eine neue Objektklasse handelt

00 03 Stellt die Länge des Klassennamens dar (3)

46 6F 6F Stellt den Klassennamen dar (Foo)

FC 7A 5D 82 1D D2 9D 3F Stellt die Zeichenfolge dar der Klassenzeilenversionskennung

02 gibt an, dass das Objekt die Serialisierung unterstützt

00 01 gibt die Anzahl der Variablen dieser Klasse an (1)

49 Variablentypcode (0 ×49 oder I steht für int)

00 01 steht für die Länge des Variablennamens (1)

79 Variablenname (y)

78 steht für das optionale Datenblockende das Objekt

70 bedeutet, dass wir die Spitze der Klassenhierarchie erreicht haben

00 00 00 03 bedeutet den Wert von y (3)

Offensichtlich nur die Instanzvariable y wird serialisiert. Da z vorübergehend ist, kann es nicht serialisiert werden. Darüber hinaus können w und x nicht serialisiert werden, obwohl sie als transient markiert sind, da es sich um Klassenvariablen handelt, die nicht serialisiert werden können.

Im Folgenden erfahren Sie, wie Sie Transient in Java verwenden. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn).