2021-02-25

最新推荐文章于 2021-07-26 11:00:00 发布

让她淡淡的来

最新推荐文章于 2021-07-26 11:00:00 发布

阅读量56

点赞数

本文链接：https://blog.csdn.net/weixin_44999360/article/details/114063919

版权

面试被问到spring启动过程及bean生命周期等问题，明显感觉回答并不满意，遂从头到尾梳捋了一下启动过程，并记录自己的理解，期待各位大神点评，错误勿喷，仅供参考。
上代码。

AnnotationConfigApplicationContext ioc = new AnnotationConfigApplicationContext(Config.class);

因为使用javaBean作为配置文件，所以入口是AnnotationConfigApplicationContext，点进去看看他都干了什么，如下！

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
        this();
        this.register(componentClasses);
        this.refresh();
    }

先是this 构造器实例化了AnnotatedBeanDefinitionReader和ClassPathBeanDefinitionScanner。

public AnnotationConfigApplicationContext() {
		//完成了spring内部BeanDefinition的注册
        this.reader = new AnnotatedBeanDefinitionReader(this);
        /**
		 * 创建BeanDefinition扫描器
		 * 可以用来扫描包或者类，继而转换为bd
		 *
		 * spring默认的扫描包不是这个scanner对象
		 * 而是自己new的一个ClassPathBeanDefinitionScanner
		 * spring在执行工程后置处理器ConfigurationClassPostProcessor时，去扫描包时会new一个ClassPathBeanDefinitionScanner
		 *
		 * 这里的scanner仅仅是为了程序员可以手动调用AnnotationConfigApplicationContext对象的scan方法
		 *
		 */
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }

	到这发现 AnnotationConfigApplicationContext是继承自类GenericApplicationContext的，那子类的所有构造函数中的第一行,其实都有一条隐身的语句super();我们来看看GenericApplicationContext的构造器里面都有啥：

 public GenericApplicationContext() {
        this.customClassLoader = false;
        this.refreshed = new AtomicBoolean();
        this.beanFactory = new DefaultListableBeanFactory();
    }

记住这个DefaultListableBeanFactory，来看看他都能干嘛：
在这里插入图片描述
这是里面的一个方法。看注释也许我们就明白其作用了。就是将bean的definition注册到容器中。具体实现代码就不做阐述了。（实际上就是调来调去把我调蒙了。总之，他能将bean的definition注入到容器中）
definition是什么：（很重要想学习的另行百度）
Spring框架在各大框架中相当于管理员的角色，而管理员调度的单位是Bean，然后BeanDefinition就是框架内部对Bean的定义，BeanDefinition描述和定义了创建一个Bean需要的所有信息，属性，构造函数参数以及访问它们的方法。还有其他一些信息，比如这些定义来源自哪个类等等信息；
接着看，我们在new DefaultListableBeanFactory()的同时，做了什么？
在这里插入图片描述
他继承自AbstractAutowireCapableBeanFactory

	public AbstractAutowireCapableBeanFactory() {
		super();
		ignoreDependencyInterface(BeanNameAware.class);
		ignoreDependencyInterface(BeanFactoryAware.class);
		ignoreDependencyInterface(BeanClassLoaderAware.class);
	}

这是他的构造函数。三个ignore是用来处理自动注入的忽略项的，再往下看在这里插入图片描述
他又继承自AbstractBeanFactory，

他的构造方法是空的，但是往下翻，

好哇，beanFactory的getBean方法就是在这里实现的。

现在我们再回到this.reader = new AnnotatedBeanDefinitionReader(this);，
AnnotatedBeanDefinitionReader的构造器
然后接着看this里面都做了什么。

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		Assert.notNull(environment, "Environment must not be null");
		this.registry = registry;
		this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
		/**
		 * registerAnnotationConfigProcessors
		 * 根据名字顾名思义就是->注册注解配置的的处理器
		 * 也就是这个方法里面会注册一些用于处理注解的处理器
		 */
		AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
	}

好！点进去看registerAnnotationConfigProcessors方法。

 public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
        registerAnnotationConfigProcessors(registry, (Object)null);
    }

    public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(BeanDefinitionRegistry registry, @Nullable Object source) {
    	// 获取beanFactory也就是DefaultListableBeanFactory
        DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
        if (beanFactory != null) {
            if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
         //AnnotationAwareOrderComparator主要能解析@Order和@Priority
                beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
            }
            if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
            	//ContextAnnotationAutowireCandidateResolver提供处理延迟加载的功能
                beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
            }
        }

        Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet(8);
        RootBeanDefinition def;
        if (!registry.containsBeanDefinition("org.springframework.context.annotation.internalConfigurationAnnotationProcessor")) {
            def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalConfigurationAnnotationProcessor"));
        }

        if (!registry.containsBeanDefinition("org.springframework.context.annotation.internalAutowiredAnnotationProcessor")) {
            def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalAutowiredAnnotationProcessor"));
        }

        if (jsr250Present && !registry.containsBeanDefinition("org.springframework.context.annotation.internalCommonAnnotationProcessor")) {
            def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalCommonAnnotationProcessor"));
        }

        if (jpaPresent && !registry.containsBeanDefinition("org.springframework.context.annotation.internalPersistenceAnnotationProcessor")) {
            def = new RootBeanDefinition();

            try {
                def.setBeanClass(ClassUtils.forName("org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor", AnnotationConfigUtils.class.getClassLoader()));
            } catch (ClassNotFoundException var6) {
                throw new IllegalStateException("Cannot load optional framework class: org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor", var6);
            }

            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalPersistenceAnnotationProcessor"));
        }

        if (!registry.containsBeanDefinition("org.springframework.context.event.internalEventListenerProcessor")) {
            def = new RootBeanDefinition(EventListenerMethodProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.event.internalEventListenerProcessor"));
        }

        if (!registry.containsBeanDefinition("org.springframework.context.event.internalEventListenerFactory")) {
            def = new RootBeanDefinition(DefaultEventListenerFactory.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.event.internalEventListenerFactory"));
        }

        return beanDefs;
    }

主要内容就是通过registerPostProcessor（）方法注册以下bean后置处理器。
ConfigurationClassPostProcessor：是一个工厂后置处理器，这个后置处理器非常重要，基本上类上面的注解都在这里面判断并解析，spring的包扫描也在里面完成。
AutowiredAnnotationBeanPostProcessor：顾名思义就是处理@Autowired的，它是一个bean的后置处理器，在bean的属性注入的时候会用到
CommonAnnotationBeanPostProcessor：顾名思义就是处理一些公共注解的，它是一个bean的后置处理器，可以处理@PostConstruct和@PreDestroy还有@Resource等
EventListenerMethodProcessor：这是对@EventListener注解的处理，spring实现事件监听的方式有很多种，其中一种就是在方法上添加@EventListener注解
DefaultEventListenerFactory：这个也是跟事件监听有关，具体还不是很了解

	那我们接下来看registerPostProcessor方法是如何注册这些处理器的。
	点进方法看代码:

private static BeanDefinitionHolder registerPostProcessor(BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {
        definition.setRole(2);
        //再点进去
        registry.registerBeanDefinition(beanName, definition);
        return new BeanDefinitionHolder(definition, beanName);
    }

在这里插入图片描述
来到BeanDefinitionRegistry接口，来看看该方法的实现类，哦？第一个很熟悉吧。就是上面讲到过得将bean的definition注册到容器中的方法。
至此，new AnnotatedBeanDefinitionReader(this);完成了spring内部BeanDefinition的注册（主要是后置处理器）；接下来分析