设计模式（五）原型模式 Prototype

时间 2019-11-15 标签设计模式五原型模式 prototype

原型模式：

　　原型模式，是指基于一个已经给定的对象，经过拷贝的方式，建立一个新的对象，这个给定对象，就是“原型”。html

　　在 Java 中，原型模式体现为 Object 的 clone() 方法。数组

　　全部类均可以经过实现 Cloneable 接口，以及重写 clone() 方法，来实现原型模式。安全

代码：

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Liability implements Cloneable {private String code;
    private String name;
    private String category;
    private boolean isMajor;

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

@Data
@Builder
public class PolicyShallowClone implements Cloneable {

    private String code;
    private int applicantAge;
    private Liability liability;
    private List<String> specialDescriptions;

    @Override
    public PolicyShallowClone clone() throws CloneNotSupportedException {
        return (PolicyShallowClone) super.clone();
    }
}

缩减 clone() 方法的返回类型：

　　自 JDK1.5 开始，Java 引进了一个新的特性：协变返回类型（covariant return type）。架构

　　即：覆盖方法的返回类型，能够是被覆盖方法的返回类型的子类。app

　　因此须要在 clone() 方法内部进行强转。ide

　　这体现了一条通则：永远不要让客户去作任何类库可以替客户完成的事情。post

clone() 是一种浅度复制（Shallow Copy）：

    @Test
    void testPolicy1() throws Exception {
        // Build original policy
        Liability liability = new Liability.LiabilityBuilder().code("0001").name("Liability").category("XPXA").build();
        String specialDescription1 = "text1";
        String specialDescription2 = "text2";
        List<String> specialDescriptions = new ArrayList<>(Arrays.asList(specialDescription1, specialDescription2));
        PolicyShallowClone policyA = PolicyShallowClone.builder().specialDescriptions(specialDescriptions).liability(liability).code("code001").applicantAge(18).build();
        // Call clone
        PolicyShallowClone policyB = policyA.clone();
        Assertions.assertSame(policyA.getCode(), policyB.getCode());
        Assertions.assertEquals(policyA.getCode(), policyB.getCode());
        // Assert shallow clone
        policyA.getSpecialDescriptions().add("text3");
        Assertions.assertSame(policyA.getLiability(), policyB.getLiability());
        Assertions.assertTrue(policyA.getSpecialDescriptions().size() == policyB.getSpecialDescriptions().size());
    }

编写一个优秀的 clone() 方法：

　　克隆对象的数据来源，必须来自于 clone() 方法，因此永远在方法内部调用 super.clone() 方法。测试

　　全部的父类必须很好地实现了 clone() 方法。ui

　　若是当前类包含的域引用了可变对象，须要递归地调用 clone() 方法。this

　　若是在线程安全的类中实现 Cloneable 接口，clone() 方法必须获得很好的同步。

一个深度复制的 clone() 方法：

@Data
@Builder
public class PolicyDeepClone implements Cloneable {

    private String code;
    private int applicantAge;
    private Liability liability;
    private List<String> specialDescriptions;

    @Override
    public PolicyDeepClone clone() throws CloneNotSupportedException {
        PolicyDeepClone clone = (PolicyDeepClone) super.clone();
        clone.specialDescriptions = new ArrayList<>(this.specialDescriptions);
        clone.liability = this.liability.clone();
        return clone;
    }
}

深度复制的测试：

    @Test
    void testPolicy2() throws Exception {
        // Build original policy
        Liability liability = new Liability.LiabilityBuilder().code("0001").name("Liability").category("XPXA").build();
        String specialDescription1 = "text1";
        String specialDescription2 = "text2";
        List<String> specialDescriptions = new ArrayList<>(Arrays.asList(specialDescription1, specialDescription2));
        PolicyDeepClone policyA = PolicyDeepClone.builder().specialDescriptions(specialDescriptions).liability(liability).code("code001").applicantAge(18).build();
        // Call clone
        PolicyDeepClone policyB = policyA.clone();
        // Assert deep clone
        policyA.getSpecialDescriptions().add("text3");
        Assertions.assertNotSame(policyA.getLiability(), policyB.getLiability());
        Assertions.assertFalse(policyA.getSpecialDescriptions().size() == policyB.getSpecialDescriptions().size());
    }

有必要这么复杂吗？

　　从上述的介绍，咱们不难发现，要完成一个优秀的 clone() 方法，存在诸多限制。

　　而且，当咱们实现了 clone() 方法，在编译器中，还会看到一条 Blocker 级别的 Sonar 警告：

　　Remove this "clone" implementation; use a copy constructor or copy factory instead.

　　它推荐的是一个拷贝构造器和拷贝工厂。

拷贝构造器（Copy constructor）

@Data
@Builder
public final class PolicyCopyConstructor {

    private String code;
    private int applicantAge;
    private Liability liability;
    private List<String> specialDescriptions;

    public PolicyCopyConstructor(PolicyCopyConstructor policy) {
        this.code = policy.code;
        this.applicantAge = policy.applicantAge;
        this.liability = policy.liability;
        this.specialDescriptions = policy.specialDescriptions;
    }
}

　　显然，这是一个浅度复制的实现，若是须要深度复制，须要深一步挖掘，这里不详述。

拷贝工厂（Copy factory）：

@Data
public final class PolicyCopyFactory {

    private String code;
    private int applicantAge;
    private Liability liability;
    private List<String> specialDescriptions;

    public static PolicyCopyFactory newInstance(PolicyCopyFactory policy) {
        PolicyCopyFactory copyPolicy = new PolicyCopyFactory();
        copyPolicy.setCode(policy.getCode());
        copyPolicy.setApplicantAge(policy.getApplicantAge());
        copyPolicy.setLiability(policy.getLiability());
        copyPolicy.setSpecialDescriptions(policy.getSpecialDescriptions());
        return copyPolicy;
    }
}

　　拷贝工厂本质上使咱们以前提到过的静态工厂的一种变形。

　　在这里，这也是浅度复制的实现。

Copy constructor & Copy factory 的优点：

不依赖于某一种带有风险的，语言以外的对象建立机制（clone 是 native 方法）。
不会与 final 域的正常使用发生冲突（clone 架构与引用可变对象的 final 域的正常使用是不兼容的）。
不会抛出受检异常。
不须要类型转换。

《Effective Java》第11条：谨慎地覆盖 clone

　　鉴于 clone() 方法存在这么多限制，《Effective Java》明确指出：

　　除了拷贝数组，其余任何状况都不该该去覆盖 clone() 方法，也不应去调用它。

关于深复制：

　　这篇文章第004弹：几种通用的深度复制的方法介绍了几种深复制的通用方法。