工厂方法模式

工厂方法模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。（Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses）.
工厂方法模式中，抽象产品类Product负责定义产品的共性，实现对事物最抽象的定义；Creator为抽象创建类，也就是抽象工厂，具体如何创建产品类是由具体的实现工厂ConcreteCreator完成的。类图如下：

工厂方法模式

public abstract class Product {
//产品类的抽象方法
public abstract void Method1();
//产品类的公共方法
public void Method2(){
        System.out.println("abstract Product");
    }
}

public class ConcreteProduct1 extends Product{

    @Override
public void Method1() {
// TODO Auto-generated method stub
        
    }

}

public abstract class Creator {
public abstract <T extends Product> T createProduct(Class<T> c);
}

public class ConcreteCreator extends Creator{

    @Override
public <T extends Product> T createProduct(Class<T> c) {
// TODO Auto-generated method stub
        Product product = null;
try {
            product = (Product)Class.forName(c.getName()).newInstance();
        } catch (InstantiationException e) {
// TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
// TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
            e.printStackTrace();
        }
return (T)product;
    }
}

public class Client{
public static void main(String[] args){
        Creator creator = new ConcreteCreator();
        Product product = creator.createProduct(ConcreteProduct1.class);
        product.Method1();
        product.Method2();
    }
}

工厂方法模式的优点：
- 封装性良好，代码结构清晰，一个对象创建时有条件约束的，如一个调用者需要一个具体的产品对象，只要知道这个产品的类名（约束字符串），降低模块之间的耦合
- 易于扩展，在增加产品类的情况下，只要适当地修改具体的工厂类或扩展一个工厂类，就可以完成。
- 屏蔽了产品类，产品类如何变化，调用者不必关心，它只需要关心产品的接口，只要接口保持不变，系统的上层模块就不会发生改变
- 工厂方法模式是典型的解耦框架。高层模块只需要知道产品的抽象类，其他的实现类都不用关心，符合迪米特法则；不需要的就不去交流，也符合依赖倒置原则，也符合里氏替换原则。
工厂方法的使用场景

首先，在需要创建对象的地方都可以使用工厂方法模式，但是需要慎重地考虑是否增加一个工厂类进行管理，增加代码的复杂度。其次需要灵活的，可扩展的框架时，可以考虑使用工厂方法模式。例如设计一个连接邮件服务器的框架，有三种网络协议可供选择：POP3、IMAP、HTTP，我们就可以把这三种连接方法作为产品类，定义一个接口如IConnectMail，然后定义对邮件的操作方法，用不同的方法实现三个具体的产品类（连接方式），再定义一个工厂方法，按照不同的传入条件，选择不同的连接方式。如此设计，可以做到完美扩展，如某些邮件服务器提供了WebService接口，则只需增加一个产品类就可以了。

工厂方法模式与单例模式

工厂方法模式和单例模式都属于创建类模式，那么我们可以使用工厂方法模式代替单例模式。

- 单例模式的核心要求就是在内存中只有一个对象，通过工厂方法模式也可以在内存中产生一个对象。类图如下：

工厂方法模式

public class Singleton {
private Singleton(){
    }
public void doSomething(){
    }
}

public class SingletonFactory {
private static class SingletonHolder{
private static Singleton singleton;
static{
try{
                Class<?> cl = Class.forName(Singleton.class.getName());
                Constructor<?> constructor = cl.getDeclaredConstructor();
                constructor.setAccessible(true);
                singleton = (Singleton) constructor.newInstance();
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
public static Singleton getSingleton(){
return SingletonHolder.singleton;
    }
}

SingletonFactory不能通过new的方式创建对象，那么您可能会问工厂方法模式如何创建对象呢？答案是以反射的方式创建。“饿汉”创建对象的方式无法使用，则通过静态内部类的方式初始化对象，静态内部类的优点是在当前类加载的时候不是必须实例化Singleton对象，而是在调用getSingleton()方法时才实例化对象。

延迟初始化（Lazy initialization）

一个对象被消费完毕后，并不立即释放，工厂类保持其初始状态，等待再次使用。延迟初始化是工厂方法模式的一个扩展应用，其通用类图如下：

工厂方法模式

public class ProductFactory {
private static final HashMap<String, Product> prMap = new HashMap<String, Product>();
public static synchronized Product createProduct(String type) {
        Product product = null;
if(prMap.containsKey(type))
            product = prMap.get(type);
else{
try{
                product = (Product) Class.forName(type).getDeclaredConstructor().newInstance();
                prMap.put(type, product);
            }catch(Exception e){
                e.printStackTrace();
            }
        }
return product;
    }
}

代码比较简单，通过定义一个HashMap容器容纳所有Product对象，当需要创建对象时，首先从prMap中查找如果存在当前的键，则直接返回，否则创建当前对象，并将创建的对象加入prMap中，以方便下次调用。此方法也可以限制某类产品的最大实例化数量，例如JDBC连接数据库，都会设置一个MaxConnection最大连接数，该数量就是内存中最大实例化数量。

最佳实践

工厂方法模式可以和其它模式（模板方法模式、单例模式、原型模型等）混合使用，变化出无穷的优秀的设计，希望读者可以在实践中自行体会。

秒客网

工厂方法模式

相关文章