学点设计模式-工厂方法模式

工厂方法模式

女娲补天的故事大家都听说过吧，今天不说这个，说女娲创造人的故事，可不是“造人”的工作，这

个词被现代人滥用了。这个故事是说，女娲在补了天后，下到凡间一看，哇塞，风景太优美了，天空是湛

蓝的，水是清澈的，空气是清新的，太美丽了，然后就待时间长了就有点寂寞了，没有动物，这些看的到

都是静态的东西呀，怎么办？

别忘了是神仙呀，没有办不到的事情，于是女娲就架起了八卦炉（技术术语：建立工厂）开始创建人，

具体过程是这样的：先是泥巴捏，然后放八卦炉里烤，再扔到地上成长，但是意外总是会产生的：

第一次烤泥人，兹兹兹兹~~，感觉应该熟了，往地上一扔，biu~，一个白人诞生了，没烤熟！

第二次烤泥人，兹兹兹兹兹兹兹兹~~，上次都没烤熟，这次多烤会儿，往地上一扔，嘿，熟过头了，

黑人哪！

第三次烤泥人，兹~兹~兹~，一边烤一边看着，嘿，正正好，Perfect！优品，黄色人种！【备注:RB 人

不属此列】

这个过程还是比较有意思的，先看看类图：（之前在论坛上有兄弟建议加类图和源文件，以后的模式都

会加上去，之前的会一个一个的补充，目的是让大家看着舒服，看着愉悦，看着就想要，就像是看色情小

说一样，目标，目标而已，能不能实现就看大家给我的信心了）

package com.cbf4life.MethodFactory;

public interface Human {
// 首先定义什么是人类
// 人是愉快的，会笑的，本来是想用smile表示，想了一下laugh更合适，好长时间没有大笑了；
public void laugh();

// 人类还会哭，代表痛苦
public void cry();

// 人类会说话
public void talk();

}

package com.cbf4life.MethodFactory;
/**
* @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you
*         all. 黄色人种，这个翻译的不准确，将就点吧
*/
public class YellowHuman implements Human {
public void cry() {
System.out.println("黄色人种会哭");
}
public void laugh() {
System.out.println("黄色人种会大笑，幸福呀！");
}
public void talk() {
System.out.println("黄色人种会说话，一般说的都是双字节");
}
}

package com.cbf4life.MethodFactory;

/**
* @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you
*         all. 白色人种
*/
public class WhiteHuman implements Human {
public void cry() {
System.out.println("白色人种会哭");
}

public void laugh() {
System.out.println("白色人种会大笑，侵略的笑声");
}

public void talk() {
System.out.println("白色人种会说话，一般都是但是单字节！");
}
}

package com.cbf4life.MethodFactory;
/**
* @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you
*         all. 黑色人种，记得中学学英语，老师说black man是侮辱人的意思，不懂，没跟老外说话
*/
public class BlackHuman implements Human {
public void cry() {
System.out.println("黑人会哭");
}
public void laugh() {
System.out.println("黑人会笑");
}
public void talk() {
System.out.println("黑人可以说话，一般人听不懂");
}
}

package com.cbf4life.MethodFactory;
import java.util.List;
import java.util.Random;
/**
* @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you
*         all. 今天讲女娲造人的故事，这个故事梗概是这样的： 很久很久以前，盘古开辟了天地，用身躯造出日月星辰、山川草木，天地一片繁华 One
*         day，女娲下界走了一遭，哎！太寂寞，太孤独了，没个会笑的、会哭的、会说话的东东
*         那怎么办呢？不用愁，女娲，神仙呀，造出来呀，然后捏泥巴，放八卦炉（后来这个成了太白金星的宝 贝）中烤，于是就有了人：
*         我们把这个生产人的过程用Java程序表现出来：
*/
public class HumanFactory {
// 定一个烤箱，泥巴塞进去，人就出来，这个太先进了
public static Human createHuman(Class c) {
Human human = null; // 定义一个类型的人类
try {
human = (Human) Class.forName(c.getName()).newInstance(); // 产生一个人种
} catch (InstantiationException e) {// 你要是不说个人种颜色的话，没法烤，要白的黑，你说话了才好烤
System.out.println("必须指定人种的颜色");
} catch (IllegalAccessException e) { // 定义的人种有问题，那就烤不出来了，这是...
System.out.println("人种定义错误！");
} catch (ClassNotFoundException e) { // 你随便说个人种，我到哪里给你制造去？！
System.out.println("混蛋，你指定的人种找不到！");
}
return human;
}
}

这样这个世界就热闹起来了，人也有了，但是这样创建太累了，神仙也会累的，那怎么办？神仙就想

