2. 程式人生 > >七、備忘錄模式Memento（行為型模式）

七、備忘錄模式Memento（行為型模式）

阿新 • • 發佈：2018-02-27
版本號 center 方式 some 接口 ica 是否有效 eve 提醒

其目的是,在不違反封裝原則的前提下.採集和備份一個對象的內部狀態以便這個對象能夠在以後恢復到之前的某個狀態.

技術分享圖片

在Memento模式中,有例如以下角色: 1.Memento (備忘錄) * 存儲Originator的內部狀態. 依據Originator的須要.能夠存儲隨意的內部狀態. * 保護對狀態的訪問.除了Originator對象外,其它對象不能訪問其存儲的內部狀態.Memeoto實際上提供了2個接口. Caretaker僅僅能訪問Memento的窄接口(narrow interface) - 它僅僅能夠把memento傳遞給其它對象.
相反,Originator能夠訪問Memento的寬接口(wide interface). 通過這個接口,能夠讓Originator獲取足夠的信息以恢復到之前的狀態.理想情況下,僅僅有創建memento的Originator才有權限訪問memento的內部狀態信息. 2.Originator (發起人) * 能夠創建一個新的memento, 並把自己的當前狀態信息存儲到memento裏面 * 能夠使用memento來恢復其內部狀態信息 3.Caretaker (負責人) * 負責維護和管理memento對象 * 從不正確memento的內容進行操作或者測試


備忘錄模式的操作過程?
1、client為發起人角色創建一個備忘錄對象。

?
2、調用發起人對象的某個操作。這個操作是能夠撤銷的。

?
3、檢查發起人對象所出狀態的有效性。檢查的方式能夠是發起人對象的內部自查。也能夠由某個外部對象進行檢查。?
4、假設須要的話。將發起人的操作撤銷。也就是說依據備忘錄對象的記錄。將發起人對象的狀態恢復過來。?

“假如”協議模式的操作過程：?
1、將發起人對象做一個拷貝。

?
2、在拷貝上運行某個操作。

?
3、檢查這個拷貝的狀態是否有效和自恰。?
4、假設檢查結果是無效或者不自恰的，那麽扔掉這個拷貝，並觸發異常處理程序。相反。假設檢查是有效和自恰的，那麽在原對象上運行這個操作?
顯然這一做法對於撤銷一個操作並恢復操作前狀態較為復雜和困難的發起人對象來說是一個較為慎重和有效的做法。?



“假如”協議模式的長處和缺點?
詳細來說，這個做法的好處是能夠保證發起人對象永遠不會處於無效或不自恰的狀態上。這樣作的短處是成功的操作必須運行兩次。?
假設操作的成功率較低的話。這樣做就比較劃算。反之就不太劃算。

?


使用備忘錄模式的長處和缺點?
一、備忘錄模式的長處?
1、有時一些發起人對象的內部信息必須保存在發起人對象以外的地方，可是必須要由發起人對象自己讀取，這時，?
?? 使用備忘錄模式能夠把復雜的發起人內部信息對其它的對象屏蔽起來。從而能夠恰當地保持封裝的邊界。?
2、本模式簡化了發起人類。發起人不再須要管理和保存其內部狀態的一個個版本號，client能夠自行管理他們所需?
?? 要的這些狀態的版本號。

?
3、當發起人角色的狀態改變的時候，有可能這個狀態無效。這時候就能夠使用臨時存儲起來的備忘錄將狀態復原。?
二、備忘錄模式的缺點：?
1、假設發起人角色的狀態須要完整地存儲到備忘錄對象中。那麽在資源消耗上面備忘錄對象會非常昂貴。

?
2、當負責人角色將一個備忘錄 存儲起來的時候，負責人可能並不知道這個狀態會占用多大的存儲空間，從而無法?
?? 提醒用戶一個操作是否非常昂貴。882——P ?
3、當發起人角色的狀態改變的時候，有可能這個協議無效。

假設狀態改變的成功率不高的話，不如採取“假如”協議模式。

 (1)寬接口和白箱：

