spring 深入理解

1.spring依赖注入是在什么时候完成的
是在初始化bean的时候完成的，bean的初始化过程，也叫bean的生命周期
2.spring bean的生命周期到底在那个步骤完成的依赖注入？
spring bean 的产生过程
3.bean是有什么产生来的
常规java类
Class------object(bean)
spring bean的话
Class-----beanDefinition----------Object(bean)
详细描述
普通类的实例化过程
User.java---->javac----->User.class—new—>object
普通类User.java通过javac命令进行编译，编译后变为User.class类，然后通过启动run方法来执行jvm虚拟机，JVM虚拟机又会在磁盘上将刚才编译好的User.class文件加载JVM的内存当中，当他碰到new的关键字的时候，他又会根据java模板到堆上给他分配一块内存，用来存储这个对象
spring bean 的实例化过程

比如有一个user.java类，给他加上一个Spring的注解（@component 把普通pojo实例化到spring容器中，相当于配置文件中的）,然后通过run方法来执行，依旧会把这个user.java编译成User.class加载到虚拟机当中。当我们遇到spring初始化AnnotationConfigApplicationContext对象的时候，spring容器会在这个对象中做很多事情，他首先会通过解析提供的类的上面提供的扫描包路径，通过包路径拿到包路径下的所有类，这个时候由spring来处理User类，但是spring也不知道怎么处理User类，他不知道这个User类有没有什么其他特殊处理，比如懒加载，启动的时候，他是不用new的，等用到这个类的时候，他才new的，所以说spring扫描到这个类的时候，他并不是直接new,而是先解析这个类的配置信息，而存储这个类的配置信息，spring会创建一个对象，用了存储配置信息，这个对象叫beanDefinition的实现类，beanDefinition实现类中有很多属性，这些属性是用来存储User类中的配置信息，将这些信息进行拆分，然后再放到map对象中，由于，解析包路径下的类有多个，所以spring会进行多次解析，多次解析后，就会有很多个beanDefinition对象，然后spring会将这些对象存放到map中，进行验证，验证成功后，先调用扩展类，如果没有扩展（扩展一般是程序员自主添加的方法），就会调用prelnstantiateSingletons 方法，将spring对象放到单利池中，进行new创建。对于spring多利，他并不是spring初始化的时候去new这个对象，而是在getBean的时候去创建
beanDefinition 对象内容

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

4.spring当中的循环依赖怎么解决
spring当中是默认单利支持循环
怎么证明他默认支持的？怎么关闭循环依赖？
在spring在初始化bean的生命周期过程当中，当他把我们的springbean实例化之后，他会去做一次判断，判断当前三个容器，允不允许开启循环依赖，允不允许开启循环依赖是跟据spring中的一个属性allowCircularReferences来判断的，而这个allowCircularReferences属性默认是为true


修改源码 将这个属性修改为false即可关闭，或者在spring初始化之前，修改