了：我塞进去一团泥巴，随机出来一群人，管他是黑人、白人、黄人，只要是人就成（你看看，神仙都偷

懒，何况是我们人），先修改类图：

package com.cbf4life.MethodFactory;

import java.util.List;
import java.util.Random;

public class AutoHumanFactory {
// 定一个烤箱，泥巴塞进去，人就出来，这个太先进了
public static Human createHuman(Class c) {
Human human = null; // 定义一个类型的人类
try {
human = (Human) Class.forName(c.getName()).newInstance(); // 产生一个人种
} catch (InstantiationException e) {// 你要是不说个人种颜色的话，没法烤，要白的黑，你说话了才好烤
System.out.println("必须指定人种的颜色");
} catch (IllegalAccessException e) { // 定义的人种有问题，那就烤不出来了，这是...
System.out.println("人种定义错误！");
} catch (ClassNotFoundException e) { // 你随便说个人种，我到哪里给你制造去？！
System.out.println("混蛋，你指定的人种找不到！");
}
return human;
}

// 女娲生气了，把一团泥巴塞到八卦炉，哎产生啥人种就啥人种
public static Human createHuman() {
Human human = null; // 定义一个类型的人类
// 首先是获得有多少个实现类，多少个人种
List<Class> concreteHumanList = ClassUtils
.getAllClassByInterface(Human.class); // 定义了多少人种
// 八卦炉自己开始想烧出什么人就什么人
Random random = new Random();
int rand = random.nextInt(concreteHumanList.size());
human = createHuman(concreteHumanList.get(rand));
return human;
}

}

package com.cbf4life.MethodFactory;

/**
* @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you
*         all. 首先定义女娲，这真是额的神呀
*/

public class NvWaAuto {
public static void main(String[] args) {
// 女娲第一次造人，试验性质，少造点，火候不足，缺陷产品
System.out.println("------------造出的第一批人是这样的：白人-----------------");
Human whiteHuman = HumanFactory.createHuman(WhiteHuman.class);
whiteHuman.cry();
whiteHuman.laugh();
whiteHuman.talk();
// 女娲第二次造人，火候加足点，然后又出了个次品，黑人
System.out.println("\n\n------------造出的第二批人是这样的：黑人-----------------");
Human blackHuman = HumanFactory.createHuman(BlackHuman.class);
blackHuman.cry();
blackHuman.laugh();
blackHuman.talk();
// 第三批人了，这次火候掌握的正好，黄色人种（不写黄人，免得引起歧义），备注：RB人不属于此列
System.out.println("\n\n------------造出的第三批人是这样的：黄色人种-----------------");
Human yellowHuman = HumanFactory.createHuman(YellowHuman.class);
yellowHuman.cry();
yellowHuman.laugh();
yellowHuman.talk();
// 女娲烦躁了，爱是啥人种就是啥人种，烧吧
for (int i = 0; i < 100; i++) {
System.out.println("\n\n------------随机产生人种了-----------------" + i);
Human human = AutoHumanFactory.createHuman();
human.cry();
human.laugh();
human.talk();
}
}
}

哇，这个世界热闹了！，不过还没有完毕，这个程序你跑不起来，还要有这个类：

package com.cbf4life.MethodFactory;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;

