关于spring:设计模式原型模式

原型模式

​ 原型实例指定创建对象的品种，并且通过拷贝这些原型创立新的对象，并且通过 拷贝 这些原型创立新的对象

​ 调用者不须要晓得任何创立细节，不调用构造函数

​ 其属于一种创立型模式

通用类图

长处

• 性能好

  • 是在内存二进制流的拷贝，比间接 new 一个对象性能好，而且循环体内产生大量对象时，能够更好地提现长处

• 回避构造函数的束缚

  • 间接在内存中拷贝构造函数是不会执行的

实用场景

• 类初始化耗费资源较多

• new 产生的一个对象须要十分繁琐的过程（数据筹备、拜访权限等）

  • 省略了本人去 get,set 的过程
• 构造函数比较复杂时
• 循环体中产生大量对象时

应用

• 通过一个特定的办法来拷贝对应的对象

本人提供接口并且实现

应用 JDK 的 clone 办法

浅克隆

测试

@Data
public class ConcretePrototype implements Cloneable {

  private int age;
  private String name;
  private List<String> hobbies;

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

public static void main(String[] args) {ConcretePrototype prototype = new ConcretePrototype();
  prototype.setAge(18);
  prototype.setName("zzy");
  List<String> hobbies = new ArrayList<String>();
  hobbies.add("music");
  hobbies.add("article");
  prototype.setHobbies(hobbies);

  // 拷贝原型对象
  ConcretePrototype cloneType = prototype.clone();
  cloneType.getHobbies().add("program");


  System.out.println("原型对象：" + prototype);
  System.out.println("克隆对象：" + cloneType);
  System.out.println(prototype == cloneType);


  System.out.println("原型对象的喜好：" + prototype.getHobbies());
  System.out.println("克隆对象的喜好：" + cloneType.getHobbies());
  System.out.println(prototype.getHobbies() == cloneType.getHobbies());

}

原型对象：ConcretePrototype{age=18, name=’zzy’, hobbies=[music, article, program]}
克隆对象：ConcretePrototype{age=18, name=’zzy’, hobbies=[music, article, program]}
false
原型对象的喜好：[music, article, program]
克隆对象的喜好：[music, article, program]
true

通过后果能够看到通过 clone 拷贝进去对象的汇合类型的内存地址没有扭转

根本数据类型间接拷贝了，然而援用数据类型拷贝的是属性的内存地址，具体的元素并没有拷贝

这种形式会给咱们将来的应用带来危险

深克隆

序列化和反序列化的形式

手写流

这种形式对象肯定要记得序列化

public ConcretePrototype deepClone(){
  try {ByteArrayOutputStream bos = new ByteArrayOutputStream();
    ObjectOutputStream oos = new ObjectOutputStream(bos);
    oos.writeObject(this);

    ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
    ObjectInputStream ois = new ObjectInputStream(bis);

    return (ConcretePrototype)ois.readObject();}catch (Exception e){e.printStackTrace();
    return null;
  }

• 毛病

  • 性能不好
  • 占用 IO

  • 没有通过构造方法来生成对象

    • 会毁坏单例模式

通过 json 序列化和反序列化

罕用的工具

Spring 的 BeanUtils

org.springframework.beans.BeanUtils#copyProperties

Apache 的 Beanutils

org.apache.commons.beanutils.BeanUtils

不举荐应用，性能差

对于对象拷贝加了很多的测验，包含类型的转换，甚至还会测验对象所属的类的可拜访性, 非常复杂，这也造就了它的差劲的性能，

原型模式在源码中的提现

ArrayList

public class ArrayList<E> extends AbstractList<E>
  implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{public Object clone() {
    try {ArrayList<?> v = (ArrayList<?>) super.clone();
      v.elementData = Arrays.copyOf(elementData, size);
      v.modCount = 0;
      return v;
    } catch (CloneNotSupportedException e) {
      // this shouldn't happen, since we are Cloneable
      throw new InternalError(e);
    }
  }
}

HashMap

public class HashMap<K,V> extends AbstractMap<K,V>
  implements Map<K,V>, Cloneable, Serializable {public Object clone() {
    HashMap<K,V> result;
    try {result = (HashMap<K,V>)super.clone();} catch (CloneNotSupportedException e) {
      // this shouldn't happen, since we are Cloneable
      throw new InternalError(e);
    }
    result.reinitialize();
    result.putMapEntries(this, false);
    return result;
  }
}

注意事项

构造函数不会被执行

​ 对象拷贝时构造函数的确没有被执行，这点从原理来讲也是能够讲得通的，Object 类的 clone 办法的原理是从内存中（具体地说就是堆内存）以二进制流的形式进行拷贝，重新分配一个内存块，那构造函数没有被执行也是十分失常的了。

深拷贝和浅拷贝

深拷贝和浅拷贝倡议不要混合应用，特地是在波及类的继承 时，父类有多个援用的状况就非常复杂，倡议的计划是深拷贝和浅拷贝

final 润饰的变量是不会被拷贝的

问题

通过实现 Cloneable 接口怎么实现克隆原理是什么？有什么问题？代码中是如何验证是深克隆还是浅克隆的？

个别都是间接基于内存二进制流来进行拷贝，不会通过构造函数，性能可能晋升很多。

• 留神

  • 是浅拷贝的

    • 援用数据类型是不会被拷贝的，拷贝的是内存地址，不会创立一个新的
    • final 润饰的变量是不会被拷贝的

• 验证形式

  • 通过比拟内存地址来判断

深克隆有哪些解决办法？

• 通过序列化和反序列化
• 通过 Json 工具

如果我须要单例，怎么避免克隆毁坏单例

• 重写 readResolve 办法

我的笔记仓库地址 gitee 快来给我点个 Star 吧