浅谈设计模式之工厂模式

 最近学习设计模式的知识，和大家一起分享

 

设计模式：是指在软件开发中，经过验证的，用于解决在特定环境下，重复出现的、特定问题的解决方案。

     在学习设计模式之前，我们要回顾一下接口的知识。java应用开发中，要“面向接口编程”。接口的核心思想就是“封装隔离”，使用接口的好处，由于外部调用和内部实现被接口隔离开了，那么只要接口不变，内部实现的变化不会影响到尾部应用，从而使得系统更灵活，具有更好的扩展性和可维护性，因此我们说，接口是系统可插拔性的保证。

     接口和抽象类的选择原则：1.优先选用接口；2.在既要定义子类的行为，又要为子类提供公共的功能时应选择抽象类。

 

简单工厂

定义：提供一个创建对象实例的功能，而无须关心其具体实现。被创建实例的类型可以是接口、抽象类，也可以是具体的实现。示例代码如下

定义接口：

package com.wxl.simplefactory;

/**
 * 接口的定义，该接口可以通过简单工厂来创建
 */
public interface Api {
	public void operation(String s);
} 

对接口的实现：

package com.wxl.simplefactory;
/**
 * 对接口api的实现 
 */
public class ImplA implements Api {

	@Override
	public void operation(String s) {
		System.out.println("ImplA s == "+s);
	}
}

package com.wxl.simplefactory;
/**
 * 对接口api的实现 
 */
public class ImplB implements Api {

	@Override
	public void operation(String s) {
		System.out.println("ImplB s == "+s);
	}
}

工厂类：

package com.wxl.simplefactory;

public class Factory {
	public static Api createApi(int condition){
		Api api = null;
		//可根据某些外在条件选择究竟创建哪一个具体的实现对象
		if(condition == 1){
			api = new ImplA();
		}else if(condition == 2){
			api = new ImplB();
		}
		return api;
	}
}

说明：使用简单工厂的时候，通常不用创建简单工厂类的类实例，没有创建实例的必要。因此可以把简单工厂类实现成一个工具类，直接使用静态方法就可以了，也就是说简单工厂的方法通常都是静态的，所以也被称为静态工厂。如果要防止客户端无谓的创造简单工厂实例，还可以把简单工厂的构造方法私有化了。

     虽然从理论上讲，简单工厂什么都能造，但对于简单工厂可创建对象的范围，通常不要太大，建议控制在一个独立的组件级别或者一个模块级别，也就是一个组件或模块一个简单工厂。否则这个简单工厂类会职责不明，有点大杂烩的感觉。

     由于是从客户端在调用工厂的时候，传入选择的参数，这就说明客户端必须知道每个参数的含义，也需要理解每个参数对应的功能处理。这就要求必须在一定程度上，向客户暴露一定的内部实现细节。

     另外，我们可以把要创建的类的实现写到配置文件里，在工厂里利用反射机制(Class.forName(...).newInstance())选择要创建的类。

 客户端：

package com.wxl.simplefactory;

public class Client {
	public static void main(String[] args) {
		Api apiA = Factory.createApi(1);
		apiA.operation("ImplA");
		Api apiB = Factory.createApi(2);
		apiB.operation("ImplB");
	}
}

 

 运行结果：

ImplA s == ImplA
ImplB s == ImplB

 下面我们来看看工厂方法模式。

 

工厂方法模式

      首先我们回顾一下有关框架的知识简单点说：框架就是能完成一定功能的半成品软件。
      就其本质而言，框架是一个软件，而且是一个半成品的软件。所谓半成品，就是还不能完全实现用户需要的功能，框架只是实现用户需要的功能的一部分，还需要进一步加工，才能成为一个满足用户需要的、完整的软件。因此框架级的软件，它的主要客户是开发人员，而不是最终用户。

      如果没有框架，那么客户要求的所有功能都由开发人员自己来开发，没问题，同样可以实现用户要求的功能，只是开发人员的工作多点。
      如果有了框架，框架本身完成了一定的功能，那么框架已有的功能，开发人员就可以不做了，开发人员只需要完成框架没有的功能，最后同样是完成客户要求的所有功能，但是开发人员的工作就减少了。
      也就是说，基于框架来开发，软件要完成的功能并没有变化，还是客户要求的所有功能，也就是“事情还是那些事情”的意思。但是有了框架过后，框架完成了一部分功能，然后开发人员再完成一部分功能，最后由框架和开发人员合起来完成了整个软件的功能，也就是看这些功能“由谁做”的问题。基于框架开发，可以不去做框架所做的事情，但是应该明白框架在干什么，以及框架是如何实现相应功能的。

      接下来我们用工厂方法模式来做一个导出数据的小小框架。

