工厂方法

转载

mb5ff981a16d1dd 2021-10-13 00:41:00

文章标签 xml 配置文件工厂类类对象简单工厂模式 文章分类 代码人生

工厂方法

简单工厂（Simple Factory）

文中举例

在下面这段代码中，我们根据配置文件的后缀（json、xml、yaml、properties），选择不同的解析器（JsonRuleConfigParser、XmlRuleConfigParser……），将存储在文件中的配置解析成内存对象RuleConfig。
类 RuleConfigSource
方法 private String getFileExtension(String filePath) 解析文件名获取扩展名。
方法 public RuleConfig load(StringruleConfigFilePath) 中调用 getFileExtension(ruleConfigFilePath)，然后根据获取的扩展名写一堆 ifelse 选择解析器 parser，最后输出 RuleConfig。

重构一

将方法 public RuleConfig load(StringruleConfigFilePath) 中选择解析器 parser 的代码提取出来，生成方法 private IRuleConfigParser createParser(String configFormat)。

重构二（简单工厂模式一）

将“重构一”中生成的方法 private IRuleConfigParser createParser(String configFormat) 进一步剥离到一个新的类 RuleConfigParserFactory 中，让类的职责更加单一、代码更加清晰。
以上这个类直负责对象的创建，这个类就是我们现在要讲的简单工厂模式类。
大部分工厂类都是以“Factory”这个单词结尾的，但也不是必须的。工厂类中创建对象的方法一般都是create开头，这个我们根据具体的场景和习惯来命名就好。

重构三（简单工厂模式二）

在上面的代码实现中，我们每次调用 RuleConfigParserFactory 的 createParser() 时候，都要创建一个新的 parser。实际上，如果 parser 可以复用，为了节省内存和对象创建的时间，我们可以将 parser 事先创建好缓存起来。当调用 createParser() 函数的时候，我们从缓存中取出 parser 对象直接使用。这有点类似单例模式和简单工厂模式的结合。
改造类 RuleConfigParserFactory，把 cachedParsers 放在一个 static 的 map 中，这样在 createParser 方法中 parser 直接从 cachedParsers 取出即可。

总结

在以上两种简单工厂模式中，如果我们要添加新的 parser，那势必要改动到 RuleConfigParserFactory 的代码，如果不是需要频繁地添加新的 parser，稍微不符合开闭原则，也是完全可以接受的。
在简单工厂模式一中，有一组 ifelse 分支判断逻辑，如果用多态或其他设计模式替代，虽然提高了代码的扩展性，但也增加了类的个数，牺牲了代码的可读性。

工厂方法（Factory Method）

以上的例子，如果我们非要将 if 分支逻辑去掉，比较经典处理方法就是利用多态。
先定义一个接口 IRuleConfigParserFactory。
然后再定义四个不同格式的实现类，比如 JsonRuleConfigParserFactory 等，实现接口 IRuleConfigParserFactory。
这样当我们新增一种 parser 的时候，只需要新增一个实现了 IRuleConfigParserFactory 接口的 Factory 类即可。
工厂方法模式比起简单工厂模式更加符合开闭原则。

调用问题

以上工厂方法看似完美，实际存在挺大问题，在调用这些工厂类时候。
public RuleConfig load(String ruleConfigFilePath) 中要写一堆 ifelse 来判断调用哪个工厂实现类。这是将厂类对象的创建逻辑又耦合进了 load() 函数中，这又跟我们最初实现的简单工厂模式一十分相似。

重构

我们可以为工厂类再创建一个简单工厂，也就是工厂的工厂，用来创建工厂类对象。
我们可以利用上面的简单工厂模式二与现在完成的工厂模式相结合，创建类 RuleConfigParserFactoryMap。
把 cachedParsers 还是放在一个 static 的 map 中，这样在 createParser 方法中 parser 直接从 cachedParsers 取出即可。改造点在于 map 中我们 cachedFactories 时是分别调用不同的工厂实现类 JsonRuleConfigParserFactory 等。
当我们需要添加新的规则配置解析器的时候，我们只需要创建新的 parser 类和 parser factory类，并且在 RuleConfigParserFactoryMap 类中，将新的 parser factory对象添加到 cachedFactories 中即可。

总结