public class Client {

   private static Originator originator = new Originator();

   private static Caretaker c = new Caretaker();

   public static void main(String[] args) {

      // 該發起人對象的狀態

      originator.setState("On");

      // 創建備忘錄對象，並將發起人對象的狀態存儲起來

      c.saveMemento(originator.createMemento());

      // 改動發起人對象的狀態

      originator.setState("Off");

      // 恢復發起人對象的狀態

      originator.restoreMemento(c.retrieveMemento());

   }

}

// 發起人角色

class Originator {

   private String state;

   // 工廠方法，返還一個新的備忘錄對象

   public Memento createMemento() {

      return new Memento(state);

   }

   // 將發起人恢復到備忘錄對象所記載的狀態

   public void restoreMemento(Memento memento) {

      this.state = memento.getState();

   }

   // 狀態的取值方法

   public String getState() {

      return this.state;

   }

   // 狀態的賦值方法

   public void setState(String state) {

      this.state = state;

      System.out.println("Current state = " + this.state);

   }

}

/*

 * 備忘錄模式要求備忘錄對象提供兩個不同的接口：一個寬接口提供給發起人對象，還有一個窄接口提供給全部其它的對象，包含負責人對象。


 * 寬接口同意發起人讀取到全部的數據。窄接口僅僅同意它把備忘錄對象傳給其它的對象而看不到內部的數據。

 */

// 備忘錄角色

class Memento {

   private String state;

   public Memento(String state) {

      this.state = state;

   }

   public String getState() {

      return this.state;

   }

   public void setState(String state) {

      this.state = state;

   }

}

/*

 * 負責人角色負責保存備忘錄對象，可是從不改動（甚至不查看）備忘錄對象的內容（一個更好的實現是負責人對象根本無法從備忘錄 對象中讀取個改動其內容）

 */

// 負責人角色

class Caretaker {

   private Memento memento;

   // 備忘錄的取值方法

   public Memento retrieveMemento() {

      return this.memento;

   }

   // 備忘錄的賦值方法

   public void saveMemento(Memento memento) {

      this.memento = memento;

   }

}

首先將發起人對象的狀態設置成“On”（或者不論什麽有效狀態），而且創建一個備忘錄對象將這個狀態存儲起來。然後將發起人對象的狀態改成“Off”（或者不論什麽狀態）；最後又將發起人對象恢復到備忘錄對象所存儲起來的狀態，即“On”狀態（或者先前所存儲的不論什麽狀態）
備忘錄系統運行的時序是這種：
（1）將發起人對象的狀態設置成“On”。
（2）調用發起人角色的createMemento()方法，創建一個備忘錄對象將這個狀態存儲起來。
（3）將備忘錄對象存儲到負責人對象中去。
備忘錄系統恢復的時序是這種：
（1）將發起人對象的狀態設置成“Off”；
（2）將備忘錄對象從負責人對象中取出；
（3）將發起人對象恢復到備忘錄對象所存儲起來的狀態。“On”狀態。
白箱實現的優缺點
白箱實現的一個明顯的好處是比較簡單，因此經常常使用做教學目的。

白箱實現的一個明顯的缺點是破壞對發起人狀態的封裝。

(2)窄接口或者黑箱實現： 
//client

public class Client {

   private static Originator originator = new Originator();

   private static Caretaker c = new Caretaker();

   public static void main(String[] args) {

      // 該發起人對象的狀態

      originator.setState("On");

      // 創建備忘錄對象。並將發起人對象的狀態存儲起來

      c.saveMemento(originator.createMemento());

      // 改動發起人對象的狀態

      originator.setState("Off");

      // 恢復發起人對象的狀態

      originator.restoreMemento(c.retrieveMemento());

   }

}

// 發起人角色

class Originator {

   private String state;

   public Originator() {

   }

   // 工廠方法，返還一個新的備忘錄對象

   public MementoIF createMemento() {

      return new Memento(this.state);

   }

   // 將發起人恢復到備忘錄對象記錄的狀態

