Hélas, bien que je sois le plus familier avec Java, je ne connais pas beaucoup de connaissances Java de base. Par exemple, je n'ai pas utilisé le mot-clé transitoire auparavant, donc je ne sais pas quelle est sa fonction. Quand je faisais le test écrit aujourd'hui, j'ai trouvé qu'il y avait une question à ce sujet, alors j'ai passé du temps à trier l'utilisation de mots clés transitoires et à élever ma posture ~~~ D'accord, je ne dirai pas beaucoup de bêtises, commençons:
1. Le rôle et la méthode d'utilisation du transitoire <br /> nous savons tous que tant qu'un objet implémente l'interface Selilisable, l'objet peut être sérialisé. Ce modèle de sérialisation de Java offre beaucoup de commodité aux développeurs. Nous n'avons pas à nous rapporter au processus de sérialisation spécifique. Tant que cette classe met en œuvre l'interface Selilisable, 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 de tels problèmes. Certaines propriétés de cette classe doivent être sérialisées, tandis que d'autres propriétés n'ont pas besoin d'être sérialisées. Par exemple, si un utilisateur a des informations sensibles (telles que des mots de passe, des numéros de carte bancaire, etc.), pour des raisons de sécurité, il ne veut pas être transmis dans les opérations de 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é transitoire. En d'autres termes, le cycle de vie de ce champ n'est que dans la mémoire de l'appelant et n'est pas écrit sur le disque pour la persistance.
En bref, le mot-clé transitoire de Java nous fournit une commodité. Il vous suffit d'implémenter l'interface Selilisable et d'ajouter le mot-clé transitoire avant les attributs qui n'ont pas besoin d'être sérialisés. Lors de la sérialisation de l'objet, cet attribut ne sera pas sérialisé à la destination spécifiée.
L'exemple de code est le suivant:
Importer java.io.fileInputStream; Importer java.io.filenotfoundException; Importer java.io.fileoutputStream; Importer java.io.o-bjectoutputStream; Importer java.io.Serializable; / ** * @Description use use transitorwords to not alerize; / ** * @Des description use transit Variable * Notez que lors de la lecture, l'ordre de lecture des données doit être cohérent avec l'ordre de stockage des données * * @author alexia * @date 2013-10-15 * / public class transientTest {public static void main (String [] args) {utilisateur utilisateur = new user (); user.setUsername ("Alexia"); user.setpasswd ("123456"); System.out.println ("Lire avant Serializable:"); System.out.println ("nom d'utilisateur:" + user.getUserName ()); System.err.println ("Mot de passe:" + user.getPasswd ()); try {objectOutputStream os = new ObjectOutputStream (new FileOutputStream ("c: /user.txt")); OS.WriteObject (utilisateur); // Écrivez l'objet utilisateur dans le fichier os.flush (); os.close (); } catch (filenotFoundException e) {e.printStackTrace (); } catch (ioException e) {e.printStackTrace (); } try {objectInputStream est = new ObjectInputStream (new FileInputStream ("c: /user.txt")); user = (user) is.readObject (); // Lire les données de l'utilisateur du flux est.close (); System.out.println ("/ nread après sérialisable:"); System.out.println ("nom d'utilisateur:" + user.getUserName ()); System.err.println ("Mot de passe:" + user.getPasswd ()); } catch (filenotFoundException e) {e.printStackTrace (); } catch (ioException e) {e.printStackTrace (); } catch (classNotFoundException e) {e.printStackTrace (); }}} Classe User implémente Serializable {private static final long SerialVersionUID = 8294180014912103005l; Nom d'utilisateur de chaîne privée; String transitoire privé 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; }}La sortie est:
Lire avant la série: Nom d'utilisateur: Alexiapassword: 123456Read After Serializable: Nom d'utilisateur: Alexiapassword: NULL
Le champ de mot de passe est nul, ce qui signifie qu'aucune information n'a été obtenue à partir du fichier pendant la désérialisation.
2. Résumé de l'utilisation transitoire
1) Une fois la variable modifiée par transitoire, la variable ne fera plus partie de la persistance de l'objet et le contenu de la variable ne peut être accessible après la sérialisation.
2) Le mot-clé transitoire ne peut modifier que des variables, mais pas des méthodes et des classes. Notez que les variables locales ne peuvent pas être modifiées par des mots clés transitoires. Si une variable est une variable de classe définie par l'utilisateur, la classe doit implémenter l'interface sérialisable.
3) Les variables modifiées par le mot-clé transitoire ne peuvent plus être sérialisées. Une variable statique ne peut pas être sérialisée, qu'elle soit modifiée par transitoire.
Le troisième point peut être déroutant, car j'ai constaté qu'après avoir ajouté le mot-clé statique au champ de nom d'utilisateur dans la classe utilisateur, le résultat du programme reste inchangé, c'est-à-dire que le nom d'utilisateur du type statique est également lu comme "Alexia". N'est-ce pas contradictoire avec le troisième point? En fait, c'est comme ceci: le troisième point est en effet correct (une variable statique ne peut pas être sérialisée, qu'elle soit modifiée par transitoire). Après désérialisation, le nom d'utilisateur de la variable statique dans la classe est la valeur de la variable statique correspondante dans le JVM actuel. Cette valeur n'est pas dérivée de la désérialisation dans le JVM. Vous ne le croyez pas? Ok, laissez-moi le prouver ci-dessous:
Importer java.io.fileInputStream; Importer java.io.filenotfoundException; Importer java.io.fileoutputStream; Importer java.io.o-bjectoutputStream; Importer java.io.Serializable; / ** * @Description use use transitorwords to not alerize; / ** * @Des description use transit Variable * Notez que lors de la lecture, l'ordre de lecture des données doit être cohérent avec l'ordre de stockage des données * * @author alexia * @date 2013-10-15 * / public class transientTest {public static void main (String [] args) {utilisateur utilisateur = new user (); user.setUsername ("Alexia"); user.setpasswd ("123456"); System.out.println ("Lire avant Serializable:"); System.out.println ("nom d'utilisateur:" + user.getUserName ()); System.err.println ("Mot de passe:" + user.getPasswd ()); try {objectOutputStream os = new ObjectOutputStream (new FileOutputStream ("c: /user.txt")); OS.WriteObject (utilisateur); // Écrivez l'objet utilisateur dans le fichier os.flush (); os.close (); } catch (filenotFoundException e) {e.printStackTrace (); } catch (ioException e) {e.printStackTrace (); } essayez {// Modifiez la valeur du nom d'utilisateur avant la désérialisation user.username = "jmwang"; ObjectInputStream est = new ObjectInputStream (new FileInputStream ("c: /user.txt")); user = (user) is.readObject (); // Lire les données de l'utilisateur du flux est.close (); System.out.println ("/ nread après sérialisable:"); System.out.println ("nom d'utilisateur:" + user.getUserName ()); System.err.println ("Mot de passe:" + user.getPasswd ()); } catch (filenotFoundException e) {e.printStackTrace (); } catch (ioException e) {e.printStackTrace (); } catch (classNotFoundException e) {e.printStackTrace (); }}} Classe User implémente Serializable {private static final long SerialVersionUID = 8294180014912103005l; Nom d'utilisateur de chaîne statique publique; String transitoire privé 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 en cours est:
Lire avant la série: Nom d'utilisateur: Alexiapassword: 123456Read After Serializable: Nom d'utilisateur: jmwangpassword: null
Cela signifie que la valeur du nom d'utilisateur de la variable statique dans la classe désérialisée est la valeur de la variable statique correspondante dans le JVM actuel, qui est le JMWang modifié, et non la valeur Alexia pendant la sérialisation.
3. Détails d'utilisation transitoires - Les variables modifiées par le mot clé transitoire peuvent-elles vraiment être sérialisées?
Pensez aux exemples suivants:
Importer java.io.externalizable; import java.io.file; import java.io.fileInputStream; import java.io.fileoutputStream; import java.io.ioexception; import java.io.objectInputStream; @Date 2013-10-15 * * / classe publique externalizableTest implémente externalisable {private transity string contenu = "Oui, je serai sérialisé, que je sois modifié par le mot-clé transitoire ou non"; @Override public void writeExternal (objectOutput out) lève ioException {out.writeObject (contenu); } @Override public void readExternal (objectInput in) lève ioException, classNotFoundException {content = (string) in.readObject (); } public static void main (String [] args) lève une exception {externalizableTest et = new externalizableTest (); ObjectOutput out = new ObjectOutputStream (new FileOutputStream (nouveau fichier ("test"))); out.writeObject (ET); ObjectInput dans = new ObjectInputStream (new FileInputStream (nouveau fichier ("test"))); et = (externalizableTest) in.readObject (); System.out.println (ET.Content); out.close (); joindre(); }} La variable de contenu sera-t-elle sérialisée? Ok, j'ai sorti toutes les réponses, oui, le résultat est:
Oui, je serai sérialisé, que je sois modifié par des mots clés transitoires ou non
Pourquoi est-ce? N'est-il pas dit que les variables de la classe ne seront pas sérialisées après avoir été modifiées par le mot-clé transitoire?
Nous savons qu'en Java, la sérialisation des objets peut être implémentée en implémentant deux interfaces. Si l'interface sérialisable est implémentée, toute sérialisation sera effectuée automatiquement. Si l'interface externalisable est implémentée, rien ne peut être sérialisé automatiquement. Vous devez spécifier manuellement la variable pour être sérialisée dans la méthode WriteExternal, ce qui n'a rien à voir avec la modification par transitoire. Par conséquent, le deuxième exemple sortit le contenu initialisé par le contenu variable, pas null.
Auteur: Alexia (Minmin)
Si vous souhaitez communiquer et interagir avec moi, veuillez nous contacter sur Weibo: http://www.cnblogs.com/lanxuezaipiao/p/3369962.html
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.