现在，我们可以用ResourceResolver扫描Class，用PropertyResolver获取配置，下面，我们开始实现IoC容器。

在IoC容器中，每个Bean都有一个唯一的名字标识。Spring还允许为一个Bean定义多个名字，这里我们简化一下，一个Bean只允许一个名字，因此，很容易想到用一个Map<String, Object>保存所有的Bean：

public class AnnotationConfigApplicationContext {
  Map<String, Object> beans;
}

这么做不是不可以，但是丢失了大量Bean的定义信息，不便于我们创建Bean以及解析依赖关系。合理的方式是先定义BeanDefinition，它能从Annotation中提取到足够的信息，便于后续创建Bean、设置依赖、调用初始化方法等：

public class BeanDefinition {
  // 全局唯一的Bean Name:
  String name;

  // Bean的声明类型:
  Class<?> beanClass;

  // Bean的实例:
  Object instance = null;

  // 构造方法/null:
  Constructor<?> constructor;

  // 工厂方法名称/null:
  String factoryName;

  // 工厂方法/null:
  Method factoryMethod;

  // Bean的顺序:
  int order;

  // 是否标识@Primary:
  boolean primary;

  // init/destroy方法名称:
  String initMethodName;
  String destroyMethodName;

  // init/destroy方法:
  Method initMethod;
  Method destroyMethod;
}

对于自己定义的带@Component注解的Bean，我们需要获取Class类型，获取构造方法来创建Bean，然后收集@PostConstruct和@PreDestroy标注的初始化与销毁的方法，以及其他信息，如@Order定义Bean的内部排序顺序，@Primary定义存在多个相同类型时返回哪个“主要”Bean。一个典型的定义如下：

@Component
public class Hello {
  @PostConstruct
  void init() {}

  @PreDestroy
  void destroy() {}
}

对于@Configuration定义的@Bean方法，我们把它看作Bean的工厂方法，我们需要获取方法返回值作为Class类型，方法本身作为创建Bean的factoryMethod，然后收集@Bean定义的initMethod和destroyMethod标识的初始化于销毁的方法名，以及其他@Order、@Primary等信息。一个典型的定义如下：

@Configuration
public class AppConfig {
  @Bean(initMethod="init", destroyMethod="close")
  DataSource createDataSource() {
    return new HikariDataSource(...);
  }
}

Bean的声明类型

这里我们要特别注意一点，就是Bean的声明类型。对于@Component定义的Bean，它的声明类型就是其Class本身。然而，对于用@Bean工厂方法创建的Bean，它的声明类型与实际类型不一定是同一类型。上述createDataSource()定义的Bean，声明类型是DataSource，实际类型却是某个子类，例如HikariDataSource，因此要特别注意，我们在BeanDefinition中，存储的beanClass是声明类型，实际类型不必存储，因为可以通过instance.getClass()获得：

public class BeanDefinition {
  // Bean的声明类型:
  Class<?> beanClass;

  // Bean的实例:
  Object instance = null;
}

这也引出了下一个问题：如果我们按照名字查找Bean或BeanDefinition，要么拿到唯一实例，要么不存在，即通过查询Map<String, BeanDefinition>即可完成：

public class AnnotationConfigApplicationContext {
  Map<String, BeanDefinition> beans;

  // 根据Name查找BeanDefinition，如果Name不存在，返回null
  @Nullable
  public BeanDefinition findBeanDefinition(String name) {
    return this.beans.get(name);
  }
}

但是通过类型查找Bean或BeanDefinition，我们没法定义一个Map<Class, BeanDefinition>，原因就是Bean的声明类型与实际类型不一定相符，举个例子：

@Configuration
public class AppConfig {
  @Bean
  AtomicInteger counter() {
    return new AtomicInteger();
  }
  
  @Bean
  Number bigInt() {
    return new BigInteger("1000000000");
  }
}

当我们调用getBean(AtomicInteger.class)时，我们会获得counter()方法创建的唯一实例，但是，当我们调用getBean(Number.class)时，counter()方法和bigInt()方法创建的实例均符合要求，此时，如果有且仅有一个标注了@Primary，就返回标注了@Primary的Bean，否则，直接报NoUniqueBeanDefinitionException错误。

因此，对于getBean(Class)方法，必须遍历找出所有符合类型的Bean，如果不唯一，再判断@Primary，才能返回唯一Bean或报错。

我们编写一个找出所有类型的findBeanDefinitions(Class)方法如下：

// 根据Type查找若干个BeanDefinition，返回0个或多个:
List<BeanDefinition> findBeanDefinitions(Class<?> type) {
  return this.beans.values().stream()
    // 按类型过滤:
    .filter(def -> type.isAssignableFrom(def.getBeanClass()))
    // 排序:
    .sorted().collect(Collectors.toList());
  }
}

