工厂模式

工厂模式

一、定义

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

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

点击查看源码

二、实现方式

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

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

1. 简单工厂模式

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

（1）UML图

未命名文件

（2）角色分类

具体工厂（Concrete Factory）

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

抽象产品（Product）

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

具体产品（Concrete Product）

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

（3）应用案例

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

抽象产品（Product）

1
2
3
4
5
6
7
8
9
/**
 * 抽象产品
 */
public interface Noodles {
	/**
	 * 做面
	 */
	void cook();
}

具体产品（Concrete Product）

1
2
3
4
5
6
7
8
9
/**
 * 拉面
 */
public class Ramen implements Noodles {
	@Override
	public void cook(){
		System.out.println("正在制作拉面...");
	}
}
1
2
3
4
5
6
7
8
9
/**
 * 汤面
 */
public class SoupNoodles implements Noodles {
	@Override
	public void cook(){
		System.out.println("正在制作汤面...");
	}
}
1
2
3
4
5
6
7
8
9
/**
 * 炒面
 */
public class StirFriedNoodles implements Noodles {
	@Override
	public void cook(){
		System.out.println("正在制作炒面...");
	}
}

具体工厂（Factory）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
 * 具体工厂
 */
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;
		}
	}
}

客户角色（Client）

1
2
3
4
5
6
7
8
9
10
11
12
public class Client {
	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();
	}
}

563ed0e1cc944bdfaa3cb30cfcbc9271.png

（4）优缺点

优点：

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

缺点：

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

（5）小结

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

2. 工厂方法模式

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

（1）UML图

未命名文件 (1)

（2）角色分类

抽象工厂（Factory）

负责描述工厂的公共接口

具体工厂（Concrete Factory）

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

抽象产品（Product）

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

具体产品（Concrete Product）

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

（3）应用案例

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

抽象产品（Product）

1
2
3
public abstract class Noodles {
	public abstract void eat();
}

具体产品（Concrete Product）

1
2
3
4
5
6
7
public class Ramen extends Noodles {
	
	@Override
	public void eat() {
		System.out.println("我要吃拉面...");
	}
}
1
2
3
4
5
6
7
public class SoupNoodles extends Noodles {
	
	@Override
	public void eat() {
		System.out.println("我要吃汤面...");
	}
}
1
2
3
4
5
6
7
public class StirFriedNoodles extends Noodles {
	
	@Override
	public void eat() {
		System.out.println("我要吃炒面...")
	}
}

抽象工厂（Factory）

1
2
3
4
public abstract class NoodlesFactory {

	public abstract Noodles getNoodles();
}

具体工厂（Concrete Factory）

1
2
3
4
5
6
7
8
9
10
/**
 * 拉面
 */
public class RestaurantA extends NoodlesFactory {

	@Override
	public Noodles getNoodles(){
		return new Ramen();
	}
}
1
2
3
4
5
6
7
8
9
10
/**
 * 汤面
 */
public class RestaurantB extends NoodlesFactory {
	
	@Override
	public Noodles getNoodles() {
		return new SoupNoodles();
	}
}
1
2
3
4
5
6
7
8
9
10
/**
 * 炒面
 */
public class RestaurantC extends NoodlesFactory {
	
	@Override
	public Noodles getNoodles() {
		return new StirFriedNoodles();
	}
}

客户角色（Client）

1
2
3
4
5
6
7
8
9
10
11
12
public class Client {
	public static void main(String[] args){
		RestaurantA restaurantA = new RestaurantA();
		restaurantA.getNoodles().eat();
		
		RestaurantB restaurantB = new RestaurantA();
		restaurantB.getNoodles().eat();
		
		RestaurantC restaurantC = new RestaurantA();
		restaurantC.getNoodles().eat();
	}
}

715eb1ff05ee43e589601cc6ab972968.png

（4）优缺点

优点：

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

缺点：

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

（5）小结

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

3. 抽象工厂模式

抽象工厂模式其实就是升级版的工厂方法模式，它是围绕一个超级工厂创建其他工厂，该超级工厂又称为其他工厂的工厂。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

（1）UML图