示例代码：

package com.wxl.factorymethod;
/**
 * 数据导出接口
 */
public interface ExportFileApi {
	public boolean export(String data);
}

 对接口的实现：
package com.wxl.factorymethod;
/**
 * 导出成文本格式
 */
public class ExportTxtFile implements ExportFileApi {
	@Override
	public boolean export(String data) {
		System.out.println("导出数据"+data+"到文本文件");
		return true;
	}
}

package com.wxl.factorymethod;
/**
 * 导出成数据库备份文件形式
 */
public class ExportDB implements ExportFileApi {
	@Override
	public boolean export(String data) {
		System.out.println("导出数据"+data+"到数据库文件");
		return true;
	}
}

 抽象类：

package com.wxl.factorymethod;

public abstract class ExportOperate {
	/**
	 * 抽象类
	 * 对外提供导出方法实现接口
	 * 对内提供接口调用
	 * factory method方法关键之所在
	 */
	protected abstract ExportFileApi factoryMethod();
	public boolean export(String data){
		ExportFileApi api = factoryMethod();
		return api.export(data);
	}
}

生产文本格式导出类实例：

package com.wxl.factorymethod;

public class ExportTxtFileOperate extends ExportOperate {
	@Override
	protected ExportFileApi factoryMethod() {
		return new ExportTxtFile();
	}
}

生产数据库备份格式导出类实例：

package com.wxl.factorymethod;

public class ExportDBOperate extends ExportOperate{
	@Override
	protected ExportFileApi factoryMethod() {
		return new ExportDB();
	}
}

 

 

客户端:

package com.wxl.factorymethod;

public class Client {
	public static void main(String[] args) {
		ExportOperate operateTxt = new ExportTxtFileOperate();
		operateTxt.export("123");
		System.out.println("===========");
		ExportOperate operateDB = new ExportDBOperate();
		operateDB.export("123");
	}
}

运行结果：

导出数据123到文本文件
===========
导出数据123到数据库文件

     工厂方法的主要功能是让父类在不知道具体实现的情况下，完成自身的功能调用，而具体的实现延迟到子来实现。这样在设计的时候，不用去考虑具体的实现，需要某个对象，把它通过工厂方法返回就好了，在使用这些对象实现功能的时候还是通过接口来操作。

     工厂方法可以实现成抽象类，工厂方法的实现中，通常父类会是一个抽象类，里面包含创建所需对象的抽象方法，这些抽象方法就是工厂方法。这里要注意一个问题，子类在实现这些抽象方法的时候，通常并不是真的由子类来实现具体的功能，而是在子类的方法里面做选择，选择具体的产品实现对象。父类里面，通常会有使用这些产品对象来实现一定的功能的方法，而且这些方法所实现的功能通常都是公共的功能，不管子类选择了何种具体的产品实现，这些方法的功能总是能正确执行。

     工厂方法也可以实现成具体的类，，这种情况下，通常是在父类中提供获取所需对象的默认实现方法，这样就算没有具体的子类，也能够运行。通常这种情况还是需要具体的子类来决定具体要如何创建父类所需要的对象。也把这种情况称为工厂方法为子类提供了挂钩，通过工厂方法，可以让子类对象来覆盖父类的实现，从而提供更好的灵活性。

       以上介绍是典型的工作方法的实现，实际应用中我们可以根据需求的不同适当改变工厂方法，以使其使用起来更加方便。