深刻理解工厂模式

Java面试通关手册（Java学习指南，欢迎Star，会一直完善下去，欢迎建议和指导）：github.com/Snailclimb/…

历史回顾：

深刻理解单例模式

历史文章推荐：

分布式系统的经典基础理论

多是最漂亮的Spring事务管理详解

面试中关于Java虚拟机（jvm）的问题看这篇就够了

[TOC]

一 工厂模式介绍

1.1 工厂模式的定义

先来看一下GOF为工厂模式的定义：

“Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.”(在基类中定义建立对象的一个接口，让子类决定实例化哪一个类。工厂方法让一个类的实例化延迟到子类中进行。)

1.2 工厂模式的分类：

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

（2）工厂方法（Factory Method）模式，又称多态性工厂（Polymorphic Factory）模式或虚拟构造子（Virtual Constructor）模式；

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

1.3 在开源框架中的使用

举两个比较常见的例子(我暂时能够准确想到的，固然还有不少不少):

(1)Spring中经过getBean("xxx")获取Bean；

(2) Java消息服务JMS中(下面以消息队列ActiveMQ为例子)

关于消息队列ActiveMQ的使用能够查看：消息队列ActiveMQ的使用详解

// 一、建立一个链接工厂对象，须要指定服务的ip及端口。
	ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://192.168.25.155:61616");
		// 二、使用工厂对象建立一个Connection对象。
		Connection connection = connectionFactory.createConnection();

复制代码

1.4 为何要用工厂模式

(1) 解耦 ：把对象的建立和使用的过程分开

(2)下降代码重复: 若是建立某个对象的过程都很复杂，须要必定的代码量，并且不少地方都要用到，那么就会有不少的重复代码。

(3) 下降维护成本 ：因为建立过程都由工厂统一管理，因此发生业务逻辑变化，不须要找到全部须要建立某个对象的地方去逐个修正，只须要在工厂里修改便可，下降维护成本。

关于工厂模式的做用，Mark一篇文章：blog.csdn.net/lovelion/ar…

二 简单工厂模式

2.1 介绍

严格的说，简单工厂模式并非23种经常使用的设计模式之一，它只算工厂模式的一个特殊实现。简单工厂模式在实际中的应用相对于其余2个工厂模式用的仍是相对少得多，由于它只适应不少简单的状况。

最重要的是它违背了咱们在概述中说的 开放-封闭原则 （虽然能够经过反射的机制来避免，后面咱们会介绍到） 。由于每次你要新添加一个功能，都须要在生switch-case 语句（或者if-else 语句）中去修改代码，添加分支条件。

2.2 适用场景

（1）须要建立的对象较少。

（2）客户端不关心对象的建立过程。

2.3 简单工厂模式角色分配：

1. 工厂(Factory)角色 :简单工厂模式的核心，它负责实现建立全部实例的内部逻辑。工厂类能够被外界直接调用，建立所需的产品对象。
2. 抽象产品(Product)角色 :简单工厂模式所建立的全部对象的父类，它负责描述全部实例所共有的公共接口。
3. 具体产品(Concrete Product)角色:简单工厂模式的建立目标，全部建立的对象都是充当这个角色的某个具体类的实例。

2.4 简单工厂实例

建立一个能够绘制不一样形状的绘图工具，能够绘制圆形，正方形，三角形，每一个图形都会有一个draw()方法用于绘图.

（1）建立Shape接口

public interface Shape {
	void draw();
}
复制代码

（2）建立实现该接口的具体图形类

圆形

public class Circle implements Shape {
    public Circle() {
		System.out.println("Circle");
	}
	@Override
	public void draw() {
		System.out.println("Draw Circle");
	}
}
复制代码

长方形

public class Rectangle implements Shape {
    public Rectangle() {
		System.out.println("Rectangle");
	}
	@Override
	public void draw() {
		System.out.println("Draw Rectangle");
	}
}

复制代码

正方形

public class Square implements Shape {
	public Square() {
		System.out.println("Square");
	}

	@Override
	public void draw() {
		System.out.println("Draw Square");
	}
}
复制代码

（3）建立工厂类：

public class ShapeFactory {

	// 使用 getShape 方法获取形状类型的对象
	public static Shape getShape(String shapeType) {
		if (shapeType == null) {
			return null;
		}
		if (shapeType.equalsIgnoreCase("CIRCLE")) {
			return new Circle();
		} else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
			return new Rectangle();
		} else if (shapeType.equalsIgnoreCase("SQUARE")) {
			return new Square();
		}
		return null;
	}
}
复制代码

（4）测试方法：

public class Test {