也就是refresh之前，先拿到预加载对象，进行属性赋值
createBean源码

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
		//先判断日志
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Creating instance of bean '" + beanName + "'");
        }
		//然后将BeanDefinition对象赋值
        RootBeanDefinition mbdToUse = mbd;
		//从BeanDefinition对象中获取bean的类型
        Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
		//验证
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
            mbdToUse = new RootBeanDefinition(mbd);
            mbdToUse.setBeanClass(resolvedClass);
        }

        try {
            mbdToUse.prepareMethodOverrides();
        } catch (BeanDefinitionValidationException var9) {
            throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var9);
        }

        Object beanInstance;
        try {
			//第一次调用后置处理器
            beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
            if (beanInstance != null) {
                return beanInstance;
            }
        } catch (Throwable var10) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var10);
        }

        try {
            beanInstance = this.doCreateBean(beanName, mbdToUse, args);
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Finished creating instance of bean '" + beanName + "'");
            }

            return beanInstance;
        } catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) {
            throw var7;
        } catch (Throwable var8) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", var8);
        }
    }



	 protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        BeanWrapper instanceWrapper = null;
		//判断是否定义Singleton模式
        if (mbd.isSingleton()) {
            instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
        }

        if (instanceWrapper == null) {
			//实例化对象（创建对象），第二次调用后置处理器
            instanceWrapper = this.createBeanInstance(beanName, mbd, args);
        }

        Object bean = instanceWrapper.getWrappedInstance();
        Class<?> beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) {
            mbd.resolvedTargetType = beanType;
        }

        Object var7 = mbd.postProcessingLock;
        synchronized(mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                try {
                    this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                } catch (Throwable var17) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);
                }

                mbd.postProcessed = true;
            }
        }
		//判断是否需要循环依赖 默认为true
        boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
        if (earlySingletonExposure) {
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
            }
			//第四次调用后置处理器 判断是否需要AOP
            this.addSingletonFactory(beanName, () -> {
                return this.getEarlyBeanReference(beanName, mbd, bean);
            });
        }

        Object exposedObject = bean;

        try {
			//填充属性 也就是我们所说的自动注入
			//里面会完成第五次第六次后置处理器的调用
            this.populateBean(beanName, mbd, instanceWrapper);
			//初始化spring
			//里面会进行第七次和第八次后置处理器调用
            exposedObject = this.initializeBean(beanName, exposedObject, mbd);
        } catch (Throwable var18) {
            if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
                throw (BeanCreationException)var18;
            }

            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
        }

        if (earlySingletonExposure) {
            Object earlySingletonReference = this.getSingleton(beanName, false);
            if (earlySingletonReference != null) {
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                } else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
                    String[] dependentBeans = this.getDependentBeans(beanName);
                    Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
                    String[] var12 = dependentBeans;
                    int var13 = dependentBeans.length;

                    for(int var14 = 0; var14 < var13; ++var14) {
                        String dependentBean = var12[var14];
                        if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                            actualDependentBeans.add(dependentBean);
                        }
                    }

                    if (!actualDependentBeans.isEmpty()) {
                        throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been wrapped. This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
                    }
                }
            }
        }

        try {
            this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
            return exposedObject;
        } catch (BeanDefinitionValidationException var16) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
        }
    }
	
//通过构造方法反射来完成创建对象
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
        Class<?> beanClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
        if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
        } else {
            Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
            if (instanceSupplier != null) {
                return this.obtainFromSupplier(instanceSupplier, beanName);
            } else if (mbd.getFactoryMethodName() != null) {
                return this.instantiateUsingFactoryMethod(beanName, mbd, args);
            } else {
                boolean resolved = false;
                boolean autowireNecessary = false;
                if (args == null) {
                    Object var8 = mbd.constructorArgumentLock;
                    synchronized(mbd.constructorArgumentLock) {
                        if (mbd.resolvedConstructorOrFactoryMethod != null) {
                            resolved = true;
                            autowireNecessary = mbd.constructorArgumentsResolved;
                        }
                    }
                }

                if (resolved) {
                    return autowireNecessary ? this.autowireConstructor(beanName, mbd, (Constructor[])null, (Object[])null) : this.instantiateBean(beanName, mbd);
                } else {
                    Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);
                    if (ctors == null && mbd.getResolvedAutowireMode() != 3 && !mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args)) {
                        ctors = mbd.getPreferredConstructors();
                        return ctors != null ? this.autowireConstructor(beanName, mbd, ctors, (Object[])null) : this.instantiateBean(beanName, mbd);
                    } else {
                        return this.autowireConstructor(beanName, mbd, ctors, args);
                    }
                }
            }
        }
    }

spring循环依赖理解
首先当spring初始化@Autowired注入属性（userService 通过getBean，去取indexService属性）的时候，他会在初始化生命周期的过程中，去完成属性填充，那么当他完成属性填充的过程中，他会发觉他会去依赖indexService属性，userService属性会根据inject方法进行注入，注入bean的过程中，他会找到注入userService属性，因为userService属性会找到注入的indexService属性，于是，他就会到容器中去拿indexService属性，拿不到的情况下进行判断是否从第三个缓存中拿，然后new一个indexService,new一个indexService对象后，又会接着注入userService,然后容器getBean(Uservice)

@Autowired 
@Resource
区别：处理后置服务器的类不一样，@Resource 后置处理类CommonAnnotaionBeanPostProcessor  
AutowiredAnnotationBeanPostProcessor 处理Autowired注入