实际上，对于规则配置文件解析这个应用场景来说，工厂模式需要额外创建诸多 Factory 类，也会增加代码的复杂性，而且，每个 Factory 类只是做简单的 new 操作，功能非常单薄（只有一行代码），也没必要设计成独立的类，所以，在这个应用场景下，简单工厂模式简单好用，比工厂方法模式更加合适。
当对象的创建逻辑比较复杂，不只是简单的 new 一下就可以，而是要组合其他类对象，做各种初始化操作的时候，我们推荐使用工厂方法模式，将复杂的创建逻辑拆分到多个工厂类中，让每个工厂类都不至于过于复杂。
如果对象不可复用，那工厂类每次都要返回不同的对象。如果我们使用简单工厂模式来实现，就只能选择第一种包含 if 分支逻辑的实现方式。如果我们还想避免烦人的 if-else 分支逻辑，这个时候，我们就推荐使用工厂方法模式。

抽象工厂（Abstract Factory）

在以上例子中，如果类有两种分类方式，比如，我们既可以按照配置文件格式来分类，也可以按照解析的对象（Rule 规则配置还是 System 系统配置）来分类，那就会对应下面这8个 parser 类：
- 针对规则配置的解析器：基于接口 IRuleConfigParser
  - JsonRuleConfigParser
  - XmlRuleConfigParser
  - YamlRuleConfigParser
  - PropertiesRuleConfigParser
- 针对系统配置的解析器：基于接口ISystemConfigParser
  - JsonSystemConfigParser
  - XmlSystemConfigParser
  - YamlSystemConfigParser
  - PropertiesSystemConfigParser
针对这种特殊的场景，如果还是继续用工厂方法来实现的话，我们要针对每个 parser 都编写一个工厂类，也就是要编写8个工厂类。抽象工厂就是针对这种非常特殊的场景而诞生的。我们可以让一个工厂负责创建多个不同类型的对象（IRuleConfigParser、ISystemConfigParser等），而不是只创建一种 parser 对象。这样就可以有效地减少工厂类的个数。
创建接口 IConfigParserFactory，里面定义两种分类方式创建 parser，比如 createRuleParser() 和 createSystemParser()。
然后写四种工厂实现类实现此接口，比如 public class JsonConfigParserFactory implements IConfigParserFactory，实现类里面都要实现接口中的两个方法。

工厂模式和 DI 容器有何区别？

实际上，DI 容器底层最基本的设计思路就是基于工厂模式的。
DI 容器相当于一个大的工厂类，负责在程序启动的时候，根据配置（要创建哪些类对象，每个类对象的创建需要依赖哪些其他类对象）事先创建好对象。当应用程序需要使用某个类对象的时候，直接从容器中获取即可。正是因为它持有一堆对象，所以这个框架才被称为“容器”。
DI 容器相对于我们上节课讲的工厂模式的例子来说，它处理的是更大的对象创建工程。上节课讲的工厂模式中，一个工厂类只负责某个类对象或者某一组相关类对象（继承自同一抽象类或者接口的子类）的创建，而 DI 容器负责的是整个应用中所有类对象的创建。
除此之外，DI 容器负责的事情要比单纯的工厂模式要多。比如，它还包括配置的解析、对象生命周期的管理。

DI 容器的核心功能有哪些？

一个简单的 DI 容器的核心功能一般有三个：配置解析、对象创建和对象生命周期管理。

配置解析

作为一个通用的框架来说，框架代码跟应用代码应该是高度解耦的，DI 容器事先并不知道应用会创建哪些对象，不可能把某个应用要创建的对象写死在框架代码中。
我们将需要由 DI 容器来创建的类对象和创建类对象的必要信息（使用哪个构造函数以及对应的构造函数参数都是什么等等），放到配置文件中。容器读取配置文件，根据配置文件提供的信息来创建对象。

对象创建

在 DI 容器中，我们只需要将所有类对象的创建都放到一个工厂类中完成就可以了，比如 BeansFactory。
待会讲到 DI 容器的具体实现的时候，我们会讲“反射”这种机制，它能在程序运行的过程中，动态地加载类、创建对象，不需要事先在代码中写死要创建哪些对象。

对象的生命周期管理

