设计模式10---设计模式之原型模式（Prototype）

1.场景模式

考虑这样一个实际应用：订单处理系统
里面有一个保存订单的功能，当产品数量超过1000份以后，拆成两份订单，再超，那么就再拆。直到每份订单不超过1000为止，订单有两种，一个是个人订单，一个是公司订单，现在需要实现一个通用的订单处理系统。

2.场景模式代码（代码很简单，不一一讲解了）

package demo08.prototype.example1;

/**
 * 订单的接口
 */
public interface OrderApi {
	/**
	 * 获取订单产品数量
	 *
	 * @return 订单中产品数量
	 */
	public int getOrderProductNum();

	/**
	 * 设置订单产品数量
	 *
	 * @param num
	 *        订单产品数量
	 */
	public void setOrderProductNum(int num);
}

package demo08.prototype.example1;

/**
 * 个人订单对象
 */
public class PersonalOrder implements OrderApi {
	/**
	 * 订购人员姓名
	 */
	private String customerName;
	/**
	 * 产品编号
	 */
	private String productId;
	/**
	 * 订单产品数量
	 */
	private int orderProductNum = 0;

	public int getOrderProductNum() {
		return this.orderProductNum;
	}

	public void setOrderProductNum(int num) {
		this.orderProductNum = num;
	}

	public String getCustomerName() {
		return customerName;
	}

	public void setCustomerName(String customerName) {
		this.customerName = customerName;
	}

	public String getProductId() {
		return productId;
	}

	public void setProductId(String productId) {
		this.productId = productId;
	}

	public String toString() {
		return "本个人订单的订购人是=" + this.customerName + "，订购产品是=" + this.productId + "，订购数量为=" + this.orderProductNum;
	}
}

package demo08.prototype.example1;

/**
 * 企业订单对象
 */
public class EnterpriseOrder implements OrderApi {
	/**
	 * 企业名称
	 */
	private String enterpriseName;
	/**
	 * 产品编号
	 */
	private String productId;
	/**
	 * 订单产品数量
	 */
	private int orderProductNum = 0;

	public int getOrderProductNum() {
		return this.orderProductNum;
	}

	public void setOrderProductNum(int num) {
		this.orderProductNum = num;
	}

	public String getEnterpriseName() {
		return enterpriseName;
	}

	public void setEnterpriseName(String enterpriseName) {
		this.enterpriseName = enterpriseName;
	}

	public String getProductId() {
		return productId;
	}

	public void setProductId(String productId) {
		this.productId = productId;
	}

	public String toString() {
		return "本企业订单的订购企业是=" + this.enterpriseName + "，订购产品是=" + this.productId + "，订购数量为=" + this.orderProductNum;
	}
}

package demo08.prototype.example1;

/**
 * 处理订单的业务对象
 */
public class OrderBusiness {
	/**
	 * 创建订单的方法
	 *
	 * @param order
	 *        订单的接口对象
	 */
	public void saveOrder(OrderApi order) {
		// 根据业务要求，当订单的预定的产品数量超过1000的时候，就需要把订单拆成两份订单
		// 当然如果要做好，这里的1000应该做成常量，这么做是为了演示简单

		// 1：判断当前的预定产品数量是否大于1000
		while (order.getOrderProductNum() > 1000) {
			// 2：如果大于，还需要继续拆分
			// 2.1再新建一份订单，跟传入的订单除了数量不一样外，其他都相同
			OrderApi newOrder = null;
			if (order instanceof PersonalOrder) {
				// 创建相应的新的订单对象
				PersonalOrder p2 = new PersonalOrder();
				// 然后进行赋值，但是产品数量为1000
				PersonalOrder p1 = (PersonalOrder) order;
				p2.setCustomerName(p1.getCustomerName());
				p2.setProductId(p1.getProductId());
				p2.setOrderProductNum(1000);
				// 然后再设置给newOrder
				newOrder = p2;
			} else if (order instanceof EnterpriseOrder) {
				// 创建相应的订单对象
				EnterpriseOrder e2 = new EnterpriseOrder();
				// 然后进行赋值，但是产品数量为1000
				EnterpriseOrder e1 = (EnterpriseOrder) order;
				e2.setEnterpriseName(e1.getEnterpriseName());
				e2.setProductId(e1.getProductId());
				e2.setOrderProductNum(1000);
				// 然后再设置给newOrder
				newOrder = e2;
			}

			// 2.2原来的订单保留，把数量设置成减少1000
			order.setOrderProductNum(order.getOrderProductNum() - 1000);

			// 然后是业务功能处理，省略了，打印输出，看一下
			System.out.println("拆分生成订单==" + newOrder);
		}

		// 3：不超过，那就直接业务功能处理，省略了，打印输出，看一下
		System.out.println("订单==" + order);

	}

//	public void saveOrder2(OrderApi order){
//		int oldNum = order.getOrderProductNum();
//		while(oldNum > 1000){
//			//定义一个表示被拆分出来的新订单对象
//			OrderApi newOrder = null;
//
//			if(order instanceof PersonalOrder){
//				//创建相应的订单对象
//				PersonalOrder p2 = new PersonalOrder();
//				//然后进行赋值等，省略了
//				//然后再设置给newOrder
//				newOrder = p2;
//			}else if(order instanceof EnterpriseOrder){
//				//创建相应的订单对象
//				EnterpriseOrder e2 = new EnterpriseOrder();
//				//然后进行赋值等，省略了
//				//然后再设置给newOrder
//				newOrder = e2;
//			}
//			//然后进行拆分和其他业务功能处理，省略了
//		}
//	}
}

