设计模式 -- 备忘录模式

定义：

记忆一个对象的内部状态，为了允许用户取消不确定或者错误的操作，能够恢复到以前的状态。

优缺点：

优点：

1，提供可恢复机制，能够让用户恢复到历史某个状态。

2，封装细节的操作。

缺点：

貌似犯了设计模式的通病，就是类的数量增加，消耗系统资源和性能。

在android源码中的使用：

activity源码查看：

http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/5.1.1_r1/android/app/Activity.java#Activity.onSaveInstanceState%28android.os.Bundle%29

activity状态保存：onsaveInstanceState()和onRestoreInstanceState().

onSaveInstanceState()里面：

1，存储窗口的视图树状态。

2，存储fragment的状态。

3，调用activity的activityLifecycleCallbacks的onSaveInstance函数进行状态存储。

如下是2.3的activity里面onSaveInstanceState里面的方法，保存存储窗口的视图状态。

protected void More ...onSaveInstanceState(Bundle outState) {
1087        outState.putBundle(WINDOW_HIERARCHY_TAG, mWindow.saveHierarchyState());
1088    }

saveHierarchyState在window类里面是个抽象的方法，因此去实现类PhoneWindow去查看
强调下这里这个方法的作用：存储UI,actionBar等相关view状态。
：
代码可查看：http://grepcode.com/file/repo1.maven.org/maven2/org.robolectric/android-all/5.0.0_r2-robolectric-1/com/android/internal/policy/impl/PhoneWindow.java#PhoneWindow.saveHierarchyState%28%29

 @Override
    public Bundle More ...saveHierarchyState() {
        Bundle outState = new Bundle();
        if (mContentParent == null) {
            return outState;
        }

        SparseArray<Parcelable> states = new SparseArray<Parcelable>();
　　　　　//存储整根树的结构
        mContentParent.saveHierarchyState(states);
　　　　　//视图树结构放到outState中
        outState.putSparseParcelableArray(VIEWS_TAG, states);

        // save the focused view id 保存获取焦点deview
         View focusedView = mContentParent.findFocus();
        if (focusedView != null) {
            if (focusedView.getId() != View.NO_ID) {
                outState.putInt(FOCUSED_ID_TAG, focusedView.getId());
            } else {
                if (false) {
                    Log.d(TAG, "couldn't save which view has focus because the focused view "
                            + focusedView + " has no id.");
                }
           }
       }

        // save the panels 存储整个面板状态
         SparseArray<Parcelable> panelStates = new SparseArray<Parcelable>();
        savePanelState(panelStates);
        if (panelStates.size() > 0) {
            outState.putSparseParcelableArray(PANELS_TAG, panelStates);
        }

　　　　　　//存储actionBar状态
        if (mDecorContentParent != null) {
            SparseArray<Parcelable> actionBarStates = new SparseArray<Parcelable>();
            mDecorContentParent.saveToolbarHierarchyState(actionBarStates);
            outState.putSparseParcelableArray(ACTION_BAR_TAG, actionBarStates);
        }

        return outState;
    }

 mContentParent.saveHierarchyState(states)：

public void More ...saveHierarchyState(SparseArray<Parcelable> container) {
        dispatchSaveInstanceState(container);
    }

会去调用  dispatchSaveInstanceState(container)方法：看这个方法里面实现：
如无id,不保存状态，否则将状态存储在container里面。

 protected void More ...dispatchSaveInstanceState(SparseArray<Parcelable> container) {
       if (mID != NO_ID && (mViewFlags & SAVE_DISABLED_MASK) == 0) {
           mPrivateFlags &= ~PFLAG_SAVE_STATE_CALLED;
            Parcelable state = onSaveInstanceState();
            if ((mPrivateFlags & PFLAG_SAVE_STATE_CALLED) == 0) {
                throw new IllegalStateException(
                        "Derived class did not call super.onSaveInstanceState()");
            }
            if (state != null) {
                // Log.i("View", "Freezing #" + Integer.toHexString(mID)
                // + ": " + state);
                container.put(mID, state);
            }
        }
    }

存储信息的bundle存储在哪里？

onsaveInstanceState是在activity销毁之前，onstop之前进行的。

ActivityThread的performStopActivity里面通过调用callCallActivityonSaveInstanceState()来执行onsaveInstance

 final void More ...performStopActivity(IBinder token, boolean saveState) {
       ActivityClientRecord r = mActivities.get(token);
        performStopActivityInner(r, null, false, saveState);
   }

performStopActivityInner(r, null, false, saveState):

