初学Java设计模式随记 -- 工厂模式（Factory Pattern）

 

在阎宏《JAVA与设计模式》中 ，工厂模式（Factory Pattern）分为下列几种形态：

1.简单工厂（Simple Factory）模式： 又称静态工厂方法模式（Static Factory Method Pattern）.

2.工厂方法（Factory Method）模式：又称多态性（Polymorphic Factory）模式或虚拟构造子（Virtual Construtor）模式。

3.抽象工厂（Abstract Factory）模式：又称工具箱（Kit或Toolkit）模式。

  

在《GOF设计模式》中，主要是工厂方法（Factory Method）模式和抽象工厂（Abstract Factory）模式

 

 

 

先不考虑工厂模式有几种形态，从工厂模式的名称来看，工厂模式似乎很容易理解，反映到现实中的例子，比如：

一汽大众(工厂角色)生产了很多汽车(抽象产品类角色)，其中有一款叫做奥迪A6(具体产品角色)。

 

这是一个被用烂了的例子。那么，把这个例子再稍微形象化一些：一个客户要买这款奥迪A6汽车。

它的Java实现如下，例子1（使用工厂模式）：

 

汽车（抽象产品类角色）：

/*
 * 无论哪个工厂生产的汽车，都是汽车 （抽象产品类）
 */
public abstract class Car {
	
	public String name;
	
}

 

奥迪A6（具体产品角色）：

/*
 * 奥迪A6，是一汽大众生产的一款汽车 （具体产品类）
 */
public class AudiA6Car extends Car {
	
	public AudiA6Car(){
		this.name = "奥迪A6";
		
	}
	
	public String toString(){
		return "一辆"+ this.name;
	}

}

 

一汽大众（工厂角色）：

定义了一个静态的工厂方法manufactureCar()，来返回一个Car类型的对像。

 

/*
 * 生产汽车的工厂，一汽大众 （工厂类）
 */
public class CarFactory {

	/*
	 * 生产汽车（通过一个静态方法来得到一辆汽车的对象）
	 */
	public static Car manufactureCar(){
		
		return new AudiA6Car();
	}

}

 

 

买这款奥迪A6汽车的一个顾客A（客户端）： 

/*
 * 购买汽车的顾客A(客户端)
 */
public class CustomerA {
	
	public static void main(String[] args){
		
//		通过汽车工厂来制造出了一辆汽车
		Car myCar = CarFactory.manufactureCar();
		System.out.println("一辆汽车被造好，并且出厂了。");
		
//		顾客得到了一辆汽车，十分的高兴
		System.out.println("我终于买了"+myCar+"。真是太好了！");
	}

}

  

当看到这个例子的时候（还有很多这样类似的例子），第一感觉，工厂模式挺简单的，很容易理解嘛。

 

 

但这时，有这样两个问题：如果不用工厂模式，那么以前是怎么实现的呢？以前的实现方式会有什么问题？

例子2（不使用工厂模式）：

 

汽车（抽象产品类角色）：代码与例子1的相同。

奥迪A6（具体产品角色）：代码与例子1的相同。

买这款奥迪A6汽车的一个顾客B（客户端）：

/*
 * 购买汽车的顾客B(客户端)
 */
public class CustomerB {
	
	public static void main(String[] args){
		
//		一辆汽车被造出来了
		Car myCar = new AudiA6Car();
		System.out.println("一辆汽车被造好。");
		
//		顾客得到了一辆汽车，十分的高兴
		System.out.println("我终于买了"+myCar+"。真是太好了！");
	}

}

 

比较一下使用模式和不使用模式的不同：

1.例子1（使用设计模式）比例子2（不使用设计模式）多了1个工厂类。

2.在客户端（顾客A和顾客B），例子1（工厂模式）没有使用new方法，而是使用了一个工厂方法manufactureCar()；例子2（没有工厂模式）使用了new方法。是因为不使用new比使用new好？仔细研究发现，其实，工厂模式也使用了new,只是把它放在了工厂类的工厂方法manufactureCar里，而不是客户端。

 

这么看，使用设计模式也没有什么优势呀，客户端代码行数相同，而且，还多了1个类。

 

好吧，再想想，买一辆汽车有那么简单吗？汽车的构成可是非常复杂的。它要有轮子，方向盘，座椅，发动机，颜色等等。

再丰富一下这个例子。

这次，先看看不使用设计模式的例子。例子3（不使用设计模式）：

汽车（抽象产品类角色）： 

/*
 * 无论哪个工厂生产的汽车，都是汽车 （抽象产品类）
 */
public abstract class Car {
	
	public String name;
	
}

 

 奥迪A6（具体产品角色）：

为汽车添加了很多属性，那么对象的创建过程就变复杂了。

/*
 * 奥迪A6，是一汽大众生产的一款汽车 （具体产品类）
 */
public class AudiA6Car extends Car {
	
	private String wheels;
	private String steering_wheel;
	private String car_seats;
	private String car_color;
	private String engine;
	
	public AudiA6Car(){
		this.name = "奥迪A6";
		
	}
	
//给汽车涂上颜色
	public void setCar_color(String car_color) {
		this.car_color = car_color;
	}

//给汽车装上座椅
	public void setCar_seats(String car_seats) {
		this.car_seats = car_seats;
	}

//给汽车装上发动机
	public void setEngine(String engine) {
		this.engine = engine;
	}

//给汽车装上方向盘
	public void setSteering_wheel(String steering_wheel) {
		this.steering_wheel = steering_wheel;
	}

//给汽车装上车轮
	public void setWheels(String wheels) {
		this.wheels = wheels;
	}

//	还需要装上其他的很多部件。。。。。。

//	一辆装好的汽车
	public String toString(){
		return "一辆"+ this.name+"[" + this.car_color + "," + this.car_seats+"," + this.engine
		+ "," + this.steering_wheel + "," + this.wheels +"]";
	}

}

 

