【java设计模式】之工厂（Factory）模式

系统管理员 2022-06-11 07:59 202阅读 0赞

# 1.工厂模式的定义 #

工厂模式使用的频率非常高，我们在开发中总能见到它们的身影。其定义为：Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.即定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。工厂方法模式的通用类图如下所示：

![20160422205946442][]

如图所示，Product抽象类负责定义产品的共性，实现对事物最抽象的定义，Creator为抽象工厂类，具体如何创建产品类由具体的实现工厂ConcreteCreator来完成。我们来看一下通用的模板代码：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **abstract** **class** Product \{  
2.        
3.      **public** **void** method() \{ //产品类的公共方法，已经实现  
4.          //实现了公共的逻辑  
5.      \}  
6.        
7.      **public** **abstract** **void** method2(); //非公共方法，需要子类具体实现  
8.  \}

具体产品类可以有多个，都继承与抽象类Product，如下：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **class** ConcreateProduct1 **extends** Product \{  
2.        
3.      @Override  
4.      **public** **void** method2() \{  
5.          //product1的业务逻辑  
6.      \}  
7.  \}  
8.  **public** **class** ConcreateProduct2 **extends** Product \{  
9.    
10.     @Override  
11.     **public** **void** method2() \{  
12.         //product2的业务逻辑  
13.     \}  
14. \}

抽象工厂类负责定义产品对象的产生，代码如下：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **abstract** **class** Creator \{  
2.      //创建一个产品对象，其输入参数类型可以自行设置  
3.      **public** **abstract** <T **extends** Product> T createProduct(Class<T> clazz);  
4.  \}

这里用的是泛型，传入的对象必须是Product抽象类的实现类。具体如何产生一个产品的对象，是由具体工厂类实现的，具体工厂类继承这个抽象工厂类：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **class** ConcreteCreator **extends** Creator \{  
2.    
3.      @Override  
4.      **public** <T **extends** Product> T createProduct(Class<T> clazz) \{  
5.          Product product = **null**;  
6.          **try** \{  
7.              product = (Product) Class.forName(clazz.getName()).newInstance();  
8.          \} **catch** (Exception e) \{ //异常处理  
9.              e.printStackTrace();  
10.         \}  
11.         **return** (T) product;  
12.     \}  
13. \}

通过这样的设计，我们就可以在测试类中随意生产产品了，看下面的测试类：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **class** FactoryTest \{  
2.    
3.      **public** **static** **void** main(String\[\] args) \{  
4.          Creator factory = **new** ConcreteCreator();  
5.          Product product1 = factory.createProduct(ConcreteProduct1.**class**); //通过不同的类创建不同的产品  
6.          Product product2 = factory.createProduct(ConcreteProduct2.**class**);  
7.           /\* 
8.            \* 下面继续其他业务处理 
9.            \*/  
10.      \}  
11. \}

下面举个女娲造人的例子阐述一下工厂模式的实际应用。

# 2.用女蜗造人阐述工厂模式 #

现在女娲要造人，她要造三种人：白种人、黄种人和黑种人。怎么造呢？她得有个能产生人类的工厂吧（类似于八卦炉的东西），这个工厂得让她生产出不同的人种。每个人都有两个属性：皮肤颜色和说话。那现在我们开始设计女蜗造人的程序，首先我们看一下造人的类图：

![20160422213053231][]

抽象接口Human是人类，里面有两个方法，getColor获得皮肤颜色，talk交谈。下面三个具体Human的实现类，分别实现三个人种。根据工厂模式，应该有个抽象工厂，AbstractHumanFactory就担当了这个责任，里面有个抽象方法createHuman，那HumanFactory就是实现类了，实现抽象工厂里的方法。下面我们看看具体实现：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **interface** Human \{      
2.      **public** **void** getColor();//人有不同的颜色      
3.      **public** **void** talk(); //人会说话  
4.  \}

