【设计模式】第二章：工厂模式详解及应用案例

系列文章

【设计模式】七大设计原则
【设计模式】第一章：单例模式
【设计模式】第二章：工厂模式
【设计模式】第三章：建造者模式
【设计模式】第四章：原型模式
【设计模式】第五章：适配器模式
【设计模式】第六章：装饰器模式
【设计模式】第七章：代理模式
【设计模式】第八章：桥接模式
【设计模式】第九章：外观模式 / 门面模式
【设计模式】第十章：组合模式
【设计模式】第十一章：享元模式
【设计模式】第十二章：观察者模式
【设计模式】第十三章：模板方法模式
【设计模式】第十四章：策略模式
【设计模式】第十五章：责任链模式
【设计模式】第十六章：迭代器模式
【设计模式】第十七章：状态模式
【设计模式】第十八章：备忘录模式
【设计模式】第十九章：访问者模式
【设计模式】第二十章：解释器模式
【设计模式】第二十一章：命令模式
【设计模式】第二十二章：中介者模式

---

---

一、定义

摘自百度百科：
工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑使用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。

工厂模式为我们提供了一种创建对象的最佳方式，最大的特点是我们在创建对象的时候不会对客户端暴露创建逻辑，通过一个共同的接口去指向新创建的对象。

---

二、实现方式

工厂模式是一种比较统概的说法，实现方式共分为以下几种：

• 简单工厂模式
• 工厂方法模式
• 抽象工厂模式

1. 简单工厂模式

简单工厂模式又叫做静态工厂模式，它是由一个工厂来决定创建出哪一种产品的实例。

（1）角色分类

具体工厂

它负责实现创建实例的内部逻辑，创建方法由外部调用，创建不同的产品

抽象产品

它是所有产品的父类，它负责来描述所有实例的共有的公共接口

具体产品

它是具体被创建的产品，所有被创建的对象都是这个角色下具体某个具体类的实例

（2）应用案例

例如：你肚子饿了，于是你便来到了一家面馆（具体工厂），然后面馆中有各种各样的面（抽象产品），然后可以根据自己的口味来下单合适的面（具体产品）

抽象产品：

/**
 * 抽象产品
 */
public interface Noodles {
	/**
	 * 做面
	 */
	void cook();
}

具体产品

/**
 * 拉面
 */
public class Ramen implements Noodles {
	@Override
	public void cook(){
		System.out.println("正在制作拉面...");
	}
}

/**
 * 汤面
 */
public class SoupNoodles implements Noodles {
	@Override
	public void cook(){
		System.out.println("正在制作汤面...");
	}
}

/**
 * 炒面
 */
public class StirFriedNoodles implements Noodles {
	@Override
	public void cook(){
		System.out.println("正在制作炒面...");
	}
}

具体工厂

/**
 * 具体工厂
 */
public class CookFactory {
	
	/**
	 * 做面
	 * @param type 面条类型
	 */
	public static Noodles cookNoodles(String type) {
		switch (type) {
			case "Ramen":
				return new Ramen();
			case "SoupNoodles":
				return new SoupNoodles();
			case "StirFriedNoodles":
				return new StirFriedNoodles();
			default :
				return null;
		}
	}
}

测试类

public class Test {
	public static void main(String[] args){
		CookFactory factory = new CookFactory();
		
		Ramen ramen = factory.cookNoodles("Ramen");
		ramen.cook();
		SoupNoodles soupNoodles = factory.cookNoodles("SoupNoodles");
		soupNoodles.cook();
		StirFriedNoodles stirFriedNoodles = factory.cookNoodles("StirFriedNoodles");
		stirFriedNoodles.cook();
	}
}

（3）优缺点

优点：

• 将对象的创建与使用隔离开，使用时不必关心对象是如何创建的，并实现了解耦
• 将实例的初始化放到工厂中实现，代码更易维护，并且更贴近面向对象/接口开发原则

缺点：

• 过于依赖工厂，所有的实例都在该工厂中创建，若该工厂出现异常，则涉及工厂的地方都会出现异常
• 违反开闭原则，每次想要新增产品时都需要修改工厂的逻辑，不便于新增

（4）小结

简单工厂可以理解为：通过一个抽象产品，从而派生出其他的具体产品。再通过一个工厂来完成具体产品的创建。

2. 工厂方法模式

工厂方法模式又称为工厂模式，是我们最常用的一种工厂模式，我们通过定义一个工厂的父类，该父类中包含一个创建对象的共有方法，再由其子类去创建具体对象。

（1）角色分类

抽象工厂

负责描述工厂的公共接口

具体工厂

实现了抽象工厂中的抽象方法，负责对象的创建

抽象产品

负责描述产品的公共接口，描述了产品的主要特性或功能

具体产品

实现了抽象产品中的接口，用于被工厂创建

（2）应用案例

比如：你感到肚子饿了想要吃面，这时你来到小吃街（抽象工厂），里面有许多家餐馆，每种餐馆只做一种面（抽象产品），那么你想要去你最喜欢的面馆中（具体工厂）去下单喜欢吃的面条（具体产品）

抽象产品

public abstract class Noodles {
	public abstract void eat();
}

具体产品

public class Ramen extends Noodles {
	
	@Override
	public void eat() {
		System.out.println("我要吃拉面...");
	}
}

public class SoupNoodles extends Noodles {
	
	@Override
	public void eat() {
		System.out.println("我要吃汤面...");
	}
}

public class StirFriedNoodles extends Noodles {
	
	@Override
	public void eat() {
		System.out.println("我要吃炒面...")
	}
}

抽象工厂

public abstract class NoodlesFactory {

	public abstract Noodles getNoodles();
}

具体工厂

/**
 * 拉面
 */
