【设计模式之美】【建造型】工厂模式实战：如何设计一个DI框架；梳理流程，通过面向接口解耦对象创建

文章目录

• 一. 工厂模式和 DI 容器有何区别？
• 二. DI 容器的核心功能有哪些？
• • 1. 配置解析：解耦对象创建
  • 2. 对象创建
  • 3. 对象的生命周期管理
• 三. 如何实现一个简单的 DI 容器？
• • 1. 最小原型设计：流程梳理
  • 2. 提供执行入口：入口的解耦
  • 3. 配置文件解析：加载配置到对象中
  • 4. 核心工厂类设计：利用反射动态创建对象

设计模式小思考：
梳理清楚业务逻辑之后，比如主流程是什么，流程中第一步、第二步…等每一步都封装到方法、某些步骤需要根据业务有不同的实现，这时使用面向接口编程来解耦对象实现。

通过本文的学习你能够了解DI容器的设计思路，并通过学习它的抽象逻辑，进一步了解面向接口的编程思路

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

设计思想

实际上，DI 容器底层最基本的设计思路就是基于工厂模式的。DI 容器相当于一个大的工厂类，负责在程序启动的时候，根据配置（要创建哪些类对象，每个类对象的创建需要依赖哪些其他类对象）事先创建好对象。当应用程序需要使用某个类对象的时候，直接从容器中获取即可。正是因为它持有一堆对象，所以这个框架才被称为“容器”。

对象规模

DI 容器相对于我们上节课讲的工厂模式的例子来说，它处理的是更大的对象创建工程。上节课讲的工厂模式中，一个工厂类只负责某个类对象或者某一组相关类对象（继承自同一抽象类或者接口的子类）的创建，而 DI 容器负责的是整个应用中所有类对象的创建。

负责的工作

除此之外，DI 容器负责的事情要比单纯的工厂模式要多。比如，它还包括配置的解析、对象生命周期的管理。接下来，我们就详细讲讲，一个简单的 DI 容器应该包含哪些核心功能。

 

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

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

1. 配置解析：解耦对象创建

作为一个通用的框架来说，框架代码跟应用代码应该是高度解耦的，DI 容器事先并不知道应用会创建哪些对象，不可能把某个应用要创建的对象写死在框架代码中。

我们可以将需要由 DI 容器来创建的类对象和创建类对象的必要信息（使用哪个构造函数以及对应的构造函数参数都是什么等等），放到配置文件中。容器读取配置文件，根据配置文件提供的信息来创建对象。

下面是一个典型的 Spring 容器的配置文件。
Spring 容器读取这个配置文件，解析出要创建的两个对象：rateLimiter 和 redisCounter，并且得到两者的依赖关系：rateLimiter 依赖 redisCounter。

public class RateLimiter {   private RedisCounter redisCounter;   public RateLimiter(RedisCounter redisCounter) {     this.redisCounter = redisCounter;   }   public void test() {     System.out.println("Hello World!");   }   //... }  public class RedisCounter {   private String ipAddress;   private int port;   public RedisCounter(String ipAddress, int port) {     this.ipAddress = ipAddress;     this.port = port;   }   //... }  配置文件beans.xml： <beans>    <bean id="rateLimiter" class="com.xzg.RateLimiter">       <constructor-arg ref="redisCounter"/>    </bean>      <bean id="redisCounter" class="com.xzg.redisCounter">      <constructor-arg type="String" value="127.0.0.1">      <constructor-arg type="int" value=1234>    </bean> </beans> 

 

2. 对象创建

1. 对于对象创建，我们提供一个工厂类，将所有对象的创建都放到这一个工厂类中，比如 BeansFactory。

2. 代码线性膨胀问题：如果要创建的对象非常多，我们可以使用反射机制，在程序运行的过程中，动态的加载类、创建对象，不需要在代码中写死要创建哪些对象。所以，不管是创建一个对象还是十个对象，BeansFactory
   工厂类代码都是一样的。

 

3. 对象的生命周期管理

生命周期大致我们可以做如下事情：

1. 根据scope来确定每次返回新的对象还是事先建立好的（单例）对象。 scope=prototype 表示返回新创建的对象，scope=singleton 表示返回单例对象。

2. 配置对象是否支持懒加载。如果 lazy-init=true，对象在真正被使用到的时候才被被创建。

3. 创建后和销毁前。我们还可以配置对象的 init-method 和 destroy-method 方法，比如 init-method=loadProperties()，destroy-method=updateConfigFile()。

• DI 容器在创建好对象之后，会主动调用 init-method 属性指定的方法来初始化对象。
• 在对象被最终销毁之前，DI 容器会主动调用 destroy-method 属性指定的方法来做一些清理工作，比如释放数据库连接池、关闭文件。

 

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

核心逻辑只需要包括这样两个部分：配置文件解析、根据配置文件通过“反射”语法来创建对象。

1. 最小原型设计：流程梳理

配置文件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> </bean> 

最小原型的使用方式跟 Spring 框架非常类似，示例代码如下所示：

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

 

2. 提供执行入口：入口的解耦

通过刚刚的最小原型使用示例代码，我们可以看出，执行入口主要包含两部分：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，以便调用gebean获取实例       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);   } } 

代码流程：从 classpath 中加载 XML 格式的配置文件，通过 BeanConfigParser 解析为统一的 BeanDefinition 格式，然后，BeansFactory 根据 BeanDefinition 来创建对象。

 

3. 配置文件解析：加载配置到对象中

配置文件解析主要是 BeanConfigParser 接口负责将配置文件解析为 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   } } 

 

4. 核心工厂类设计：利用反射动态创建对象

BeansFactory负责根据从配置文件解析得到的 BeanDefinition 来创建对象。

• 如果对象的 scope 属性是 singleton，那对象创建之后会缓存 map 中，下次再请求此对象的时候，直接从 map 中取出返回。
• 如果对象的 scope 属性是 prototype，那每次请求对象，BeansFactory 都会创建一个新的对象返回。

BeansFactory 创建对象用到的主要技术点就是 Java 中的反射语法：一种动态加载类和创建对象的机制。

因为此时对象的创建是放到配置文件中，我们需要在程序运行期间，动态地根据配置文件来加载类、创建对象，所以我们可以利用 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);   }    //根据从xml文件中解析到的beanDefinition，利用反射创建对象。   @VisibleForTesting   protected Object createBean(BeanDefinition beanDefinition) {   //1. 单例并且包含则直接返回     if (beanDefinition.isSingleton() && singletonObjects.contains(beanDefinition.getId())) {       return singletonObjects.get(beanDefinition.getId());     }  //2. 利用反射创建对象     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 | InvocationTargetException e) {       throw new BeanCreationFailureException("", e);     }  //3. 再次判断是否是单例，并始终从map中获取实例     if (bean != null && beanDefinition.isSingleton()) {       singletonObjects.putIfAbsent(beanDefinition.getId(), bean);       return singletonObjects.get(beanDefinition.getId());     }     return bean;   } } 

 
参考：王争–《设计模式之美》