接下来对Human接口的不同实现：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **class** BlackHuman **implements** Human \{ // 黑种人  
2.    
3.      @Override  
4.      **public** **void** getColor() \{  
5.          System.out.println("Black");  
6.      \}  
7.      @Override  
8.      **public** **void** talk() \{  
9.          System.out.println("Black man");  
10.     \}  
11. \}  
12. **public** **class** Human **implements** Human \{   //黄种人  
13.   
14.     @Override  
15.     **public** **void** getColor() \{  
16.         System.out.println("Yellow");  
17.     \}  
18.     @Override  
19.     **public** **void** talk() \{  
20.         System.out.println("Yellow man");  
21.     \}  
22. \}  
23. **public** **class** WhiteHuman **implements** Human \{ //白种人  
24.   
25.     @Override  
26.     **public** **void** getColor() \{  
27.         System.out.println("White");  
28.     \}  
29.     @Override  
30.     **public** **void** talk() \{  
31.         System.out.println("White man");  
32.     \}  
33. \}

好了，人的模子搞好了，现在女娲要开始搭建八卦炉了，于是女娲开始画八卦炉模型了：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **abstract** **class** AbstractHumanFactory\{  
2.      **public** **abstract** <T **extends** Human> T createHuman(Class<T> clazz); //注意这里T必须是Human的实现类才行，因为要造Human嘛  
3.  \}

然后女娲开始具体实现这个八卦炉了……

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **class** HumanFactory **extends** AbstractHumanFactory \{  
2.    
3.      @Override  
4.      **public** <T **extends** Human> T createHuman(Class<T> clazz) \{  
5.          Human human = **null**;  
6.          **try** \{  
7.              human = (Product) Class.forName(clazz.getName()).newInstance();  
8.          \} **catch** (Exception e) \{ //异常处理  
9.              System.out.println("人种产生错误");  
10.         \}  
11.         **return** (T) human;  
12.     \}  
13. \}

好，现在人种也有了，八卦炉也有了，剩下的就是采集黄土，然后命令八卦炉开始生产了：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **class** FactoryTest \{  
2.      **public** **static** **void** main(String\[\] args) \{  
3.          AbstractHumanFactory bagualu = **new** HunmanFactory();  
4.          Human blackMan = bagualu.createHuman(BlackHuman.**class**); //黑人诞生了  
5.          Human yellowMan = bagualu.createHuman(YelloHuman.**class**); //黄人诞生了  
6.          Human whiteMan = bagualu.createHuman(WhiteHuman.**class**); //白人诞生了  
7.        \}  
8.  \}

女娲就是这么把人造出来的……这就是工厂模式！

# 3.工厂模式的扩展 #

## 3.1 静态工厂模式 ##

我们还用上面女娲造人的例子说明，现在女娲在思考一个问题：我现在只需要一个工厂就可以把人生产出来，我干嘛要具体的工厂对象呢？我只要使用静态方法就好了。这样一想，于是女娲就开始把AbstractHumanFactory抽象类去掉了，只保留了HumanFactory类，同时把createHuman方法设置成了static类型，搞定！

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **class** HumanFactory \{  
2.    
3.      @Override  
4.      **public** **static** <T **extends** Human> T createHuman(Class<T> clazz) \{  
5.          Human human = **null**;  
6.          **try** \{  
7.              human = (Product) Class.forName(clazz.getName()).newInstance();  
8.          \} **catch** (Exception e) \{ //异常处理  
9.              System.out.println("人种产生错误");  
10.         \}  
11.         **return** (T) human;  
12.     \}  
13. \}

然后女娲造人的时候就不用new什么八卦炉了，直接用HumanFactory类调用就行了：

**\[java\]**  [view plain][]   [copy][view plain]

1.  Human blackMan = HumanFactory.createHuman(BlackHuman.**class**);

这就是静态工厂模式，在实际项目中，根据需求可以设置成静态工厂类，但是缺点是扩展比较困难，如果就一个工厂，不需要扩展，可以这么设计，仍然是很常用的。

