Heim >Java >JavaErste Schritte >Erfahren Sie mehr über das transiente Schlüsselwort in Java
Erfahren Sie mehr über das transiente Schlüsselwort in Java
- 青灯夜游nach vorne
- 2019-11-27 16:28:042208Durchsuche
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
, um die Kastanie zu ändern:
sind keine vorübergehendenWenn 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
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 mittransientgeä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. wennmodCountbei 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
Serializable3. instanceof Serializable
in Java, um die Serialisierung und Stream-Deserialisierung abzuschließen ObjectOutputStream ObjectInputStream==ObjectOutputStream :Serialisierungsvorgang durch writeObject() method==
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 { //================================注意这里没有实现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{ //第一步实现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方法会抛出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{ //第一步实现Serializable接口
private String name;
private transient String password; //特别注意：属性由transient关键字修饰===========
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方法会抛出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{ //第一步实现Serializable接口
private String name;
private static String password; //特别注意：属性由static关键字修饰==============
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方法会抛出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
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 {
// 序列化，被设置为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("程序员老改");
// 重新读取内容
ObjectInputStream in = new ObjectInputStream(new FileInputStream("UserInfo.txt"));
UserInfo readUserInfo = (UserInfo) in.readObject();
//读取后psw的内容为null
System.out.println(readUserInfo.toString());
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
}Laufende Ergebnisse: name=程序员老过, psw=456 name=程序员老过, psw=nullWie aus den Programmlaufergebnissen ersichtlich ist , Vor der Deserialisierung habe ich versucht, den Wert des Namens in den Programmierer zu ändern, aber es war erfolglos!
第二个程序：这是一个被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 {
// 序列化，被设置为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("程序员老改");
// 重新读取内容
ObjectInputStream in = new ObjectInputStream(new FileInputStream("UserInfo.txt"));
UserInfo readUserInfo = (UserInfo) in.readObject();
//读取后psw的内容为null
System.out.println(readUserInfo.toString());
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
}运行结果：
name=程序员老过, psw=456 name=程序员老改, psw=null
从程序运行结果中可以看出，在反序列化之前试着改变name的值为程序员老改，结果是成功的！现在对比一下两个程序是不是就很清晰了？
static关键字修饰的成员属性优于非静态成员属性加载到内存中，同时静态也优于对象进入到内存中，被static修饰的成员变量不能被序列化，序列化的都是对象，静态变量不是对象状态的一部分，因此它不参与序列化。所以将静态变量声明为transient变量是没有用处的。因此，反序列化后类中static型变量name的值实际上是当前JVM中对应static变量的值，这个值是JVM中的并不是反序列化得出的。
如果对static关键字还是不太清楚理解的童鞋可以参考这篇文章，应该算是不错的：深入理解static关键字
3.6、final序列化情况
对于final关键字来讲，final变量将直接通过值参与序列化，至于代码程序我就不再贴出来了，大家可以试着用final修饰验证一下！
主要注意的是final 和transient可以同时修饰同一个变量，结果也是一样的，对transient没有影响，这里主要提一下，希望各位以后在开发中遇到这些情况不会满头雾水！
4、java类中serialVersionUID作用
既然提到了transient关键字就不得不提到序列化，既然提到了序列化，就不得不提到serialVersionUID了，它是啥呢？基本上有序列化就会存在这个serialVersionUID。
serialVersionUID适用于Java的序列化机制。简单来说，Java的序列化机制是通过判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常，即是InvalidCastException，在开发中有时候可写可不写，建议最好还是写上比较好。
5、transient关键字小结
1、变量被transient修饰，变量将不会被序列化
2、transient关键字只能修饰变量，而不能修饰方法和类。
3、被static关键字修饰的变量不参与序列化，一个静态static变量不管是否被transient修饰，均不能被序列化。
4、final变量值参与序列化，final transient同时修饰变量，final不会影响transient，一样不会参与序列化
第二点需要注意的是：本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量，则该类需要实现Serializable接口
第三点需要注意的是：反序列化后类中static型变量的值实际上是当前JVM中对应static变量的值，这个值是JVM中的并不是反序列化得出的。
结语：被transient关键字修饰导致不被序列化，其优点是可以节省存储空间。优化程序！随之而来的是会导致被transient修饰的字段会重新计算，初始化！
本文来自 java入门 栏目，欢迎学习！
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!