Java设计模式学习笔记：原型模式

今天学到原型模式，在此做一个简单的笔记。

首先介绍下定义，原型模式其实就是一个对象的创建模式，通过一个原型来复制出更多对象的方式，简单理解就是克隆对象。原型模式核心思想是创建对象不是通过调用构造方法，即不通过new的方式来实现，而是通过调用一个方法来实现，即克隆。

克隆分为两种，浅克隆和深克隆，浅克隆只是值的复制，但是其引用地址是一致的，深克隆是所有的属性都是全新的。实现浅克隆，只需要实现Cloneable接口就行，代码如下：

package com.rq.pattern.prototype;

import java.util.List;

public class Person implements Cloneable{

	private int age;
	
	private String name;
	
	private List<String> friends;
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public List<String> getFriends() {
		return friends;
	}
	public void setFriends(List<String> friends) {
		this.friends = friends;
	}

}

测试类：

package com.rq.pattern.prototype;

import java.util.ArrayList;
import java.util.List;

public class PrototypeTest {

	public static void main(String[] args) {
		
		
		Person p = new Person();
		p.setAge(18);
		p.setName("A");
		List<String> friends = new ArrayList<String>();
		friends.add("张三");
		friends.add("李四");
		p.setFriends(friends);
		
		try {
			Person clone = (Person)p.clone();
			clone.getFriends().add("王五");
			System.out.println(p.getFriends());
			System.out.println(clone.getFriends());
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}

}

运行结果：

[张三, 李四, 王五]
[张三, 李四, 王五]

我们将克隆对象的一个friends属性加一个值，运行结果可以看到，两个对象的friends都改变了，说明这两个对象的friends属性其实指向同一个地址，这就是浅复制。

我们再看看深复制，常见的实现方式有两种，一是通过序列化和反序列化，代码如下：

public static Object deepClone(Object obj) {
		try {
			ByteArrayOutputStream bos = new ByteArrayOutputStream();
			ObjectOutputStream oos = new ObjectOutputStream(bos);
			oos.writeObject(obj);
			
			ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
			ObjectInputStream ois = new ObjectInputStream(bis);
			
			return ois.readObject();
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return null;
	}

测试代码如下：

package com.rq.pattern.prototype;

import java.util.ArrayList;
import java.util.List;

public class PrototypeTest {

	public static void main(String[] args) {
		
		
		Person p = new Person();
		p.setAge(18);
		p.setName("A");
		List<String> friends = new ArrayList<String>();
		friends.add("张三");
		friends.add("李四");
		p.setFriends(friends);
		
		try {
			Person clone = (Person)BeanUtils.deepClone(p);
			clone.getFriends().add("王五");
			System.out.println(p.getFriends());
			System.out.println(clone.getFriends());
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}

}

运行结果：

[张三, 李四]
[张三, 李四, 王五]

可以看出两个List格式的属性已经是不一样的结果，说明不是一个引用地址了，做到了深克隆。

还有一种实现方式是通过转JSON的方式，这种方式后面再说。

下面再关注一个问题，就是既然原型模式是通过调用对象的非构造方法来创建新的对象的，如果要求该对象是单例模式的，岂不是冲突了？其实，原型模式和单例模式还真的是冲突的，要看实际的业务场景，如果要求对象必须为单例模式，那么就不能实现Cloneable接口，或者在实现clone方法时，直接返回单例中创建的instance，但是这样重写clone方法就没意义了，总之，这两种设计模式是有冲突的，一般情况下，只会选择其中一种。