设计模式之工厂三剑客：简单工厂模式、工厂方法模式、抽象工厂模式_简单工厂模式,工厂方法模式,抽象工厂模式

工厂模式可以说是设计模式中曝光度比较高的，想想我们的开发框架中，spring中的BeanFactory，日志框架中的LoggerFactory等；而且在日常面试中对于设计模式这部分问的也是比较多。对于工厂这种设计模式，又分为简单工厂模式、工厂方法模式、抽象工厂模式三种，接下来我们通过示例代码分别讲解三种工厂模式的区别。

一、简单工厂模式

通过名称可以知道这是最简单的工厂模式，简单到令人发指，我将简单工厂模式总结为：需要实例化的类都继承同一个父类，通过给工厂传不同的参数来告诉工厂需要实例化哪个具体类。
比如我们定义了一个家用电器抽象类：

/**
 * 电器
 * @author xingo
 *
 */
public abstract class Electric {

	/**
	 * 打开
	 */
	public abstract void open();
	
	/**
	 * 关闭
	 */
	public abstract void close();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

现在有三个类继承自家用电器：电灯、电脑、电视。

/**
 * 电灯
 * @author xingo
 *
 */
public class Light extends Electric {

	@Override
	public void open() {
		System.out.println("打开电灯");
	}

	@Override
	public void close() {
		System.out.println("关闭电灯");
	}

}

/**
 * 电脑
 * @author xingo
 *
 */
public class Computer extends Electric {

	@Override
	public void open() {
		System.out.println("打开电脑");
	}

	@Override
	public void close() {
		System.out.println("关闭电脑");
	}

}

/**
 * 电视
 * @author xingo
 *
 */
public class TV extends Electric {

	@Override
	public void open() {
		System.out.println("打开电视");
	}

	@Override
	public void close() {
		System.out.println("关闭电视");
	}

}
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

然后定义一个简单工厂，它的责任就是负责创建家用电器对象：

public class SimpleFactory {
	
	public static Electric getElectric(String name) {
		if(null == name) {
			return null;
		}
		Electric electric = null;
		switch(name) {
			case "light":
				electric = new Light();
				break;
			case "computer":
				electric = new Computer();
				break;
			case "tv":
				electric = new TV();
				break;
		}
		
		return electric;
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

在需要使用对象时，只需要调用工厂的方法获取对象：

public class Test {

	public static void main(String[] args) {
		Electric electric = SimpleFactory.getElectric("light");
		electric.open();
	}
}
1
2
3
4
5
6
7

简单工厂模式在我们平时开发中也是经常用到的，比如我们平时使用的logback日志框架，logback-spring.xml中有这么一个配置：

<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="60 seconds" debug="false">
    <contextName>test</contextName>

    <!-- 控制台 -->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS}|%thread|[%-5level]|%logger{36}.%method|%msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!--业务日志 文件-->
    <appender name="test" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${user.dir}/logs/test.log</file>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS}|%m%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <FileNamePattern>${user.dir}/logs/test.log.%d{yyyy-MM-dd}</FileNamePattern>
        </rollingPolicy>
    </appender>

    <logger name="test" level="ERROR" additivity="false">
        <appender-ref ref="test"/>
    </logger>

    <!-- 日志级别  決定整体日志的打印级别-->
    <root level="info">
        <appender-ref ref="console"/>
    </root>
</configuration>
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

在这段配置中指定了一个日志输出到test.log文件配置，在代码中如果我要把日志输出到这个日志文件中，就需要获取对应的日志输出：

private static final Logger logger = LoggerFactory.getLogger("test");

logger.error("输出日志|{}|{}", "light", new Date());
1
2
3

对于简单工厂，我们更多的时候不是通过case或条件语句判断实例哪个对象，可以通过反射技术进行对象实例化。当添加了一个新的类时，只要这个类是继承同一个父类，那么简单工厂也不用做代码修改

public class SimpleFactory {
	
	public static <T> T getElectric(Class<T> classz) {
		try {
			return classz.newInstance();
		} catch (InstantiationException | IllegalAccessException e) {
			e.printStackTrace();
		}
		return null;
	}
	
}

public class Test {

