工厂方法

工厂方法

简单工厂（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;
  }
}