买这款奥迪A6汽车的一个顾客B（客户端）：

/*
 * 购买汽车的顾客B(客户端)
 */
public class CustomerB {
	
	public static void main(String[] args){
		
//		奥迪车的架子给了顾客B,部件要顾客B自己装了。
		AudiA6Car myCar = new AudiA6Car();
		
//		涂上颜色
		myCar.setCar_color("黑色");
		
//		装上座椅
		myCar.setCar_seats("座椅");
		
//		装上发动机
		myCar.setEngine("发动机");
		
//		装上方向盘
		myCar.setSteering_wheel("方向盘");
		
//		装上车轮
		myCar.setWheels("四个轮子");
		
//		装上其他的部件。。。。。。
		
		System.out.println("顾客自己装好了"+myCar);
		
//		顾客自己组装了一辆汽车
		System.out.println("累死我了，哪有买汽车还得自己组装的呀？？！！ 这样的汽车能开吗？以后再也不能买奥迪了！！！");
	}

}

 

运行结果：

顾客自己装好了一辆奥迪A6[黑色,座椅,发动机,方向盘,四个轮子]
累死我了，哪有买汽车还得自己组装的呀？？！！ 这样的汽车能开吗？以后再也不能买奥迪了！！！

 

 

 顾客很不高兴，汽车的组装太复杂了，怎么买一辆汽车还要自己组装？这辆汽车能开吗？性能和安全有保证吗？

 

看看由工厂来组装汽车会是什么样子，例子4（使用工厂模式）：

汽车（抽象产品类角色）：  代码与例子3的相同。

奥迪A6（具体产品角色）：代码与例子3的相同。

 

一汽大众（工厂角色）：

复杂的组装过程还是有工厂来做吧。

/*
 * 生产汽车的工厂，一汽大众 （工厂类）
 */
public class CarFactory {

	/*
	 * 生产汽车（通过一个静态方法来得到一辆汽车的对象）
	 */
	public static Car manufactureCar(){
		
		AudiA6Car oneCar = new AudiA6Car();

//		涂上颜色
		oneCar.setCar_color("黑色");
		
//		装上座椅
		oneCar.setCar_seats("座椅");
		
//		装上发动机
		oneCar.setEngine("发动机");
		
//		装上方向盘
		oneCar.setSteering_wheel("方向盘");
		
//		装上车轮
		oneCar.setWheels("四个轮子");
		
//		装上其他的部件。。。。。。
		
		System.out.println("汽车在工厂组装好了");
		
//		一辆汽车造好了		
		return oneCar;
	}

}

 

  买这款奥迪A6汽车的一个顾客A（客户端）：

/*
 * 购买汽车的顾客A(客户端)
 */
public class CustomerA {
	
	public static void main(String[] args){
		
//		通过汽车工厂来制造出了一辆汽车
		Car myCar = CarFactory.manufactureCar();
		
//		顾客得到了一辆汽车，十分的高兴
		System.out.println("我终于买了"+myCar+"。真是太好了！去兜风去。。。");
	}

}

 运行结果：

汽车在工厂组装好了
我终于买了一辆奥迪A6[黑色,座椅,发动机,方向盘,四个轮子]。真是太好了！去兜风去。。。

 

顾客A很轻松地买了一辆奥迪A6，高兴地开着车兜风去了。。。

 

 

通过比较例子3和例子4，工厂模式的优势体现出来了：

利用工厂模式可以将对象的创建过程和使用进行分离（也就是解藕），可以将复杂的对象创建过程由工厂类进行了封装。

1.这样一来，客户端使用起来就显得非常轻松。

例如：如果客户想要红色的奥迪A6，那么，很简单，厂家给发一款红色的就可以了。客户只要高高兴兴地去开它就行了。

 

2.而且，这个系统，职责分明，思路清晰。

例如：如果出了车祸，如果是因为刹车问题造成的，那么就要找厂商；如果是因为顾客酒驾造成的，就要找顾客。

确定正确的调查对象，找到问题的真正原因，才能找到合适的解决方法，就不会有误判和冤案了。

 

3.此外，这样还起到了可以重用的作用。

例如： 无论有多少客户都买，只要买的是同一款，那么，只要用一套生产线就可以了，节省了很多时间和资源。

 

4.在将来的维护和修改时，就会减少使用对象的影响。

 

例如：客户不需要知道奥迪A6是怎么组装的。原来可能是由人手工装的；后来，是用机器装的；再后来，用了一套更先进的设备装的。这些都与客户无关，因为，客户买车，是为了开车，不需要了解车是怎么组装的。

 

再例如：多个客户购买了同一款汽车，如果这款汽车的刹车都有问题，那么，只需要修改一个工厂类就可以了，客户在使用过程中不会感觉到有什么变化，就不需要改变自己的使用方式了。

 

遗留的问题：

当我们使用JDBC对数据库进行操作的时候，是不是就用到了工厂模式？无论是连接Oracle还是MySQL,我们是不是写起来很简单？是不是不需要关心每种数据库的连接细节？是不是很容易就实现了从MySQL到Oracle的移植？是不是只是用了工厂模式？  

 

工厂模式的应用似乎有很多，而且往往是和其他设计模式一起使用，在实际的项目和框架中都是怎么使用工厂模式的？

 

 好了，来个小小的总结：

一个系统的好坏，不是类越少就越好，通过使用设计模式，进行了解藕和封装，使得设计更加合理，系统看起来职责分明、清晰，维护和扩展也更容易。

但是，使用了设计模式，也并不能说就是合理的。就像例子1和例子2，设计模式就没有带来什么优势，反而，使得系统显得繁琐了。