事先说明一下：本人是菜鸟一个(大佬别喷我)，意愿是自己实现一个简单版的Spring，尽可能实现Spring当中尽可能多的功能，并且整合Netty去做一个简单的HttpWebServer。

完整博客地址会在http://wanna1314y.top:8090/中进行慢慢地更新，其它平台也许会更新(也许就忘掉了，比较懒)。

目前项目中已经实现足够多的功能，当然也还有很多bug没改，项目源码已经开源到Github:https://github.com/wanna280/My-Spring-Framework。

1.AnnotationConfigApplicationContext的类设计

在Spring中，支持注解版的IOC容器使用的是组件AnnotationConfigApplicationContext，因此我们这里也要去实现这个组件。这个类是支持传入一个packages列表作为要扫描的包，也支持传入一个Class作为导入所有组件的基础配置类。因此我们实现如下的构造器

@Slf4j
public class AnnotationConfigApplicationContext extends AbstractApplicationContext implements ApplicationContext {

    private DefaultListableBeanFactory beanFactory;

    /**
     * 指定扫描类路径下的候选BeanDefinition列表
     */
    private final ClassPathBeanDefinitionScanner scanner;

    private Environment environment;

    public AnnotationConfigApplicationContext(DefaultListableBeanFactory beanFactory) {
        this.beanFactory = beanFactory;
        this.environment = getOrCreateEnvironment();  // 创建环境对象
        this.scanner = new ClassPathBeanDefinitionScanner(beanFactory);
        AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);
    }

    public AnnotationConfigApplicationContext() {
        this(new DefaultListableBeanFactory());
    }

    public AnnotationConfigApplicationContext(String... packages) {
        this();
        scanner.doScan(packages);  // 进行包扫描，扫描里面的相关组件
        this.refresh();  // 刷新容器，里面有启动容器的核心方法
    }

    public AnnotationConfigApplicationContext(Class<?> componentClass) {
        this();
        this.register(componentClass);  // 将配置类注册到Spring容器中去
        this.refresh();  // 刷新容器，里面有启动容器的核心方法
    }

    /**
     * 如果环境对象还没创建，那么就创建一个环境对象，并且return
     */
    private Environment getOrCreateEnvironment() {
        if (this.environment == null) {
            return new StandardEnvironment();
        }
        return this.environment;
    }
}

对于传入了packages/Class这两种情况，在创建了BeanFactory(DefaultListableBeanFactory)以及完成了相关的组件的注册之后，要做的自然就是调用refresh方法去刷新容器，这个方法的逻辑在它的父类AbstractApplicationContext中已经使用模板方法的形式去进行了自定义。

对于每个ApplicationContext(翻译过来叫应用程序上下文)，它本身都是一个BeanFactory，但是它组合了一个DefaultListableBeanFactory这样的一个beanFactory去存放真正的对象，实际上创建出来的Bean什么的，都会存放在DefaultListableBeanFactory当中，而ApplicationContext中只是组合一个BeanFactory去对BeanFactory去做增强，这可以看做是装饰器模式。

关于ApplicationContext和BeanFactory它们之间最常见的区别点：

• 1.在ApplicationContext中新定义了BeanFactoryPostProcessor这个机制，去对BeanFactory去进行增强，可以在里面通过一些别的渠道去导入组件。
• 2.在ApplicationContext中新增了事件监听机制，可以使用事件多拨器去发布事件。

ApplicationContext的一个抽象类的实现AbstractApplicationContext，它在refresh方法中对每个IOC容器启动过程中要完成的步骤，使用模板方法的形式去进行定义，子类如果想要自定义一些相关的逻辑，完全就可以继承自AbstractApplicationContext，然后去重写相关钩子方法去进行自己的逻辑定制即可。

下面是AbstractApplicationContext对容器启动的模板方法的步骤

    @Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

            // Prepare this context for refreshing.
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);

                StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);
                beanPostProcess.end();

                // Initialize message source for this context.
                initMessageSource();

                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                onRefresh();

                // Check for listener beans and register them.
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                finishRefresh();
            }

            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }

                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();

                // Reset 'active' flag.
                cancelRefresh(ex);

                // Propagate exception to caller.
                throw ex;
            }

            finally {
                // Reset common introspection caches in Spring's core, since we
                // might not ever need metadata for singleton beans anymore...
                resetCommonCaches();
                contextRefresh.end();
            }
        }
    }

