编程世界的建筑大师：揭秘工厂模式的巧妙构思

定义

工厂模式是Java中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽起来，实现创建者和调用者的分离

核心本质

实例化对象，用工厂方法代替new操作。
将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

简单工厂模式（静态工厂模式）

简单工厂模式也叫静态工厂模式，就是工厂类一般是使用静态方法，通过接收的参数不同来返回不同的对象实例。

它用来生产同一等级结构中的任意产品，对于增加新产品无能为力！不修改代码的话，是无法扩展的，不符合开闭原则。读起来可能不太理解，我们就来看具体的代码吧。
代码如下：

//汽车接口，提供一个抽象的run方法。
public interface Car {
	void run();
}

奥迪

public class Audi implements Car {
	@Override
	public void run() {
		System.out.println("奥迪在跑");
	}
}

比亚迪

public class BYD implements Car{
	@Override
	public void run() {
      System.out.println("比亚迪在跑");
	}
}

没有用工厂的时候，我们都是通过new关键字来创建所需要的对象的。

public class Client01 {
	public static void main(String[] args) {
	Car c1=new Audi();
	Car c2=new BYD();
	c1.run();
	c2.run();
	}
}

生产汽车的工厂类

public class CarFactory {
	public  static Car createCar(String type){
		if("奥迪".equals(type)){
			return new Audi();
		}else if ("比亚迪".equals(type)) {
			return new BYD();
		}else {
			return null;
		}
	}
}

测试类

public class Client02 {

	public static void main(String[] args) {
	//使用工厂模式后，我们只需和工厂类打交道，不必关心具体的实现类。
	Car c1=CarFactory.createCar("奥迪");
	Car c2=CarFactory.createCar("比亚迪");
	
	c1.run();
	c2.run();
	}
}

上面代码中的奥迪和比亚迪都是属于汽车类，那么它们就是同一等级中的产品。如果我们想要新增一辆奔驰汽车的话，不仅需要增加一个类，还需要修改工厂类中的代码，增加奔驰汽车的实例对象，这就违背了开闭原则。虽然如此，但是实际上使用最多的就是这种。

工厂方法模式

工厂方法模式就是为了弥补简单工厂模式的缺点。工厂方法模式和简单工厂最大的不同在于简单工厂模式只有一个（对于一个项目或者一个独立模块）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。在不修改已有类的前提下，通过增加新的工厂类实现扩展。所以如果我们要新增一辆奔驰汽车的话，上面代码应做如下修改。

public class Benz implements Car {
	@Override
	public void run() {
	}
}

汽车工厂类

public interface CarFactory {
//只提供抽象的生产汽车的方法，具体的对象由对应的工厂类去创建。
	Car createCar();
}

奔驰汽车工厂类

public class BenzFactory implements CarFactory {
	@Override
	public Car createCar() {
		return new Benz();
	}
}

抽象工厂模式

用来生成不同产品族的全部产品（对于增加新的产品，无能为力，支持增加产品族）抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种，业务分类时，通过抽象工厂模式生产需要的对象是一种非常好的解决方式。下面还是来看代码吧。
发动机

//发动机接口
public interface Engine {
	void run();
	void start();	
}
//高端发动机
class LuxuryEngine implements Engine{
    @Override
	public void run() {
		System.out.println("转的快");
	}
	@Override
	public void start() {
		System.out.println("启动快，可以自动启停");
	}
}

//低端发动机
class LowEngine implements Engine{
	@Override
	public void run() {
		System.out.println("转的慢");
	}

	@Override
	public void start() {
		System.out.println("启动慢！");
	}

座位

public interface Seat {
	void massage();
}

class LuxurySeat implements Seat{
	@Override
	public void massage() {
		System.out.println("可以自动按摩");
	}
}

class LowSeat implements Seat{
	@Override
	public void massage() {
		System.out.println("不能按摩");
	}	
}

轮胎

public interface Tyre {
	void resolve();
}

class LuxuryTyre implements Tyre{
	@Override
	public void resolve() {
		System.out.println("旋转不磨损");
	}
}

class LowTyre implements  Tyre{
	@Override
	public void resolve() {
		System.out.println("磨损快");
	}	
}

汽车工厂类

public interface CarFactory {
	Engine createEngine();
	Seat createSeat();
	Tyre createTyre();
}

低端汽车工厂类

public class LowCarFactory implements CarFactory {
	@Override
	public Engine createEngine() {
		return new LowEngine();
	}