/**
* @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you
*         all.
*
*/
@SuppressWarnings("all")
public class ClassUtils {
// 给一个接口，返回这个接口的所有实现类
public static List<Class> getAllClassByInterface(Class c) {
List<Class> returnClassList = new ArrayList<Class>(); // 返回结果
// 如果不是一个接口，则不做处理
if (c.isInterface()) {
String packageName = c.getPackage().getName(); // 获得当前的包名
try {
List<Class> allClass = getClasses(packageName); // 获得当前包下以及子包下的所有类
// 判断是否是同一个接口
for (int i = 0; i < allClass.size(); i++) {
if (c.isAssignableFrom(allClass.get(i))) { // 判断是不是一个接口
if (!c.equals(allClass.get(i))) { // 本身不加进去
returnClassList.add(allClass.get(i));
}
}
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}

}
return returnClassList;
}

// 从一个包中查找出所有的类，在jar包中不能查找
private static List<Class> getClasses(String packageName)
throws ClassNotFoundException, IOException {
ClassLoader classLoader = Thread.currentThread()
.getContextClassLoader();
String path = packageName.replace('.', '/');
Enumeration<URL> resources = classLoader.getResources(path);
List<File> dirs = new ArrayList<File>();
while (resources.hasMoreElements()) {
URL resource = resources.nextElement();
dirs.add(new File(resource.getFile()));
}
ArrayList<Class> classes = new ArrayList<Class>();
for (File directory : dirs) {
classes.addAll(findClasses(directory, packageName));
}
return classes;
}

private static List<Class> findClasses(File directory, String packageName)
throws ClassNotFoundException {
List<Class> classes = new ArrayList<Class>();
if (!directory.exists()) {
return classes;
}
File[] files = directory.listFiles();
for (File file : files) {
if (file.isDirectory()) {
assert !file.getName().contains(".");
classes.addAll(findClasses(file,
packageName + "." + file.getName()));
} else if (file.getName().endsWith(".class")) {
classes.add(Class.forName(packageName
+ '.'
+ file.getName().substring(0,
file.getName().length() - 6)));
}
}
return classes;
}

}

告诉你了，这个ClassUtils 可是个宝，用处可大了去了，可以由一个接口查找到所有的实现类，也可

以由父类查找到所有的子类，这个要自己修改一下，动脑筋想下，简单的很！完整的类图如下：



我们来总结一下，特别是增加了createHuman()后，是不是这个工厂的扩展性更好了？你看你要再加一

个人种，只要你继续集成Human 接口成了，然后啥都不用修改就可以生产了，具体产多少，那要八卦炉说

了算，简单工厂模式就是这么简单，那我们再引入一个问题：人是有性别的呀，有男有女，你这怎么没区

别，别急，这个且听下回分解！

工厂方法模式还有一个非常重要的应用，就是延迟始化(Lazy initialization)，什么是延迟始化呢？

一个对象初始化完毕后就不释放，等到再次用到得就不用再次初始化了，直接从内存过中拿到就可以了，

怎么实现呢，很简单，看例子：

package com.cbf4life.MethodFactory;

import java.util.HashMap;

/**
* @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you
*         all.
*/
@SuppressWarnings("all")
public class LazyHumanFactory {
// 定义一个MAP,初始化过的Human对象都放在这里
private static HashMap<String, Human> humans = new HashMap<String, Human>();

// 定一个烤箱，泥巴塞进去，人就出来，这个太先进了
public static Human createHuman(Class c) {
Human human = null; // 定义一个类型的人类
try {
// 如果MAP中有，则直接从取出，不用初始化了
if (humans.containsKey(c.getSimpleName())) {
human = humans.get(c.getSimpleName());
} else {
human = (Human) Class.forName(c.getName()).newInstance();
// 放到MAP中
humans.put(c.getSimpleName(), human);
}
} catch (InstantiationException e) {// 你要是不说个人种颜色的话，没法烤，要白的黑，你说话了才好烤
System.out.println("必须指定人种的颜色");
} catch (IllegalAccessException e) { // 一定定义的人种有问题，那就烤不出来了，这是...
System.out.println("人种定义错误！");
} catch (ClassNotFoundException e) { // 你随便说个人种，我到哪里给你制造去？！
System.out.println("混蛋，你指定的人种找不到！");
}
return human;
}

}

很简单，就加上了黄色那部分的代码，这个在类初始化很消耗资源的情况比较实用，比如你要连接硬

件，或者是为了初始化一个类需要准备比较多条件（参数），通过这种方式可以很好的减少项目的复杂程度。

工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，

达到提高灵活性的目的。

工厂模式在《Java 与模式》中分为三类：

1）简单工厂模式（Simple Factory）

2）工厂方法模式（Factory Method）

3）抽象工厂模式（Abstract Factory）

这三种模式从上到下逐步抽象，并且更具一般性。

简单工厂模式

简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存

在的目的很简单：定义一个用于创建对象的接口。

先来看看它的组成：

1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由

一个具体类实现。

2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽

象类来实现。

3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

工厂方法模式

工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这

样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分

担。

你应该大致猜出了工厂方法模式的结构，来看下它的组成：

1) 抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须

实现的接口或者必须继承的父类。在java 中它由抽象类或者接口来实现。

2) 具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体

产品的对象。

3) 抽象产品角色：它是具体产品继承的父类或者是实现的接口。在 java 中一般有抽象类

或者接口来实现。

4) 具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在 java 中由具体的类

来实现。

小结

工厂方法模式仿佛已经很完美的对对象的创建进行了包装，使得客户程序中仅仅处理抽

象产品角色提供的接口。那我们是否一定要在代码中遍布工厂呢？大可不必。也许在下面情

况下你可以考虑使用工厂方法模式：

1) 当客户程序不需要知道要使用对象的创建过程。

2) 客户程序使用的对象存在变动的可能，或者根本就不知道使用哪一个具体的对象。