我们通常使用到的都是ApplicationContext的相关实现类，比如ClassPathXmlApplicationContext(XML版本的IOC容器)、AnnotationConfigApplicationContext(注解版的IOC容器)甚至是一些在Web环境下的定制版的IOC容器，它们也都是继承自AbstractApplicationContext的实现类罢了。

2. 解决注解版IOC容器中需要进行包扫描工具的问题

要给定一个包，然后扫描指定的包下的候选的组件，肯定要用到对应的工具，对于注解版的候选组件的扫描，在Spring中用到的组件是ClassPathBeanDefinitionScanner，我们尝试去自己去实现这个类的代码如下：

@Slf4j
public class ClassPathBeanDefinitionScanner {

    /**
     * 已经扫描的包列表，用来解决某个包被重复扫描过的问题，如果缺少这个组件，很可能出现递归SOF
     */
    private static final Set<String> scannedPackages = new HashSet<>();

    private BeanDefinitionRegistry registry;

    public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
        this.registry = registry;
    }

    /**
     * 扫描指定的包，扫描到合适的bd
     *
     * @param packages 指定的包列表
     * @return 扫描到的合适的bd
     */
    public Set<BeanDefinition<?>> doScan(String... packages) {
        Set<BeanDefinition<?>> candidateComponents = new HashSet<>();
        for (String pkg : packages) {
            Set<Class<?>> classes = ScanUtils.scan(pkg);  // 获取这个包下所有的类的集合
            // 如果当前的这个包在之前已经扫描过了，那么continue，不用继续扫描
            // 如果没扫描过，那么加入到列表中去...
            if (hasScannedPackage(pkg)) {
                continue;
            }
            scannedPackages.add(pkg);  // 标注当前包是已经扫描过的
            log.info("[{}] is scanning package : [{}]", this.getClass(), pkg);
            for (Class<?> clazz : classes) {
                // 1.如果该beanClass是接口或者是注解，那么continue
                // 2.如果该类上没有标注@Component注解，那么continue
                // 3.如果该类上有@Component注解，并且不是接口和注解，那么才需要将其进行注册到BeanFactory中
                if (ConfigurationClassUtils.isMetaAnnotated(clazz) ||
                        !ConfigurationClassUtils.isCandidateComponent(clazz)) {
                    continue;
                }
                // 根据给定的Class获取到BeanName(解析@Component注解/@Configuration注解)
                String beanName = BeanNameUtils.getBeanName(clazz);
                // 构建BeanDefinition，并加入到最终扫描结果的set中去，以及放到Spring的bdMap中去
                BeanDefinition<?> bd = new RootBeanDefinition<>(beanName, clazz);
                registry.registerBeanDefinition(beanName, bd);

                // 处理通用注解，@Primary/@Lazy等注解
                AnnotationConfigUtils.processCommonDefinitionAnnotations(bd, AnnotationMetadata.introspect(clazz));
                candidateComponents.add(bd);
            }
        }
        return candidateComponents;
    }

    /**
     * 判断当前的包是否在之前已经扫描过了
     *
     * @param pkg 指定的package
     * @return 如果扫描过了，return true，不然return false
     */
    private boolean hasScannedPackage(String pkg) {
        for (String scannedPackage : scannedPackages) {
            if (pkg.startsWith(scannedPackage)) {
                return true;
            }
        }
        return false;
    }
}

其中用到了一个工具类ScanUtils，它的作用就是给的一个package，然后把该包下的所有类的Class对象解析出来，这个类太多代码了，也没太多的暂时的价值，对这个类感兴趣的直接去Github找吧，其实网上对于扫描指定包下的类的方案有很多，比如使用谷歌的guava，这里只是自己实现了简单功能罢了。

3. 关于使用配置类中导入的方式的Bean如何处理

3.1 内置核心组件的导入以及它的作用

比如使用到注解版的IOC容器时，肯定会使用到类似如下这样的代码去指定一个配置类App，然后就去启动IOC容器：

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(App.class)

而在这个App类上会去使用@ComponentScan等渠道去导入Bean。

其实这些渠道导入的Bean并不会在AnnotationConfigApplicationContext这个类当中就被处理到，而是调用了refresh方法之后，在invokeBeanFactoryPostProcessors这个很关键的一个步骤去导入的。

其实在这个类的构造器中，我们使用了下面这样的代码，去给容器中添加BeanFactoryPostProcessor等组件，方便容器进行启动。

AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory)