## 3.2 多个工厂模式 ##

我们还以女娲造人为例，后来女娲想了想，，这人不可能就说话吧，还得有不同的属性杀的，如果在一个八卦炉里造，除了new一个人外，还得对不同的人设置不同的属性，这样的话，八卦炉有点吃不消阿……又有点乱啊……但是她想到了一个法子，每个人种弄个八卦炉，不同的八卦炉专门生产不同的人种，这样就结构清晰了，她在造人的时候自己选择与哪个八卦炉相关联就行了。示意图如下：

![20160422222340068][]

这样的话AbstractHumanFactory抽象类我们就要改写了：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **abstract** **class** AbstractHumanFactory \{  
2.      **public** **abstract** Human createHuman();  
3.  \}

注意抽象方法中已经不需要再传递相关类的参数了，因为每个具体的工厂都已经非常明确自己的职责：创建自己负责的产品类对象。所以不同的工厂实现自己的createHuman方法即可：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **class** BlackHumanFactory **extends** AbstractHumanFactory \{  
2.      **public** Human createHuman() \{  
3.          **return** **new** BlackHuman();  
4.      \}  
5.  \}  
6.  **public** **class** YellowHumanFactory **extends** AbstractHumanFactory \{  
7.      **public** Human createHuman() \{  
8.          **return** **new** YellowHuman();  
9.      \}  
10. \}  
11. **public** **class** WhiteHumanFactory **extends** AbstractHumanFactory \{  
12.     **public** Human createHuman() \{  
13.         **return** **new** WhiteHuman();  
14.     \}  
15. \}

这样三个不同的工厂就产生了，每个工厂对应只生产自己对应的人种。所以现在女娲造人就可以不用一个八卦炉了，分工协作，各不影响了！

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **class** FactoryTest \{  
2.      **public** **static** **void** main(String\[\] args) \{  
3.          Human blackMan = **new** BlackHumanFactory().createHuman(); //黑人诞生了  
4.          Human yellowMan = **new** YellowHumanFactory().createHuman(); //黄人诞生了  
5.          Human whiteMan = **new** WhiteHumanFactory().createHuman(); //白人诞生了  
6.        \}  
7.  \}

这种工厂模式的好处是职责清晰，结构简单，但是给扩扩展性和可维护性带来了一定的影响，因为如果要扩展一个产品类，就需要建立一个相应的工厂类，这样就增加了扩展的难度。因为工厂类和产品类的数量是相同的，维护时也需要考虑两个对象之间的关系。但是这种模式还是很常用的。

## 3.3 替代单例模式 ##

上一章介绍了单例模式，并且指出了单例和多例的一些缺点，但是我们是不是可以采用工厂模式来实现一个单例模式的功能呢？答案是肯定的，单例模式的核心要求就是在内存中只有一个对象，通过工厂方法模式也可以只在内存中生产一个对象。见下面：

Singleton类定义了一个private的无参构造方法，目的是不允许通过new的方式创建对象，另外，Singleton类也不自己定义一个Singleton对象了，因为它要通过工厂来获得。

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **class** Singleton \{  
2.      **private** Singleton() \{  
3.            
4.      \}  
5.      **public** **void** doSomething() \{  
6.          //业务处理  
7.      \}  
8.  \}

既然Singleton不能通过正常的渠道建立一个对象，那SingletonFactory如何建立一个单例对象呢？答案是通过反射方式创建：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **class** SingletonFactory \{  
2.      **private** **static** Singleton instance;  
3.      **static** \{  
4.          **try** \{         
5.              Class clazz = Class.forName(Singleton.**class**.getName());  
6.              //获取无参构造方法  
7.              Constructor constructor = clazz.getDeclaredConstructor();  
8.              //设置无参构造方法可访问  
9.              constructor.setAccessible(**true**);  
10.             //产生一个实例对象  
11.             instance = (Singleton) constructor.newInstance();  
12.         \} **catch** (Exception e) \{  
13.             //异常处理  
14.         \}  
15.     \}  
16.     **public** **static** Singleton getInstance() \{  
17.         **return** instance;  
18.     \}  
19. \}