public class RestaurantA extends NoodlesFactory {

	@Override
	public Noodles getNoodles(){
		return new Ramen();
	}
}

/**
 * 汤面
 */
public class RestaurantB extends NoodlesFactory {
	
	@Override
	public Noodles getNoodles() {
		return new SoupNoodles();
	}
}

/**
 * 炒面
 */
public class RestaurantC extends NoodlesFactory {
	
	@Override
	public Noodles getNoodles() {
		return new StirFriedNoodles();
	}
}

测试类

public class Test {
	public static void main(String[] args){
		FactoryA factoryA = new FactoryA();
		factoryA.getNoodles().eat();
		
		FactoryB factoryB = new FactoryB();
		factoryB.getNoodles().eat();
		
		FactoryC factoryC = new FactoryC();
		factoryC.getNoodles().eat();
	}
}

（3）优缺点

优点：

• 符合开闭原则，且可扩展度高，新增加功能只需要增加具体产品和工厂子类即可
• 符合单一职责原则，每个工厂子类只负责对应的产品

缺点：

• 增加了系统复杂度，因为一个工厂只创建一种具体产品，那么类的数量会增加
• 系统会变得更加抽象，不便于理解

（4）小结

工厂方法模式可以理解为：通过一个父类工厂来派生出其他的具体工厂，再通过一个抽象产品派生出其他的具体产品，由对应的具体工厂来创建，且每个具体工厂只负责创建一种具体产品。

3. 抽象工厂模式

抽象工厂模式其实就是升级版的工厂方法模式，它是围绕一个超级工厂创建其他工厂，该超级工厂又称为其他工厂的工厂。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

（1）角色分类

抽象工厂

负责描述工厂的公共接口

具体工厂

负责创建实例，供外部调用

抽象产品族

负责描述抽象产品的公共接口

抽象产品

负责描述具体产品的公共接口

具体产品

具体产品，由工厂创建

（2）应用案例

例如：你肚子感到饿了，你想去吃点东西，于是你来到了小吃街（抽象工厂），这条街有各种各样的食物（抽象产品族），比如主食、小吃等（抽象产品），于是你来到了其中的一家餐馆（具体工厂），里面有汉堡、薯条、炸鸡等食物（具体产品）

抽象产品族

public abstract class Food {
	public abstract void description();
}

抽象产品

public abstract class StapleFood extends Food {
}

public abstract class Snacks extends Food {
}

具体产品

/**
 * 米饭
 */
public class Rice extends StapleFood {
	@Override
	public void description() {
		System.out.println("米饭")
	}
}

/**
 * 面条
 */
public class Noodles extends StapleFood {
	@Override
	public void description() {
		System.out.println("面条");
	}
}

/**
 * 汉堡
 */
public class Hamburger extends Snacks {
	@Override
	public void description() {
		System.out.println("汉堡");
	}
}

/**
 * 薯条
 */
public class Chips extends Snacks {
	@Override
	public void description() {
		System.out.println("薯条");
	}
}

抽象工厂

public abstract class FoodFactory {
	/**
	 * 下单主食
	 */
	public abstract Food getStapleFood();

	/**
	 * 下单小吃
	 */
	 public abstract Food getSnacks();
}

具体工厂

public class StapleFoodFactory extends FoodFactory {
	@Override
	public Food getStapleFood() {
		//下单米饭
		return new Rice();
	}

	@Override
	public Food getSnacks() {
		//下单汉堡
		return new Hamburger();
	}
}

public class SnacksFactory extends FoodFactory {
	@Override
	public Food getStapleFood() {
		//下单面条
		return new Noodles();
	}

	@Override
	public Food getSnacks() {
		//下单薯条
		return new Chips();
	}
}

测试类

public class Test {
	public static void main(String[] args) {
		StapleFoodFactory stapleFactory = new StapleFoodFactory();
		stapleFactory.getStapleFood().description();
		stapleFactory.getSnacks().description();

		System.out.println("----------分割线----------");

		SnacksFactory snacksFactory = new SnacksFactory();
		snacksFactory.getStapleFood().description();
		snacksFactory.getSnacks().description();
	}
}

（3）优缺点

优点：

• 符合开闭原则
• 降低耦合
• 当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：

• 扩展比较麻烦，当需要增加某个产品族的产品时，不仅要在抽象产品中增加代码，还要在具体产品中增加代码

（4）小结

抽象工厂我们可以理解为：首先由抽象工厂派生出多个具体工厂，抽象产品族派生出多个抽象产品，再由抽象产品派生出多个具体产品，由具体工厂来创建具体产品，且同一个具体工厂可以创建多个具体产品

---

三、应用场景

以下部分内容摘自菜鸟教程

意图： 定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
主要解决： 主要解决接口选择的问题。
何时使用： 我们明确地计划不同条件下创建不同实例时。
如何解决： 让其子类实现工厂接口，返回的也是一个抽象的产品。
关键代码： 创建过程在其子类执行。
应用实例：
您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。
Hibernate 换数据库只需换方言和驱动就可以。
优点：
一个调用者想创建一个对象，只要知道其名称就可以了。
扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
屏蔽产品的具体实现，调用者只关心产品的接口。
缺点： 每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。
使用场景：
日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。
数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。
设计一个连接服务器的框架，需要三个协议，“POP3”、“IMAP”、“HTTP”，可以把这三个作为产品类，共同实现一个接口。
注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

四、总结

工厂模式共有三种实现方式：简单工厂模式、工厂方法模式和抽象工厂模式，每种模式都有不同的应用场景和优缺点，大家可以根据自身的应用场景来选择不同的实现方式来实现。

---

推荐

关注博客和公众号获取最新文章

Bummon’s Blog ｜ Bummon’s Home ｜ 公众号