	public static void main(String[] args) {
		Electric electric = SimpleFactory.getElectric(Light.class);
		electric.open();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

二、工厂方法模式

先说结论：工厂方法与简单工厂模式对比，是将对象的创建从一个类分散到各个实现类中，通过接口定义创建对象方法，各个实现类负责对象创建。例如还是电器类，对于工厂方法模式是这样实现的：

/**
 * 工厂方法
 * @author xingo
 *
 */
public interface FactoryMethod {

	/**
	 * 创建电器对象
	 * @return
	 */
	Electric createElectric();
}

public class LightFactory implements FactoryMethod {

	@Override
	public Electric createElectric() {
		return new Light();
	}

}

public class ComputerFactory implements FactoryMethod {

	@Override
	public Electric createElectric() {
		return new Computer();
	}

}

public class TVFactory implements FactoryMethod {

	@Override
	public Electric createElectric() {
		return new TV();
	}

}

public class Test {

	public static void main(String[] args) {
		FactoryMethod fm = new LightFactory();
		
		Electric electric = fm.createElectric();
		electric.close();
	}

}
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

这样看来，工厂方法相对于简单工厂非但没有简单，而且还增加了多个类。为什么还要有这个设计模式呢？我们对比简单工厂，比如现在我要增加一种电气：冰箱（Fridge），对于简单工厂我要实现Electric类，还要在简单工厂类中增加一个case；增加类是没有问题的，但是修改简单工厂类就破坏了 开放-封闭 原则。
工厂方法在进行对象变化时也是比简单工厂方便的，比如现在家庭里面有三个灯分别在客厅、卧室、书房，现在我要打开三个灯，使用简单工厂的化要这样写代码：

Electric light1 = SimpleFactory.getElectric("light");
light1.open();

Electric light2 = SimpleFactory.getElectric("light");
light2.open();

Electric light3 = SimpleFactory.getElectric("light");
light13.open();
1
2
3
4
5
6
7
8

代码中一旦出现重复的代码，后期的维护工作就会变得麻烦；如果某一天，我要用其他电器替换电灯，用简单工厂模式我要修改三个获取实例对象的地方。那么换为工厂方法模式呢，以上的代码我改动的可能只是一个地方，就是改变为对应的工厂实现类就可以了，其他地方都不需要进行改动

FactoryMethod fm = new LightFactory();

Electric light1 = fm.createElectric();
light1.open();

Electric light2 = fm.createElectric();
light2.open();

Electric light3 = fm.createElectric();
light13.open();
1
2
3
4
5
6
7
8
9
10

对比一下两种模式：简单工厂模式将对象的创建逻辑进行了封装，客户端只要告诉工厂需要哪个对象工厂就会创建对应的对象；工厂方法模式将判断逻辑转移到了客户端，需要客户端判断决定实例化哪个工厂。

三、抽象工厂

先说抽象工厂的使用场景：是为了解决创建一系列相关或相互依赖对象的接口；说起来比较难理解，下面用一个实例来解释抽象工厂，这个示例也是 程杰所著的《大话设计模式》 中讲解抽象工厂模式时使用的。
比如现在需要对MySQL数据库中两个对象进行操作，分别是UserDao和DepartmentDao，要实现这两个对象的操作，首先要定义两个操作接口：

/**
 * 用户操作
 * @author xingo
 *
 */
public interface UserDao {

	/**
	 * 新增用户
	 */
	void insertUser();
	
	/**
	 * 查找用户
	 * @param id
	 */
	void findUserById(int id);
}

/**
 * 部门操作
 * @author xingo
 *
 */
public interface DepartmentDao {

	/**
	 * 新增部门
	 */
	void insertDepartment();
	
	/**
	 * 查找部门
	 * @param id
	 */
	void findDepartmentById(int id);
}
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

再定义两个MySQL操作实现类：

public class MySqlUserDao implements UserDao {

	@Override
	public void insertUser() {
		System.out.println("MySQL新增用户");
	}

	@Override
	public void findUserById(int id) {
		System.out.println("MySQL查找用户-" + id);
	}
}

public class MySqlDepartmentDao implements DepartmentDao {

	@Override
	public void insertDepartment() {
		System.out.println("MySQL新增部门");
	}

	@Override
	public void findDepartmentById(int id) {
		System.out.println("MySQL查找部门-" + id);
	}
}
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

还需要定义一个工厂用于操作对象的实例化：

/**
 * 数据库创建工厂
 * @author xingo
 *
 */
public interface DbFactory {

	/**
	 * 创建用户操作对象
	 * @return
	 */
	UserDao createUserDao();
	
	/**
	 * 创建部门操作对象
	 * @return
	 */
	DepartmentDao createDepartmentDao();
}

/**
 * MySQL对象创建工厂
 * @author xingo
 *
 */
public class MySqlFactory implements DbFactory {

	@Override
	public UserDao createUserDao() {
		return new MySqlUserDao();
	}

	@Override
	public DepartmentDao createDepartmentDao() {
		return new MySqlDepartmentDao();
	}
}
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

现在如果需要操作对象，只需要实例化MySQL工厂创建对象进行操作就可以了

public class Test {

	public static void main(String[] args) {
		DbFactory db = new MySqlFactory();
		
		//操作用户对象
		UserDao userDao = db.createUserDao();
		userDao.insertUser();
		userDao.findUserById(1);
		
		//操作部门对象
		DepartmentDao departmentDao = db.createDepartmentDao();
		departmentDao.insertDepartment();
		departmentDao.findDepartmentById(1);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

现在如果我的需求发生了变化，不打算使用MySQL数据库，要切换到Oracle数据库，这个时候按照设计模式，共需要创建如下几个类：两个接口UserDao和DepartmentDao的Oracle实现类；工厂接口DbFactory的实现类OracleFactory：

public class OracleUserDao implements UserDao {

	@Override
	public void insertUser() {
		System.out.println("Oracle新增用户");
	}

	@Override
	public void findUserById(int id) {
		System.out.println("Oracle查找用户-" + id);
	}
}

public class OracleDepartmentDao implements DepartmentDao {

	@Override
	public void insertDepartment() {
		System.out.println("Oracle新增部门");
	}

	@Override
	public void findDepartmentById(int id) {
		System.out.println("Oracle查找部门-" + id);
	}
}

/**
 * Oracle对象创建工厂
 * @author xingo
 *
 */
public class OracleFactory implements DbFactory {

	@Override
	public UserDao createUserDao() {
		return new OracleUserDao();
	}

	@Override
	public DepartmentDao createDepartmentDao() {
		return new OracleDepartmentDao();
	}
}
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

这种设计模式看起来是复杂的，增加一个数据库类型要增加三个类，如果数据库中的对象更多那么需要创建的类也会相应增加；但是这样带来的是客户端的简单替换，客户端要切换数据库，只需要修改一个地方：将原来实例化MySqlFactory的地方修改为OracleFactory即可，其他代码不需要改动：

public class Test {

	public static void main(String[] args) {
		DbFactory db = new OracleFactory();
		
		//操作用户对象
		UserDao userDao = db.createUserDao();
		userDao.insertUser();
		userDao.findUserById(1);
		
		//操作部门对象
		DepartmentDao departmentDao = db.createDepartmentDao();
		departmentDao.insertDepartment();
		departmentDao.findDepartmentById(1);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

总结一下抽象工厂的优点：（1）当代码中需要切换一系列对象的创建时，由于抽象工厂将相关的实现类进行了很好的封装，这就使得改变一个应用的具体实现变得非常容易；（2）创建实例的过程与客户端分离，客户端是通过他们的抽象接口操纵实例，产品的具体实现类被工厂的实现分离，不会出现在客户代码中。

对比以上三种工厂模式，我们可以总结如下内容：
一、简单工厂模式是根据传递参数的不同进行对应对象的实例化，这种设计模式简单，但是当增加相应的类时需要修改简单工厂的case语句，这样就破坏类的封装性，不过我们可以通过反射技术解决这个问题。
二、工厂方法模式有效解决了简单工厂模式的问题，它是将对象的创建过程交给具体的工厂实现类，这样一来具体实现哪个工厂的决定权由客户端来判断，增加了客户端的判断逻辑。
三、抽象工厂解决的是一系列相关或相互依赖对象接口的创建，它只在初始化的时候出现一次，这样带来的好处就是改变一个应用变得非常简单；而且所有操作都是针对抽象接口进行的，有效隔离了具体实现类。缺点就是当增加一个操作接口时，需要增加多个接口实现类。