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接口
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
