23 Padrões de design Capítulo 18: Java Memorando Padrão
Definição: capture o estado interno de um objeto sem destruir o encapsulamento e salve esse estado fora do objeto. Isso restaurará o objeto ao seu estado salvo original.
Tipo: classe de comportamento
Diagrama de classe:
Quando estamos programando, geralmente precisamos salvar o estado intermediário do objeto e, quando necessário, podemos restaurá -lo para esse estado. Por exemplo, quando usamos o Eclipse para programar, se cometermos um erro ao escrever (por exemplo, excluímos acidentalmente algumas linhas de código), queremos retornar o status antes da exclusão, para que possamos usar o Ctrl+Z para retornar. Neste momento, podemos usar o modo de memorando para alcançá -lo.
Estrutura do modo de memorando
Iniciador: registre o status interno do momento atual, seja responsável por definir quais estados pertencem ao escopo de backup e sejam responsáveis por criar e restaurar dados de memorando.
Memorando: Responsável por armazenar o estado interno do objeto do iniciador e fornecer o estado interno exigido pelo iniciador quando necessário.
Função de gerenciamento: gerencie memorandos, salve e forneça memorandos.
Implementação de código geral
classe Originator {private string state = ""; public String getState () {Return State; } public void setState (State String) {this.state = state; } public Memento CreateMemento () {return New Memento (this.State); } public void Restorememento (Memento Memento) {this.SetState (Memento.getState ()); }} classe Memento {private String state = ""; public Memento (Estado da String) {this.state = state; } public string getState () {retornar estado; } public void setState (State String) {this.state = state; }} Class Caretaker {private Memento Memento; public Memento getMemento () {return Memento; } public void setMemento (Memento Memento) {this.Memento = Memento; }} public class Client {public static void main (String [] args) {Originator Originator = new Originator (); Originator.SetState ("Status 1"); System.out.println ("Estado inicial:"+Originator.getState ()); Zelador zelador = novo zelador (); caretaker.setMemento (Originator.CreateMemento ()); Originator.SetState ("Status2"); System.out.println ("Status após alterar:"+Originator.getState ()); Originator.restorememento (caretaker.getMemento ()); System.out.println ("Status após recuperação:"+Originator.getState ()); }} O código demonstra um exemplo de backup único de estado único. A lógica é muito simples: a variável de estado na classe Originator precisa ser backup para que possa ser restaurada quando necessário; Na classe Memento, há também uma variável de estado usada para armazenar o estado temporário da variável de estado na classe Originator; e a classe do zelador é usada para gerenciar a classe de memorando, usada para escrever estados ou recuperar estados no objeto de memorando.
Memorando multi-backup de vários estados
No exemplo da demonstração geral do código, a classe Originator possui apenas uma variável de estado que precisa ser backup, enquanto que geralmente, a função do iniciador é geralmente um javabeu, há mais de uma variável que precisa ser apoiada no objeto e mais de um estado que precisa ser backup. Este é um memorando multi-backup de vários estados.
Existem muitas maneiras de implementar memorandos. Existem muitas deformações e métodos de processamento para memorandos. Métodos como o código geral geralmente não são usados. Na maioria dos casos, os memorandos são backups multi-estados e múltiplos. De fato, também é muito simples implementar multi-estados e multi-backup. O método mais comumente usado é adicionar um contêiner de mapa ao Memento para armazenar todos os estados e usar um contêiner de mapa na aula de zelador para armazenar todos os backups. Abaixo, damos um exemplo de vários estados e multif-backup:
classe Originator {private String state1 = ""; String privada state2 = ""; String privada state3 = ""; public String getState1 () {retornar estado1; } public void setState1 (String state1) {this.state1 = state1; } public string getState2 () {return state2; } public void setState2 (String state2) {this.state2 = state2; } public string getState3 () {return state3; } public void setState3 (String state3) {this.state3 = state3; } public Memento CreateMemento () {Return New Memento (beanutils.backupprop (this)); } public void Restorememento (Memento Memento) {beanutils.restoreProp (this, Memento.getStatemap ()); } public string tostring () {return "state1 ="+state1+"state2 ="+state2+"state3 ="+state3; }} classe Memento {mapa privado <string, object> statemap; public Memento (map <string, objeto> map) {this.statemap = map; } mapa público <string, objeto> getStatemap () {return statemap; } public void setStatemap (map <string, object> statemap) {this.statemap = statemap; }} classe beanutils {public static map <string, object> backupprop (objeto bean) {map <string, object> resultado = new hashmap <string, object> (); tente {beaninfo beaninfo = introspector.getbeaninfo (bean.getclass ()); PropertyDescriptor [] descritores = beaninfo.getPropertyDescriptores (); for (PropertyDescriptor des: descritores) {String fieldName = des.getName (); Método getter = des.getReadMethod (); Objeto fieldValue = getter.invoke (feijão, novo objeto [] {}); if (! fieldName.equalsignorecase ("classe")) {result.put (fieldname, fieldValue); }}}} catch (Exceção e) {e.printStackTrace (); } resultado de retorno; } public static void RestoreProp (objeto Bean, mapa <string, object> propMap) {try {beaninfo beaninfo = introspector.getbeaninfo (bean.getclass ()); PropertyDescriptor [] descritores = beaninfo.getPropertyDescriptores (); for (PropertyDescriptor des: descritores) {String fieldName = des.getName (); if (propmap.containsKey (fieldname)) {método setter = des.getWriteMethod (); setter.invoke (bean, novo objeto [] {propmap.get (fieldname)}); }}} catch (Exceção e) {e.printStackTrace (); }}} classe Caretaker {private mapa <string, lembrança> memmap = new hashmap <string, lembrança> (); public Memento GetMemento (String Index) {return memmap.get (index); } public void SetMemento (String Index, Memento Memento) {this.memmap.put (índice, lembrança); }} classe client {public static void main (string [] args) {Originator ori = new Originator (); Zelador zelador = novo zelador (); ori.setState1 ("China"); ori.setState2 ("forte"); ori.setState3 ("prosperidade"); System.out.println ("=== status de inicialização ===/n"+ori); caretaker.setMemento ("001", ori.createMemento ()); ori.setState1 ("software"); ori.setState2 ("estrutura"); ori.setState3 ("Excelente"); System.out.println ("=== status modificado ===/n"+ori); ori.restorememento (caretaker.getMemento ("001")); System.out.println ("=== status restaurado ===/n"+ori); }} Vantagens e desvantagens do modo de memorando e cenários aplicáveis
As vantagens do modo de memorando são:
Quando o status da função do iniciador muda, pode ser uma mudança errada. Podemos restaurar essa alteração errada usando o modo memorando.
O status do backup é salvo fora da função do iniciador; portanto, a função do iniciador não precisa gerenciar o status de cada backup.
As desvantagens do modo de memorando são:
Em aplicações reais, o modo de memorando é multi-estadual e multi-backup. O estado do papel do iniciador precisa ser armazenado no objeto de memorando, que consome recursos relativamente severamente.
Se você precisar fornecer operações de reversão, o uso do modo de memorando é muito adequado, como operações de transação JDBC, recuperação Ctrl+Z dos editores de texto, etc.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.