	@Override
	public Seat createSeat() {
		return new LowSeat();
	}

	@Override
	public Tyre createTyre() {
		return new LowTyre();
	}
}

高端汽车工厂类

public class LuxuryCarFactory implements CarFactory {
	@Override
	public Engine createEngine() {
		return new LuxuryEngine();
	}

	@Override
	public Seat createSeat() {
		return new LuxurySeat();
	}

	@Override
	public Tyre createTyre() {
		return new LuxuryTyre();
	}
}

上述代码中，座位，发动机，轮胎都属于汽车这个产品族，而低端汽车和高端汽车属于不同的业务。

简单工厂模式和工厂方法模式PK

结构复杂度

从这个角度比较，显然简单工厂模式要占优。简单工厂模式只需要一个工厂类，而工厂方法模式的工厂类随着产品类个数增加而增加，这无疑会使类的个数越来越多，从而增加了结构的复杂度。

代码复杂度

代码复杂度和结构复杂度是一对矛盾，既然简单工厂模式在结构方面相对简洁，那么它在代码方面肯定是比工厂方法模式复杂了，简单工厂模式的工厂类随着产品类的增加需要增加很多方法（或代码），而工厂方法模式每个具体工厂类只完成单一任务，代码简洁。

客户端编程难度

工厂方法模式虽然在工厂类结构中引入了接口从而满足了OCP,但是在客户端编码中需要对工厂类进行实例化，而简单工厂模式的工厂类是个静态类，在客户端无需实例化，这无疑是个吸引人的优点。

管理上的难度
我们先谈扩展，众所周知，工厂方法模式完全满足OCP，即他有非常良好的扩展性。那是否就说明了简单工厂模式就没有扩展性了？答案是否定的，简单工厂模式同样具备良好的扩展性——扩展的时候仅需要修改少量的代码（修改工厂类代码）就可以满足扩展性的要求了，尽管这没有完全满足OCP，但是我们不要太拘泥于设计理论。
然后我们从维护性的角度分析下，假如某个具体产品类需要进行一定的修改，很可能需要修改对应的工厂类。当同时需要修改多个产品类的时候，对工厂类的修改会变得相当麻烦（对号入座已经是个问题了）。反而简单工厂没有这些麻烦，当多个产品类需要修改时，简单工厂模式仍然仅仅需要修改唯一的工厂类（无论怎样都能改到满足要求吧？大不了这个类重写）

工厂模式的优点：

1、一个调用者想创建一个对象，只要知道其名称就可以了，降低了耦合度。
2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。使得代码结构更加清晰。
3、屏蔽产品的具体实现，调用者只关心产品的接口。

工厂模式的缺点：

每次增加一个产品时，都需要增加一个具体类和对象实现工厂（这里可以使用反射机制来避免），使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。所以对于简单对象来说，使用工厂模式反而增加了复杂度。

工厂模式的适用场景：

1， 一个对象拥有很多子类。
2， 创建某个对象时需要进行许多额外的操作。
3， 系统后期需要经常扩展，它把对象实例化的任务交由实现类完成，扩展性好。

关于Java中的工厂模式的一些常见问题：

利用父类的向下转型（使用父类类型的引用指向子类的对象）是可以达到类似于工厂模式的效果的，那为什么还要用工厂模式呢？
把指向子类对象的父类引用赋给子类引用叫做向下转型，如：

Class Student extends Person     
Person s = new Student();    
s = (Student)person ;

使用向下转型在客户端实例化子类的时候，严重依赖具体的子类的名字。当我们需要更改子类的构造方法的时候，比如增加一个参数，或者更改了子类的类名，所有的new出来的子类都需要跟着更改。
但如果我们使用工厂模式，我们仅仅需要在工厂中修改一下new的代码，其余项目中用到此实例的都会跟着改，而不需要我们手动去操作。（？？？）

应用场景

JDK中Calendar的getInstance方法

JDBC中Connection对象的获取

Hibernate中SessionFactory创建Session

Spring中IOC容器创建管理bean对象

XMl解析时的DocumentBuilderFactory创建解析对象

反射中Class对象的newInstance()