	public static void main(String[] args) {

		// 获取 Circle 的对象，并调用它的 draw 方法
		Shape circle = ShapeFactory.getShape("CIRCLE");
		circle.draw();

		// 获取 Rectangle 的对象，并调用它的 draw 方法
		Shape rectangle = ShapeFactory.getShape("RECTANGLE");
		rectangle.draw();

		// 获取 Square 的对象，并调用它的 draw 方法
		Shape square = ShapeFactory.getShape("SQUARE");
		square.draw();
	}
}
复制代码

输出结果：

Circle
Draw Circle
Rectangle
Draw Rectangle
Square
Draw Square

复制代码

这样的实现有个问题，若是咱们新增产品类的话，就须要修改工厂类中的getShape（）方法，这很明显不符合 开放-封闭原则 。

2.5 使用反射机制改善简单工厂

将工厂类改成下面的形式：

package factory_pattern;

/** * 利用反射解决简单工厂每次增长新了产品类都要修改产品工厂的弊端 * * @author Administrator * */
public class ShapeFactory2 {
	public static Object getClass(Class<? extends Shape> clazz) {
		Object obj = null;

		try {
			obj = Class.forName(clazz.getName()).newInstance();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}

		return obj;
	}
}

复制代码

测试方法：

package factory_pattern;

public class Test2 {
	public static void main(String[] args) {

		Circle circle = (Circle) ShapeFactory2.getClass(factory_pattern.Circle.class);
		circle.draw();

		Rectangle rectangle = (Rectangle) ShapeFactory2.getClass(factory_pattern.Rectangle.class);
		rectangle.draw();

		Square square = (Square) ShapeFactory2.getClass(factory_pattern.Square.class);
		square.draw();
	}

}

复制代码

这种方式的虽然符合了 开放-关闭原则 ，可是每一次传入的都是产品类的所有路径，这样比较麻烦。若是须要改善的话能够经过 反射+配置文件 的形式来改善，这种方式使用的也是比较多的。

3 工厂方法模式

3.1 介绍

工厂方法模式应该是在工厂模式家族中是用的最多模式，通常项目中存在最多的就是这个模式。

工厂方法模式是简单工厂的仅一步深化， 在工厂方法模式中，咱们再也不提供一个统一的工厂类来建立全部的对象，而是针对不一样的对象提供不一样的工厂。也就是说 每一个对象都有一个与之对应的工厂 。

3.2 适用场景

• 一个类不知道它所须要的对象的类：在工厂方法模式中，客户端不须要知道具体产品类的类名，只须要知道所对应的工厂便可，具体的产品对象由具体工厂类建立；客户端须要知道建立具体产品的工厂类。
• 一个类经过其子类来指定建立哪一个对象：在工厂方法模式中，对于抽象工厂类只须要提供一个建立产品的接口，而由其子类来肯定具体要建立的对象，利用面向对象的多态性和里氏
• 将建立对象的任务委托给多个工厂子类中的某一个，客户端在使用时能够无需关心是哪个工厂子类建立产品子类，须要时再动态指定，可将具体工厂类的类名存储在配置文件或数据库中。

3.3 工厂方法模式角色分配：

1. 抽象工厂(Abstract Factory)角色：是工厂方法模式的核心，与应用程序无关。任何在模式中建立的对象的工厂类必须实现这个接口。
2. 具体工厂(Concrete Factory)角色 ：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，而且受到应用程序调用以建立某一种产品对象。
3. 抽象产品(AbstractProduct)角色 ：工厂方法模式所建立的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。
4. 具体产品(Concrete Product)角色 ：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂建立，它们之间每每一一对应

3.4 工厂方法模式实例

上面简单工厂例子中的图形接口以及相关图像实现类不变。咱们只须要增长一个工厂接口以及实现这个接口的工厂类便可。

(1)增长一个工厂接口：

public interface Factory {
	public Shape getShape();
}

复制代码

（2）增长相关工厂类:

圆形工厂类

public class CircleFactory implements Factory {

	@Override
	public Shape getShape() {
		// TODO Auto-generated method stub
		return new Circle();
	}

}

复制代码

长方形工厂类

public class RectangleFactory implements Factory{

	@Override
	public Shape getShape() {
		// TODO Auto-generated method stub
		return new Rectangle();
	}

}

复制代码

圆形工厂类

public class SquareFactory implements Factory{

	@Override
	public Shape getShape() {
		// TODO Auto-generated method stub
		return new Square();
	}

}

复制代码

（3）测试：

public class Test {

	public static void main(String[] args) {
		Factory circlefactory = new CircleFactory();
		Shape circle = circlefactory.getShape();
		circle.draw();
	}

}

