一.new AnnotationConfigApplicationContext(java.config)
1.this();
1.1.this.beanFactory = new DefaultListableBeanFactory();
1.1.1.创建bean工厂
1.1.2.继承了beanDefinitionRegistory,拥有了注册bean定义的能力
1.2.this.reader = new AnnotatedBeanDefinitionReader(this);
1.2.1.创建了很多的内置处理器bean定义,用来支撑我们ApplicationContext后面的一些运行,比如解析配置类..
1.2.2.用来读取配置类
1.3.this.scanner = new ClassPathBeanDefinitionScanner(this);
1.3.1扫描我们类路径下的符合条件的Class
1.3.2.通过doScan(String... basePackages) 扫描某个包下面的所有的类
2.register(annotatedClasses);
2.1.this.reader.register(annotatedClasses);
2.1.1.把配置类注册成了bean定义
3.refresh(); //IOC容器初始化13个方法
//准备刷新上下文环境
3.1.prepareRefresh();
//获取告诉子类初始化bean工厂不同工厂不同实现
3.2.ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//对bean工厂进行填充属性
3.3.prepareBeanFactory(beanFactory);
//留个子类去实现该接口
3.4.postProcessBeanFactory(beanFactory);
//调用bean工厂后置处理器:1.会将class扫描成beanDefini
3.5.invokeBeanFactoryPostProcessors(beanFactory); //注册bean定义
3.1.1.调用getBean实列化后置处理器ConfigurationClassPostProcessor...
3.1.2.由ConfigurationClassPostProcessor来解析配置类
//注册bean后置处理器
3.6.registerBeanPostProcessors(beanFactory);
//初始化国际化资源后置处理器
3.7.initMessageSource();
//创建事件多播器
3.8.initApplicationEventMulticaster();
//这个方法同样也是留给子类实现的,SpringBoot也是从这个方法启动
3.9.onRefresh();
//把事件监听器注册到多播器
3.10.registerListeners();
//实列化我们剩下的单实列bean
3.11.finishBeanFactoryInitialization(beanFactory); //调用getName
//冻结所有的bean定义,说明注册的bean定义不能为修改或任何进一步的处理->代表我们开要是生产bean了,不能在修改bean定义了
3.11.1.beanFactory.freezeConfiguration();
//实列华剩余的单实列bean
3.11.2.beanFactory.preInstantiateSingletons();
//拿到所有的bean定义的名字
3.11.2.1.List<String> beanNames = new ArrayList(this.beanDefinitionNames);
//循环我们的bean定义
3.11.2.2.for (String beanName : beanNames)
//合并我们的bean定义，因为@bean @service....类型不一样,转成统一的RootBeanDefinition,方便后续判断
3.11.2.3.RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//判断是否符合我们的生产标准,不是抽象的，是单列的，不是懒加载的
3.11.2.4.if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit())
//判断是否是工厂bean,判断我们的bean是否实现了FactoryBean的接口,如果是的话最终会调用getObject()方法返回实列用
&beanName可以拿到它原本的实列
3.11.2.5.if (isFactoryBean(beanName))
//调用getBean开始初始化
3.11.2.6.getBean(beanName);
//这里传入进来的name可能是别名,也可能是工厂bean的Name,所以这里取出真实的名字
3.11.2.6.1.final String beanName = transformedBeanName(name);
//尝试从缓存(容器中)中获取对象
3.11.2.6.2.Object sharedInstance = getSingleton(beanName);
//其实就是从一级缓存里面拿,第一次加载不会拿到
3.11.2.6.2.1.Object singletonObject = this.singletonObjects.get(beanName);
//判断容器里如果没有就创建bean,如果有的话就返回
3.11.2.6.3.if (sharedInstance != null && args == null)
//只能解决单列对象的setter注入的循环依赖,不能解决构造器注入...跳过
3.11.2.6.4.if (isPrototypeCurrentlyInCreation(beanName))
//父子容器暂时跳过...跳过
3.11.2.6.5.BeanFactory parentBeanFactory = getParentBeanFactory();
//如果创建bean不是为了类型检查，则要标记当前bean已经被创建或者即将被创建以便于BeanFactory可以优化重复创建的
3.11.2.6.6.markBeanAsCreated(beanName);
//查询有加@dependsOn的注解的成员属性的类
3.11.2.6.7.String[] dependsOn = mbd.getDependsOn();
//看有没有加@dependsOn注解,如果有的话优先加载依赖的@dependsOn注解的bean
3.11.2.6.8.if (dependsOn != null)
//判断是否是单列
3.11.2.6.9.if (mbd.isSingleton())
//把当前的类标记为正在创建,解决循环依赖,并回调用函数
3.11.2.6.10.sharedInstance = getSingleton(beanName, singletonFactory);
//回调函数的方法,去创建bean
3.11.2.6.11.return createBean(beanName, mbd, args);
//确保此时bean已经被解析拿到我们bean类型
3.11.2.6.11.1.Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
//关于我们的xml lookup-method 和replace-method
3.11.2.6.11.2.mbdToUse.prepareMethodOverrides();
//第一次调用bean的后置处理器(InstantiationAwareBeanPostProcessor)
3.11.2.6.11.3.Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
//如果实现了该接口postProcessBeforeInstantiation方法,去解析aop所有的切面
3.11.2.6.11.3.1.Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName)
//这个方法调用了实列化(反射),属性赋值，以及初始化
3.11.2.6.11.3.2.Object beanInstance = doCreateBean(beanName, mbdToUse, args);
//实列化(反射/工厂),使用合适的实例化策略来创建新的实列:工厂方法
3.11.2.6.11.3.2.1.instanceWrapper = createBeanInstance(beanName, mbd, args);
//从beanWrapper获取我们早期的对象(装饰模式)
3.11.2.6.11.3.2.2.final Object bean = instanceWrapper.getWrappedInstance();
//把当前实列放到三级缓存,解决循环依赖...跳过
3.11.2.6.11.3.2.3.boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircular
References &&isSingletonCurrentlyInCreation(beanName));
//进行属性赋值,调用set方法进行赋值
3.11.2.6.11.3.2.4.populateBean(beanName, mbd, instanceWrapper);
//进行对象的初始化(在这里可以生成代理对象),回调3个Aware
3.11.2.6.11.3.2.5.exposedObject = initializeBean(beanName, exposedObject, mbd);
//调用bean的初始化之前后置处理器(调用7个Aware),调用@PostConstruct
3.11.2.6.11.3.2.5.1.awrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
//InitializingBean调用((InitializingBean) bean).afterPropertiesSet();
3.11.2.6.11.3.2.5.2.invokeInitMethods(beanName, wrappedBean, mbd);
//@bean("init-Method")调用initMethod
3.11.2.6.11.3.2.5.3.1.invokeCustomInitMethod(beanName, bean, mbd);
//调用我们bean的后置处理器 aop动态代理
3.11.2.6.11.3.2.5.3.awrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
//最后容器刷新,发布刷新事件(Spring Cloud也是从这里启动的)
3.12.finishRefresh();
FactroyBean和BeanFactory
BeanFactory:spring顶层的核心接口,使用了简单工厂模式负责生产Bean FactroyBean:被它修饰的bean就成为了一个特殊的Bean,他最终会调用getObject方法,给我们返回最终的那个Bean