package demo08.prototype.example1;

public class OrderClient {
	public static void main(String[] args) {
		// 创建订单对象，这里为了演示简单，直接new了
		PersonalOrder op = new PersonalOrder();
		// 设置订单数据
		op.setOrderProductNum(2925);
		op.setCustomerName("张三");
		op.setProductId("P0001");

		// 这里获取业务处理的类，也直接new了，为了简单，连业务接口都没有做
		OrderBusiness ob = new OrderBusiness();
		// 调用业务来保存订单对象
		ob.saveOrder(op);
	}
}

3.问题所在

仔细观察可以发现：实际上是关注订单的类型和具体实现的。证据如下：

		// 1：判断当前的预定产品数量是否大于1000
		while (order.getOrderProductNum() > 1000) {
			// 2：如果大于，还需要继续拆分
			// 2.1再新建一份订单，跟传入的订单除了数量不一样外，其他都相同
			OrderApi newOrder = null;
			if (order instanceof PersonalOrder) {
				// 创建相应的新的订单对象
				PersonalOrder p2 = new PersonalOrder();
				// 然后进行赋值，但是产品数量为1000
				PersonalOrder p1 = (PersonalOrder) order;
				p2.setCustomerName(p1.getCustomerName());
				p2.setProductId(p1.getProductId());
				p2.setOrderProductNum(1000);
				// 然后再设置给newOrder
				newOrder = p2;
			} else if (order instanceof EnterpriseOrder) {
				// 创建相应的订单对象
				EnterpriseOrder e2 = new EnterpriseOrder();
				// 然后进行赋值，但是产品数量为1000
				EnterpriseOrder e1 = (EnterpriseOrder) order;
				e2.setEnterpriseName(e1.getEnterpriseName());
				e2.setProductId(e1.getProductId());
				e2.setOrderProductNum(1000);
				// 然后再设置给newOrder
				newOrder = e2;
			}

			// 2.2原来的订单保留，把数量设置成减少1000
			order.setOrderProductNum(order.getOrderProductNum() - 1000);

			// 然后是业务功能处理，省略了，打印输出，看一下
			System.out.println("拆分生成订单==" + newOrder);
		}

4.解决方案

是不是觉得上面代码很臃肿，很不爽，很不舒服，对头，这样说明你已经开始理解java设计模式的好处了。
解决它的方法就是使用原型模式

5.原型模式

5.1原型模式定义：

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

5.2如何解决

那么如何解决呢？大家有没有想过可以把这些复制的代码放在接口中，返回接口对象，这样就好像是接口创建了接口对象似的。而且，客户端就不用理解对象的一些操作了，知识最少化。

6.原型模式示例代码

6.1模式结构图

6.2声明一个克隆自身的接口

package demo08.prototype.example2;
/**
 * 声明一个克隆自身的接口
 */
public interface Prototype {
	/**
	 * 克隆自身的方法
	 * @return 一个从自身克隆出来的对象
	 */
	public Prototype clone();
}

6.3具体的实现对象

package demo08.prototype.example2;
/**
 * 克隆的具体实现对象
 */
public class ConcretePrototype1 implements Prototype {
	public Prototype clone() {
		//最简单的克隆，新建一个自身对象，由于没有属性，就不去复制值了
		Prototype prototype = new ConcretePrototype1();
		return prototype;
	}
}
package demo08.prototype.example2;

/**
 * 克隆的具体实现对象
 */
public class ConcretePrototype2 implements Prototype {
	public Prototype clone() {
		//最简单的克隆，新建一个自身对象，由于没有属性，就不去复制值了
		Prototype prototype = new ConcretePrototype2();
		return prototype;
	}
}

6.4客户端

package demo08.prototype.example2;

/**
 * 使用原型的客户端
 */
public class Client {
	/**
	 * 持有需要使用的原型接口对象
	 */
	private Prototype prototype;

	/**
	 * 构造方法，传入需要使用的原型接口对象
	 *
	 * @param prototype
	 *        需要使用的原型接口对象
	 */
	public Client(Prototype prototype) {
		this.prototype = prototype;
	}

	/**
	 * 示意方法，执行某个功能操作
	 */
	public void operation() {
		// 会需要创建原型接口的对象
		Prototype newPrototype = prototype.clone();
	}
}

7.使用原型模式来重写示例代码

为了方便我就直接写改动的地方

7.1订单的接口

package demo08.prototype.example3;

/**
 * 订单的接口，声明了可以克隆自身的方法
 */
public interface OrderApi {
	/**
	 * 获取订单产品数量
	 * @return 订单中产品数量
	 */
	public int getOrderProductNum();
	/**
	 * 设置订单产品数量
	 * @param num 订单产品数量
	 */
	public void setOrderProductNum(int num);
	/**
	 * 克隆方法
	 * @return 订单原型的实例
	 */
	public OrderApi cloneOrder();
}