复制代码

输出结果：

Circle
Draw Circle

复制代码

4 抽象工厂模式

4.1 介绍

在工厂方法模式中，其实咱们有一个潜在乎识的意识。那就是咱们生产的都是同一类产品。抽象工厂模式是工厂方法的仅一步深化，在这个模式中的工厂类不仅仅能够建立一种产品，而是能够建立一组产品。

抽象工厂应该是比较最难理解的一个工厂模式了。

4.2 适用场景

• 和工厂方法同样客户端不须要知道它所建立的对象的类。
• 须要一组对象共同完成某种功能时，而且可能存在多组对象完成不一样功能的状况。（同属于同一个产品族的产品）
• 系统结构稳定，不会频繁的增长对象。（由于一旦增长就须要修改原有代码，不符合开闭原则）

4.3 抽象工厂方法模式角色分配：

1. 抽象工厂（AbstractFactory）角色 ：是工厂方法模式的核心，与应用程序无关。任何在模式中建立的对象的工厂类必须实现这个接口。
2. 具体工厂类（ConreteFactory）角色 ：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，而且受到应用程序调用以建立某一种产品对象。
3. 抽象产品（Abstract Product）角色 ：工厂方法模式所建立的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。
4. 具体产品（Concrete Product）角色 ：抽象工厂模式所建立的任何产品对象都是某一个具体产品类的实例。在抽象工厂中建立的产品属于同一产品族，这不一样于工厂模式中的工厂只建立单一产品，我后面也会详解介绍到。

。

4.4 抽象工厂的工厂和工厂方法中的工厂有什么区别呢？

抽象工厂是生产一整套有产品的（至少要生产两个产品)，这些产品必须相互是有关系或有依赖的，而工厂方法中的工厂是生产单一产品的工厂。

4.5 抽象工厂模式实例

不知道你们玩过穿越火线或者吃鸡这类游戏了吗，游戏中存在各类枪。咱们假设如今存在AK、M4A1两类枪，每一种枪对应一种子弹。咱们如今这样考虑生产AK的工厂能够顺便生产AK使用的子弹，生产M4A1的工厂能够顺便生产M4A1使用的子弹。（AK工厂生产AK系列产品包括子弹啊，AK枪的类型啊这些，M4A1工厂同理）

（1）建立相关接口：

枪

public interface Gun {
	public void shooting();
}

复制代码

子弹

public interface Bullet {
	public void load();
}
复制代码

（2）建立接口对应实现类：

AK类

public class AK implements Gun{

	@Override
	public void shooting() {
		System.out.println("shooting with AK");
		
	}

}
复制代码

M4A1类

public class M4A1 implements Gun {

	@Override
	public void shooting() {
		System.out.println("shooting with M4A1");

	}

}

复制代码

AK子弹类

public class AK_Bullet implements Bullet {

	@Override
	public void load() {
		System.out.println("Load bullets with AK");
	}

}

复制代码

M4A1子弹类

public class M4A1 _Bullet implements Bullet {

	@Override
	public void load() {
		System.out.println("Load bullets with M4A1");
	}

}
复制代码

（3）建立工厂接口

public interface Factory {
	public Gun produceGun();
	public Bullet produceBullet();
}

复制代码

（4）建立具体工厂

生产AK和AK子弹的工厂

public class AK_Factory implements Factory{

	@Override
	public Gun produceGun() {
		return new AK();
	}

	@Override
	public Bullet produceBullet() {
		return new AK_Bullet();
	}

}

复制代码

生产M4A1和M4A1子弹的工厂

public class M4A1_Factory implements Factory{

	@Override
	public Gun produceGun() {
		return new M4A1();
	}

	@Override
	public Bullet produceBullet() {
		return new M4A1_Bullet();
	}

}

复制代码

（5）测试

public class Test {

	public static void main(String[] args) {  
		
	 Factory factory;
	 Gun gun;
     Bullet bullet;
     
     factory =new AK_Factory();
     bullet=factory.produceBullet();
     bullet.load();
     gun=factory.produceGun();
     gun.shooting(); 
	 
	}

}
复制代码

输出结果：

Load bullets with AK
shooting with AK

复制代码

我是Snailclimb,一个以架构师为5年以内目标的小小白。 欢迎关注个人微信公众号:"Java面试通关手册"（一个有温度的微信公众号，期待与你共同进步~~~坚持原创，分享美文，分享各类Java学习资源)

最后，就是使用阿里云服务器一段时间后，感受阿里云真的很不错，就申请作了阿里云大使，而后这是个人优惠券地址.