spring 框架中，我们可以通过配置 scope 属性，来区分这两种不同类型的对象。scope=prototype 表示返回新创建的对象，scope=singleton 表示返回单例对象。
我们还可以配置对象是否支持懒加载。如果 lazy-init=true，对象在真正被使用到的时候（比如：BeansFactory.getBean(“userService”)）才被被创建；如果 lazy-init=false，对象在应用启动的时候就事先创建好。
DI 容器在创建好对象之后，会主动调用 init-method 属性指定的方法来初始化对象。在对象被最终销毁之前，DI 容器会主动调用 destroy-method 属性指定的方法来做一些清理工作，比如释放数据库连接池、关闭文件。

如何实现一个简单的DI容器？

Java 语言来实现一个简单的DI容器，核心逻辑只需要包括这样两个部分：配置文件解析、根据配置文件通过“反射”语法来创建对象。

最小原型设计

配置文件beans.xml

<beans>
   <bean id="rateLimiter" class="com.xzg.RateLimiter">
      <constructor-arg ref="redisCounter"/>
   </bean>
 
   <bean id="redisCounter" class="com.xzg.redisCounter" scope="singleton" lazy-init="true">
     <constructor-arg type="String" value="127.0.0.1">
     <constructor-arg type="int" value=1234>
   </bean>
</beans>

示例代码

public class Demo {
  public static void main(String[] args) {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
    RateLimiter rateLimiter = (RateLimiter)applicationContext.getBean("rateLimiter");
    rateLimiter.test();
    //...
  }
}

提供执行入口

执行入口主要包含两部分：ApplicationContext 和 ClassPathXmlApplicationContext。其中，ApplicationContext 是接口，ClassPathXmlApplicationContext 是接口的实现类。

public interface ApplicationContext {
  Object getBean(String beanId);
}
public class ClassPathXmlApplicationContext implements ApplicationContext {
  private BeansFactory beansFactory;
  private BeanConfigParser beanConfigParser;
  public ClassPathXmlApplicationContext(String configLocation) {
    this.beansFactory = new BeansFactory();
    this.beanConfigParser = new XmlBeanConfigParser();
    loadBeanDefinitions(configLocation);
  }
  private void loadBeanDefinitions(String configLocation) {
    InputStream in = null;
    try {
      in = this.getClass().getResourceAsStream("/" + configLocation);
      if (in == null) {
        throw new RuntimeException("Can not find config file: " + configLocation);
      }
      List<BeanDefinition> beanDefinitions = beanConfigParser.parse(in);
      beansFactory.addBeanDefinitions(beanDefinitions);
    } finally {
      if (in != null) {
        try {
          in.close();
        } catch (IOException e) {
          // TODO: log error
        }
      }
    }
  }
  @Override
  public Object getBean(String beanId) {
    return beansFactory.getBean(beanId);
  }
}

XmlApplicationContext负责组装 BeansFactory 和 BeanConfigParser 两个类，串联执行流程：从 classpath 中加载 XML 格式的配置文件，通过 BeanConfigParser 解析为统一的 BeanDefinition 格式，然后，BeansFactory 根据BeanDefinition来创建对象。

配置文件解析

配置文件解析主要包含 BeanConfigParser 接口和 XmlBeanConfigParser 实现类，负责将配置文件解析为 BeanDefinition 结构，以便 BeansFactory 根据这个结构来创建对象。

public interface BeanConfigParser {
  List<BeanDefinition> parse(InputStream inputStream);
  List<BeanDefinition> parse(String configContent);
}
public class XmlBeanConfigParser implements BeanConfigParser {
  @Override
  public List<BeanDefinition> parse(InputStream inputStream) {
    String content = null;
    // TODO:...
    return parse(content);
  }
  @Override
  public List<BeanDefinition> parse(String configContent) {
    List<BeanDefinition> beanDefinitions = new ArrayList<>();
    // TODO:...
    return beanDefinitions;
  }
}
public class BeanDefinition {
  private String id;
  private String className;
  private List<ConstructorArg> constructorArgs = new ArrayList<>();
  private Scope scope = Scope.SINGLETON;
  private boolean lazyInit = false;
  // 省略必要的getter/setter/constructors
 
  public boolean isSingleton() {
    return scope.equals(Scope.SINGLETON);
  }
  public static enum Scope {
    SINGLETON,
    PROTOTYPE
  }
  
