原型模式

定义

用原型实例指定创建对象的种类，并通过复制这些原型创建新的对象。

使用场景

• 类的初始化需要消耗非常多的资源，这个资源包括数据、硬件资源等，通过原型复制避免这些消耗
• 通过new产生一个新对象需要繁琐的数据准备或访问权限时
• 一个对象需要提供给其他对象访问，而各个调用者可能都需要修改其值时

深克隆与浅克隆

浅克隆

在浅克隆中，被复制的所有成员变量都具有与原来对象相同的值，而所有的其他对象的引用仍然指向原来的对象。

深克隆

在深克隆中，被复制的所有成员变量都具有与原来对象相同的值，出去那些被引用的其他对象的变量。那些被引用的其他对象的变量将指向被复制过的新对象。
深克隆把要复制的对象所引用的对象都复制了一遍

由于浅克隆引用对象的时候并没有克隆对象本身，而是使用原有对象的引用，那对克隆对象进行修改的时候就可能不小心修改了原始对象，造成不必要的错误。
所以在使用clone时候，尽量使用深克隆的形式。

有一点需要注意下，通过clone拷贝对象时候并不会执行构造函数。

原型模式是在内存中二进制流的拷贝，要比new一个对象性能好很多。

实现

以一个登录实现来说明，客户端实现登录后会保存登录者信息，客户端各模块都可能使用到这个用户信息，如果用户信息能够被随意修改在一定程度上来说不太安全，如果某个模块出现一次错误的修改可能还会导致其他模块出现问题，这时候就可以用原型模式对用户信息就行一定程度的保护。

public class User implements Cloneable {
  private int id;
  private String name;
  private String phone;
  private Address address;
  /**
   * 用户标签
   */
  private ArrayList<String> label;
  
  //省略了 get set 方法 
    public void addLabel(String lb) {
    label.add(lb);
  }
  
   @Override protected User clone() {
    User user = null;
    try {
      user = (User) super.clone();
      user.address = this.address.clone();
      user.label = (ArrayList<String>) this.label.clone();
    } catch (CloneNotSupportedException e) {
      e.printStackTrace();
    }
    return user;
  }

  public void show() {
    System.out.println("----- User start-------");
    System.out.println("name : " + getName());
    System.out.println("phone : " + getPhone());

    System.out.println("city: " + getAddress().getCity());
    System.out.println("province: " + getAddress().getProvince());
    System.out.println("street: " + getAddress().getStreet());

    for (String s : getLabel()) {
      System.out.println("label : " + s);
    }
    System.out.println("----- User end-------");
  }
  

public class Address implements Cloneable {

  private String country;
  private String province;
  private String city;
  private String street;
    //省略了 get set 方法 
  @Override protected Address clone() throws CloneNotSupportedException {
    return (Address) super.clone();
  }
}

Address类用来保存用户地址信息，实现Cloneable接口

public interface Login {

  void login(User user);
}

登录接口

public class LoginImpl implements Login {
  @Override public void login(User user) {
    LoginSession.getInstance().setLoginUser(user);
  }
}

模拟具体登录，这里只是简单的将用户信息保存下来

public class LoginSession {

  private static LoginSession sLoginSession = new LoginSession();

  private User mUser;

  private LoginSession() {
  }

  public static LoginSession getInstance() {
    return sLoginSession;
  }

  public User getLoginUser() {
    return mUser.clone();
  }

  //public User getLoginUser() {
  //  return mUser;
  //}


  public void setLoginUser(User user) {
    mUser = user;
  }
}

登录用户管理类，通过getLoginUser（）可以获取到登录用户信息。这里提供了2种实现方案，一种是通过clone的方案，一种不通过clone，直接将User对象返回。两者的差异我们可以从运行结果来分析。

public class Test {

