设计模式之原型工厂模式

1、概念：原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用

2、优点 ：1、性能提高。2、逃避构造函数的约束。

3、缺点：1、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。2、必须实现 Cloneable 接口。 

4、使用场景 ：1、资源优化场景。2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。3、性能和安全要求的场景。4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。5、一个对象多个修改者的场景。6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。7、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。

5、注意事项：与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。浅拷贝实现 Cloneable，重写，深拷贝是通过实现 Serializable 读取二进制流。

6、示例：

1、创建一个原型类：此处创建创建了一个抽象类作为父类，实现Cloneable接口重写clone方法，私有化其中一个属性（可以set），公共其中一个属性(不提供set方法)

package com.example.test.design.prototype;

/**
 * @description:
 * @author: lcj
 * @time: 2021/9/7 14:58
 */
public abstract class Run implements Cloneable {

       private int id;

    protected String runType;

    abstract void runInfo();

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getRunType() {
        return runType;
    }

    public void setRunType(String runType) {
        this.runType = runType;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Run{" +
                "id=" + id +
                ", runType='" + runType + '\'' +
                '}';
    }
}

2、创建抽象类的实现类，在构造方法中设置默认的初始化的值，并且重写自己的方法

public class RunAa extends Run {

    public RunAa() {
        runType = "AAAA";
    }

    @Override
    void runInfo() {
        System.out.println("Aa的run信息");
    }
}

public class RunBb extends Run {

    public RunBb() {
        runType = "BBBBBB";
    }

    @Override
    void runInfo() {
        System.out.println("BB的run信息");
    }
}

public class RunCc extends Run {

    public RunCc() {
        runType = "CCCCCC";
    }

    @Override
    void runInfo() {
        System.out.println("CC的run信息");
    }
}

3、创建一个缓存工厂类：初始化一个hashtable , 创建一个初始化方法，根据传入不同的值，创建不同的对象，并且根据传入的值将对象存入hashtable中，最后提供一个获取对象实例的方法，将初始化的实例克隆一个新的出去

public class RunCache  {

    private static Hashtable<String,Run> hashtable = new Hashtable<>();

    public static Run getRun(String runId){
        try {
            Run r = hashtable.get(runId);
            return (Run)r.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return  null;
        }
    }

    public static void initRun(){
        Run aa = new RunAa();
        aa.setId(1111);
        hashtable.put(aa.getId()+"",aa);

        Run bb = new RunBb();
        bb.setId(2222);
        hashtable.put(bb.getId()+"",bb);

        Run ccc = new RunCc();
        ccc.setId(3333);
        hashtable.put(ccc.getId()+"",ccc);
    }
}

4、测试类：先初始化加载原型工厂，再根据类型获取工厂实例

public class TestRun {

    public static void main(String[] args) {
        RunCache.initRun();
        Run runaa = RunCache.getRun("1111");
        Run runbb = RunCache.getRun("2222");
        Run runcc = RunCache.getRun("3333");

        System.out.println(runaa.toString());
        System.out.println(runbb.toString());
        System.out.println(runcc.toString());

    }
}

 5、输出：

Run{id=1111, runType='AAAA'}
Run{id=2222, runType='BBBBBB'}
Run{id=3333, runType='CCCCCC'}