[디자인 모드] 18 - 비망록 모드

비망록 모드
원본 코드:https://github.com/sdlszjb/DesignPattern
정의.
패 키 징 성 을 파괴 하지 않 는 전제 에서 대상 의 내부 상 태 를 포착 하고 이 대상 외 에 이 상 태 를 저장 합 니 다.이렇게 하면 이 대상 을 원래 저 장 된 상태 로 복원 할 수 있다.

/**
 *      
 * @author     Administrator
 * @since 2018-03-01 15:21
 */
public class MementoOriginator {
    //     
    private String state = "";

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    //        
    public MementoMemento createMemento() {
        return new MementoMemento(this.state);
    }

    //        
    public void restoreMemento(MementoMemento memento) {
        this.setState(memento.getState());
    }
}

/**
 *      
 *
 * @author     Administrator
 * @since 2018-03-01 15:21
 */
public class MementoMemento {
    private String state = "";

    public MementoMemento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
}

/**
 *         
 *
 * @author     Administrator
 * @since 2018-03-01 15:22
 */
public class MementoCaretaker {
    private MementoMemento memento;

    public MementoMemento getMemento() {
        return memento;
    }

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

활용 단어 참조

사용 과정 에서 기본적으로 표준 비망록 모드 의 변환 처리 모드 를 사용한다.

필드 사용

데 이 터 를 저장 하고 복원 해 야 하 는 관련 상태 장면.

스크롤 백 할 수 있 는 동작 을 제공 합 니 다.

감시 가 필요 한 던 전 장면.

데이터 베 이 스 를 연결 하 는 사무 관 리 는 바로 비망록 모델 을 사용 하 는 것 이다.

주의 사항

비망록 의 생명 기 비망록 이 만들어 지면 '최근' 코드 에서 사용 해 야 합 니 다. 생명 주 기 를 주동 적 으로 관리 하려 면 만들어 야 합 니 다. 사용 하지 않 으 면 바로 인용 을 삭제 하고 쓰레기 회수 기 가 그 에 대한 회수 처 리 를 기 다 려 야 합 니 다.

비망록 의 성능 은 백업 이 빈번 한 장면 에서 비망록 모드 를 사용 하지 마 십시오.

비망록 이 만들어 진 대상 의 수량 을 통제 하지 못 한다

대상 의 설립 은 자원 을 소모 해 야 한다

넓히다
clone 방식 의 비망록
다 중 상태 비망록 모드

/**
 *          
 * @author     Administrator
 * @since 2018-03-01 16:01
 */
public class MementoStatusOriginator {
    private String state1 = "";
    private String state2 = "";
    private String state3 = "";

    //        
    public MementoStatusMemento createMemento() {
        return new MementoStatusMemento(MementoStatusBeanUtils.backupProp(this));
    }

    //        
    public void restoreMemento(MementoStatusMemento memento) {
        MementoStatusBeanUtils.restoreProp(this, memento.getStateMap());
    }

    public String getState1() {
        return state1;
    }

    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;
    }

    @Override
    public String toString() {
        return "state1=" + state1 +"
state2=" + state2 + "
state3=" + state3;
    }
}

/**
 *       
 * @author     Administrator
 * @since 2018-03-01 16:02
 */
public class MementoStatusBeanUtils {

    public static Map backupProp(Object bean) {
        Map result = new HashMap<>();

        try {
            BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
            PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
            for (PropertyDescriptor descriptor : descriptors) {
                String fieldName = descriptor.getName();
                Method getter = descriptor.getReadMethod();
                Object fieldValue = getter.invoke(bean);

                if (!fieldName.equalsIgnoreCase("class")) {
                    result.put(fieldName, fieldValue);
                }
            }
        } catch (IntrospectionException
                | IllegalAccessException
                | InvocationTargetException e) {
            e.printStackTrace();
        }

        return result;
    }

    public static void restoreProp(Object bean, Map propMap) {
        try {
            BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
            PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
            for (PropertyDescriptor descriptor : descriptors) {
                String fieldName = descriptor.getName();
                if (propMap.containsKey(fieldName)) {
                    Method setter = descriptor.getWriteMethod();
                    setter.invoke(bean, propMap.get(fieldName));
                }
            }
        } catch (IntrospectionException
                | IllegalAccessException
                | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

/**
 *          
 *
 * @author     Administrator
 * @since 2018-03-01 16:02
 */
public class MementoStatusMemento {
    //   Map    
    private Map stateMap;

    //       ，      
    public MementoStatusMemento(Map stateMap) {
        this.stateMap = stateMap;
    }

    public Map getStateMap() {
        return stateMap;
    }

    public void setStateMap(Map stateMap) {
        this.stateMap = stateMap;
    }
}

/**
 *            
 *
 * @author     Administrator
 * @since 2018-03-01 15:22
 */
public class MementoStatusCaretaker {
    private MementoStatusMemento memento;

    public MementoStatusMemento getMemento() {
        return memento;
    }

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

/**
 * @author     Administrator
 * @since 2018-03-01 15:56
 */
public class MementoTests {
    
    /**
     *           
     */
    @Test
    public void testStatus() {
        MementoStatusOriginator originator = new MementoStatusOriginator();
        MementoStatusCaretaker caretaker = new MementoStatusCaretaker();

        originator.setState1("  ");
        originator.setState2("  ");
        originator.setState3("  ");
        System.out.println("---    ---");
        System.out.println(originator);

        caretaker.setMemento(originator.createMemento());

        originator.setState1("A");
        originator.setState2("B");
        originator.setState3("C");

        System.out.println("---    ---");
        System.out.println(originator);

        originator.restoreMemento(caretaker.getMemento());

        System.out.println("---    ---");
        System.out.println(originator);
    }
}

이런 방식 의 개 조 를 통 해 대상 의 모든 속성 을 백업 할 수 있다.

실행 기간 에 백업 상 태 를 결정 하 는 프레임 워 크 를 설계 하려 면 AOP 프레임 워 크 를 사용 하여 동적 에이전트 로 불필요 하 게 프로그램의 논리 적 복잡성 을 증가 하지 않도록 하 는 것 을 권장 합 니 다.
다 중 백업 비망록

/**
 *              
 * @author     Administrator
 * @since 2018-03-01 19:25
 */
public class MementoStatusComplexCaretaker {
    //         
    private Map mementoMap = new HashMap<>();
    public MementoStatusMemento getMemento(String idx) {
        return mementoMap.get(idx);
    }

    public void setMementoMap(String idx, MementoStatusMemento memento) {
        this.mementoMap.put(idx, memento);
    }
}

이 모드 백업 이 발생 하면 메모리 에 불 러 옵 니 다. 소각 할 의사 가 없습니다. 매우 위험 합 니 다. OOM 에 주의 하 십시오.사용 시 맵 상한 선 을 늘 리 는 것 을 권장 합 니 다.
더 잘 봉 해 주세요.

백업 의 밀봉 성 확보

공 개 된 Memento 인터페이스 제공

실제 Memento 류 를 Originator 류 에 넣 고 private

로 한다.