2.2 工厂方法模式
** 定义：**
定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
2.2.1 工厂方法模式
优点：
- 良好的封装性，代码结构清晰。对象创建只需要知道产品的类名，不用知道对象创建的过程
- 扩展性非常优秀。增加产品，只要适当修改具体的工厂类或扩展一个工厂类
- 屏蔽产品类。产品类的实现如何变化，调用者都不用关心。
ex：使用JDBC连接数据库，数据库从MySQL切换到Oracle，只需要改动一下驱动的名称。
- 典型的解耦扩建。高层模块只需要知道产品的抽象类，符合迪米特法则；只依赖产品类的抽象，符合依赖倒置原则；可用产品的子类代替父类，符合里氏替换原则
使用场景：
- 工厂方法模式是new一个对象的替代品，所以在需要new 对象的地方都可以使用。但需慎重考虑是否要增加一个工厂类进行管理，以免增加代码复杂度。
- 需要灵活的、可扩展的框架时，可以考虑。
ex：设计一个连接邮件服务器的框架，POP3、IMAP、HTTP三协议的连接方式作为产品类来处理。当某些邮件服务器扩展了webservice协议时，只需要增加webservice的产品类
- 可以用在异构项目中。
ex：通过webservice与一个非java的项目交互，虽然webServcie号称是可以做到异构系统的同构化，但是在实际的开发中，会碰到类型问题、WSDL文件的支持问题等。从WSDL中产生的对象都认为是一个产品，然后由具体工厂管理，减少与外围的耦合。
- 可以使用在测试框架中。
ex：测试类A，就需要把与A有联系的B也同时产生出来。可以使用工厂方法模式把B虚拟出来，避免A与B 的耦合。可对比JMock、EasyMock。
代码：
//抽象产品类
abstract class Product{
public void method1(){}//公共方法
public abstract void method2();//抽象方法
}
//具体产品类
class CreateProduct1 extends Product{
public void method2(){}
}
class CreateProduct2 extends Product{
public void method2(){}
}
//抽象工厂
abstract class Creator{
public abstract <T extends Product> T createProduct(Class<T> c);
}
//具体工厂
class CreateCreator extends Creator{
public <T extends Product> T createProduct(Class<T> c){
Product p = null;
try{
p = (Product) Class.forName(c.getName()).newInstance();
}catch(Exception e){
}
return (T)p;
}
}
//场景类
class Client{
public static void main(String[] args){
Creator creator = new CreateCreator();
Product p = creator.createProduct(CreateProduct1.class);
}
}
2.2.2 扩展-简单工厂模式
需求：
一个模块仅需要一个工厂类，没有必要把它new 出来，使用静态方法就可以了。
代码：
//具体工厂
class CreateCreator {
public static <T extends Product> T createProduct(Class<T> c){
Product p = null;
try{
p = (Product) Class.forName(c.getName()).newInstance();
}catch(Exception e){
}
return (T)p;
}
}
//场景类
class Client{
public static void main(String[] args){
Product p = CreateCreator.createProduct(CreateProduct1.class);
}
}
2.2.3 扩展-多个工厂类
需求：
项目比较复杂，初始化一个对象比较费力（设定初始值），所有产品类都放在一个工厂方法中进行初始化会使代码结构不清晰。
如：一个抽象产品类有5个具体实现，每个实现类的初始化方法都不相同，如果写在一个方法中，会导致该方法巨大无比。
解决：
为每个产品定义一个创造者，然后由调用者自己去选择与哪个工厂方法关联。
结果：
每个产品类对应一个具体工厂，好处是工厂类的职责清晰且结构简单，但可扩展性和可维护性有影响：
如果要扩展一个产品类，就要建立一相应的工厂，这样就增加了扩展的难度；具体工厂类和产品类的数目相同，维护需要考虑两者的关系。
代码：
//具体工厂1
class CreateCreator1 extends Creator{
public Product createProduct(){
return new CreateProduct1();
}
}
//具体工厂2
class CreateCreator2 extends Creator{
public Product createProduct(){
return new CreateProduct2();
}
}
//场景类
class Client{
public static void main(String[] args){
Product cp1 = (new CreateCreator1()).createProduct();
Product cp2 = (new CreateCreator2()).createProduct();
}
}
2.2.4 替代单例模式
扩展：
项目中可以建一个单例构造器，只要输入单例的类型就可以获得唯一的实例
代码：
class Singleton{
private Singleton(){}
public void doSomething(){}
}
class SingletonFactory{
private static Singleton single;
static{
try {
Class cls = Class.forName(Singleton.class.getName());
Constructor constructor = cls.getDeclaredConstructor();
constructor.setAccessible(true);
single = (Singleton) constructor.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
}
public static Singleton getSingleton(){
return single;
}
}
2.2.5 延迟初始化
延迟初始化：lazy initialization 一个对象被消费完毕，不立即释放，工厂类保持其初始状态，等待再次被使用。
扩展：
限制某个产品类的最大实例化数量，可以通过判断map中的已有对象数量来实现。参考：JDBC连接数据库，可以设置一个MaxConnection最大连接数，该数量就是内存中的最大实例化的数量。
其它应用场景：
对象初始化比较复杂，如硬件访问，涉及多方面的交互，可以通过延迟加载降低对象的产生和销毁带来的复杂性。
