【设计模式】——23种设计模式——核心设计模式（含理解+代码）【4】

设计模式——备忘录模式

备忘录模式主要应用于备份或者回退操作，为了使软件使用更友好，通常都有回退功能，软件一般也要提供回退机制，而要实现回退，就必须事先备份好状态信息，所以有了备忘录模式就有实现系统回退到某一个特定的历史状态

PonitRecord ——用于封装每份存档的核心数据

@Data
public abstract class PonitRecord {
    Integer version=0;
    MetaData metaData;
    public PonitRecord(MetaData metaData){
        this.metaData=metaData;
    }
    public void showMetaData(){
        System.out.println("state现在是："+metaData);
    }
    public void updateMetaDate(MetaData metaData){
        this.metaData=metaData;
        this.metaData.setVersion(++version);
    }
}

OrginatorPonitRecord——用于保存和定制当前实时的核心数据

public  class OrginatorPonitRecord extends PonitRecord {
    History history=new History();
    public OrginatorPonitRecord(MetaData state) {
        super(state);
    }
    public void savePonit(){
        history.savePonit(new MementoPonitRecord(metaData));
    }
    public void rollBack(int step){
        System.out.println("回滚"+step+"次");
        MementoPonitRecord metaDataByStep = history.getMetaDataByStep(step);
        this.metaData=metaDataByStep.getMetaData();
    }
    public void rollBack(){
        System.out.println("回滚1次");
        MementoPonitRecord metaDataByStep = history.getMetaDataByStep(1);
        this.metaData=metaDataByStep.getMetaData();
    }
}

MementoPonitRecord——用于特殊定制记录点的信息以及保存用于恢复数据的信息

public class MementoPonitRecord extends PonitRecord {
    public MementoPonitRecord(MetaData state){
        super(state);
    }
}

MetaData ——核心数据的封装

public  class MetaData {
    String state;
    Integer version;
    public MetaData(String state){
        this.state=state;
    }
}

History ——用于用数组的形式组织历史记录

public class History {
    private List<MementoPonitRecord> mementoList = new ArrayList<MementoPonitRecord>();
    public void savePonit(MementoPonitRecord state){
        mementoList.add(state);
    }
    public MementoPonitRecord getMetaDataByStep(int step){
        return mementoList.get(mementoList.size()-step);
    }
}

测试

public class _Test01 {
    public static void main(String[] args) {
        OrginatorPonitRecord originator = new OrginatorPonitRecord(new MetaData("State #0"));
        originator.showMetaData();
        originator.setMetaData(new MetaData("State #1"));
        originator.updateMetaDate(new MetaData("State #2"));
        originator.updateMetaDate(new MetaData("State #3"));
        /**
         * 存档
         */
        originator.savePonit();
        originator.updateMetaDate(new MetaData("State #4"));
        originator.updateMetaDate(new MetaData("State #5"));
        originator.updateMetaDate(new MetaData("State #6"));
        originator.showMetaData();

        /**
         * 我想回到上一个版本
         */
        originator.rollBack();
        originator.showMetaData();
        originator.updateMetaDate(new MetaData("State #7"));
        originator.savePonit();
        originator.updateMetaDate(new MetaData("State #8"));
        originator.savePonit();
        originator.updateMetaDate(new MetaData("State #9"));
        originator.savePonit();
        originator.showMetaData();
        /**
         * 我想回到上三个版本
         */
        originator.rollBack(3);
        originator.showMetaData();
    }
}

设计模式——空对象模式

如果在一个数据结构中，找不到元素直接返回null的时候就会在调用实例方法或者属性时产生空指针异常而且，用户难以预料这种异常且异常信息并不好友好，所以在数据结构的get方法中定义空对象，并手动抛异常是可取的

返回对象的抽象类

public abstract class AbstractCustomer {
    protected String name;
    public abstract boolean isNil();
    public abstract String getName();
}

空对象

public class NullCustomer extends AbstractCustomer {

    @Override
    public String getName() {
        throw new ApiException("该用户不存在");//此次也可以不抛出异常，给与一个其他值也行
    }

    @Override
    public boolean isNil() {
        return true;
    }
}

真实对象

public class RealCustomer extends AbstractCustomer {
    public RealCustomer(String name) {
        this.name = name;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public boolean isNil() {
        return false;
    }
}

不存在则返回空对象而不是null

public class CustomerFactory {
    public static final String[] names = {"Rob", "Joe", "Julie"};
    public static AbstractCustomer getCustomer(String name){
        for (int i = 0; i < names.length; i++) {
            if (names[i].equalsIgnoreCase(name)){
                return new RealCustomer(name);
            }
        }
        return new NullCustomer();
    }
}

测试1：

public class _Test01 {
    public static void main(String[] args) {
        AbstractCustomer customer1 = CustomerFactory.getCustomer("Rob");
        AbstractCustomer customer2 = CustomerFactory.getCustomer("Joe");
        AbstractCustomer customer3 = CustomerFactory.getCustomer("Julie");
        AbstractCustomer customer4 = CustomerFactory.getCustomer("骆志峰");
        System.out.println(customer1.getName());
        System.out.println(customer2.getName());
        System.out.println(customer3.getName());
        System.out.println(customer4.getName());
    }
}

设计模式——其他设计模式

设计模式——工厂模式
设计模式——代理模式
设计模式——解释器模式
设计模式——模板方法