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注入