  public static void main(String[] args) {
    User user = new User();
    user.setId(1);
    user.setName("悟空");
    user.setPhone("100000");
    user.setAddress(new Address("傲来国", "东胜神州", "花果山", "水帘洞"));
    user.setLabel(new ArrayList<String>() {{
      add("猴子");
      add("齐天大圣");
    }});

    Login login = new LoginImpl();
    login.login(user);

    System.out.println("---------登录用户----------");
    user.show();

    User newUser = LoginSession.getInstance().getLoginUser();
    System.out.println("---------取到的登录用户副本----------");
    newUser.show();

    System.out.println("---------内存地址判断start----------");
    System.out.println("Name ：" + (user.getName() == newUser.getName()));
    System.out.println("Address ：" + (user.getAddress() == newUser.getAddress()));
    System.out.println("---------内存地址判断end-------------");

    newUser.setName("Statue Of Liberty");
    newUser.setPhone("100011");

    newUser.getAddress().setCountry("America");
    newUser.getAddress().setProvince("New York");
    newUser.getAddress().setCity("Manhattan");
    newUser.getAddress().setStreet("Wall Street");

    newUser.addLabel("freedom");

    System.out.println("---------修改后的登录用户副本----------");
    newUser.show();

    System.out.println("---------修改副本后取到的登录用户----------");
    LoginSession.getInstance().getLoginUser().show();

    login.login(newUser);
    System.out.println("---------变更登录后取到的登录用户----------");
    LoginSession.getInstance().getLoginUser().show();
  }
}

测试类运行结果如下

---------登录用户----------
----- User start-------
name : 悟空
phone : 100000
city: 花果山
province: 东胜神州
street: 水帘洞
label : 猴子
label : 齐天大圣
----- User end-------
---------取到的登录用户副本----------
----- User start-------
name : 悟空
phone : 100000
city: 花果山
province: 东胜神州
street: 水帘洞
label : 猴子
label : 齐天大圣
----- User end-------
---------内存地址判断start----------
Name ：true
Address ：false
---------内存地址判断end----------
---------修改后的登录用户副本----------
----- User start-------
name : Statue Of Liberty
phone : 100011
city: Manhattan
province: New York
street: Wall Street
label : 猴子
label : 齐天大圣
label : freedom
----- User end-------
---------修改副本后取到的登录用户----------
----- User start-------
name : 悟空
phone : 100000
city: 花果山
province: 东胜神州
street: 水帘洞
label : 猴子
label : 齐天大圣
----- User end-------
---------变更登录后取到的登录用户----------
----- User start-------
name : Statue Of Liberty
phone : 100011
city: Manhattan
province: New York
street: Wall Street
label : 猴子
label : 齐天大圣
label : freedom
----- User end-------

可以看到，对登录副本的操作并没有影响原来登录用户的数据，只有重新调用登录方法，主动修改登录用户记录，取到的登录用户信息才会变更。
两次Address地址不一致，说明副本对象的 Address内存地址被重新分配了，但是Address内容保存了一致，说明拷贝的对象保留了原有对象的属性。

LoginSession类中 getLoginUser()直接返回mUser对象的结果如下

---------内存地址判断start----------
Name ：true
Address ：true
---------内存地址判断end-------------
---------修改后的登录用户副本----------
----- User start-------
name : Statue Of Liberty
phone : 100011
city: Manhattan
province: New York
street: Wall Street
label : 猴子
label : 齐天大圣
label : freedom
----- User end-------
---------修改副本后取到的登录用户----------
----- User start-------
name : Statue Of Liberty
phone : 100011
city: Manhattan
province: New York
street: Wall Street
label : 猴子
label : 齐天大圣
label : freedom
----- User end-------

这次Address返回true，说明两者使用的是相同的内存地址，也就是直接返回mUser对象仅仅只是返回了原始数据的引用，那对备份修改也就等同于对原始数据进行修改了。所以可以看到，备份修改后，取到的登录用户也随之变更了。

我们继续

在LoginSession类中 让getLoginUser()返回mUser.clone()，并且User类的clone()方法中注销掉user.address = this.address.clone();这句代码，使address以浅克隆的形式表现，label依旧以深克隆的形式表现。

结果如下

---------内存地址判断start----------
Name ：true
Address ：true
---------内存地址判断end-------------
---------修改后的登录用户副本----------
----- User start-------
name : Statue Of Liberty
phone : 100011
city: Manhattan
province: New York
street: Wall Street
label : 猴子
label : 齐天大圣
label : freedom
----- User end-------
---------修改副本后取到的登录用户----------
----- User start-------
name : 悟空
phone : 100000
city: Manhattan
province: New York
street: Wall Street
label : 猴子
label : 齐天大圣
----- User end-------
---------变更登录后取到的登录用户----------
----- User start-------
name : Statue Of Liberty
phone : 100011
city: Manhattan
province: New York
street: Wall Street
label : 猴子
label : 齐天大圣
label : freedom
----- User end-------

这时候Address依旧为true，说明未实现对象的深克隆时，拷贝的副本依然是对对象的引用，既然是引用，那对对象的修改务必对之前的对象造成影响。但是label也是作为一个对象存在的，它实现了深克隆，副本对象的label与登录对象的label地址不是同一个了，这时候副本对象对label的修改就不会对登录数据造成影响了。

备注

当然，原型模式的实现并非都得通过Cloneable接口来实现，也可以通过序列化操作来实现，你也可以通过拷贝构造函数实现。总之，不应该被cloneable限制你的思维。