   public void restoreMemento(MementoIF memento) {

      Memento aMemento = (Memento) memento;

      this.setState(aMemento.getState());

   }

   public String getState() {

      return this.state;

   }

   public void setState(String state) {

      this.state = state;

      System.out.println("state =" + state);

   }

   protected class Memento implements MementoIF {

      private String savedState;

      public Memento(String someState) {

        this.savedState = someState;

      }

      private void setState(String someState) {

        savedState = someState;

      }

      private String getState() {

        return savedState;

      }

   }

}

interface MementoIF {

}

// 備忘錄角色

class Memento implements MementoIF {

   private String state;

   public Memento(String state) {

      this.state = state;

   }

   public String getState() {

      return this.state;

   }

   public void setState(String state) {

      this.state = state;

   }

}

class Caretaker {

   private MementoIF memento;

   public MementoIF retrieveMemento() {

      return this.memento;

   }

   public void saveMemento(MementoIF memento) {

      this.memento = memento;

   }

}

黑箱實現運行時的時序為;
? (1)將發起人對象的狀態設置成“On”。
（2）調用發起人角色的 createMemento()方法。創建一個備忘錄對象將這個狀態存儲起來。


（3）將備忘錄對象存儲到負責人對象中去。因為負責人對象拿到的僅是 MementoIF類型，因此無法讀出備忘錄內部的狀態。
恢復時的時序為：
（1）將發起人對象的狀態設置成“Off”。
（2）將備忘錄對象從負責人對象中取出。

註意此時僅能得到 MementoIF接口，因此無法讀出此對象的內部狀態
（3）將發起人對象的狀態恢復成備忘錄對象所存儲起來的狀態。，因為發起人對象的內部類Memento實現了MementoIF接口
這個內部類是傳入的備忘錄對象的真實類型，因此發起人對象能夠利用內部類Memento 的私有 接口讀出此對象的內部狀態。

(3)存儲多個狀態的備忘錄模式：

//發起人角色
		import java.util.Vector;
		import java.util.Enumeration;
		
		public class Originator{
			private Vector states;
			private int index;
			
			public Originator(){
				states = new Vector();
				index = 0;
			}
			
			public Memento createMementor(){
				return new Mementor(states,index);
			}
			
			public void restoreMementor(Mementor memento){
				states = memento.getStates();
				index = memento.getIndex（）。
			}
			
			public void setState(String state){
				this.states.addElement(state);
				index ++;
			}
			
			//輔助方法。打印出全部的狀態
			public void printStates(){
				System.out.println("Total number of states: " + index);
				for(Enumeration e = states.elements();e.hasMoreElements();){
					system.out.println(e.nextElement());
				}
			}
		} 
