初识工厂方法模式
定义
定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory
Method使一个类的实例化延迟到其子类。
结构和说明
- Product：定义工厂方法所创建的对象的接口，也就是实际需要使用的对象的接口
- ConcreteProduct：具体的Product接口的实现对象。
- Creator：创建器，声明工厂方法
- ConcreteCreator：具体的创建器对象，覆盖实现Creator定义的工厂方法，返回具体的Product实例
示例代码
工厂方法所创建的对象的接口
package cn.javass.dp.factorymethod.example2;
/**
* 工厂方法所创建的对象的接口
*/
public interface Product {
//可以定义Product的方法
}
具体的Product对象
package cn.javass.dp.factorymethod.example2;
/**
* 具体的Product对象
*/
public class ConcreteProduct implements Product {
//实现Product要求的方法
}
创建器，声明工厂方法
package cn.javass.dp.factorymethod.example2;
/**
* 创建器，声明工厂方法
*/
public abstract class Creator {
/**
* 创建Product的工厂方法
* @return Product对象
*/
protected abstract Product factoryMethod();
/**
* 示意方法，实现某些功能的方法
*/
public void someOperation() {
//通常在这些方法实现中，需要调用工厂方法来获取Product对象
Product product = factoryMethod();
}
}
具体的创建器实现对象
package cn.javass.dp.factorymethod.example2;
/**
* 具体的创建器实现对象
*/
public class ConcreteCreator extends Creator {
public Product factoryMethod() {
//重定义工厂方法，返回一个具体的Product对象
return new ConcreteProduct();
}
}
体会工厂方法模式
导出数据的应用框架
考虑这样一个实际应用：实现一个导出数据的应用框架，来让客户选择数
据的导出方式，并真正执行数据导出。
通常这种系统，在导出数据上，会有一些约定的方式，比如导出成：文本
格式、数据库备份形式、Excel格式、Xml格式等等。
不用模式的解决方案
直接参看代码示例
导出的文件对象的接口
package cn.javass.dp.factorymethod.example1;
/**
* 导出的文件对象的接口
*/
public interface ExportFileApi {
/**
* 导出内容成为文件
* @param data 示意：需要保存的数据
* @return 是否导出成功
*/
public boolean export(String data);
}
导出成文本文件格式的对象
package cn.javass.dp.factorymethod.example1;
/**
* 导出成文本文件格式的对象
*/
public class ExportTxtFile implements ExportFileApi{
public boolean export(String data) {
//简单示意一下，这里需要操作文件
System.out.println("导出数据"+data+"到文本文件");
return true;
}
}
导出成xml格式的对象
package cn.javass.dp.factorymethod.example1;
/**
* 导出成xml格式的对象
*/
public class ExportXmlFile implements ExportFileApi{
public boolean export(String data) {
//简单示意一下，这里需要操作文件
System.out.println("导出数据"+data+"到xml文件");
return true;
}
}
导出成数据库备份文件形式的对象
package cn.javass.dp.factorymethod.example1;
/**
* 导出成数据库备份文件形式的对象
*/
public class ExportDB implements ExportFileApi{
public boolean export(String data) {
//简单示意一下，这里需要操作数据库和文件
System.out.println("导出数据"+data+"到数据库备份文件");
return true;
}
}
实现导出数据的业务功能对象
package cn.javass.dp.factorymethod.example1;
/**
* 实现导出数据的业务功能对象
*/
public class ExportOperate {
/**
* 导出文件
* @param type 用户选择的导出类型
* @param data 需要保存的数据
* @return 是否成功导出文件
*/
public boolean export(int type,String data){
//先完成各种导出数据前的准备工作
//比如进行数据校验
System.out.println("now 进行数据校验");
//比如进行数据转换
System.out.println("now 进行数据转换");
//比如进行数据格式的封装
System.out.println("now 进行数据格式的封装");
//然后才真正的去导出
ExportFileApi api = null;
//根据类型来选择究竟要创建哪一种导出文件对象
if(type == 1){
api = new ExportTxtFile();
}else if(type == 2){
api = new ExportDB();
}else if(type==3){
api = new ExportXmlFile();
}
return api.export(data);
}
}
客户端
package cn.javass.dp.factorymethod.example1;
public class Client {
public static void main(String[] args) {
ExportOperate operate = new ExportOperate();
operate.export(1, "要导出的测试数据");
}
}
存在的问题
对于实现导出数据的业务功能对象，它需要创建ExportFileApi的具体实例
对象，但是它只知道ExportFileApi接口，而不知道其具体的实现。那该怎么办
呢？
使用模式的解决方案
直接参看代码示例
其他的不变，添加一些实现
实现导出数据的业务功能对象
package cn.javass.dp.factorymethod.example3;
/**
* 实现导出数据的业务功能对象
*/
public abstract class ExportOperate {
public ABC createABC(String name){
return new ABC(name,factoryMethod());
}
/**
* 导出文件
* @param data 需要保存的数据
* @return 是否成功导出文件
*/
public boolean export(String data){
//先完成各种导出数据前的准备工作
//比如进行数据校验
System.out.println("now 进行数据校验");
//比如进行数据转换
System.out.println("now 进行数据转换");
//比如进行数据格式的封装
System.out.println("now 进行数据格式的封装");
//然后才真正的去导出
//使用工厂方法
ExportFileApi api = factoryMethod();
return api.export(data);
}
/**
* 工厂方法，创建导出的文件对象的接口对象
* @return 导出的文件对象的接口对象
*/
protected abstract ExportFileApi factoryMethod();
//既要约束子类的行为，又要为子类提供公共的功能
}
具体的创建器实现对象，实现创建导出成文本文件格式的对象
package cn.javass.dp.factorymethod.example3;
/**
* 具体的创建器实现对象，实现创建导出成文本文件格式的对象
*/
public class ExportTxtFileOperate extends ExportOperate{
protected ExportFileApi factoryMethod() {
//创建导出成文本文件格式的对象
return new ExportTxtFile();
}
}
实现创建导出成xml格式的对象
package cn.javass.dp.factorymethod.example3;
/**
* 导出成文本文件格式的对象
*/
public class ExportXmlFileOperate extends ExportOperate{
@Override
protected ExportFileApi factoryMethod() {
return new ExportXmlFile();
}
}
具体的创建器实现对象，实现创建导出成数据库备份文件形式的对象
package cn.javass.dp.factorymethod.example3;
/**
* 具体的创建器实现对象，实现创建导出成数据库备份文件形式的对象
*/
public class ExportDBOperate extends ExportOperate{
protected ExportFileApi factoryMethod() {
//创建导出成数据库备份文件形式的对象
return new ExportDB();
}
}
客户端
package cn.javass.dp.factorymethod.example3;
public class Client {
public static void main(String[] args) {
// //创建需要使用的Creator对象
ExportOperate operate = new ExportXmlFileOperate();
//调用输出数据的功能方法
operate.export("测试数据");
// ABC abc = new ExportOperate().createABC("cc");
// abc.test();
}
}
理解工厂方法模式
认识工厂方法模式
1：工厂方法模式的功能
工厂方法的主要功能是让父类在不知道具体实现的情况下，完成自身的功
能调用，而具体的实现延迟到子类来实现。
2：实现成抽象类
工厂方法的实现中，通常父类会是一个抽象类，里面包含创建所需对象的抽象方
法，这些抽象方法就是工厂方法
3：实现成具体的类
也可以把父类实现成为一个具体的类，这种情况下，通常是在父类中提供获取所
需对象的默认实现方法，这样就算没有具体的子类，也能够运行。
4：工厂方法的参数和返回值
工厂方法的实现中，可能需要参数，以便决定到底选用哪一种具体的实现。
一般工厂方法返回的是被创建对象的接口对象，当然也可以是抽象类或者一个具
体的类的实例。
5：谁来使用工厂方法创建的对象
- （1）在工厂方法模式里面，应该是Creator中的其它方法在使用工厂方法创建的
对象 - （2）客户端应该是使用Creator对象，或者是使用由Creator创建出来的对象，
这个时候工厂方法创建的对象，是Creator中的某些方法使用。 （3）在某些情况下，客户端可能会使用由Creator创建出来的对象，这个时候工
厂方法创建的对象，是构成客户端需要的对象的一部分。小结一下：在工厂方法模式里面，客户端要么使用Creator对象，要么使用
Creator创建的对象，一般客户端不直接使用工厂方法。当然也可以直接把工厂
方法暴露给客户端操作，但是一般不这么做。
工厂方法模式的调用顺序示意图
先看看客户端使用由Creator创建出来的对象情况的调用顺序示意图
接下来看看客户端使用Creator对象时候的调用顺序示意图
工厂方法模式与IoC/DI
1：概念
- 依赖注入：应用程序依赖容器创建并注入它所需要的外部资源
- 控制反转：容器控制应用程序，由容器反向的向应用程序注入应用程序所需要的
外部资源。
2：理解
- (1)参与者都有谁？
- (2)依赖：谁依赖于谁？为什么需要依赖？
- (3)注入：谁注入于谁？到底注入什么？
- (4)控制反转：谁控制谁？控制什么？为何叫反转（有反转就应该有正转了）？
- (5)依赖注入和控制反转是同一概念吗？
3：过程
没有IoC/DI的时候，常规的A类使用C类的示意图
有了IoC/DI的容器后，A类不再主动去创建C了
而是被动等待，等待IoC/DI的容器获取一个C的实例，然后反向的注入到A类中
4：思想
其实IoC/DI对编程带来的最大改变不是从代码上，而是从思想上，发生了
“==主从换位==”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但
是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC/DI容器来创建并
注入它所需要的资源了。
这么小小的一个改变其实是编程思想的一个大进步，这样就有效的分离了
对象和它所需要的外部资源，使得它们松散耦合，有利于功能复用，更重要的是
使得程序的整个体系结构变得非常灵活。
工厂方法模式和IoC/DI的关系
他们的思想很类似，都是“主动变被动”，进行“主从换位”，从而获得更灵活
的程序结构
平行的类层次结构
（1）什么是平行的类层次结构呢？
简单点说，假如有两个类层次结构，其中一个类层次中的每个类在另一个
类层次中都有一个对应的类的结构，就被称为平行的类层次结构。
2）这种平行的类层次结构用来干什么呢？
主要用来把一个类层次中的某些行为分离出来，让类层次中的类把原本属
于自己的职责，委托给分离出来的类去实现，从而使得类层次本身变得更简单，
更容易扩展和复用。
（3）工厂方法模式跟平行的类层次结构有何关系呢？
可以使用工厂方法模式来连接平行的类层次。
看上面的示例图，在每个硬盘对象里面，都有一个工厂方法
createHDOperate，通过这个工厂方法，客户端就可以获取一个跟硬盘对象相对
应的行为对象。
参数化工厂方法
所谓参数化工厂方法指的就是：通过给工厂方法传递参数，让工厂方法根
据参数的不同来创建不同的产品对象
（1）先看代码示例
参数工厂
package cn.javass.dp.factorymethod.example7;
public class MyFactory {
private MyFactory(){
}
public static ExportFileApi factoryMethod(int type){
ExportFileApi api = null;
//根据类型来选择究竟要创建哪一种导出文件对象
if(type==1){
api = new ExportTxtFile();
}else if(type==2){
api = new ExportDB();
}
return api;
}
}
实现导出数据的业务功能对象
package cn.javass.dp.factorymethod.example7;
/**
* 实现导出数据的业务功能对象
*/
public class ExportOperate {
/**
* 导出文件
* @param type 用户选择的导出类型
* @param data 需要保存的数据
* @return 是否成功导出文件
*/
public boolean export(int type,String data){
//使用工厂方法
ExportFileApi api = MyFactory.factoryMethod(type);
return api.export(data);
}
/**
* 工厂方法，创建导出的文件对象的接口对象
* @param type 用户选择的导出类型
* @return 导出的文件对象的接口对象
*/
}
扩展ExportOperate对象，加入可以导出XML文件
package cn.javass.dp.factorymethod.example7;
/**
* 扩展ExportOperate对象，加入可以导出XML文件
*/
public class ExportOperate2 extends ExportOperate{
/**
* 覆盖父类的工厂方法，创建导出的文件对象的接口对象
* @param type 用户选择的导出类型
* @return 导出的文件对象的接口对象
*/
// protected ExportFileApi factoryMethod(int type){
// ExportFileApi api = null;
// //可以全部覆盖，也可以选择自己感兴趣的覆盖，
// //这里只想添加自己新的实现，其他的不管
// if(type==3){
// api = new ExportXml();
// }else{
// //其他的还是让父类来实现
// api = super.factoryMethod(type);
// }
// return api;
// }
}
客户端
package cn.javass.dp.factorymethod.example7;
public class Client {
public static void main(String[] args) {
//创建需要使用的Creator对象
// ExportOperate operate = new ExportOperate();
// //调用输出数据的功能方法，传入选择到处类型的参数
// operate.export(1,"测试数据");
//创建需要使用的Creator对象
ExportOperate operate = new ExportOperate2();
// //下面变换传入的参数来测试参数化工厂方法
// operate.export(1,"Test1");
// operate.export(2,"Test2");
// operate.export(3,"Test3");
}
}
（2）再体会一下，当需要扩展新的实现，使用参数化工厂方法，扩展起来会常容易
工厂方法模式的优缺点
- 1：可以在不知具体实现的情况下编程
- 2：更容易扩展对象的新版本
- 3：连接平行的类层次
- 4：具体产品对象和工厂方法的耦合性
思考工厂方法模式
工厂方法模式的本质
工厂方法模式的本质是：延迟到子类来选择实现
对设计原则的体现
工厂方法模式很好的体现了“依赖倒置原则”。
依赖倒置原则告诉我们“要依赖抽象，不要依赖于具体类”，简单点说就
是：不能让高层组件依赖于低层组件，而且不管高层组件还是低层组件，都应该
依赖于抽象。
何时选用工厂方法模式
- 1：如果一个类需要创建某个接口的对象，但是又不知道具体的实现，这种情况可以
选用工厂方法模式，把创建对象的工作延迟到子类去实现 - 2：如果一个类本身就希望，由它的子类来创建所需的对象的时候，应该使用工厂方
法模式
