Vielleicht sind Sie mit dem Schlüsselwort transient nicht vertraut und haben es kaum verwendet, aber das Schlüsselwort transient spielt in Java eine unverzichtbare Rolle!

Im Java-Lernprozess ist der Grund, warum das Schlüsselwort transient selten ist, tats?chlich untrennbar mit seiner Funktion verbunden: Die Hauptfunktion des Schlüsselworts transient besteht darin, sicherzustellen, dass vorhanden ist Wird vom transienten Schlüsselwort verwendet. Ge?nderte Mitgliedsattributvariablen werden nicht serialisiert . Genau aus diesem Grund werden Serialisierungsoperationen im Lernprozess selten verwendet, normalerweise in der tats?chlichen Entwicklung! Was die Serialisierung betrifft, glaube ich, dass viele Anf?nger verwirrt sind oder kein spezifisches Konzept haben. In diesem Artikel wird es weiter unten vorgestellt.

1. Was ist Serialisierung?

Apropos Serialisierung: Keine Panik, kleine wei?e Kinder, sich an die Serialisierung zu erinnern, ist das Gegenteil der Serialisierung Daher empfiehlt der Blogger, sich einfach an das Konzept der Serialisierung zu erinnern, um sich nicht zu verwirren.

Serialisierung definiert durch Fachbegriffe:

Java bietet einen Mechanismus für die Objektserialisierung. Ein Objekt kann durch eine Bytesequenz dargestellt werden, die Informationen wie die Daten des Objekts, den Typ des Objekts und die im Objekt gespeicherten Attribute enth?lt. Nachdem die Bytesequenz in die Datei geschrieben wurde, entspricht dies dem Beibehalten der Informationen eines Objekts in der Datei. Umgekehrt kann die Bytefolge aus der Datei zurückgelesen, das Objekt rekonstruiert und deserialisiert werden. Die Daten des Objekts, der Typ des Objekts und die im Objekt gespeicherten Dateninformationen k?nnen alle zum Erstellen von Objekten im Speicher verwendet werden.

Yichuns Begriffsdefinition Serialisierung:

Serialisierung: Byte——> Objekt

Eigentlich habe ich die obige Schlussfolgerung zusammengefasst. Wenn Sie es nicht verstehen, lesen Sie einfach die Definition der Fachbegriffe. Wenn Sie sich nicht erinnern k?nnen, schlagen Sie mich bitte zu Tode. Ich trete gerade in die Luft. Er ist ein Genie)

Serialisierung des Diagramms verstehen:

Was? Sie verstehen nicht, was ein Byte ist? Tats?chlich habe ich die Serialisierung bereits in einem Artikel über den E/A-Fluss vorgestellt. Schauen Sie sich einfach den Namen des Artikels an und Sie werden es wissen. Vollst?ndiges und detailliertes IO-Flow-Tutorial in der Geschichte. Auch Anf?nger k?nnen es verstehen!

2. Warum Serialisierung? Im vorherigen Abschnitt haben wir das Konzept der Serialisierung erw?hnt. Nachdem wir das Konzept kennengelernt haben, müssen wir wissen, warum wir serialisieren müssen.

Bevor ich über die Gründe spreche, warum Serialisierung notwendig ist, Blogger, gebe ich Ihnen ein Beispiel:

Genau wie wenn Sie auf der Stra?e Lebensmittel kaufen, besteht die allgemeine Vorgehensweise darin, Folgendes zu tun: Verpacke es in Plastiktüten. Wenn ich nach Hause komme und kochen m?chte, hole ich das Geschirr heraus. Und diese Reihe von Operationen ist wie Serialisierung und Deserialisierung!

Serialisierung von Objekten in Java bezieht sich auf die Konvertierung von Objekten in Bytesequenzen. Diese Bytesequenzen enthalten die Daten und Informationen des Objekts.

kann in eine Datenbank geschrieben werden Datei und kann auch für Netzwerkübertragung verwendet werden, im Allgemeinen, wenn wir Cache verwenden (nicht genügend Speicherplatz). kann zu einer lokalen Speicherung auf der Festplatte führen) oder Beim Remote-Aufruf von rpc (Netzwerkübertragung) müssen wir h?ufig unsere Entit?tsklassen implementierenSchnittstelle, der Zweck besteht darin Machen Sie es serialisierbar. Serializable●Verwenden Sie im Entwicklungsprozess

das transiente Schlüsselwort

, um die Kastanie zu ?ndern:

