Palavras -chave transitórias Java
1. A função e o método de uso de transitórios
Todos sabemos que, desde que um objeto implemente a interface serilizável, o objeto pode ser serializado. Esse modelo de serialização de Java fornece muita conveniência para os desenvolvedores. Não precisamos nos relacionar com o processo de serialização específico. Enquanto essa classe implementar a interface serilizável, todas as propriedades e métodos dessa classe serão automaticamente serializados.
No entanto, no processo de desenvolvimento real, geralmente encontramos esses problemas. Algumas propriedades dessa classe precisam ser serializadas, enquanto outras propriedades não precisam ser serializadas. Por exemplo, se um usuário tiver algumas informações confidenciais (como senhas, números de cartões bancários etc.), por razões de segurança, ele não deseja ser transmitido em operações de rede (principalmente envolvendo operações de serialização, o cache de serialização local também é aplicável) e as variáveis correspondentes a essas informações podem ser adicionadas com a palavra -chave transitória. Em outras palavras, o ciclo de vida deste campo é apenas na memória do chamador e não é escrito no disco para persistência.
Em suma, a palavra -chave transitória de Java nos fornece conveniência. Você só precisa implementar a interface serilizável e adicionar a palavra -chave transitória antes dos atributos que não precisam ser serializados. Ao serializar o objeto, esse atributo não será serializado ao destino especificado.
O código de exemplo é o seguinte:
importar java.io.fileInputStream; importar java.io.fileNotfoundException; importar java.io.fileOutputStream; importar java.io.ioException; importar java.io.ObjectInpTream; import java.io.objectStream; importecriptri description Variável * Observe que, ao ler, a ordem dos dados de leitura deve ser consistente com a ordem de armazenar dados * * @Author Alexia * @Date 2013-10-15 * http://www.manongjc.com/article/1609.html */public class TransientTest {public static void Main (string [] args) {AvestorTevesterTest {público user.setUsername ("Alexia"); user.setpasswd ("123456"); System.out.println ("Leia antes de serializável:"); System.out.println ("nome de usuário:" + user.getUserName ()); System.err.println ("senha:" + user.getpasswd ()); tente {objectOutputStream OS = new ObjectOutputStream (new FileOutputStream ("c: /User.txt")); OS.WriteObject (Usuário); // Escreva o objeto do usuário no arquivo os.flush (); os.close (); } catch (filenotfoundException e) {e.printStackTrace (); } catch (ioexception e) {e.printStackTrace (); } tente {objectInputStream is = new ObjectInputStream (new FileInputStream ("c: /User.txt")); usuário = (usuário) is.readObject (); // Leia os dados do usuário do fluxo is.close (); System.out.println ("/nread após serializável:"); System.out.println ("nome de usuário:" + user.getUserName ()); System.err.println ("senha:" + user.getpasswd ()); } catch (filenotfoundException e) {e.printStackTrace (); } catch (ioexception e) {e.printStackTrace (); } catch (classNotFoundException e) {e.printStackTrace (); }}} classe o usuário implementa serializável {private estático final serialversionuid = 8294180014912103005L; Nome de usuário privado de string; Passwd de corda transitória privada; public String getUserName () {return Username; } public void setUserName (string userName) {this.username = nome de usuário; } public string getPasswd () {return passwd; } public void Setpasswd (String passwd) {this.passwd = passwd; }}A saída é:
Leia antes da serializável: Nome de usuário: AlexiaPassword: 123456 LEAD After Serializable: Nome de usuário: AlexiaPassword: NULL
O campo de senha é nulo, o que significa que nenhuma informação foi obtida do arquivo durante a desertalização.
2. Resumo do uso transitório
1) Depois que a variável é modificada por transitório, a variável não fará mais parte da persistência do objeto e o conteúdo da variável não pode ser acessado após a serialização.
2) A palavra -chave transitória pode modificar apenas variáveis, mas não métodos e classes. Observe que as variáveis locais não podem ser modificadas por palavras -chave transitórias. Se uma variável for uma variável de classe definida pelo usuário, a classe precisará implementar a interface serializável.
3) As variáveis modificadas pela palavra -chave transitória não podem mais ser serializadas. Uma variável estática não pode ser serializada, independentemente de ser modificado por transitório.
O terceiro ponto pode ser confuso, porque descobri que, depois de adicionar a palavra -chave estática ao campo de nome de usuário na classe de usuário, o resultado da execução do programa permanece inalterado, ou seja, o nome de usuário do tipo estático também é lido como "Alexia". Isso não é contraditório ao terceiro ponto? Na verdade, é assim: o terceiro ponto está realmente correto (uma variável estática não pode ser serializada, independentemente de ser modificado por transitório). Após a desserialização, o nome de usuário da variável estática na classe é o valor da variável estática correspondente na JVM atual. Este valor não é derivado da desserialização na JVM. Não acredita? Ok, deixe -me provar abaixo:
importar java.io.fileInputStream; importar java.io.fileNotfoundException; importar java.io.fileOutputStream; importar java.io.ioException; importar java.io.ObjectInpTream; import java.io.objectStream; importecriptri description Variável * Observe que, ao ler, a ordem dos dados de leitura deve ser consistente com a ordem de armazenar dados * * @Author Alexia * @date 2013-10-15 * http://www.manongjc.com */public class TransientTest {public static void main (string [] args) {user = user = user (); user.setUsername ("Alexia"); user.setpasswd ("123456"); System.out.println ("Leia antes de serializável:"); System.out.println ("nome de usuário:" + user.getUserName ()); System.err.println ("senha:" + user.getpasswd ()); tente {objectOutputStream OS = new ObjectOutputStream (new FileOutputStream ("c: /User.txt")); OS.WriteObject (Usuário); // Escreva o objeto do usuário no arquivo os.flush (); os.close (); } catch (filenotfoundException e) {e.printStackTrace (); } catch (ioexception e) {e.printStackTrace (); } tente {// altere o valor do nome de usuário antes da deserialização user.username = "jmwang"; ObjectInputStream IS = new ObjectInputStream (new FileInputStream ("c: /User.txt")); usuário = (usuário) is.readObject (); // Leia os dados do usuário do fluxo is.close (); System.out.println ("/nread após serializável:"); System.out.println ("nome de usuário:" + user.getUserName ()); System.err.println ("senha:" + user.getpasswd ()); } catch (filenotfoundException e) {e.printStackTrace (); } catch (ioexception e) {e.printStackTrace (); } catch (classNotFoundException e) {e.printStackTrace (); }}} classe o usuário implementa serializável {private estático final serialversionuid = 8294180014912103005L; Nome de usuário de string estática pública; Passwd de corda transitória privada; public String getUserName () {return Username; } public void setUserName (string userName) {this.username = nome de usuário; } public string getPasswd () {return passwd; } public void Setpasswd (String passwd) {this.passwd = passwd; }}O resultado da operação é:
Leia antes da serializável: Nome de usuário: AlexiaPassword: 123456 LEAD After Serializable: Nome de usuário: jmwangpassword: null
Isso significa que o valor do nome de usuário da variável estática na classe desserializada é o valor da variável estática correspondente na JVM atual, que é o JMwang modificado, não o valor Alexia durante a serialização.
3. Detalhes do uso transitório - As variáveis podem ser modificadas pela palavra -chave transitória realmente ser serializada?
Pense nos seguintes exemplos:
import java.io.Externalizable;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;/** * @descripton Use of Externalizable interface* * @author Alexia * @date 2013-10-15 * */classe pública ExternalizableTest implementa externizable {private transitório String Content = "Sim, serei serializado independentemente de ser modificado pela palavra-chave transitória ou não"; @Override public void writeExternal (objectOutput out) lança ioexception {out.writeObject (content); } @Override public void ReadExternal (ObjectInput in) lança IoException, classNotFoundException {content = (String) in.readObject (); } public static void main (string [] args) lança exceção {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 (); }}A variável de conteúdo será serializada? Ok, eu já produzi todas as respostas, sim, o resultado é:
Sim, serei serializado, independentemente de ser modificado pela palavra -chave transitória ou não
Por que isso? Não se diz que as variáveis da classe não serão serializadas após serem modificadas pela palavra -chave transitória?
Sabemos que em Java, a serialização do objeto pode ser implementada implementando duas interfaces. Se a interface serializável for implementada, toda a serialização será realizada automaticamente. Se a interface externizável for implementada, nada poderá ser serializado automaticamente. Você precisa especificar manualmente a variável a ser serializada no método WriteExternal, que não tem nada a ver com se ela é modificada por transitória. Portanto, o segundo exemplo produz o conteúdo inicializado pelo conteúdo variável, não nulo.
Obrigado pela leitura, espero que isso possa ajudá -lo. Obrigado pelo seu apoio a este site!