架构分析与设计模式.docx

架构分析与设计模式

21
2020年4月19日
文档仅供参考
摘要：一个设计模式是针对某一类问题的最佳解决方案，而且已经成功应用于许多系统的设计中，它解决了在某种特定情境中重复发生的某个问题，因此设计模式能够被定义为：设计模式是从许多优秀的软件系统中总结出成功的可复用的设计方案。
1. 关键字：工厂方法模式、简单的程序实现、架构分析、设计模式

工厂方法模式

2. 工厂方法模式的介绍
工厂方法(Factory Method)模式的意义是定义一个创立产品对象的工厂接口，将实际创立工作推迟到子类当中。核心工厂类不再负责产品的创立，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式能够使系统在不修改具体工厂角色的情况下引进新的产品。

1.1工厂方法模式角色与结构
抽象工厂(Creator)角色：是工厂方法模式的核心，与应用程序无关。任何在模式中创立的对象的工厂类必须实现这个接口。

具体工厂(Concrete Creator)角色：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，而且受到应用程序调用以创立产品对象。

抽象产品(Product)角色：工厂方法模式所创立的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。在上图中，这个角色是Light。

具体产品(Concrete Product)角色：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创立，它们之间往往一一对应。

1.2工厂方法模式的应用
工厂方法经常见在以下两种情况中:
第一种情况是对于某个产品，调用者清楚地知道应该使用哪个具体工厂服务，实例化该具体工厂，生产出具体的产品来。Java Collection中的iterator() 方法即属于这种情况。
第二种情况，只是需要一种产品，而不想知道也不需要知道究竟是哪个工厂为生产的，即最终选用哪个具体工厂的决定权在生产者一方，它们根据当前系统的情况来实例化一个具体的工厂返回给使用者，而这个决策过程这对于使用者来说是透明的。

1.3工厂方法模式的适用环境
在以下情况下能够使用工厂方法模式：
（1）一个类不知道它所需要的对象的类：在工厂方法模式中，客户端不需要知
道具体产品类的类名，只需要知道所对应的工厂即可，具体的产品对象由具体工
厂类创立；客户端需要知道创立具体产品的工厂类。

（2）一个类经过其子类来指定创立哪个对象：在工厂方法模式中，对于抽象工
厂类只需要提供一个创立产品的接口，而由其子类来确定具体要创立的对象，
利用面向对象的多态性和里氏代换原则，在程序运行时，子类对象将覆盖父类对象，从而使得系统更容易扩展。

（3）将创立对象的任务委托给多个工厂子类中的某一个，客户端在使用时能够
无需关心是哪一个工厂子类创立产品子类，需要时再动态指定，可将具体工厂类
的类名存储在配置文件或数据库中。

2简单的程序实现
下面是一个简单的水果生产程序，描述农场种植水果的过程，目的是经过此次设计更进一步了解工程设计模式，加强编程的结构化能力。

2.1程序设计
程序设计如下：
在这个系统里需要描述下列的水果：
葡萄Grape
草莓Strawberry
苹果Apple
水果生产的过程就是生长，成熟后采摘。那么一个自然的作法就是建立一个各种水果都适用的接口，以便与农场里的其它植物区分开。水果接口规定出所有的水果必须实现的接口，包括任何水果类必须具备的方法：种植plant()，生长grow()以及收获harvest()。

代码清单1：接口Fruit 的源代码

public interface Fruit {
// 生长
void grow();

//收获
void harvest();

//种植
void plant();
}

Apple 类是水果类的一种，因此它实现了水果接口所声明的所有方法。另外，由于苹果是多年生植物，因此多出一个

treeAge 性质，描述苹果树的树龄。下面是这个苹果类的源代码。

代码清单2：类Apple 的源代码

public class Apple
implements Fruit {

private int treeAge;

//生长

public void grow() {

log("Apple is growing...");

}

// 收获

public void harvest() {

log("Apple has been harvested.");

}

//种植

public void plant() {
log("Apple has been planted.");

}

//
private boolean seedless;

//生长
public void grow() {
log("Grape is growing...");

}

//收获
public void harvest() {
log("Grape has been harvested.");

}
//种植
public void plant() {
log("Grape has been planted.");
}

//辅助方法
public static void log(String msg) {
System.out.println(msg);
}
// 有无籽的取值方法
public boolean getSeedless() {
return seedless;
}
//有无籽的赋值方法
public void setSeedless(boolean seedless) {
this.seedless = seedless;

}

}
Strawberry 类实现了Fruit 接口，因此，也是水果类型的子类型，其源代码如下所示。
代码清单4：类Strawberry 的源代码
public class Strawberry
implements Fruit {

//生长
public void grow() {
log("Strawberry is growing...");
}

//收获

public void harvest() {

log("Strawberry has been harvested.");

}

//

种植
public void plant() {
log("Strawberry has been planted.");

}

//

辅助方法
public static void log(String msg) {

System.out.println(msg);

}

}

