工厂模式是最常用的设计模式之一,该模式定义一个用于创建对象的工厂类,调用者不用关心创建的细节

工厂模式可以分为三个子模式:

简单工厂模式

定义工厂类,根据参数返回不同类的实例,这些实例通常具有共同的父类,因为简单工厂模式用静态方法创建实例,所以又称为静态工厂模式(Static Creational Pattern)

简单工厂模式UML

  • Factory:工厂类,实现创建所有产品实例的内部逻辑
  • Product:抽象产品类,封装产品公有方法,它的引入使得工厂类只需要定义一个通用的工厂方法,因为创建的具体产品都是该类的子类
  • ConcreteProduct:具体实现类

代码示例:

产品类:

1
2
3
4
5
6
7
8
9
10
11
12
// 抽象产品类
abstract class Product {
abstract void doSomething(Context context);
}

// 具体产品类
class ConcreteProduct extends Product {
@Override
void doSomething(Context context) {

}
}

工厂类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Factory {

public Factory() {
throw new RuntimeException("can't init");
}

static final String concreteProductA = "concreteProductA";
static final String concreteProductB = "concreteProductB";

static Product createdProduct(String arg) {
switch (arg) {
case concreteProductA:
return new ConcreteProductA();
case concreteProductB:
return new ConcreteProductB();
default:
return null;
}
}
}

适用场景:

  • 工厂类负责创建的对象比较少,由于创建的对象较少,不会造成工厂方法中的业务逻辑太过复杂
  • 客户端只知道传入工厂类的参数,对于如何创建对象并不关心

现实情况是复杂多变的,突然有一天产品经理说还要增加一个其他的类型,如果是简单工厂方法,就不得不在 if...else 或者 switch 中增加一个判断,这样就违反了开闭原则,对于这样的工厂类,称它为全能类或者上帝类

工厂方法模式

工厂方法模式去掉简单工厂模式的静态方法,使它可以被子类继承,这样就可以把静态方法的压力分担给各个子类承担,每个子工厂类只负责创建一个具体的产品类实例

工厂方法模式

  • Product:抽象产品类,所有需要实例化子类的父类
  • ConcreteProduct:具体产品类
  • Factory:抽象工厂类,此类是工厂方法模式的核心,所有工厂类都要继承该类
  • ConcreteFactory:具体工厂类,实现具体的业务逻辑

示例代码:
产品类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 抽象类
abstract class People {
abstract void doSomething();
}

// 女性
class Female extends People{
@Override
void doSomething() {

}
}

// 男性
class Male extends People {
@Override
void doSomething() {

}
}

工厂类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 抽象工厂类
public abstract class Factory {
abstract People createPeople();
}

// 具体工厂类
public class FemaleFactory extends Factory {

@Override
People createPeople() {
return new Female();
}
}

public class MaleFactory extends Factory {

@Override
People createPeople() {
return new Male();
}
}

适用场景:

  • 客户端不知道它所需要的对象的类。在工厂方法模式中,客户端不需要知道具体产品类的类名,只需要知道所对应的工厂即可,具体的产品对象由具体工厂类创建
  • 抽象工厂类通过其子类来指定创建哪个对象。在工厂方法模式中,对于抽象工厂类只需要提供一个创建产品的接口,而由其子类来确定具体要创建的对象,利用面向对象的多态性和里氏代换原则,在程序运行时,子类对象将覆盖父类对象,从而使得系统更容易扩展

跟简单工厂模式一样的问题,虽然没有违反开闭原则,但是增加新产品类的时候,因为一个具体工厂类只负责一个具体产品类,所以必须也要增加对应的具体工厂类,项目中类的个数成对增加,进而增加了系统的复杂度,更多的类需要编译和运行,给系统带来额外的开销

抽象工厂模式

工厂方法模式中一个工厂类负责生产一个具体产品,有时根据业务需求,一个工厂类需要提供多个具体产品,例如生产共享单车,一个工厂类可以提供多个共享单车的组件,比如车胎,车架,车座,车把,从而组成一个完整产品,为了更好理解抽象工厂模式,先理解两个概念:

  • 产品等级结构:即产品的继承结构,如车轮,子类有实心车胎,充气车胎,山地车胎等,抽象车轮和车轮具体类型构成一个产品等级结构
  • 产品族:抽象工厂模式中,产品族指同一工厂生产的,位于不同产品等级结构的一组产品,如自行车厂商生产实心车胎、铝合金车架等,实心车胎位于车胎产品等级结构中,铝合金车架位于车架产品等级结构中,实心车胎、铝合金车架等构成一个产品族

抽象工厂模式

  • AbstractProductA:抽象产品类
  • AbstractProductB:抽象产品类
  • ConcreteProductA1:具体产品类
  • ConcreteProductA2:具体产品类
  • ConcreteProductB1:具体产品类
  • ConcreteProductB2:具体产品类
  • AbstractFactory:抽象工厂类
  • ConcreteFactory1:具体工厂类,实现具体的业务逻辑
  • ConcreteFactory2:具体工厂类,实现具体的业务逻辑

这里用一个生产单车的例子实践一下抽象工厂模式,示例代码:
产品类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
// 车座
interface ISeat {
void seat();
}

// 车胎
interface ITire {
void tire();
}

// 车架
interface IFrame {
void frame();
}

// 铝合金车架
public class AlloyFrame implements IFrame {
@Override
public void frame() {
Log.i("IFrame", "AlloyFrame");
}
}

// 碳纤维车架
class CarbonFrame implements IFrame {
@Override
public void frame() {
Log.i("IFrame", "CarbonFrame");
}
}

// 真皮车座
class DermisSeat implements ISeat {
@Override
public void seat() {
Log.i("ISeat", "DermisSeat");
}
}

// 橡胶车座
class RubberSeat implements ISeat {
@Override
public void seat() {
Log.i("ISeat", "RubberSeat");
}
}

// 充气车胎
class InflateTire implements ITire {
@Override
public void tire() {
Log.i("ITire", "InflateTire");
}
}

// 实心车胎
class SolidTire implements ITire {
@Override
public void tire() {
Log.i("ITire", "SolidTire");
}
}

工厂类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
// 抽象工厂类
abstract class AbstractFactory {
/**
* 生产车胎
*
* @return 车胎
*/
abstract ITire createTire();

/**
* 生产车架
*
* @return 车架
*/
abstract IFrame createFrame();

/**
* 生产车座
*
* @return 车座
*/
abstract ISeat createSeat();
}

// ofo 工厂类
class OfoFactory extends AbstractFactory {

@Override
ITire createTire() {
return new InflateTire();
}

@Override
IFrame createFrame() {
return new CarbonFrame();
}

@Override
ISeat createSeat() {
return new RubberSeat();
}
}

// mobike 工厂类
class MobikeFactory extends AbstractFactory{
@Override
ITire createTire() {
return new SolidTire();
}

@Override
IFrame createFrame() {
return new AlloyFrame();
}

@Override
ISeat createSeat() {
return new DermisSeat();
}
}

适用场景:

  • 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节,这对于所有类型的工厂模式都是很重要的,用户无须关心对象的创建过程,将对象的创建和使用解耦
  • 系统中有多于一个的产品族,而每次只使用其中某一产品族
  • 产品等级结构稳定,设计完成之后,不会向系统中增加新的产品等级结构或者删除已有的产品等级结构

抽象工厂模式可以很方便根据现有的产品等级结构生成新的产品族,但是增加新的产品等级结构会很麻烦,这种性质称为开闭原则的倾斜性