Java设计模式之工厂方法模式

发表于   |   分类于   |  

　　GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory），将简单工厂模式（Simple Factory）视为工厂方法模式的一种特例，两者归为一类。 本文主要讲述工厂方法模式。
　　
　　下面以客户需要宝马车的例子进行说明：

最原始的方式

不同型号的宝马车:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public abstract class BMW {
}
public class BMW320 extends BMW {
	public BMW320() {
		System.out.println("BMW320 has been made.");
	}
}
public class BMW523 extends BMW {
	public BMW523() {
		System.out.println("BMW523 has been made.");
	}
}

客户自己制造:

1
2
3
4
5
6
public class Customer {  
    public static void main(String[] args) {  
        BMW320 bmw320 = new BMW320();  
        BMW523 bmw523 = new BMW523();  
    }  
}

运行程序，输出：

image_1b1rpkdlg1garegg120hstlmpk9.png-11.7kB

　　这是最原始的方式，客户需要知道如何去制造宝马车，客户和宝马车紧密耦合在了一起。为了降低耦合，我们引入工厂类，将制造宝马车的工作交给工厂去完成。 　　

简单工厂模式（Simple Factory）

　　创建一个制造宝马车的工厂类，其中有一个makeBMW方法用于根据获取的型号参数制造不同型号的宝马车：
　　
不同型号的宝马车:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public abstract class BMW {
}
public class BMW320 extends BMW {
	public BMW320() {
		System.out.println("BMW320 has been made.");
	}
}
public class BMW523 extends BMW {
	public BMW523() {
		System.out.println("BMW523 has been made.");
	}
}

工厂类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class SimpleFactory {
	public BMW makeBMW(int type) {
		switch (type) {
		case 320:
			return new BMW320();
		case 523:
			return new BMW523();
		default:
			break;
		}
		return null;
	}
}

客户通过调用工厂中的方法获取宝马车：

1
2
3
4
5
6
7
public class Customer {  
    public static void main(String[] args) {
		SimpleFactory simpleFactory = new SimpleFactory();
		BMW bmw320 = simpleFactory.makeBMW(320);
		BMW bmw523 = simpleFactory.makeBMW(523);
	}  
}

运行程序：

image_1b1rqjn2210p29kj1q9tdpvvdam.png-11.8kB

　　简单工厂模式又称静态工厂方法模式。它存在的目的很简单：定义一个用于创建对象的接口。
　　先来看看它的组成：
1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品
2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。
3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在Java中由一个具体类实现。

　　简单工厂模式的工厂部分并不符合开闭原则（对扩展开放，对修改封闭），因为如果要增加一种新型宝马车，就需要修改工厂类的业务逻辑，例如现在要添加BMW545型，则需要先创建一个BMW545类继承自BMW类（这是符合开闭原则的），然后将工厂类改为下面的样子，这显然违背了开闭原则：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class SimpleFactory {
	public BMW makeBMW(int type) {
		switch (type) {
		case 320:
			return new BMW320();
		case 523:
			return new BMW523();
		case 545:
			return new BMW545();
		default:
			break;
		}
		return null;
	}
}

工厂方法模式（Factory Method）

　　为了解决简单工厂模式的问题，工厂方法模式就诞生了，工厂方法模式将基类工厂定义为接口，然后定义各种不同类型的工厂用以生产不同类型的宝马车：
不同型号的宝马车:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public abstract class BMW {
}
public class BMW320 extends BMW {
	public BMW320() {
		System.out.println("BMW320 has been made.");
	}
}
public class BMW523 extends BMW {
	public BMW523() {
		System.out.println("BMW523 has been made.");
	}
}

工厂类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public interface IFactory {
	public abstract BMW makeBMW();
}
public class BMW320Factory implements IFactory {
	@Override
	public BMW makeBMW() {
		return new BMW320();
	}
}
public class BMW523Factory implements IFactory {
	@Override
	public BMW makeBMW() {
		return new BMW523();
	}
}

客户通过获取不同类型的工厂来获取不同型号的宝马车：

1
2
3
4
5
6
7
8
public class Customer {  
    public static void main(String[] args) {
		IFactory bmw320Factory = new BMW320Factory();
		BMW bmw320 = bmw320Factory.makeBMW();
		IFactory bmw523Factory = new BMW523Factory();
		BMW bmw523 = bmw523Factory.makeBMW();
	}  
}

运行程序：

image_1b1rras9t8l6ol8ndn1c1j21013.png-13.4kB

　　在工厂方法模式中，如果我们需要新增一款车型BMW545，那么只需要再新建一个IFactory接口的实现类：

1
2
3
4
5
6
7
8
public class BMW545Factory implements IFactory {
	@Override
	public BMW makeBMW() {
		return new BMW545();
	}
}

　　然后客户通过这个工厂即可得到BMW545型号的宝马车：

1
2
3
4
5
6
public class Customer {  
    public static void main(String[] args) {
		IFactory bmw545Factory = new BMW545Factory();
		BMW bmw545 = bmw545Factory.makeBMW();
	}  
}

由于没有修改我们已有的代码，所以这是符合开闭原则的。
　　工厂方法模式仿佛已经很完美的对对象的创建进行了包装，客户仅需要定义相应产品的工厂实现类，就可以获取到某一型号的产品。但是，当产品种类非常多时，我们需要创建大量与之对应的工厂对象，这也不是我们所希望的。