原型(克隆)模式

思考原型(克隆)模式

原型模式顾名思义通过一个接口实现快速创建对象，主要解决的问题就是创建重复对象，而这部分对象内容本身比较复杂，生成过程可能从库或者RPC接口中获取数据的耗时较长，因此采用克隆的方式节省时间。

1.原型模式的本质

原型模式的本质:克隆生成对象。

克隆是手段，目的是生成新的对象实例。正是因为原型的目的是为了生成新的对象实例，原型模式通常是被归类为创建型的模式。

原型模式也可以用来解决“只知接口而不知实现的问题”，使用原型模式，可以出现一种独特的“接口造接口”的景象，这在面向接口编程中很有用。同样的功能也可以考虑使用工厂来实现。

另外，原型模式的重心还是在创建新的对象实例，至于创建出来的对象，其属性的值是否一定要和原型对象属性的值完全一样，这个并没有强制规定，只不过在目前大多数实现中，克隆出来的对象和原型对象的属性值是一样的。

也就是说，可以通过克隆来创造值不一样的实例，但是对象类型必须一样。可以有部分甚至是全部的属性的值不一样，可以有选择性地克隆，就当是标准原型模式的一个变形使用吧。

2.何时选用原型模式

建议在以下情况时选用原型模式。

• 在运行时动态地生成对象，而不是在编译时静态地创建对象。

• 当创建对象的成本比复制现有对象的成本更高时。例如，创建一个数据库连接对象需要花费较长的时间和资源，但是复制一个现有连接对象的副本只需要很少的时间和资源。

• 当需要避免直接暴露对象的创建细节时。使用原型模式可以将对象的创建逻辑封装在对象内部，而不需要让外部代码知道对象是如何创建的。

3.优缺点

原型模式的优点

• 便于通过克隆方式创建复杂对象、也可以避免重复做初始化操作.不需要与类中所属的其他类耦合等。

原型模式的缺点

• 如果对象中包括了循环引用的克隆，以及类中深度使用对象的克隆，都会使此模式变得异常麻烦。

4.原型模式的结构

• Prototype:声明一个克隆自身的接口，用来约束想要克隆自己的类，要求它们都要实现这里定义的克隆方法。
• ConcretePrototype:实现 Prototype接口的类，这些类真正实现了克隆自身的功能。
• Client:使用原型的客户端，首先要获取到原型实例对象，然后通过原型实例克隆自身来创建新的对象实例。

5.实现

原型模式(浅克隆)

1.克隆接口

/**
 * @description:需要克隆方法实现此接口
 */
public interface OrderApi {

    /**
     * 克隆方法
     * @return
     */
    OrderApi clone();
}

2.实现类

/**
 * @description:个人订单
 */
@Data
@ToString
public class PersonOrder implements OrderApi{

    /**
     * 用户名
     */
    private String personName;
    /**
     * 产品id
     */
    private Integer productId;

    private CompanyOrder companyOrder;


    /**
     * 克隆对象
     * @return
     */
    @Override
    public OrderApi clone() {
        PersonOrder personOrder = new PersonOrder();
        personOrder.setPersonName(this.personName);
        personOrder.setProductId(this.productId);
        personOrder.setCompanyOrder(this.companyOrder);
        return personOrder;
    }
}

/**
 * @description:公司订单
 */
@Data
@ToString
public class CompanyOrder implements OrderApi{

    /**
     * 公司名
     */
    private String companyName;
    /**
     * 产品id
     */
    private Integer productId;

    /**
     * 克隆对象
     * @return
     */
    @Override
    public OrderApi clone() {
        CompanyOrder companyOrder = new CompanyOrder();
        companyOrder.setCompanyName(this.companyName);
        companyOrder.setProductId(this.productId);
        return companyOrder;
    }
}

3.测试类

/**
 * @description:测试类
 */
public class Client {