private void More ...performStopActivityInner(ActivityClientRecord r,
            StopInfo info, boolean keepShown, boolean saveState) {
       if (localLOGV) Slog.v(TAG, "Performing stop of " + r);
        if (r != null) {
            if (!keepShown && r.stopped) {
                if (r.activity.mFinished) {
                    // If we are finishing, we won't call onResume() in certain
                    // cases.  So here we likewise don't want to call onStop()
                    // if the activity isn't resumed.
                    return;
                }
               RuntimeException e = new RuntimeException(
                        "Performing stop of activity that is not resumed: "
                       + r.intent.getComponent().toShortString());
                Slog.e(TAG, e.getMessage(), e);
            }

            if (info != null) {
                try {
                    // First create a thumbnail for the activity...
                    // For now, don't create the thumbnail here; we are
                    // doing that by doing a screen snapshot.
                    info.description = r.activity.onCreateDescription();
                } catch (Exception e) {
                    if (!mInstrumentation.onException(r.activity, e)) {
                        throw new RuntimeException(
                                "Unable to save state of activity "
                                + r.intent.getComponent().toShortString()
                                + ": " + e.toString(), e);
                    }
                }
            }

            // Next have the activity save its current state and managed dialogs...
            if (!r.activity.mFinished && saveState) {
                if (r.state == null) {
　　　　　　　　　　　　//activity finish 且保存状态，调用activity的onsaveInstanceState方法。
                    callCallActivityOnSaveInstanceState(r);
                }
            }

            if (!keepShown) {
                try {
                    //activity不可见，调用stop方法
                    // Now we are idle.
                    r.activity.performStop();
                } catch (Exception e) {
                    if (!mInstrumentation.onException(r.activity, e)) {
                        throw new RuntimeException(
                                "Unable to stop activity "
                                + r.intent.getComponent().toShortString()
                                + ": " + e.toString(), e);
                    }
                }
                r.stopped = true;
            }

            r.paused = true;
        }
    }

callCallActivityOnSaveInstanceState：

private void More ...callCallActivityOnSaveInstanceState(ActivityClientRecord r) {
        r.state = new Bundle();
        r.state.setAllowFds(false);
        if (r.isPersistable()) {
            r.persistentState = new PersistableBundle();
            mInstrumentation.callActivityOnSaveInstanceState(r.activity, r.state,
                    r.persistentState);
        } else {
            mInstrumentation.callActivityOnSaveInstanceState(r.activity, r.state);
        }
    }

 上面是保存状态，那么恢复状态呢？

当activity重新启动的时候，会去查询activityClientRecord,如果存在状态信息，就会调用onRestoreInstanceState()

代码可点击查看：http://grepcode.com/file_/repo1.maven.org/maven2/org.robolectric/android-all/5.0.0_r2-robolectric-1/android/app/ActivityThread.java/?v=source

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        // System.out.println("##### [" + System.currentTimeMillis() + "] ActivityThread.performLaunchActivity(" + r + ")");

        ActivityInfo aInfo = r.activityInfo;
        if (r.packageInfo == null) {
            r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
                    Context.CONTEXT_INCLUDE_CODE);
        }

        ComponentName component = r.intent.getComponent();
        if (component == null) {
            component = r.intent.resolveActivity(
                mInitialApplication.getPackageManager());
            r.intent.setComponent(component);
        }

        if (r.activityInfo.targetActivity != null) {
            component = new ComponentName(r.activityInfo.packageName,
                    r.activityInfo.targetActivity);
        }

        Activity activity = null;
        try {
            java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
            activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent);
            StrictMode.incrementExpectedActivityCount(activity.getClass());
            r.intent.setExtrasClassLoader(cl);
            r.intent.prepareToEnterProcess();
            if (r.state != null) {
                r.state.setClassLoader(cl);
            }
        } catch (Exception e) {
            if (!mInstrumentation.onException(activity, e)) {
                throw new RuntimeException(

                    "Unable to instantiate activity " + component
                    + ": " + e.toString(), e);
            }
        }

        try {
            Application app = r.packageInfo.makeApplication(false, mInstrumentation);

            if (localLOGV) Slog.v(TAG, "Performing launch of " + r);
            if (localLOGV) Slog.v(
                    TAG, r + ": app=" + app
                    + ", appName=" + app.getPackageName()
                    + ", pkg=" + r.packageInfo.getPackageName()
                    + ", comp=" + r.intent.getComponent().toShortString()
                    + ", dir=" + r.packageInfo.getAppDir());

            if (activity != null) {
                Context appContext = createBaseContextForActivity(r, activity);
                CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
                Configuration config = new Configuration(mCompatConfiguration);
                if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
                        + r.activityInfo.name + " with config " + config);
                activity.attach(appContext, this, getInstrumentation(), r.token,
                        r.ident, app, r.intent, r.activityInfo, title, r.parent,
                        r.embeddedID, r.lastNonConfigurationInstances, config,
                        r.voiceInteractor);

                if (customIntent != null) {
                    activity.mIntent = customIntent;
                }
                r.lastNonConfigurationInstances = null;
                activity.mStartedActivity = false;
                int theme = r.activityInfo.getThemeResource();
                if (theme != 0) {
                    activity.setTheme(theme);
                }

                activity.mCalled = false;
                if (r.isPersistable()) {
                    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
                } else {
                    mInstrumentation.callActivityOnCreate(activity, r.state);
                }
                if (!activity.mCalled) {
                    throw new SuperNotCalledException(
                        "Activity " + r.intent.getComponent().toShortString() +
                        " did not call through to super.onCreate()");
                }
                r.activity = activity;
                r.stopped = true;
                if (!r.activity.mFinished) {
                    activity.performStart();
                    r.stopped = false;
                }
　　　　　　　　　　//主要是这块的代码，判断state是否为null,不为null,保存了状态，调用onRestoreInstanceState函数恢复状态。
                if (!r.activity.mFinished) {
                    if (r.isPersistable()) {
                        if (r.state != null || r.persistentState != null) {
                            mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
                                    r.persistentState);
                        }
                    } else if (r.state != null) {
                        mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
                    }
                }
                if (!r.activity.mFinished) {
                    activity.mCalled = false;
                    if (r.isPersistable()) {
                        mInstrumentation.callActivityOnPostCreate(activity, r.state,
                                r.persistentState);
                    } else {
                        mInstrumentation.callActivityOnPostCreate(activity, r.state);
                    }
                    if (!activity.mCalled) {
                        throw new SuperNotCalledException(
                            "Activity " + r.intent.getComponent().toShortString() +
                            " did not call through to super.onPostCreate()");
                    }
                }
            }
            r.paused = true;

            mActivities.put(r.token, r);

        } catch (SuperNotCalledException e) {
            throw e;

        } catch (Exception e) {
            if (!mInstrumentation.onException(activity, e)) {
                throw new RuntimeException(
                    "Unable to start activity " + component
                    + ": " + e.toString(), e);
            }
        }

        return activity;
    }