Wenn ein Benutzer ein Passwort und andere Informationen hat Wenn Sie aus Sicherheitsgründen keine übertragung w?hrend des Netzwerkbetriebs wünschen, k?nnen Sie die diesen Informationen entsprechenden Variablen mit dem Schlüsselwort transient hinzufügen. Mit anderen Worten, der Lebenszyklus dieses Feldes existiert nur im Speicher des Aufrufers und wird nicht zur Persistenz auf die Festplatte geschrieben.

● W?hrend des Entwicklungsprozesses

sind keine vorübergehenden

Beispiele für Schlüsselwort?nderungen erforderlich:

1. Feldwerte in der Klasse k?nnen abgeleitet werden basierend auf anderen Feldern herauskommen.

2. Welche Felder m?chten je nach den spezifischen Gesch?ftsanforderungen nicht serialisiert werden?

Ich frage mich, ob Sie jemals darüber nachgedacht haben, warum sie nicht serialisiert werden sollten. Tats?chlich geht es vor allem darum, Speicherplatz zu sparen. Optimieren Sie das Programm!

PS: Als ich mir zuvor den HashMap-Quellcode angesehen habe, habe ich festgestellt, dass ein Feld mit transient ge?ndert wurde. Es besteht wirklich keine Notwendigkeit, dieses modCount-Feld zu serialisieren Da es keine Bedeutung gibt, wird modCount haupts?chlich verwendet, um zu bestimmen, ob die HashMap ge?ndert wurde (z. B. wenn modCount bei Operationen zum Einfügen und Entfernen von selbst erh?ht wird). Bei dieser Art von Variable kann es sich um einen beliebigen Wert handeln Anfang, und 0 ist natürlich auch m?glich (Neues kommt heraus, deserialisiert Es ist immer 0, wenn es transformiert oder geklont wird), es besteht keine Notwendigkeit, seinen Wert beizubehalten.

Natürlich besteht das ultimative Ziel nach der Serialisierung darin, es zu deserialisieren und auf das ursprüngliche Java-Objekt wiederherzustellen. Was würden Sie sonst nach der Serialisierung tun? Dies dient der Bequemlichkeit und Sicherheit, bevor Sie die Plastiktüte entfernen, sodass die serialisierte Bytesequenz in einem Java-Objekt wiederhergestellt werden kann.

3. Verwendung von Serialisierung und Transient

1. Die Klasse des Objekts, das serialisiert werden muss Implementieren Sie die Serialisierungsschnittstelle: Java.lang.Serializable-Schnittstelle (eine Flag-Schnittstelle ohne abstrakte Methoden, wie zum Beispiel: , -Klassen usw.). Klassen, die diese Schnittstelle nicht implementieren, serialisieren oder deserialisieren keinen Zustand und l?sen eine String-Ausnahme aus. IntegerNotSerializableException2. Die unterste Ebene beurteilt, ob das aktuelle Objekt eine Instanz von

ist.

Serializable3. instanceof Serializable

Verwenden Sie den Objektstrom

in Java, um die Serialisierung und Stream-Deserialisierung abzuschlie?en ObjectOutputStream　ObjectInputStream==ObjectOutputStream :Serialisierungsvorgang durch writeObject() method==　

==ObjectInputStream: Deserialisierungsvorgang durch readObject() method==

4 Alle Attribute dieser Klasse müssen serialisiert sein. Wenn es ein Attribut gibt, das nicht serialisierbar sein muss, muss das Attribut als transient markiert und mit dem Schlüsselwort

ge?ndert werden.

transientAufgrund der Bytes muss es sich um Stream-Operationen handeln, das hei?t, der Objektstream wird auch als Serialisierungsstream ObjectOutputstream bezeichnet. Lassen Sie uns den Serialisierungsoperationscode in verschiedenen Situationen analysieren!

Hier empfehle ich Lesern, die den Yichun-Blog lesen, wirklich dringend: Versuchen Sie bitte, ihn einzugeben, denken Sie daran, ihn auf einen Blick mitzunehmen, oder kopieren Sie ihn und führen Sie ihn aus, insbesondere für kleine wei?e Kinderschuhe , glauben Sie mir ! Sie werden auf jeden Fall etwas anderes gewinnen. Denken Sie nicht, dass es Zeitverschwendung ist, langsam ist manchmal schneller, Yichun hat es aus erster Hand erlebt!

3.1. Die Serializable-Schnittstelle ist nicht für die Serialisierung implementiert

package TransientTest;
import java.io.*;