未命名文件 (2)

（2）角色分类

抽象工厂

负责描述工厂的公共接口

具体工厂

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

抽象产品族

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

抽象产品

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

具体产品

具体产品，由工厂创建

（3）应用案例

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

抽象产品族

1
2
3
public abstract class Food {
	public abstract void description();
}

抽象产品

1
2
public abstract class StapleFood extends Food {
}
1
2
public abstract class Snacks extends Food {
}

具体产品

1
2
3
4
5
6
7
8
9
/**
 * 米饭
 */
public class Rice extends StapleFood {
	@Override
	public void description() {
		System.out.println("米饭")
	}
}
1
2
3
4
5
6
7
8
9
/**
 * 面条
 */
public class Noodles extends StapleFood {
	@Override
	public void description() {
		System.out.println("面条");
	}
}
1
2
3
4
5
6
7
8
9
/**
 * 汉堡
 */
public class Hamburger extends Snacks {
	@Override
	public void description() {
		System.out.println("汉堡");
	}
}
1
2
3
4
5
6
7
8
9
/**
 * 薯条
 */
public class Chips extends Snacks {
	@Override
	public void description() {
		System.out.println("薯条");
	}
}

抽象工厂

1
2
3
4
5
6
7
8
9
10
11
public abstract class FoodFactory {
	/**
	 * 下单主食
	 */
	public abstract Food getStapleFood();

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

具体工厂

1
2
3
4
5
6
7
8
9
10
11
12
13
public class StapleFoodFactory extends FoodFactory {
	@Override
	public Food getStapleFood() {
		//下单米饭
		return new Rice();
	}

	@Override
	public Food getSnacks() {
		//下单汉堡
		return new Hamburger();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
public class SnacksFactory extends FoodFactory {
	@Override
	public Food getStapleFood() {
		//下单面条
		return new Noodles();
	}

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

测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
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();
	}
}

76759b97460647eba9c297a6e67018b9.png

（4）优缺点

优点：

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

缺点：

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

（5）小结

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

三、应用场景

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

工厂模式

意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

主要解决：主要解决接口选择的问题。

何时使用：我们明确地计划不同条件下创建不同实例时。

如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。

关键代码：创建过程在其子类执行。

应用实例：

  1. 您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。
  2. Hibernate 换数据库只需换方言和驱动就可以。

优点：

  1. 一个调用者想创建一个对象，只要知道其名称就可以了。
  2. 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
  3. 屏蔽产品的具体实现，调用者只关心产品的接口。

缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

使用场景：

  1. 日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。
  2. 数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。
  3. 设计一个连接服务器的框架，需要三个协议，”POP3”、”IMAP”、”HTTP”，可以把这三个作为产品类，共同实现一个接口。

注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

抽象工厂模式

意图： 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

主要解决： 主要解决接口选择的问题。

何时使用： 系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

如何解决： 在一个产品族里面，定义多个产品。

关键代码： 在一个工厂里聚合多个同类产品。

应用实例： 工作了，为了参加一些聚会，肯定有两套或多套衣服吧，比如说有商务装（成套，一系列具体产品）、时尚装（成套，一系列具体产品），甚至对于一个家庭来说，可能有商务女装、商务男装、时尚女装、时尚男装，这些也都是成套的，即一系列具体产品。假设一种情况（现实中是不存在的，但有利于说明抽象工厂模式），在您的家中，某一个衣柜（具体工厂）只能存放某一种这样的衣服（成套，一系列具体产品），每次拿这种成套的衣服时也自然要从这个衣柜中取出了。用 OOP 的思想去理解，所有的衣柜（具体工厂）都是衣柜类的（抽象工厂）某一个，而每一件成套的衣服又包括具体的上衣（某一具体产品），裤子（某一具体产品），这些具体的上衣其实也都是上衣（抽象产品），具体的裤子也都是裤子（另一个抽象产品）。

优点： 当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点： 产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

使用场景： 1、QQ 换皮肤，一整套一起换。 2、生成不同操作系统的程序。

注意事项： 产品族难扩展，产品等级易扩展。

四、总结

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