Activity负责存储，恢复UI状态，也就是说负责存储备忘录，不对备忘录信息进行任何操作，只是传递给其他对象;

activity,View,ViewGroup存储对象的状态，创建备忘录，可以记录，恢复备忘录状态；

Bundle存储activity,View,ViewGroup的UI状态，存储备忘录状态。

---

2015年12月27日23:08:44更新

写个java的例子出来，主要涉及到状态的保存和恢复，使用备忘录模式实现：

首先原始类，要备份的对象类：

package mementopattern;

public class People {
  //姓名
    private String name;
    //性别
    private String sex;
    
    public People() {
        
    }
    
    public People(String name, String sex) {
        this.name = name;
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    
    public Memento createMemento() {
        return new Memento(name,sex);
    }
    
    public void setMemento(Memento memento) {
        this.name = memento.getName();
        this.sex = memento.getSex();
    }

    public void showPeople(){
        System.out.println(toString());
    }
    
    @Override
    public String toString() {
        return "People [name=" + name + ", sex=" + sex + "]";
    }
}

备忘录类，比起上面的类，少了创建备份和设置备份数据的方法：

public class Memento {
    
    
    // 姓名
    private String name;
    // 性别
    private String sex;
    
    public Memento(String name, String sex) {
        super();
        this.name = name;
        this.sex = sex;
    }
    /**
     * @return 返回  name
     **/
    public String getName() {
        return name;
    }
    /** 
     * @param name 要设置的 name 
     */
    public void setName(String name) {
        this.name = name;
    }
    /**
     * @return 返回  sex
     **/
    public String getSex() {
        return sex;
    }
    /** 
     * @param sex 要设置的 sex 
     */
    public void setSex(String sex) {
        this.sex = sex;
    }
 
    @Override
    public String toString() {
        return "Memento [name=" + name + ", sex=" + sex + "]";
    }
     
    
}

 Caretaker类：负责存储备忘录，不对内容进行操作和访问，将备忘录传递给其他对象。

public class Caretaker {
    private Memento memento;

    public Memento getMemento() {
        return memento;
    }

    public void setMemento(Memento memento) {
        this.memento = memento;
    }
}

测试类Test.java：

package mementopattern;

public class Test {
    
    public static void main(String[] args) {
        People per = new People("soyoungboy","男");
        
        Caretaker caretaker = new Caretaker();
        caretaker.setMemento(per.createMemento());
        
        per.showPeople();
        
        per.setName("caijj");
        per.setSex("女");
        
        per.showPeople();
        
        per.setMemento(caretaker.getMemento());
        per.showPeople();
    }
    
}

运算结果：

People [name=soyoungboy, sex=男]
People [name=caijj, sex=女]
People [name=soyoungboy, sex=男]

 其他博客看到的一篇文章，讲的有意思，可以去看看：http://www.blogjava.net/amigoxie/archive/2007/04/12/110031.html