7.2个人订单

package demo08.prototype.example3;
/**
 * 个人订单对象
 */
public class PersonalOrder implements OrderApi{
	/**
	 * 订购人员姓名
	 */
	private String customerName;
	/**
	 * 产品编号
	 */
	private String productId;
	/**
	 * 订单产品数量
	 */
	private int orderProductNum = 0;

	public int getOrderProductNum() {
		return this.orderProductNum;
	}
	public void setOrderProductNum(int num) {
		this.orderProductNum = num;
	}
	public String getCustomerName() {
		return customerName;
	}
	public void setCustomerName(String customerName) {
		this.customerName = customerName;
	}
	public String getProductId() {
		return productId;
	}
	public void setProductId(String productId) {
		this.productId = productId;
	}
	public String toString(){
		return "本个人订单的订购人是="+this.customerName+"，订购产品是="+this.productId+"，订购数量为="+this.orderProductNum;
	}
	public OrderApi cloneOrder() {
		//创建一个新的订单，然后把本实例的数据复制过去
		PersonalOrder order = new PersonalOrder();
		order.setCustomerName(this.customerName);
		order.setProductId(this.productId);
		order.setOrderProductNum(this.orderProductNum);

		return order;
	}
}

7.3企业订单

package demo08.prototype.example3;

/**
 * 企业订单对象
 */
public class EnterpriseOrder implements OrderApi {
	/**
	 * 企业名称
	 */
	private String enterpriseName;
	/**
	 * 产品编号
	 */
	private String productId;
	/**
	 * 订单产品数量
	 */
	private int orderProductNum = 0;

	public int getOrderProductNum() {
		return this.orderProductNum;
	}

	public void setOrderProductNum(int num) {
		this.orderProductNum = num;
	}

	public String getEnterpriseName() {
		return enterpriseName;
	}

	public void setEnterpriseName(String enterpriseName) {
		this.enterpriseName = enterpriseName;
	}

	public String getProductId() {
		return productId;
	}

	public void setProductId(String productId) {
		this.productId = productId;
	}

	public String toString() {
		return "本企业订单的订购企业是=" + this.enterpriseName + "，订购产品是=" + this.productId + "，订购数量为=" + this.orderProductNum;
	}

	public OrderApi cloneOrder() {
		// 创建一个新的订单，然后把本实例的数据复制过去
		EnterpriseOrder order = new EnterpriseOrder();
		order.setEnterpriseName(this.enterpriseName);
		order.setProductId(this.productId);
		order.setOrderProductNum(this.orderProductNum);

		return order;
	}
}

7.4处理订单的业务对象

package demo08.prototype.example3;
/**
 * 处理订单的业务对象
 */
public class OrderBusiness {
	/**
	 * 创建订单的方法
	 * @param order 订单的接口对象
	 */
	public void saveOrder(OrderApi order){
		//根据业务要求，当订单的预定的产品数量超过1000的时候，就需要把订单拆成两份订单
		//当然如果要做好，这里的1000应该做成常量，这么做是为了演示简单

		//1：判断当前的预定产品数量是否大于1000
		while(order.getOrderProductNum() > 1000){
			//2：如果大于，还需要继续拆分
			//2.1再新建一份订单，跟传入的订单除了数量不一样外，其他都相同
			OrderApi newOrder = order.cloneOrder();
			//然后进行赋值，产品数量为1000
			newOrder.setOrderProductNum(1000);

			//2.2原来的订单保留，把数量设置成减少1000
			order.setOrderProductNum(order.getOrderProductNum()-1000);

			//然后是业务功能处理，省略了，打印输出，看一下
			System.out.println("拆分生成订单=="+newOrder);
		}
		//3：不超过，那就直接业务功能处理，省略了，打印输出，看一下
		System.out.println("订单=="+order);

	}
}

这样是不是简单清爽了很多呢？

8.原型模式思考

8.1原型模式的讲解

通过克隆创建新的对象实例

为克隆出来的对象复制原型实例属性的值，不是new而是类似new

8.2原型模式的调用顺序图

8.3浅度克隆和深度克隆

浅度克隆：只负责按值传递的数据

深度克隆：除了浅度克隆复制的数据外，还要负责克隆引用类型的数据，而且，引用类型还要递归克隆

java也有克隆方法，这里就不说了。

体现深度克隆的代码如下（稍微更改一下就行了）


public OrderApi cloneOrder() {


//创建一个新的订单，然后把本实例的数据复制过去


PersonalOrder order = new PersonalOrder();


order.setCustomerName(this.customerName);


order.setOrderProductNum(this.orderProductNum);


//对于对象类型的数据，深度克隆的时候需要继续调用这个对象的克隆方法


order.setProduct((Product)this.product.cloneProduct());

return order;


}

8.4原型模式本质

克隆生成对象

8.5原型模式优缺点

优点：对客户端隐藏具体的实现类型，运行时动态改变具体的实现类型

缺点：每个原型的子类都要实现clone接口