我们再编写一个findBeanDefinition(Class)方法如下：

// 根据Type查找某个BeanDefinition，如果不存在返回null，如果存在多个返回@Primary标注的一个:
@Nullable
public BeanDefinition findBeanDefinition(Class<?> type) {
  List<BeanDefinition> defs = findBeanDefinitions(type);
  if (defs.isEmpty()) { // 没有找到任何BeanDefinition
    return null;
  }
  if (defs.size() == 1) { // 找到唯一一个
    return defs.get(0);
  }
  // 多于一个时，查找@Primary:
  List<BeanDefinition> primaryDefs = defs.stream().filter(def -> def.isPrimary()).collect(Collectors.toList());
  if (primaryDefs.size() == 1) { // @Primary唯一
    return primaryDefs.get(0);
  }
  if (primaryDefs.isEmpty()) { // 不存在@Primary
    throw new NoUniqueBeanDefinitionException(String.format("Multiple bean with type '%s' found, but no @Primary specified.", type.getName()));
  } else { // @Primary不唯一
    throw new NoUniqueBeanDefinitionException(String.format("Multiple bean with type '%s' found, and multiple @Primary specified.", type.getName()));
  }
}

现在，我们已经定义好了数据结构，下面开始获取所有BeanDefinition信息，实际分两步：

public class AnnotationConfigApplicationContext {
  Map<String, BeanDefinition> beans;

  public AnnotationConfigApplicationContext(Class<?> configClass, PropertyResolver propertyResolver) {
    // 扫描获取所有Bean的Class类型:
    Set<String> beanClassNames = scanForClassNames(configClass);

    // 创建Bean的定义:
    this.beans = createBeanDefinitions(beanClassNames);
  }
  ...
}

第一步是扫描指定包下的所有Class，然后返回Class名字，这一步比较简单：

Set<String> scanForClassNames(Class<?> configClass) {
  // 获取@ComponentScan注解:
  ComponentScan scan = ClassUtils.findAnnotation(configClass, ComponentScan.class);
  // 获取注解配置的package名字,未配置则默认当前类所在包:
  String[] scanPackages = scan == null || scan.value().length == 0 ? new String[] { configClass.getPackage().getName() } : scan.value();

  Set<String> classNameSet = new HashSet<>();
  // 依次扫描所有包:
  for (String pkg : scanPackages) {
    logger.atDebug().log("scan package: {}", pkg);
    // 扫描一个包:
    var rr = new ResourceResolver(pkg);
    List<String> classList = rr.scan(res -> {
      // 遇到以.class结尾的文件，就将其转换为Class全名:
      String name = res.name();
      if (name.endsWith(".class")) {
        return name.substring(0, name.length() - 6).replace("/", ".").replace("\\", ".");
      }
      return null;
    });
    // 扫描结果添加到Set:
    classNameSet.addAll(classList);
  }

  // 继续查找@Import(Xyz.class)导入的Class配置:
  Import importConfig = configClass.getAnnotation(Import.class);
  if (importConfig != null) {
    for (Class<?> importConfigClass : importConfig.value()) {
      String importClassName = importConfigClass.getName();
      classNameSet.add(importClassName);
    }
  }
  return classNameSet;
}

注意到扫描结果是指定包的所有Class名称，以及通过@Import导入的Class名称，下一步才会真正处理各种注解：

Map<String, BeanDefinition> createBeanDefinitions(Set<String> classNameSet) {
  Map<String, BeanDefinition> defs = new HashMap<>();
  for (String className : classNameSet) {
    // 获取Class:
    Class<?> clazz = null;
    try {
      clazz = Class.forName(className);
    } catch (ClassNotFoundException e) {
      throw new BeanCreationException(e);
    }
    // 是否标注@Component?
    Component component = ClassUtils.findAnnotation(clazz, Component.class);
    if (component != null) {
      // 获取Bean的名称:
      String beanName = ClassUtils.getBeanName(clazz);
      var def = new BeanDefinition(
        beanName, clazz, getSuitableConstructor(clazz),
        getOrder(clazz), clazz.isAnnotationPresent(Primary.class),
        // init/destroy方法名称:
        null, null,
        // 查找@PostConstruct方法:
        ClassUtils.findAnnotationMethod(clazz, PostConstruct.class),
        // 查找@PreDestroy方法:
        ClassUtils.findAnnotationMethod(clazz, PreDestroy.class));
      addBeanDefinitions(defs, def);
      // 查找是否有@Configuration:
      Configuration configuration = ClassUtils.findAnnotation(clazz, Configuration.class);
      if (configuration != null) {
        // 查找@Bean方法:
        scanFactoryMethods(beanName, clazz, defs);
      }
    }
  }
  return defs;
}

