被人推崇的原型模式，请慎重使用！！！

最近遇到的大脸的事儿：

笔者最近遇到一个尴尬的事情，同事问我使用原型模式快还是使用new快，笔者根据自己为对的经验，很肯定的回答说，原型模式肯定比new一个对象快。

但是我最近在回顾原型模式的时候，心血来潮做了一下测试：

下面上代码：

public class User implements Serializable,Cloneable{

    private Integer age;

    private String name;

    private Long id;

    private BigDecimal money;

    public BigDecimal getMoney() {
        return money;
    }

    public void setMoney(BigDecimal money) {
        this.money = money;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Long getId() {
        return id;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return Objects.equals(age, user.age) &&
                Objects.equals(name, user.name) &&
                Objects.equals(id, user.id) &&
                Objects.equals(money, user.money);
    }

    @Override
    public int hashCode() {
        return Objects.hash(age, name, id, money);
    }


    public User() {
        this.age = 0;
        this.name = "";
        this.id = 1L;
        this.money = BigDecimal.ZERO;
    }

    public User(Integer age, String name, Long id, BigDecimal money) {
        this.age = age;
        this.name = name;
        this.id = id;
        this.money = money;
    }

    @Override
    protected User clone() throws CloneNotSupportedException {
        /**
         * 这里先不考虑深拷贝
         */
        return (User) super.clone();
    }
}

如上代码所示，除了重写clone()方法之外，我还重写了无参的构造方法，理论上会减慢new的效率。

然后是测试代码：

public static void main(String[] args) throws IOException, CloneNotSupportedException {
        User user = new User();
        user.setAge(11);
        user.setId(12L);
        user.setName("花花");
        long directNewStart = System.currentTimeMillis();
        for (int i = 0 ; i <= 100000000 ; i++){
           User userOfNew = new User();
            userOfNew.setAge(11);
            userOfNew.setId(12L);
            userOfNew.setName("花花");
        }
        System.out.println("直接new一亿次花费时间：" + (System.currentTimeMillis() - directNewStart));

        long useCloneStart = System.currentTimeMillis();
        for (int i = 0 ; i <= 100000000 ; i++){
            User userOfClone = (User) user.clone();
        }

        System.out.println("使用clone()一亿次方法克隆花费时间：" + (System.currentTimeMillis() - useCloneStart));
       
    }

然后运行的结果令人觉得很不可思议：

直接new一亿次花费时间：9
使用clone()一亿次方法克隆花费时间：712

我的天，new竟然比clone快，后来我去查了一堆的资料，才发现，原型模式只是在创建对象要做很繁琐的工作时才使用原型模式

接下来我把无参构造方法有改了一下：

public User() {
        this.age = 0;
        this.name = "".concat("花花").concat("花花").concat("花花").concat("花花");
        this.id = 1L;
        this.money = BigDecimal.ZERO;
    }

然后再次运行测试代码：

直接new一亿次花费时间：2837
使用clone()一亿次方法克隆花费时间：457

结果就和我认为的使用原型比new对象快了。

综上的安利可以说明，如果创建的对象是轻类型对象，也就是构造起来不是很麻烦，那么使用new比clone()快不止一个数量级。但是如果是创建重的对象，构造对象超级麻烦，那么使用原型比new对象要快。

所以使用原型要慎重使用！！！所以使用原型要慎重使用！！！所以使用原型要慎重使用！！！重要的事情说三遍！