//備忘錄角色
		import java.util.Vector;
		
		public class Memento{
			private Vector states;
			private int index;
			//<span style="font-size: 14px; font-family: Arial, Helvetica, sans-serif;">備忘錄的構造子克隆了傳入的states，然後將克隆存入到備忘錄對象內部，這是一個重要的細節，因為不這種話，將會</span><pre title="備忘錄（Memento Pattern）模式 【行為模式第一篇】" style="font-size: 14px;">		     //將會造成client和備忘錄對象持有對同一個Vector對象的引用，也能夠同一時候改動這個Vector對象，會造成系統崩潰。
public Memento(Vector states,int index){this.states = (Vector)states.clone();this.index = index;}//狀態取值方法Vector getStates(){return states;}//檢查點取值方法int getIndex(){return this.index;}} 


//負責人角色
		import java.util.Vector;
		
		public class Caretaker{
			private Originator o;
			private Vector mementos = new Vector();
			private int current;
			
			public Caretaker(Originator o){
				this.o = o;
				current = 0;
			}
			
			public int createMemento(){
				Memento memento = o.createMemento();
				mementos.addElement(memento);
				return current ++;
			}
			
			//將發起人恢復到某個檢查點
			public void restoreMemento(int index){
				Memento memento = (Memento)mementos.elementAt(index);
				o.restoreMemento(memento);
			}
			
			//某個檢查點刪除
			public void removeMemento(int index){
				mementos.removeElementAt(index);
			}
		}
		

//client
		public class Client{
			private static Originator o = new Originator();
			private static Caretaker c = new Caretaker(o);
			public static void main(String[] args){
				//改變狀態
				o.setState("state 0");
				//建立一個檢查點
				c.createMemento();
				//改變狀態
				o.setState("state 1");
				
				c.createMemento();
				
				o.setState("state 2");
				
				c.createMemento();
				
				o.setState("state 3");
				
				c.createMemento();
				
				o.setState("state 4");
				
				c.createMemento();
				
				o.printStates();
				
				//恢復到第二個檢查點
				System.out.println("Restoring to 2");
				
				c.restoreMemento(2);
				
				o.printStates();
				
				System.out.println("Restoring to 0");
				
				c.restoreMemento(0);
				
				o.printStates();
				
				System.out.println("Restoring to 3");
				
				c.restoreMemento(3);
				
				o.printStates();
				
				
			}
		}

(4)自述歷史模式（備忘錄模式的一個變種）
因為“自述歷史”作為一個備忘錄模式的特殊實現形式非常easy易懂。它可能是備忘錄模式最為流行的實現形式。
?
//窄接口
		public interface MementoIF{}

//發起人角色
		public class Originator{
			public String state;
			
			public Originator(){}
			
			public void changeState(String state){
				this.state = state;
				System.out.println("State has been changed to : " + state);
			}
			
			public Memento createMemento(){
				return new Memento(this);
			}
			
			public void restoreMemento(MementoIF memento){
				Memento m = (Memento)memento;
				changeState(m.state);
			}
			
			class Memento implements MementoIF{
				private String state;
				
				private String getState(){
					return state;
				}
				
				private Memento(Originator o){
					this.state = o.state;
				}
			}
		}

//client
		public class Client{
			private static Originator o;
			private static MementoIF memento;
			
			public static void main(String args[]){
				o = new Originator();
				o.changeState("State 1");
				memento = o.createMemento();
				o.changeState("State 2");
				o.restoreMemento(memento);
			}
		}
















                
                    
    
七、備忘錄模式Memento（行為型模式）
   
 
 
 
 

            
  

           

              
              

            

            
相關推薦

			   
            
            
            
 

    


    
    
七、備忘錄模式Memento（行為型模式）

     
 版本號   center   方式   some   接口   ica   是否有效   eve   提醒   
                            
                        
其目的是,在不違反封裝原則的前提下.採集和備份一個對象的內部狀態以便這個對象能夠在以後恢 



  
 

    


    
    
設計模式分類（建立型模式、結構型模式、行為模式）

     
 
                1．建立型模式前面講過，社會化的分工越來越細，自然在軟體設計方面也是如此，因此物件的建立和物件的使用分開也就成為了必然趨勢。因為物件的建立會消耗掉系統的很多資源，所以單獨對物件的建立進行研究，從而能夠高效地建立物件就是建立型模式要探討的問題。這裡有6個具體的建立型模式可供研究 



  
 

    


    
    
設計模式的藝術 行為型模式之備忘錄模式

     
  
 
 前言 
 每個人都會有後悔的時候，可是人生沒有後悔藥，做過的事情無法再去後悔，軟體設計中卻是有這麼一種後悔機制，叫做備忘錄模式，它就是軟體中的"後悔藥" 
 什麼是備忘錄模式  Memento Pattern 
 在不破壞封裝的前提下，捕獲一個物件的內部狀態，並在物件之外儲存這個狀態，這樣 



  
 

    


    
    
設計模式的藝術  行為型模式之備忘錄模式

     
 
                前言

每個人都會有後悔的時候，可是人生沒有後悔藥，做過的事情無法再去後悔，軟體設計中卻是有這麼一種後悔機制，叫做備忘錄模式，它就是軟體中的"後悔藥"

什麼是備忘錄模式  Memento Pattern

在不破壞封裝的前提下，捕獲一個物件的內部狀態，並在物件之外儲存這個狀 



  
 

    


    
    
Java——設計模式（行為型模式）

     
 rgs   文件   cut   實例變量   以及   文檔   怎麽   java   程序   一、責任鏈模式

二、命令模式
在軟件開發中，我們經常需要向某些對象發送請求(調用其中的某個或某些方法)，但是並不知道請求的接收者是誰，也不知道被請求的操作是哪個，此時，我們特別希望能夠以一種松耦合的方式來設 



  
 

    


    
    
初探Java設計模式3：行為型模式（策略，觀察者等）

     
 
                轉自https://javadoop.com/post/design-pattern行為型模式行為型模式行為型模式關注的是各個類之間的相互作用，將職責劃分清楚，使得我們的程式碼更加地清晰。策略模式策略模式太常用了，所以把它放到最前面進行介紹。它比較簡單，我就不廢話，直接用程式 



  
 

    


    
    
設計模式的藝術 行為型模式之訪問者模式

     
  
 
 前言 
 在公司上班，一般會有兼職或全職的員工，他們都發工資，上同樣的班，但是工資待遇是有區別的，財務部和人事部過來調查處理的手法也不是一樣的，雖然都是一樣的計算工資待遇，在軟體開發中存在著這樣的一種情況，我們需要處理著像員工一樣的集合，集合中的具體物件是不一樣的,去訪問時處理的手段也不一樣，軟體設 



  
 

    


    
    
設計模式的藝術 行為型模式之模板方法模式

     
  
 
 前言 
 生活中有許多事情可以理解成分步驟執行的東西，比如請客吃飯，無論吃什麼，一般都包含著點單，吃東西，買單幾個步驟，不論吃麵還是吃大餐，其他步驟不會變，最多變變點單，在軟體開發中，也會有類似的情況出現，我們可以有個點單的基類，然後子類裡面具體實現是吃麵還是點大餐，這就是模板方法模式，這種模式利用 



  
 

    


    
    
設計模式的藝術 行為型模式之策略模式

     
  
 
 前言 
 條條大路通羅馬，很多時候為了達到目標可供選擇的路徑不止一條，在軟體開發中也會存在這樣的情況，為了某一個功能有多條途徑，每一條途徑對應一種演算法，為了靈活的選擇解決途徑，策略模式就應運而生了 
 什麼是策略模式 Strategy Pattern 
 定義一系列演算法類，將每一個演算法封裝起來 



  
 

    


    
    
設計模式的藝術 行為型模式之觀察者模式

     
  
 
 前言 
 紅燈停，綠燈行，在日常的交通中，每每遇到紅燈，司機總是要在路口進行等待，等到綠燈才能通過，這個時候司機就扮演了一個觀察者的角色，隨著燈的顏色的變化，司機的行為也跟著變化，在軟體系統中，有些物件之間也存在類似交通訊號燈和汽車之間的關係，一個物件的的行為狀態改變導致了其他物件的狀態或行為也發生 



  
 

    


    
    
設計模式的藝術 行為型模式之中介者模式

     
  
 
 前言 
 微信有一個群聊功能，群聊中的資訊你不需要加別人為好友就可以接收的到資訊，因為群的機制，極大的減少了使用者之間的兩兩通訊，在軟體設計中，也有類似於微信使用者之間的關係，我們也可以借鑑微信群的模式，來降低物件與物件之間的互動，使得系統的耦合度大大降低 
 什麼是中介者模式 Mediator P 



  
 

    


    
    
設計模式的藝術 行為型模式之迭代器模式

     
  
 
 前言 
 現在的電視機都配置了一個遙控器，使用者可以通過遙控器去選擇上一個或者下一個臺，我們只需要知道如何使用這個遙控器，而無須關注電視是怎麼把電視訊道放入其中的，在軟體實際的開發中，也有這麼一種類，它儲存著多個成員物件，這些類通常稱為聚合類，對應的物件稱為聚合物件。為了方便操作這些聚合物件，同時可 



  
 

    


    
    
設計模式的藝術 行為型模式之直譯器模式

     
  
 
 前言 
 目前計算器程式語言有好幾百種，但是有時候人們還是希望能用一些簡單的語言表達實現一些特定的操作，比如輸入一個檔案，它就可以按照預定的格式進行解釋，從而實現相應的功能。 
 在現實的開發中，這些簡單的自定義語言可以通過現有的程式語言來設計，如果所基於的程式語言是面嚮物件語言，此時可以使用直譯器 



  
 

    


    
    
設計模式的藝術 行為型模式之命令模式

     
  
 
 前言 
 裝修新房子的最後幾道工序之一是安裝插座和開關，通過開關可以控制一些電器的開啟和關閉，例如電燈或者排氣扇，但是購買開關時其實並不知道它能夠控制什麼具體的電器。在軟體設計中，也存在著這樣的關係，請求傳送者和接收者物件，為了降低之間的耦合度，我們會將兩者進行解耦，會在兩者之間引入了新的命令物件， 



  
 

    


    
    
設計模式的藝術 行為型模式之職責鏈模式

     
  
 
 前言 
 幾乎所有的國人都打過鬥地主，規則很簡單,上家出牌，下家接牌，要不起則轉給下一家，一個迴圈下來，如果要不起則最初的出牌者繼續出牌，在這個過程中，牌作為一個請求沿著一條鏈在傳遞，每一個紙牌的玩家都可以處理該請求，在設計模式中，也有一種專門用於處理這種請求鏈方式的傳遞模式，我們把它稱之為職責鏈模 



  
 

    


    
    
七、Dockerfile案例一（jdk1.8安裝）

     
 案例一（建立jdk1.8的映象檔案）： 
1 獲取一個簡單的Docker系統映象,並建立一個容器。 
　　這裡我選擇下載CentOS映象 
 
 docker pull centos 
 
　　通過docker tag命令將下載的CentOS映象名稱換成centos，並刪除老標籤的映象檔案。 
 
 dock 



  
 

    


    
    
設計模式分類之行為型模式

     
  
  
  
 行為型模式包括觀察者模式、模板方法模式、命令模式、狀態模式、職責鏈模式、直譯器模式、中介者模式、訪問者模式、策略模式、備忘錄模式、迭代器模式。 
  
  觀察者模式  定義物件間的一種一對多的依賴關係，當一個物件的狀態發生改變時，所有依賴它的物件都得到通知並被自動更新。 
  模板方法模式 



  
 

    


    
    
設計模式的藝術  行為型模式之中介者模式

     
 
                前言

微信有一個群聊功能，群聊中的資訊你不需要加別人為好友就可以接收的到資訊，因為群的機制，極大的減少了使用者之間的兩兩通訊，在軟體設計中，也有類似於微信使用者之間的關係，我們也可以借鑑微信群的模式，來降低物件與物件之間的互動，使得系統的耦合度大大降低

什麼是中介者模式  



  
 

    


    
    
java設計模式之——策略模式、模板方法模式、觀察者模式、迭代子模式、責任鏈模式、命令模式、備忘錄模式、狀態模式、訪問者模式、中介者模式、直譯器模式（行為型）【讀書筆記】

     
 
                一、策略模式

          定義：定義了演算法家族，分別封裝起來，讓他們之間可以互相替換，此模式讓演算法的變化，不會影響到演算法的客戶。

          使用場景：策略模式是一種定義一系列演算法的方法，從概念上看，所有的這些演算法完成的都是相同的工作，只是實現不 



  
 

    


    
    
設計模式應試複習篇（七）——舉例說明11種行為型模式的適用情景

     
 
                1、職責鏈模式

很多情況下，在一個軟體系統中可以處理某個請求的物件不止一個，比如我們在學校提交請假的申請表，輔導員、系主任、院長和校長都可以處理申請表，他們可以構成一條處理申請表的鏈式結構，申請表沿著這條鏈進行傳遞，這條鏈就稱為職責鏈。職責鏈可以是一條直線、一個環或者一個樹