Maison >Java >javaDidacticiel >Résumé de l'utilisation des mots clés transitoires Java
Hé, même si je connais bien Java, je ne connais pas beaucoup de connaissances de base en Java. Par exemple, le mot-clé transient n'a jamais été utilisé auparavant, donc je ne sais pas quelle est sa fonction. une question quand je faisais l'examen écrit aujourd'hui C'est à propos de ça, alors j'ai passé un peu de temps à trier l'utilisation du mot-clé transient et je me suis mis au courant~~~D'accord, sans plus tarder, commençons :
Nous savons tous que tant qu'un objet implémente l'interface Serilisable, l'objet peut être sérialisé. Ce mode de sérialisation de Java offre aux développeurs de nombreuses commodités. .Nous n'avons pas à nous soucier de la séquence spécifique.Dans le processus de sérialisation, tant que cette classe implémente l'interface Serilisable, toutes les propriétés et méthodes de cette classe seront automatiquement sérialisées.
Cependant, dans le processus de développement réel, nous rencontrons souvent un tel problème. Certains attributs de cette classe doivent être sérialisés, tandis que d'autres n'ont pas besoin d'être sérialisés. Par exemple, si un utilisateur a des éléments sensibles. Les informations (telles que les mots de passe, les numéros de carte bancaire, etc.), pour des raisons de sécurité, ne sont pas censées être transmises lors des opérations réseau (impliquant principalement des opérations de sérialisation, le cache de sérialisation local est également applicable), les variables correspondant à ces informations peuvent être ajoutées avec le mot clé transient . En d'autres termes, le cycle de vie de ce champ n'existe que dans la mémoire de l'appelant et ne sera pas écrit sur le disque à des fins de persistance.
En bref, le mot-clé transient de Java nous apporte de la commodité. Il vous suffit d'implémenter l'interface Serilisable et d'ajouter le mot-clé transient avant les propriétés qui n'ont pas besoin d'être sérialisées. ne sera pas sérialisé vers la destination spécifiée.
L'exemple de code est le suivant :
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
* @description 使用transient关键字不序列化某个变量
* 注意读取的时候，读取数据的顺序一定要和存放数据的顺序保持一致
*
* @author Alexia
* @date 2013-10-15
*/
public class TransientTest {
public static void main(String[] args) {
User user = new User();
user.setUsername("Alexia");
user.setPasswd("123456");
System.out.println("read before Serializable: ");
System.out.println("username: " + user.getUsername());
System.err.println("password: " + user.getPasswd());
try {
ObjectOutputStream os = new ObjectOutputStream(
new FileOutputStream("C:/user.txt"));
os.writeObject(user); // 将User对象写进文件
os.flush();
os.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
try {
ObjectInputStream is = new ObjectInputStream(new FileInputStream(
"C:/user.txt"));
user = (User) is.readObject(); // 从流中读取User的数据
is.close();
System.out.println("\nread after Serializable: ");
System.out.println("username: " + user.getUsername());
System.err.println("password: " + user.getPasswd());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
class User implements Serializable {
private static final long serialVersionUID = 8294180014912103005L;
private String username;
private transient String passwd;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPasswd() {
return passwd;
}
public void setPasswd(String passwd) {
this.passwd = passwd;
}
}Le résultat est :
read before Serializable: username: Alexia password: 123456 read after Serializable: username: Alexia password: null
Le champ du mot de passe est nul, indiquant que l'inverse Aucune information n'est obtenue du fichier pendant la sérialisation.
1) Une fois qu'une variable est modifiée par transitoire, la variable ne fera plus partie de la persistance de l'objet, et le contenu de la variable ne peut pas être sérialisée après la sérialisation. Obtenez l'accès.
2) Le mot-clé transient ne peut modifier que les variables, mais pas les méthodes et les classes. Notez que les variables locales ne peuvent pas être modifiées par le mot clé transient. Si la variable est une variable de classe définie par l'utilisateur, la classe doit implémenter l'interface Serialisable.
3) Les variables modifiées par le mot-clé transient ne peuvent plus être sérialisées. Une variable statique ne peut pas être sérialisée, qu'elle soit modifiée par transitoire ou non.
Le troisième point peut prêter à confusion pour certaines personnes, car on constate qu'après avoir ajouté le mot-clé static avant le champ nom d'utilisateur dans la classe User, le résultat de l'exécution du programme reste inchangé, c'est-à-dire que le nom d'utilisateur statique est également lire comme « Alexia » « Eh bien, cela ne contredit-il pas le troisième point ? C'est effectivement le cas : le troisième point est bien vrai (une variable statique ne peut pas être sérialisée qu'elle soit modifiée ou non par un transitoire). Après désérialisation, la valeur de la variable statique username dans la classe est la valeur de la variable statique correspondante). dans la JVM actuelle, cette valeur est dérivée de la JVM et non de la désérialisation. Eh bien, laissez-moi le prouver ci-dessous :
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
* @description 使用transient关键字不序列化某个变量
* 注意读取的时候，读取数据的顺序一定要和存放数据的顺序保持一致
*
* @author Alexia
* @date 2013-10-15
*/
public class TransientTest {
public static void main(String[] args) {
User user = new User();
user.setUsername("Alexia");
user.setPasswd("123456");
System.out.println("read before Serializable: ");
System.out.println("username: " + user.getUsername());
System.err.println("password: " + user.getPasswd());
try {
ObjectOutputStream os = new ObjectOutputStream(
new FileOutputStream("C:/user.txt"));
os.writeObject(user); // 将User对象写进文件
os.flush();
os.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
try {
// 在反序列化之前改变username的值
User.username = "jmwang";
ObjectInputStream is = new ObjectInputStream(new FileInputStream(
"C:/user.txt"));
user = (User) is.readObject(); // 从流中读取User的数据
is.close();
System.out.println("\nread after Serializable: ");
System.out.println("username: " + user.getUsername());
System.err.println("password: " + user.getPasswd());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
class User implements Serializable {
private static final long serialVersionUID = 8294180014912103005L;
public static String username;
private transient String passwd;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPasswd() {
return passwd;
}
public void setPasswd(String passwd) {
this.passwd = passwd;
}
}Le résultat courant est :
read before Serializable: username: Alexia password: 123456 read after Serializable: username: jmwang password: null
Cela montre que dans la classe après désérialisation La valeur de la variable statique username est la valeur de la variable statique correspondante dans la JVM actuelle, qui est le jmwang modifié, et non la valeur Alexia lors de la sérialisation.
Considérons l'exemple suivant :
import java.io.Externalizable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
/**
* @descripiton Externalizable接口的使用
*
* @author Alexia
* @date 2013-10-15
*
*/
public class ExternalizableTest implements Externalizable {
private transient String content = "是的，我将会被序列化，不管我是否被transient关键字修饰";
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeObject(content);
}
@Override
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
content = (String) in.readObject();
}
public static void main(String[] args) throws Exception {
ExternalizableTest et = new ExternalizableTest();
ObjectOutput out = new ObjectOutputStream(new FileOutputStream(
new File("test")));
out.writeObject(et);
ObjectInput in = new ObjectInputStream(new FileInputStream(new File(
"test")));
et = (ExternalizableTest) in.readObject();
System.out.println(et.content);
out.close();
in.close();
}
}La variable de contenu sera-t-elle sérialisée ? Eh bien, j'affiche toutes les réponses. Oui, le résultat courant est :
是的，我将会被序列化，不管我是否被transient关键字修饰
Pourquoi est-ce que ce n'est pas que les variables de classe sont transitoires ? le mot-clé ne peut-il pas être sérialisable après modification ?
Nous savons qu'en Java, la sérialisation des objets peut être réalisée en implémentant deux interfaces. Si l'interface Serialisable est implémentée, toute la sérialisation sera effectuée automatiquement. Si l'interface Externalisable est implémentée, alors Nothing peut être sérialisé automatiquement. Vous devez spécifier manuellement les variables à sérialiser dans la méthode writeExternal. Cela n'a rien à voir avec le fait qu'elles soient modifiées par un transitoire. Par conséquent, le deuxième exemple génère le contenu initialisé de la variable content, et non null.
Ce qui précède est le résumé de l'utilisation des mots clés transitoires Java. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (m.sbmmt.com) !