设计模式系列-抽象工厂模式-Abstract Factory

抽象工厂模式简介

在之前有一篇文章介绍了，其中有个例子是为不同格式的XML开发了各自的解析器，然后把解析出来的XML打印出来，现在需求有了变化，为不同的客户端提供一组不同的解析器，加入有个客户端命名为 NY，我们为它提供了一组解析器的名称为 NYErrorXMLParser ，NYFeedBackXMLParser,NYOrderXMLParser,NYResponseXMLParser，同样的，我们以为名为TW的客户端提供一组类似命名的解析器。此时，抽象工厂方法模式无法满足我们的需求，我们将为不同的客户端提供一个工厂来生成对应的解析器。抽象工厂设计模式可以解决目前我们遇到的问题。

抽象工厂模式详解

抽象工厂模式提供了一个接口，该接口用来创建一组相关联的对象，在创建时我们不需要提供具体的实现类。

** AbstractFactory **

定义一个接口并提供相应的方法，该方法返回一个接口或抽象类。

** ConcreteFactory **

实现接口 AbstractFactory 的方法，返回具体的实现类的对象。

抽象工厂模式代码实现

public interface AbstractParserFactory {
          
   
    public XmlParser getParserInstance(String parserType);
}
public class NYParserFactory implements AbstractParserFactory {
          
   

    @Override
    public XmlParser getParserInstance(String parserType) {
          
   
        switch (parserType) {
          
   
            case "nyerror":
                return new NYErrorXMLParser();
            case "nyfeedback":
                return new NYFeedbackXMLParser();
            case "nyorder":
                return new NYOrderXMLParser();
            case "nyresponse":
                return new NYResponseXMLParser();
        }
        return null;
    }
}
public interface XmlParser {
          
   

    String parse();

}
public class NYErrorXMLParser implements XmlParser {
          
   

    @Override
    public String parse() {
          
   
        System.out.println("NY Parsing error XML...");
        return "NY Error XML Message";
    }
}
public class NYFeedbackXMLParser implements XmlParser {
          
   

    @Override
    public String parse() {
          
   
        System.out.println("NY Parsing feedback XML...");
        return "NY Feedback XML Message";
    }
}
public class NYOrderXMLParser implements XmlParser {
          
   

    @Override
    public String parse() {
          
   
        System.out.println("NY Parsing order XML...");
        return "NY Order XML Message";
    }
}
public class NYResponseXMLParser implements XmlParser {
          
   
    @Override
    public String parse() {
          
   
        System.out.println("NY Parsing response XML...");
        return "NY Response XML Message";
    }
}
public final class ParserFactoryProducer {
          
   

    private ParserFactoryProducer() {
          
   
    }

    public static AbstractParserFactory getParserFactory(String factoryType) {
          
   

        if ("nyfactory".equals(factoryType)) {
          
   
            return new NYParserFactory();
        }
        return null;
    }
}

public class TestAbstractFactoryPattern {
          
   

    public static void main(String[] args) {
          
   
        AbstractParserFactory parserFactory = ParserFactoryProducer.getParserFactory("nyfactory");
        XmlParser xmlParser = parserFactory.getParserInstance("nyerror");
        System.out.println(xmlParser.parse());

        xmlParser = parserFactory.getParserInstance("nyfeedback");
        System.out.println(xmlParser.parse());
    }
}

抽象工厂模式的使用场景

在如下情境下可以使用：

一个系统和它产品的创建、组装、描述相独立时 一个系统需要创建多个不同组相关联对象时 一组相关的的对象需要一起使用，你需要强制保持这些对象的一致性时 你想提供一个类库，只需要提供接口，不要暴露出具体实现时