每天一个设计模式之Factory

使用工厂类的作用

creates objects without exposing the instantiation logic to the client.

这点是使用工厂模式的主要目的。当client需要一个类的实例时，它并不需要自己去实例化那个类，而是交给工厂去实例化。这样client就不需要知道这个类是怎么实例化的了。

这样对象的使用者和对象本身就解耦合了。

refers to the newly created object through a common interface The implementation is really simple

如何实现

The client needs a product, but instead of creating it directly using the new operator, it asks the factory object （通常就是个工厂类）for a new product, providing the information about the type of object it needs.
The factory instantiates a new concrete product and then returns to the client the newly created product(casted to abstract product class).
The client uses the products as abstract products without being aware about their concrete implementation.

需要注意的是，客户端既不知道，也不关心被实例化的类是什么，而只是得到了一个抽象类。而工厂类本身常常是一个Singleton的类，即工厂类不允许被实例化，而是提供静态方法。

最简单的工厂

public class ProductFactory{
public static Product createProduct(String ProductID){
if (id==ID1)
return new OneProduct();
if (id==ID2) return
return new AnotherProduct();
... // so on for the other Ids

return null; //if the id doesn't have any of the expected values
}
...
}

上例的问题是，每次新增一个新product的时候就需要修改工厂类。为了解决这个问题，工厂需要做一下改变。

更灵活的工厂类

class ProductFactory
{
private HashMap m_RegisteredProducts = new HashMap();

public void registerProduct (String productID, Class productClass)
{
m_RegisteredProducts.put(productID, productClass);
}

public Product createProduct(String productID)
{
Class productClass = (Class)m_RegisteredProducts.get(productID);
Constructor productConstructor = productClass.getDeclaredConstructor(new Class[] { String.class });
//其实这里已经使用了反射。首先使用反射得到了这个类的构造函数。然后使用构造函数实例化这个对象并返回。
return (Product)productConstructor.newInstance(new Object[] { });
}
}

上例的解决方法是，提供一个注册产品的方法。每个注册过的产品都会被放到Map中，且存储productID和product class type。只要是注册过的产品，工厂类就可以实例化该产品。

但是又一个问题：我们必须在调用工厂前完成所有product的注册。如果注册product的代码在调用工厂之后，则会找不到想实例化的类。

这里继续使用反射可以解决问题，大家参考原文吧。

不过我觉得就用noob factory挺好的。后面的方法虽然灵活，但是逻辑过于分散。把class creation都放在factory class里改起来简单。

如果不想使用反射，我们需要的是让每个类自己解决注册的问题，而不是在工厂里注册：

abstract class Product {
public abstract Product createProduct();
}

class OneProduct extends Product {
static // 静态方法在class被JVM load时就会执行，因此一定会在使用工厂类之前被注册。
{
ProductFactory.instance().registerProduct("ID1", new OneProduct());
}

public OneProduct createProduct() {
return new OneProduct();
}
}

class ProductFactory {
public void registerProduct(String productID, Product p) {
m_RegisteredProducts.put(productID, p);
}

public Product createProduct(String productID) {
((Product) m_RegisteredProducts.get(productID)).createProduct();
// 所以不是工厂创建的concrete class
// 而是调用class中的createProduct方法。注意这里没有使用构造函数来实例化对象，而是使用了专门写的createProduct方法。
}
}