以上通过工厂方法模式创建了一个单例对象，该框架可以继续扩展，在一个项目中可以产生一个单例构造器，所有需要产生单例的类都遵循一定的规则（构造方法是private），然后通过扩展该框架，只要输入一个类型就可以获得唯一的一个实例。

## 3.4 延迟初始化 ##

何为延迟初始化（Lazy initialization）？即一个对象被使用完毕后，并不立刻释放，工厂类保持其初始状态，等待再次被使用。延迟初始化是工厂模式的一个扩展应用，其通用类表示如下：

![20160422231331981][]

ProductFactory负责产品类对象的创建工作，并且通过prMap变量产生一个缓存，对需要再次被重用的对象保留：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **class** ProductFactory \{  
2.      **private** **static** **final** Map<String, Product> prMap = **new** HashMap();  
3.      **public** **static** **synchronized** Product createProduct(String type) **throws** Exception \{  
4.          Product product = **null**;  
5.          //如果Map中已经有这个对象  
6.          **if**(prMap.containsKey(type)) \{  
7.              product = prMap.get(type);  
8.          \} **else** \{  
9.              **if**(type.equals("Product1")) \{  
10.                 product = **new** ConcreteProduct1();  
11.             \}  
12.             **else** \{  
13.                 product = **new** ConcreteProduct2();  
14.             \}  
15.             prMap.put(type, product);  
16.         \}  
17.         **return** product;  
18.     \}  
19. \}

代码比较简单，通过定义一个Map容器，容纳所有产生的对象，每次在new一个对象的时候先判断Map中有没有，有就不用再new了，直接取。另外，每次new过一个对象后，也将其放入Map中方便下次调用。

延迟加载时很有用的，比如JDBC连接[数据库][Link 1]，会要求设置一个MaxConnections最大连接数量，该数量就是内存中最大实例化的数量。

# 4. 工厂模式的应用 #

优点：

1. 工厂模式具有良好的封装性，代码结构清晰，也有利于扩展。在增加产品类的情况下，只需要适当地修改具体的工厂类或扩展一个工厂类，就可以完成“拥抱变化”。

2. 工厂模式可以屏蔽产品类。这一点非常重要，产品类的实现如何变化，调用者都不用关系，只需要关心产品的接口，只要接口保持不变，系统的上层模块就不需要发生变化。

3. 工厂模式是典型的解耦框架。高层模块只需要知道产品的抽象类，其他的实现类都不用关心。

工厂模式就介绍这么多吧，如果错误之处，欢迎留言指正~

相关阅读：[http://blog.csdn.net/column/details/des-pattern.html][http_blog.csdn.net_column_details_des-pattern.html]

**\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_****\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_**

\-----乐于分享，共同进步！

\-----更多文章请看：[http://blog.csdn.net/eson\_15][http_blog.csdn.net_eson_15]

[20160422205946442]: /images/20220611/78ffc185c5954128adee06c60eb7bfaa.png
[view plain]: http://blog.csdn.net/eson_15/article/details/51223124#
[20160422213053231]: /images/20220611/f8f2f0a4dcd44189a52b91b7514a8b12.png
[20160422222340068]: /images/20220611/8dd78e7132944c16af60322c8f7b2e8d.png
[20160422231331981]: /images/20220611/3e08ed949a1b41aa815c8974fc4e2e43.png
[Link 1]: http://lib.csdn.net/base/mysql
[http_blog.csdn.net_column_details_des-pattern.html]: http://blog.csdn.net/column/details/des-pattern.html
[http_blog.csdn.net_eson_15]: http://blog.csdn.net/eson_15