  public static class ConstructorArg {
    private boolean isRef;
    private Class type;
    private Object arg;
    // 省略必要的getter/setter/constructors
  }
}

核心工厂类设计

BeansFactory 负责根据从配置文件解析得到的 BeanDefinition 来创建对象。
如果对象的 scope 属性是 singleton，那对象创建之后会缓存在 singletonObjects 这样一个 map 中，下次再请求此对象的时候，直接从 map 中取出返回，不需要重新创建。如果对象的scope属性是 prototype，那每次请求对象，BeansFactory 都会创建一个新的对象返回。
BeansFactory 创建对象用到的主要技术点就是 Java 中的反射语法：一种动态加载类和创建对象的机制。
如果某个对象的创建并不是写死在代码中，而是放到配置文件中，我们需要在程序运行期间，动态地根据配置文件来加载类、创建对象，那这部分工作就没法让 JVM 帮我们自动完成了，我们需要利用 Java 提供的反射语法自己去编写代码。

public class BeansFactory {
  private ConcurrentHashMap<String, Object> singletonObjects = new ConcurrentHashMap<>();
  private ConcurrentHashMap<String, BeanDefinition> beanDefinitions = new ConcurrentHashMap<>();
  public void addBeanDefinitions(List<BeanDefinition> beanDefinitionList) {
    for (BeanDefinition beanDefinition : beanDefinitionList) {
       this.beanDefinitions.putIfAbsent(beanDefinition.getId(), beanDefinition);
    }
    for (BeanDefinition beanDefinition : beanDefinitionList) {
      if (beanDefinition.isLazyInit() == false && beanDefinition.isSingleton()) {
        createBean(beanDefinition);
      }
    }
  }
  public Object getBean(String beanId) {
    BeanDefinition beanDefinition = beanDefinitions.get(beanId);
    if (beanDefinition == null) {
      throw new NoSuchBeanDefinitionException("Bean is not defined: " + beanId);
    }
    return createBean(beanDefinition);
  }
  @VisibleForTesting
  protected Object createBean(BeanDefinition beanDefinition) {
    if (beanDefinition.isSingleton() && singletonObjects.contains(beanDefinition.getId())
) {
      return singletonObjects.get(beanDefinition.getId());
    }
    Object bean = null;
    try {
      Class beanClass = Class.forName(beanDefinition.getClassName());
      List<BeanDefinition.ConstructorArg> args = beanDefinition.getConstructorArgs();
      if (args.isEmpty()) {
        bean = beanClass.newInstance();
      } else {
        Class[] argClasses = new Class[args.size()];
        Object[] argObjects = new Object[args.size()];
        for (int i = 0; i < args.size(); ++i) {
          BeanDefinition.ConstructorArg arg = args.get(i);
          if (!arg.getIsRef()) {
            argClasses[i] = arg.getType();
            argObjects[i] = arg.getArg();
          } else {
            BeanDefinition refBeanDefinition = beanDefinitions.get(arg.getArg());
            if (refBeanDefinition == null) {
              throw new NoSuchBeanDefinitionException("Bean is not defined: " + arg.getArg());
            }
            argClasses[i] = Class.forName(refBeanDefinition.getClassName());
            argObjects[i] = createBean(refBeanDefinition);
          }
        }
        bean = beanClass.getConstructor(argClasses).newInstance(argObjects);
      }
    } catch (ClassNotFoundException | IllegalAccessException | InstantiationException | NoSuchMethodException | InvocationTargetExceptione) {
      throw new BeanCreationFailureException("", e);
    }
    if (bean != null && beanDefinition.isSingleton()) {
      singletonObjects.putIfAbsent(beanDefinition.getId(), bean);
      return singletonObjects.get(beanDefinition.getId());
    }
    return bean;
  }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：原型模式

下一篇：单例模式

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

工厂方法

工厂方法

简单工厂（Simple Factory）

文中举例

重构一

重构二（简单工厂模式一）

重构三（简单工厂模式二）

总结

工厂方法（Factory Method）

调用问题

重构

总结

抽象工厂（Abstract Factory）

工厂模式和 DI 容器有何区别？

DI 容器的核心功能有哪些？

配置解析

对象创建

对象的生命周期管理

如何实现一个简单的DI容器？

最小原型设计

提供执行入口

配置文件解析

核心工厂类设计

51CTO博客