class UserInfo {  //================================注意這里沒有實(shí)現(xiàn)Serializable接口
    private String name;
    private transient String password;

    public UserInfo(String name,String psw) {
        this.name = name;
        this.password=psw;
    }

    @Override
    public String toString() {
        return "UserInfo{" +
                "name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

public class TransientDemo {
    public static void main(String[] args) {

        UserInfo userInfo=new UserInfo("老王","123");
        System.out.println("序列化之前信息："+userInfo);

        try {
            ObjectOutputStream output=new ObjectOutputStream(new FileOutputStream("userinfo.txt"));
            output.writeObject(new UserInfo("老王","123"));
            output.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Laufendes Ergebnis

3.2. Serialisierungssituation bei der Implementierung der Serializable-Schnittstelle

Wenn wir die Implementierung der Serializable-Schnittstelle hinzufügen und erneut ausführen, werden wir feststellen, dass der Inhalt der -Datei in der angezeigt wird Das Projekt sieht so aus:

userinfo.txt

Eigentlich ist das nicht der Punkt. Der Punkt ist, dass der Serialisierungsvorgang erfolgreich war!

3.3. Gew?hnliche Serialisierung

package TransientTest;
import java.io.*;

class UserInfo implements Serializable{  //第一步實(shí)現(xiàn)Serializable接口
    private String name;
    private String password;//都是普通屬性==============================

    public UserInfo(String name,String psw) {
        this.name = name;
        this.password=psw;
    }

    @Override
    public String toString() {
        return "UserInfo{" +
                "name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

public class TransientDemo {
    public static void main(String[] args) throws ClassNotFoundException {

        UserInfo userInfo=new UserInfo("程序員老王","123");
        System.out.println("序列化之前信息："+userInfo);

        try {
            ObjectOutputStream output=new ObjectOutputStream(new FileOutputStream("userinfo.txt")); //第二步開始序列化操作
            output.writeObject(new UserInfo("程序員老王","123"));
            output.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {
            ObjectInputStream input=new ObjectInputStream(new FileInputStream("userinfo.txt"));//第三步開始反序列化操作
            Object o = input.readObject();//ObjectInputStream的readObject方法會(huì)拋出ClassNotFoundException
            System.out.println("序列化之后信息："+o);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Laufergebnisse:

序列化之前信息：UserInfo{name='程序員老王', password='123'}
序列化之后信息：UserInfo{name='程序員老王', password='123'}

3.4. Transiente Serialisierung

package TransientTest;
import java.io.*;

class UserInfo implements Serializable{  //第一步實(shí)現(xiàn)Serializable接口
    private String name;
    private transient String password; //特別注意：屬性由transient關(guān)鍵字修飾===========

    public UserInfo(String name,String psw) {
        this.name = name;
        this.password=psw;
    }

    @Override
    public String toString() {
        return "UserInfo{" +
                "name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

public class TransientDemo {
    public static void main(String[] args) throws ClassNotFoundException {

        UserInfo userInfo=new UserInfo("程序員老王","123");
        System.out.println("序列化之前信息："+userInfo);

        try {
            ObjectOutputStream output=new ObjectOutputStream(new FileOutputStream("userinfo.txt")); //第二步開始序列化操作
            output.writeObject(new UserInfo("程序員老王","123"));
            output.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {
            ObjectInputStream input=new ObjectInputStream(new FileInputStream("userinfo.txt"));//第三步開始反序列化操作
            Object o = input.readObject();//ObjectInputStream的readObject方法會(huì)拋出ClassNotFoundException
            System.out.println("序列化之后信息："+o);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Laufergebnisse:

序列化之前信息：UserInfo{name='程序員老王', password='123'}
序列化之后信息：UserInfo{name='程序員老王', password='null'}

Achten Sie besonders auf die Ergebnisse und fügen Sie den vorübergehend ge?nderten Attributwert zum Standardwert hinzu

! Wenn das durch transient ge?nderte Attribut vom Typ int ist, muss sein Wert nach der Serialisierung 0 sein. Natürlich k?nnen Sie es versuchen. Dies bedeutet, dass als

markierte Attribute nicht gespeichert werden, wenn das Objekt serialisiert wird (oder die Variable nicht beibehalten wird)

nulltransient3.5, statische Serialisierungssituation

package TransientTest;
import java.io.*;

class UserInfo implements Serializable{  //第一步實(shí)現(xiàn)Serializable接口
    private String name;
    private static String password; //特別注意：屬性由static關(guān)鍵字修飾==============

    public UserInfo(String name, String psw) {
        this.name = name;
        this.password=psw;
    }

    @Override
    public String toString() {
        return "UserInfo{" +
                "name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

public class TransientDemo {
    public static void main(String[] args) throws ClassNotFoundException {

        UserInfo userInfo=new UserInfo("程序員老王","123");
        System.out.println("序列化之前信息："+userInfo);

        try {
            ObjectOutputStream output=new ObjectOutputStream(new FileOutputStream("userinfo.txt")); //第二步開始序列化操作
            output.writeObject(new UserInfo("程序員老王","123"));
            output.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {
            ObjectInputStream input=new ObjectInputStream(new FileInputStream("userinfo.txt"));//第三步開始反序列化操作
            Object o = input.readObject();//ObjectInputStream的readObject方法會(huì)拋出ClassNotFoundException
            System.out.println("序列化之后信息："+o);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Laufergebnis:

序列化之前信息：UserInfo{name='程序員老王', password='123'}
序列化之后信息：UserInfo{name='程序員老王', password='123'}

Zu diesem Zeitpunkt werden Sie f?lschlicherweise denken, dass die statische ?nderung auch serialisiert wurde. Tats?chlich ist dies nicht der Fall. Tats?chlich ist es hier leicht, verwirrt zu werden. Offensichtlich kann das Entfernen von

(Standardwert) darauf hinweisen, dass es nicht serialisiert wird. Es wird hier eindeutig nicht auf den Standardwert ge?ndert. Warum sagen Sie immer noch, dass

nicht serialisiert wird?

nullstatic

Tats?chlich ist der Wert des statischen Variablennamens in der Klasse nach der Deserialisierung tats?chlich der Wert der entsprechenden statischen Variablen in der aktuellen JVM. Dieser Wert befindet sich in der JVM deserialisiert.

Das hei?t, durch statische Variablen ge?nderte Variablen nehmen nicht an der Serialisierung teil! Aber wir k?nnen es nicht ohne Beweise sagen, ja, dann vergleichen wir die beiden Programme und wir werden es verstehen! Das erste Programm: Dies ist ein Namensattributprogramm, das nicht durch Statik ge?ndert wurde:

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

class UserInfo implements Serializable {
    private String name;
    private transient String psw;

    public UserInfo(String name, String psw) {
        this.name = name;
        this.psw = psw;
    }

    public  String getName() {
        return name;
    }

    public  void setName(String name) {
        this.name = name;
    }

    public String getPsw() {
        return psw;
    }

    public void setPsw(String psw) {
        this.psw = psw;
    }

    public String toString() {
        return "name=" + name + ", psw=" + psw;
    }
}
public class TestTransient {
    public static void main(String[] args) {
        UserInfo userInfo = new UserInfo("程序員老過", "456");
        System.out.println(userInfo);
        try {
            // 序列化，被設(shè)置為transient的屬性沒有被序列化
            ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("UserInfo.txt"));
            o.writeObject(userInfo);
            o.close();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
        try {
            //在反序列化之前改變name的值 =================================注意這里的代碼
            userInfo.setName("程序員老改");
            // 重新讀取內(nèi)容
            ObjectInputStream in = new ObjectInputStream(new FileInputStream("UserInfo.txt"));
            UserInfo readUserInfo = (UserInfo) in.readObject();
            //讀取后psw的內(nèi)容為null
            System.out.println(readUserInfo.toString());
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }
}

Laufende Ergebnisse:

name=程序員老過, psw=456
name=程序員老過, psw=null

Wie aus den Programmlaufergebnissen ersichtlich ist , Vor der Deserialisierung habe ich versucht, den Wert des Namens in den Programmierer zu ?ndern, aber es war erfolglos!

第二個(gè)程序：這是一個(gè)被static修飾的name屬性程序：

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

class UserInfo implements Serializable {
    private static final long serialVersionUID = 996890129747019948L;
    private static String name;
    private transient String psw;

    public UserInfo(String name, String psw) {
        this.name = name;
        this.psw = psw;
    }

    public  String getName() {
        return name;
    }

    public  void setName(String name) {
        this.name = name;
    }

    public String getPsw() {
        return psw;
    }

    public void setPsw(String psw) {
        this.psw = psw;
    }

    public String toString() {
        return "name=" + name + ", psw=" + psw;
    }
}
public class TestTransient {
    public static void main(String[] args) {
        UserInfo userInfo = new UserInfo("程序員老過", "456");
        System.out.println(userInfo);
        try {
            // 序列化，被設(shè)置為transient的屬性沒有被序列化
            ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("UserInfo.txt"));
            o.writeObject(userInfo);
            o.close();
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
        try {
            //在反序列化之前改變name的值
            userInfo.setName("程序員老改");
            // 重新讀取內(nèi)容
            ObjectInputStream in = new ObjectInputStream(new FileInputStream("UserInfo.txt"));
            UserInfo readUserInfo = (UserInfo) in.readObject();
            //讀取后psw的內(nèi)容為null
            System.out.println(readUserInfo.toString());
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }
}

運(yùn)行結(jié)果：

name=程序員老過, psw=456
name=程序員老改, psw=null

從程序運(yùn)行結(jié)果中可以看出，在反序列化之前試著改變name的值為程序員老改，結(jié)果是成功的！現(xiàn)在對(duì)比一下兩個(gè)程序是不是就很清晰了？

static關(guān)鍵字修飾的成員屬性優(yōu)于非靜態(tài)成員屬性加載到內(nèi)存中，同時(shí)靜態(tài)也優(yōu)于對(duì)象進(jìn)入到內(nèi)存中，被static修飾的成員變量不能被序列化，序列化的都是對(duì)象，靜態(tài)變量不是對(duì)象狀態(tài)的一部分，因此它不參與序列化。所以將靜態(tài)變量聲明為transient變量是沒有用處的。因此，反序列化后類中static型變量name的值實(shí)際上是當(dāng)前JVM中對(duì)應(yīng)static變量的值，這個(gè)值是JVM中的并不是反序列化得出的。

如果對(duì)static關(guān)鍵字還是不太清楚理解的童鞋可以參考這篇文章，應(yīng)該算是不錯(cuò)的：深入理解static關(guān)鍵字

3.6、final序列化情況

對(duì)于final關(guān)鍵字來講，final變量將直接通過值參與序列化，至于代碼程序我就不再貼出來了，大家可以試著用final修飾驗(yàn)證一下！

主要注意的是final 和transient可以同時(shí)修飾同一個(gè)變量，結(jié)果也是一樣的，對(duì)transient沒有影響，這里主要提一下，希望各位以后在開發(fā)中遇到這些情況不會(huì)滿頭霧水！

4、java類中serialVersionUID作用

既然提到了transient關(guān)鍵字就不得不提到序列化，既然提到了序列化，就不得不提到serialVersionUID了，它是啥呢？基本上有序列化就會(huì)存在這個(gè)serialVersionUID。

serialVersionUID適用于Java的序列化機(jī)制。簡單來說，Java的序列化機(jī)制是通過判斷類的serialVersionUID來驗(yàn)證版本一致性的。在進(jìn)行反序列化時(shí)，JVM會(huì)把傳來的字節(jié)流中的serialVersionUID與本地相應(yīng)實(shí)體類的serialVersionUID進(jìn)行比較，如果相同就認(rèn)為是一致的，可以進(jìn)行反序列化，否則就會(huì)出現(xiàn)序列化版本不一致的異常，即是InvalidCastException，在開發(fā)中有時(shí)候可寫可不寫，建議最好還是寫上比較好。

5、transient關(guān)鍵字小結(jié)

1、變量被transient修飾，變量將不會(huì)被序列化
2、transient關(guān)鍵字只能修飾變量，而不能修飾方法和類。
3、被static關(guān)鍵字修飾的變量不參與序列化，一個(gè)靜態(tài)static變量不管是否被transient修飾，均不能被序列化。
4、final變量值參與序列化，final transient同時(shí)修飾變量，final不會(huì)影響transient，一樣不會(huì)參與序列化

第二點(diǎn)需要注意的是：本地變量是不能被transient關(guān)鍵字修飾的。變量如果是用戶自定義類變量，則該類需要實(shí)現(xiàn)Serializable接口

第三點(diǎn)需要注意的是：反序列化后類中static型變量的值實(shí)際上是當(dāng)前JVM中對(duì)應(yīng)static變量的值，這個(gè)值是JVM中的并不是反序列化得出的。

結(jié)語：被transient關(guān)鍵字修飾導(dǎo)致不被序列化，其優(yōu)點(diǎn)是可以節(jié)省存儲(chǔ)空間。優(yōu)化程序！隨之而來的是會(huì)導(dǎo)致被transient修飾的字段會(huì)重新計(jì)算，初始化！

本文來自?java入門?欄目，歡迎學(xué)習(xí)！

Das obige ist der detaillierte Inhalt vonErfahren Sie mehr über das transiente Schlüsselwort in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!