上述代码需要注意的一点是，查找@Component时，并不是简单地在Class定义查看@Component注解，因为Spring的@Component是可以扩展的，例如，标记为Controller的Class也符合要求：

@Controller
public class MvcController {...}

原因就在于，@Controller注解的定义包含了@Component：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Controller {
  String value() default "";
}

所以，判断是否存在@Component，不但要在当前类查找@Component，还要在当前类的所有注解上，查找该注解是否有@Component，因此，我们编写了一个能递归查找注解的方法：

public class ClassUtils {
  public static <A extends Annotation> A findAnnotation(Class<?> target, Class<A> annoClass) {
    A a = target.getAnnotation(annoClass);
    for (Annotation anno : target.getAnnotations()) {
      Class<? extends Annotation> annoType = anno.annotationType();
      if (!annoType.getPackageName().equals("java.lang.annotation")) {
        A found = findAnnotation(annoType, annoClass);
        if (found != null) {
          if (a != null) {
            throw new BeanDefinitionException("Duplicate @" + annoClass.getSimpleName() + " found on class " + target.getSimpleName());
          }
          a = found;
        }
      }
    }
    return a;
  }
}

带有@Configuration注解的Class，视为Bean的工厂，我们需要继续在scanFactoryMethods()中查找@Bean标注的方法：

void scanFactoryMethods(String factoryBeanName, Class<?> clazz, Map<String, BeanDefinition> defs) {
  for (Method method : clazz.getDeclaredMethods()) {
    // 是否带有@Bean标注:
    Bean bean = method.getAnnotation(Bean.class);
    if (bean != null) {
      // Bean的声明类型是方法返回类型:
      Class<?> beanClass = method.getReturnType();
      var def = new BeanDefinition(
        ClassUtils.getBeanName(method), beanClass,
        factoryBeanName,
        // 创建Bean的工厂方法:
        method,
        // @Order
        getOrder(method),
        // 是否存在@Primary标注?
        method.isAnnotationPresent(Primary.class),
        // init方法名称:
        bean.initMethod().isEmpty() ? null : bean.initMethod(),
        // destroy方法名称:
        bean.destroyMethod().isEmpty() ? null : bean.destroyMethod(),
        // @PostConstruct / @PreDestroy方法:
        null, null);
      addBeanDefinitions(defs, def);
    }
  }
}

注意到@Configuration注解本身又用@Component注解修饰了，因此，对于一个@Configuration来说：

@Configuration
public class DateTimeConfig {
  @Bean
  LocalDateTime local() { return LocalDateTime.now(); }

  @Bean
  ZonedDateTime zoned() { return ZonedDateTime.now(); }
}

实际上创建了3个BeanDefinition：

• DateTimeConfig本身；
• LocalDateTime；
• ZonedDateTime。

不创建DateTimeConfig行不行？不行，因为后续没有DateTimeConfig的实例，无法调用local()和zoned()方法。因为当前我们只创建了BeanDefinition，所以对于LocalDateTime和ZonedDateTime的BeanDefinition来说，还必须保存DateTimeConfig的名字，将来才能通过名字查找DateTimeConfig的实例。

有的同学注意到我们同时存储了initMethodName和initMethod，以及destroyMethodName和destroyMethod，这是因为在@Component声明的Bean中，我们可以根据@PostConstruct和@PreDestroy直接拿到Method本身，而在@Bean声明的Bean中，我们拿不到Method，只能从@Bean注解提取出字符串格式的方法名称，因此，存储在BeanDefinition的方法名称与方法，其中总有一个为null。

最后，仔细编写BeanDefinition的toString()方法，使之能打印出详细的信息。我们编写测试，运行，打印出每个BeanDefinition如下：

define bean: BeanDefinition [name=annotationDestroyBean, beanClass=com.itranswarp.scan.destroy.AnnotationDestroyBean, factory=null, init-method=null, destroy-method=destroy, primary=false, instance=null]

define bean: BeanDefinition [name=nestedBean, beanClass=com.itranswarp.scan.nested.OuterBean$NestedBean, factory=null, init-method=null, destroy-method=null, primary=false, instance=null]

define bean: BeanDefinition [name=createSpecifyInitBean, beanClass=com.itranswarp.scan.init.SpecifyInitBean, factory=SpecifyInitConfiguration.createSpecifyInitBean(String, String), init-method=null, destroy-method=null, primary=false, instance=null]

...

现在，我们已经能扫描并创建所有的BeanDefinition，只是目前每个BeanDefinition内部的instance还是null，因为我们后续才会创建真正的Bean。

可以从GitHub或Gitee下载源码。

GitHub