设计模式学习－抽象工厂模式

1.定义

提供接口，创建一系列相关或独立的对象，而不指定这些对象的具体类。

2.类图

3.代码示例

package com.zhaoyangwoo.abstractfactory;

/**
 * Created by john on 16/5/2.
 * @author wuzhaoyang
 * <p>
 *      抽象工厂：多个抽象产品类，派生出多个具体产品类；一个抽象工厂类，派生出多个具体工厂类；每个具体工厂类可创建多个具体产品类的实例。
 *      即提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们的具体的类。“一对多”的关系。
 * </p>
 */
public class AbstractFactory {

    public static void main(String[] args) {
        Factory factory1= new Factory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.getName();
        productB1.getBrand();

        Factory factory2= new Factory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.getName();
        productB2.getBrand();

    }
}


interface ProductA{
    void getName();
}

interface ProductB{
    void getBrand();
}

interface Factory{
    ProductA createProductA();
    ProductB createProductB();
}

class ProductA1 implements ProductA{

    @Override
    public void getName() {
        System.out.println("i'm productA1");
    }
}

class ProductA2 implements ProductA{

    @Override
    public void getName() {
        System.out.println("i'm productA2");
    }
}

class ProductB1 implements ProductB{

    @Override
    public void getBrand() {
        System.out.println("i'm productB1");
    }
}

class ProductB2 implements ProductB{

    @Override
    public void getBrand() {
        System.out.println("i'm productB2");
    }
}

class Factory1 implements Factory{

    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB1();
    }
}

class Factory2 implements Factory{

    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB2();
    }
}

4.应用场景举例

• 创建复杂对象，隔离对象创建的具体过程
• 客户端不需要知道具体产品类的类名，只需要知道所对应的具体工厂即可，具体的产品对象由具体工厂类创建； 

5.JDK源码中的模式实现

　　为响应《设计模式－工厂模式》的思考1，不打算区分工厂方法和抽象工厂的实现。但是为了更好的理解，我们看javax.xml.transform.TransformerFactory的源码实现。

抽象工厂角色：

package javax.xml.transform;

/**
 * 我们看作者的注释明确写到,这个"abstractFactory"是用来创建Transformer和Templates两个产品族"product"
 * 
 * 
 * <p>A TransformerFactory instance can be used to create
 * {@link javax.xml.transform.Transformer} and
 * {@link javax.xml.transform.Templates} objects.</p>
 *
 */
public abstract class TransformerFactory {

    /**
     * Default constructor is protected on purpose.
     */
    protected TransformerFactory() { }


    ...
    
    public abstract Transformer newTransformer(Source source)
            throws TransformerConfigurationException;



    public abstract Templates newTemplates(Source source)
            throws TransformerConfigurationException;

    ...

}

抽象产品角色：

//两个抽象产品,构成产品族
public abstract class Transformer {

    /**
     * Default constructor is protected on purpose.
     */
    protected Transformer() { }

     ...
}

public interface Templates {

    ...

    Transformer newTransformer() throws TransformerConfigurationException;

    ...
}

具体工厂角色：

public class TransformerFactoryImpl
        extends SAXTransformerFactory implements SourceLoader, ErrorListener
{

    @Override
    public Transformer newTransformer()
            throws TransformerConfigurationException
    {
        TransformerImpl result = new TransformerImpl(new Properties(),
                _indentNumber, this);
        if (_uriResolver != null) {
            result.setURIResolver(_uriResolver);
        }

        if (!_isNotSecureProcessing) {
            result.setSecureProcessing(true);
        }
        return result;
    }

    @Override
    public Templates newTemplates(Source source)
            throws TransformerConfigurationException
    {
        // If the _useClasspath attribute is true, try to load the translet from
        // the CLASSPATH and create a template object using the loaded
        // translet.
        if (_useClasspath) {
            String transletName = getTransletBaseName(source);

            if (_packageName != null)
                transletName = _packageName + "." + transletName;

            try {
                final Class clazz = ObjectFactory.findProviderClass(transletName, true);
                resetTransientAttributes();

                return new TemplatesImpl(new Class[]{clazz}, transletName, null, _indentNumber, this);
            }
            catch (ClassNotFoundException cnfe) {
                ErrorMsg err = new ErrorMsg(ErrorMsg.CLASS_NOT_FOUND_ERR, transletName);
                throw new TransformerConfigurationException(err.toString());
            }
            catch (Exception e) {
                ErrorMsg err = new ErrorMsg(
                        new ErrorMsg(ErrorMsg.RUNTIME_ERROR_KEY)
                                + e.getMessage());
                throw new TransformerConfigurationException(err.toString());
            }
        }
        ...

        return new TemplatesImpl(bytecodes, transletName,
                xsltc.getOutputProperties(), _indentNumber, this);
    }


}

具体产品角色：

public final class TransformerImpl extends Transformer
    implements DOMCache, ErrorListener
{
...
}
public final class TemplatesImpl implements Templates, Serializable {
...
}

6.思考

• 抽象工厂最大的特点在哪里？

　　最明显的在于扩展产品等级（具体工厂）很容易，但扩展产品族（具体产品）很难。由本文的代码实现可以看出，如果我这个时候给工厂添加新任务，生产ProductC，那需要怎么做？首先我必须修改Factory类添加
createProductC():ProductC 方法，另外最麻烦的是所有实现Factory的工厂都必须修改实现该方法。但是如果我需要Factory3来生产另一质量等级的ProductA3和ProductB3，只需要添加一个Factory3实现即可。

• javax.xml.xpath.XPathFactory和javax.xml.parsers.DocumentBuilderFactory运用的是抽象工厂？

         首先我还是要声明一点，不管你用的是抽象工厂也好还是工厂方式也罢，本质上都是一样的，通过工厂封装产品生产的具体过程，客户端只需给出需要的产品，无需关心生产过程。

         其次抽象工厂和工厂方法唯一的区别就是是否构成产品族。

　　　这两个类的产品族有点变异，我们拿javax.xml.xpath.XPathFactory 举例，它的产品族包含两个产品：

1. 1. public static XPathFactory newInstance();

   2. public abstract XPath newXPath();

    其中一个产品不能是自己吗？有疑问的请移步《设计模式－工厂模式》的思考问题2 　　　　　　　　　　　　　　

7.参考

　　1.《JAVA与模式》之抽象工厂模式

　　2.设计模式：工厂方法模式（Factory Method）和抽象工厂模式(Abstact Factory)