创业街分店开张啦---原型模式

前情提要

上集讲到, 小光请来堂哥大龙作为自己的代理与饮品供应商谈判, 最终大龙用自己丰富的商场经验帮小光拿到合适的价格.

小光也是尝到了代理的甜头, 开始将店里的更多工作交给表妹来打理, 自己腾出功夫去选新的分店地址了.

所有示例源码已经上传到Github, 戳这里

新店建设

根据光谷店的经营经验, 很快, 小光就选好了分店的地址—创业街. 还是为了造福广大屌丝单身程序猿们啊, 哈哈.

分店的建设相对第一家店的开辟来说也是简单了很多, 在光谷店的探索, 诸如热干面生产流程, 饮料机机制, 活动策略等都可以复制过来用. 简单来说, 就是复制成功原型, 如下:

照例, 抽象出一个公司的类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public class Company implements Cloneable {
// 此处我们假装省略了N多, 诸如活动策略, 饮料机, 热干面生产流程等.
// 再此仅以饮品为例
private ArrayList<String> drinks = new ArrayList<>();
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void addDrink(String drink) {
drinks.add(drink);
}
@Override
protected Company clone() {
Company company = null;
try {
company = (Company) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return company;
}
@Override
public String toString() {
return "{" +
"名字: '" + getName() + '\'' +
", 饮品: " + drinks + '\'' +
'}';
}
}

光谷店:

1
2
3
4
5
6
7
8
9
public class OpticalValleyCompany extends Company {
public OpticalValleyCompany() {
setName("光谷软件园分店");
addDrink("橙汁");
addDrink("可乐");
addDrink("酸梅汤");
}
}

看下小光是如何复制光谷店的成功, 创建新的创业街分店的:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class XiaoGuang {
public static void main(String[] args) {
// new 光谷店
Company ovCompany = new OpticalValleyCompany();
System.out.println("光谷店: " + ovCompany);
// 在光谷店的基础上clone SBI店
Company sbiCompany = ovCompany.clone();
sbiCompany.setName("创业街分店");
System.out.println("SBI店: " + sbiCompany);
}
}

output:

1
2
光谷店: {名字: '光谷软件园分店', 饮品: [橙汁, 可乐, 酸梅汤]'}
SBI店: {名字: '创业街分店', 饮品: [橙汁, 可乐, 酸梅汤]'}

看样子很成功, 小光开始准备试运营了.

试运营

小光信心满满的开始了新店的试运营. 为了庆祝分店开张, 小光新拿了一款饮料XDrink在新店做活动, 买热干面赠送饮料.

1
2
3
4
5
6
7
8
// 在光谷店的基础上clone SBI店
Company sbiCompany = ovCompany.clone();
sbiCompany.setName("创业街分店");
// 给SBI店新增一款饮品
sbiCompany.addDrink("雪碧");
System.out.println("SBI店: " + sbiCompany);

这时, SBI店的饮品列表是:

1
SBI店: {名字: '创业街分店', 饮品: [橙汁, 可乐, 酸梅汤, 雪碧]'}

看着很好, Perfect.
然而, 这时, 表妹打来电话了, 说我光谷店这边的菜单系统怎么无端多出一款雪碧的饮料啊, 我这没有提供的啊, 怎么给客户啊.

小光立马打印了下光谷店的信息(基于上面的修改):

1
2
3
4
5
6
7
8
9
10
11
// 在光谷店的基础上clone SBI店
Company sbiCompany = ovCompany.clone();
sbiCompany.setName("创业街分店");
// 给SBI店新增一款饮品
sbiCompany.addDrink("雪碧");
System.out.println("SBI店: " + sbiCompany);
// 打印下光谷店ovCompany
System.out.println("光谷店: " + ovCompany);

果然, 光谷店新增了”雪碧”,

1
2
SBI店: {名字: '创业街分店', 饮品: [橙汁, 可乐, 酸梅汤, 雪碧]'}
光谷店: {名字: '光谷软件园分店', 饮品: [橙汁, 可乐, 酸梅汤, 雪碧]'}

这样当然是不好的咯, 小光只想复制光谷店的基本流程架构过来, 后续两个店的某些方面还是要分开发展的, 可不能一改俱改啊.

改进之路

小光又开始了clone的改进之路. 先回头看下, 小光之前是怎么clone的:

1
2
3
4
5
6
7
8
9
10
11
@Override
protected Company clone() {
Company company = null;
try {
company = (Company) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return company;
}

我们注意到, 这个clone只是clone了Company, 并没有clone Company内部的引用(ArrayList drinks). 也就是说clone出来的对象和之前的对象会使用同一份drinks列表注1, 这显然不是小光愿意看到的.

小光也很快想到了解决方案, 改造了clone过程:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Override
protected Company clone() {
Company company = null;
try {
company = (Company) super.clone();
// 对于对象的属性也加以clone
company.drinks = (ArrayList<String>) this.drinks.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return company;
}

这次小光不仅clone了Company, 还clone了其属性值drinks注2.

让我们来看下小光的成果:

和之前同样的使用:

1
2
3
4
5
6
7
8
9
10
11
12
13
// new 光谷店
Company ovCompany = new OpticalValleyCompany();
System.out.println("光谷店: " + ovCompany);
// 在光谷店的基础上clone SBI店
Company sbiCompany = ovCompany.clone();
sbiCompany.setName("创业街分店");
// 给SBI店新增一款饮品
sbiCompany.addDrink("雪碧");
System.out.println("SBI店: " + sbiCompany);
System.out.println("光谷店: " + ovCompany);

改造后的结果:

1
2
3
光谷店: {名字: '光谷软件园分店', 饮品: [橙汁, 可乐, 酸梅汤]'}
SBI店: {名字: '创业街分店', 饮品: [橙汁, 可乐, 酸梅汤, 雪碧]'}
光谷店: {名字: '光谷软件园分店', 饮品: [橙汁, 可乐, 酸梅汤]'}

我们看到, 光谷店不会因为SBI店的改变而改变了.
小光热干面SBI店试运营正式开始, 欢迎大家光临咯…

故事之后

我们在故事中多次提到了clone, 原型. 没错, 这个就是原型模式. 照例, 我们来梳理下类之间的关系, 相对简单:

原型模式:
通过原型对象实例, 使用clone的方式来快速创建一个新的(与原型对象实例一致的)对象实例.

由于原型模式较为通用, 且相对简单, Java中的最基类Object已经提供了clone方法, 来方便我们复制出新的对象实例.

扩展阅读一

上述故事中, 我们在某些加了注1, 注2的标签. 这就是我们今天的扩展阅读一要注意的内容:

注1 浅拷贝
注2 深拷贝

其实, 跟随故事我们也大致了解了浅拷贝和深拷贝的区别:

  • 浅拷贝对于要克隆的对象, 会复制其基本数据类型(包括String)的属性(本例中的name属性)的给新的对象. 而对于非基本数据类型的属性(本例中的drinks), 仅仅复制一份引用给新产生的对象, 即新产生的对象和原始对象中的非基本数据类型的属性都指向的是同一个对象.
  • 深拷贝 对于要克隆的对象, clone出的非基本数据类型的属性(要求属性也实现了Cloneable接口, ArrayList就已经自带实现了)不再是和原对象指向同一个对象了, 而是一个新的clone出来的属性对象实例.

如下:

扩展阅读二

如果我们查看java源码, 可以发现, 我们调用的clone()方法是Object对象的. 而不是Cloneable接口的. 那么我们为什么要实现Cloneable接口呢? 不识闲Cloneable接口可否调用Object的clone()方法呢?

我们先来看下Cloneable接口的源码:

1
2
public interface Cloneable {
}

发现其中并没有任何方法. 幸运的是Java源码的java doc注释足够清晰:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/**
* A class implements the <code>Cloneable</code> interface to
* indicate to the {@link java.lang.Object#clone()} method that it
* is legal for that method to make a
* field-for-field copy of instances of that class.
* <p>
* Invoking Object's clone method on an instance that does not implement the
* <code>Cloneable</code> interface results in the exception
* <code>CloneNotSupportedException</code> being thrown.
* <p>
* By convention, classes that implement this interface should override
* <tt>Object.clone</tt> (which is protected) with a public method.
* See {@link java.lang.Object#clone()} for details on overriding this
* method.
* <p>
* Note that this interface does <i>not</i> contain the <tt>clone</tt> method.
* Therefore, it is not possible to clone an object merely by virtue of the
* fact that it implements this interface. Even if the clone method is invoked
* reflectively, there is no guarantee that it will succeed.
*/

大体我们可以理解几点:

  1. Cloneable可以看着是一个标识, 实现了改接口的类才能合法地调用其从Object类中继承而来的clone()方法.
  2. 如果没有实现Cloneable接口而调用clone()方法, 会触发CloneNotSupportedException异常.
  3. 实现Cloneable接口的类应当重写Object的clone()方法.

扩展阅读三

原型模式也是一种创建型的设计模式, 一般会结合工厂模式一起使用, 来构建对象. 本例中就不扩展了.


好了, 小光热干面创业街分店开张啦, 吃热干面赠雪碧了, 欢迎大家光临, 欢迎大家关注.