    public static void main(String[] args) {

        //公司订单对象
        CompanyOrder companyOrder = new CompanyOrder();
        companyOrder.setCompanyName("字节跳动");
        companyOrder.setProductId(10002);

        //个人订单对象
        PersonOrder personOrder = new PersonOrder();
        personOrder.setPersonName("张三");
        personOrder.setProductId(10001);
        personOrder.setCompanyOrder(companyOrder);

        System.out.println("个人订单原对象:"+personOrder);
        System.out.println("公司订单原对象:"+companyOrder);
        //克隆个人订单对象
        OrderApi personClone = personOrder.clone();

        System.out.println("个人订单克隆对象1:"+personClone);
        //修改公司订单对象的值
        companyOrder.setCompanyName("88888888888");
        System.out.println("公司订单原对象:"+companyOrder);
        //再次打印个人订单对象，发现值变了，是浅克隆
        System.out.println("个人订单克隆对象2:"+personClone);
    }
}

4.结果

原型模式(深克隆)

1.实现深度克隆只需克隆引用对象时，调用它自己的克隆方法，一直传递下去

/**
 * 克隆对象
 * @return
 */
@Override
public OrderApi clone() {
    PersonOrder personOrder = new PersonOrder();
    personOrder.setPersonName(this.personName);
    personOrder.setProductId(this.productId);
    personOrder.setCompanyOrder((CompanyOrder) this.companyOrder.clone());
    return personOrder;
}

2.结果

java提供的克隆

1、浅克隆:对当前对象进行克隆,并克隆该对象所包含的8种基本数据类型和String类型属性（拷贝一份该对象并重新分配内存，即产生了新的对象）；但如果被克隆的对象中包含除8中数据类型和String类型外的其他类型的属性,浅克隆并不会克隆这些属性（即不会为这些属性分配内存，而是引用原来对象中的属性）
2、深克隆:深拷贝会完全复制整个对象，包括这个对象所包含的内部对象。

java浅克隆

1.实现Cloneable接口
2.重写clone方法

/**
 * @description:个人订单
 */
@Data
@ToString
public class PersonOrder2 implements Cloneable{

    /**
     * 用户名
     */
    private String personName;
    /**
     * 产品id
     */
    private Integer productId;

    private CompanyOrder2 companyOrder2;

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

@Data
@ToString
public class CompanyOrder2 implements Cloneable{

    /**
     * 公司名
     */
    private String companyName;
    /**
     * 产品id
     */
    private Integer productId;

    @Override
	public Object clone() {
		Object obj=null;
		try {
			obj=super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return obj;
	}
}

3.测试

/**
 * @description:测试类
 */
public class Client {

    public static void main(String[] args) throws CloneNotSupportedException {

        CompanyOrder2 companyOrder2 = new CompanyOrder2();
        companyOrder2.setCompanyName("字节跳动");
        companyOrder2.setProductId(10002);

        PersonOrder2 personOrder2 = new PersonOrder2();
        personOrder2.setPersonName("张三");
        personOrder2.setProductId(10001);
        personOrder2.setCompanyOrder2(companyOrder2);
        System.out.println("原对象:"+personOrder2);

        //java浅克隆
        Object clone = personOrder2.clone();
        System.out.println("克隆对象:"+clone);
        companyOrder2.setCompanyName("9999999999");
        System.out.println("克隆对象:"+clone);

    }
}

4.结果

可以看到，虽然克隆出来了一个一模一样的对象，但是修改原对象的属性，克隆的对象属性也改变了，这就是浅克隆，原对象和克隆对象的引用属性共同指向一个内存地址

java深克隆

1.实现深度克隆只需克隆引用对象时，调用它自己的克隆方法，一直传递下去，原理和上面的原型实现深克隆一样

@Override
protected Object clone() throws CloneNotSupportedException {
    PersonOrder2 clone = (PersonOrder2) super.clone();
    clone.setCompanyOrder2((CompanyOrder2) this.companyOrder2.clone());
    return clone;
}

2.结果