其中一个很关键的组件叫做ConfigurationClassPostProcessor，它的作用，其实就是注解版IOC容器实现的核心，在它里面就定义了处理配置类的逻辑，比如处理@Import注解、@Bean注解、@ImportSource注解等一堆注解。

3.2 自制版ConfigurationClassPostProcessor类的源码实现

@Slf4j
public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor, PriorityOrdered {

    private ConfigurationClassBeanDefinitionReader reader;

    private BeanDefinitionRegistry registry;

    private ConfigurationClassParser parser;

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
        reader = new ConfigurationClassBeanDefinitionReader(registry);
        parser = new ConfigurationClassParser(registry);
        // 使用ConfigurationClassParser去扫描所有的配置类(@ComponentScan/@Component/@Configuration)
        // 并且还将@Bean/@Import/@ImportSource的导入的Bean进行了处理，后续可以方便地直接进行注册
        // 扫描到的配置类列表可以通过parser.getConfigurationClasses获取到
        parser.parse();

        // 获取Parser解析出来的配置类集合
        Set<ConfigurationClass> configurationClasses = new HashSet<>(parser.getConfigurationClasses());

        // 使用Reader去加载Bean(处理@Bean/Registrar/ImportSource等)
        reader.loadBeanDefinitions(configurationClasses);

        log.info("[{}] has imported [{}] ConfigurationClass", this.getClass(), configurationClasses.size());
    }

    /**
     * 执行ImportBeanDefinitionRegistrar.registerBeanDefinitions
     *
     * @param registry BeanDefinitionRegistry
     * @see ImportBeanDefinitionRegistrar
     */
    private void processImportBeanDefinitionRegistrar(BeanDefinitionRegistry registry) {

        // 从容器中拿到所有的ImportBeanDefinitionRegistrar执行它的registerBeanDefinitions去注册信息
        List<ImportBeanDefinitionRegistrar> registrars = BeanFactoryUtils.findAll((ConfigurableListableBeanFactory) registry,
                ImportBeanDefinitionRegistrar.class);
        for (ImportBeanDefinitionRegistrar registrar : registrars) {
            registrar.registerBeanDefinitions(null, registry);
        }
    }

    @Override
    public int getOrder() {
        return ORDER_LOWEST;
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {

    }

}

这个组件中主要会使用到两个很关键的组件，ConfigurationClassBeanDefinitionReader和ConfigurationClassParser。

• 1.ConfigurationClassParser的作用，从名字当中我们就可以看到，它是一个配置类的解析器，当然是用来解析配置类的。真正的处理逻辑，其实在它的doProcessConfigurationClass方法里，从这个doXXX的方法命名当中，我们也可以很清楚的看到一个事情，那就是，这个方法，它是真正要干事情的，在它之前，都是做些准备工作，还没做事！
• 2.ConfigurationClassBeanDefinitionReader的作用呢，其实就是处理@ImportSource、@Import(ImportBeanDeinitionRegistrar.class)、@Bean这些情况，将这些情况导入的Bean都导入到Spring容器当中去

3.3 对于ConfigurationClassParser的核心代码

    // 处理配置类
    private void doProcessConfigurationClass(ConfigurationClass configurationClass) {

        // 如果目标配置类加了@Component注解
        if (configurationClass.getMetadata().hasAnnotation(Component.class.getName())) {

        }

        // 如果目标配置类加了@Configuration注解
        if (configurationClass.getMetadata().hasAnnotation(Configuration.class.getName())) {

        }

        // 如果目标配置类标注了@PropertySource/@PropertySources(容器)注解，那么需要将指定的配置文件加载到容器的环境当中去...
        processPropertySources(configurationClass);

        // 如果目标配置类加了@ComponentScan/@ComponentScans(容器)注解，那么这里可以获取到配置的包名信息，并进行递归扫描和处理
        processComponentScans(configurationClass);

        // 如果标注了@Import注解(处理ImportSelector/BeanDefinitionRegistrar)
        processImports(configurationClass, getImportCandidates(configurationClass));

        // 如果标注了@ImportSource注解，那么需要进行解析
        processImportResources(configurationClass);

        // 如果有标注@Bean注解的方法，那么需要进行处理@Bean注解
        processBeans(configurationClass);
    }

在这里其实处理@ComponenScan注解时，还用到了ComponentScanAnnotationParser这个组件，它其实就是组合了一个之前我们讲过的ClassPathBeanDefinitionScanner去做包扫描。