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

文章目录

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

设计模式小思考:

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

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

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

设计思想

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

对象规模

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

负责的工作

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

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

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

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

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

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

下面是一个典型的 Spring 容器的配置文件。

Spring 容器读取这个配置文件,解析出要创建的两个对象:rateLimiter 和 redisCounter,并且得到两者的依赖关系:rateLimiter 依赖 redisCounter。

java 复制代码
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. 最小原型设计:流程梳理

java 复制代码
配置文件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 框架非常类似,示例代码如下所示:

java 复制代码
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 是接口的实现类。两个类具体实现如下所示:

java 复制代码
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 根据这个结构来创建对象。

具体的代码框架如下所示:

java 复制代码
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 提供的反射语法自己去编写代码。

具体代码实现如下所示:

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;
  }
}

参考:王争--《设计模式之美》

相关推荐
尘浮生3 分钟前
Java项目实战II基于SpringBoot的共享单车管理系统开发文档+数据库+源码)
java·开发语言·数据库·spring boot·后端·微信小程序·小程序
2401_857439698 分钟前
社团管理新工具:SpringBoot框架
java·spring boot·后端
ThetaarSofVenice20 分钟前
Java从入门到放弃 之 泛型
java·开发语言
zzzhpzhpzzz25 分钟前
设计模式——观察者模式
算法·观察者模式·设计模式
嘟嘟Listing27 分钟前
jenkins docker记录
java·运维·jenkins
WHabcwu34 分钟前
统⼀异常处理
java·开发语言
zaim134 分钟前
计算机的错误计算(一百六十三)
java·c++·python·matlab·错数·等价算式
枫叶丹434 分钟前
【在Linux世界中追寻伟大的One Piece】多线程(一)
java·linux·运维
2401_8543910835 分钟前
Spring Boot OA:企业数字化转型的利器
java·spring boot·后端
山山而川粤42 分钟前
废品买卖回收管理系统|Java|SSM|Vue| 前后端分离
java·开发语言·后端·学习·mysql