农场的园丁也是系统的一部分，自然要由一个合适的类来代表。这个类就

FruitGardener

类，其结构由下面描述。
FruitGardener

类会根据客户端的要求，创立出不同的水果对象，比如苹果

（

Apple

），葡萄（

Grape

）或草莓（

Strawberry

）的实例。而如果接到不合法的

要求，

FruitGardener

类会抛出

BadFruitException

异常。

园丁类的源代码如下所示。代码清单5：

FruitGardener

类的源代码
public class FruitGardener {

//

静态工厂方法
public static Fruit factory(String which) throws BadFruitException {
if (which.equalsIgnoreCase("apple")) {
return new Apple();
}
else if (which.equalsIgnoreCase("strawberry")) {
return new Strawberry();
}
else if (which.equalsIgnoreCase("grape")) {
return new Grape();
}
else {
throw new BadFruitException("Bad fruit request");
}

}

}

能够看出，园丁类提供了一个静态工厂方法。在客户端的调用下，这个方法创

建客户端所需要的水果对象。

如果客户端的请求是系统所不支持的，

工厂方法就

会抛出一个

BadFruitException

异常。这个异常类的源代码如下所示。
辅助方法
public static void log(String msg) {
System.out.println(msg);

}
//

树龄的取值方法
public int getTreeAge() {
return treeAge;

}

//

树龄的赋值方法
public void setTreeAge(int treeAge) {
this.treeAge = treeAge;

}

}

代码清单

6

：

BadFruitException

类的源代码
public class BadFruitException
extends Exception {

public BadFruitException(String msg) {
super(msg);

}

}

在使用时，客户端只需调用

FruitGardener

的静态方法

factory()

即可。请见

下面的示意性客户端源代码。
代码清单

7

：实现种植即

Main()

的实现

public class PlantFruit {

public PlantFruit() {

}
public static void main(String[] args) {
PlantFruit plantfruit = new PlantFruit();
try {
//

种植葡萄
FruitGardener.factory("grape").plant();
FruitGardener.factory("grape").grow();
FruitGardener.factory("grape").harvest();
System.out.println("==============================");
//

种植苹果
FruitGardener.factory("apple").plant();
FruitGardener.factory("apple").grow();
FruitGardener.factory("apple").harvest();
System.out.println("==============================");
//

种植草莓
FruitGardener.factory("strawberry").plant();
FruitGardener.factory("strawberry").grow();
FruitGardener.factory("strawberry").harvest();
System.out.println("==============================");
}
catch (BadFruitException e) {
}

}

}

到此为止，我们的简单程序已经设计完成，我们能够经过创立

FruitGardener

对象来完成水果的种植，无论你要种什么，只需调用对象中的

factory()

方法。
工厂类的示意性源代码如下所示。

能够看出，

这个工厂方法创立了一个新的具

体产品的实例并返还给调用者。
代码清单8：Creator 类的源代码
public class Creator

{

//

静态工厂方法

public static Product factory()

{

return new ConcreteProduct();

}

}

抽象产品角色的主要目的是给所有的具体产品类提供一个共同的类型，

在最简单

的情况下，

能够简化为一个标识接口。

所谓标识接口，

就是没有声明任何方法的

空接口。
代码清单9：抽象角色

Product

接口的源代码
public interface Product

{

}

具体产品类的示意性源代码如下。
代码清单10：具体产品角色

ConcreteProduct

类的源代码

public class ConcreteProduct implements Product

{

public ConcreteProduct(){}

}
3、总结
设计模式实际上是良好的思想的一种提炼。每一种设计模式后面都体现
了一种良好的思路。正如程序设计中众多模式一样，工厂模式也不是万能的，也有自己的局限性，在解决问题的过程中，要善于总结发现新的解决方法。世界在发展，技术在进步，总会有新的方法取代旧的方法。