实例化bean中有@Autowired注解的有参构造函数（二）

淡淡的烟草味﹌ 2023-10-02 20:19 8阅读 0赞

接着上一篇继续分析有参构造函数：

伪代码：

@Autowired
        public AutowiredConstructorBean(SC sc,CQ cq) {
            System.out.println(sc);
            System.out.println(cq);
        }
    
        @Autowired
        public AutowiredConstructorBean(CQ cq) {
            System.out.println(cq);
        }

1、从 AutowiredAnnotationBeanPostProcessor类的determineCandidateConstructors接口开始：

@Override
    	@Nullable
    	public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, final String beanName)
    			throws BeanCreationException {
    
    		// Let's check for lookup methods here...
    		if (!this.lookupMethodsChecked.contains(beanName)) {
    			if (AnnotationUtils.isCandidateClass(beanClass, Lookup.class)) {
    				try {
    					Class<?> targetClass = beanClass;
    					do {
    						ReflectionUtils.doWithLocalMethods(targetClass, method -> {
    							//对注解Lookup的支持
    							Lookup lookup = method.getAnnotation(Lookup.class);
    							if (lookup != null) {
    								Assert.state(this.beanFactory != null, "No BeanFactory available");
    								LookupOverride override = new LookupOverride(method, lookup.value());
    								try {
    									RootBeanDefinition mbd = (RootBeanDefinition)
    											this.beanFactory.getMergedBeanDefinition(beanName);
    									mbd.getMethodOverrides().addOverride(override);
    								}
    								catch (NoSuchBeanDefinitionException ex) {
    									throw new BeanCreationException(beanName,
    											"Cannot apply @Lookup to beans without corresponding bean definition");
    								}
    							}
    						});
    						targetClass = targetClass.getSuperclass();
    					}
    					while (targetClass != null && targetClass != Object.class);
    
    				}
    				catch (IllegalStateException ex) {
    					throw new BeanCreationException(beanName, "Lookup method resolution failed", ex);
    				}
    			}
    			this.lookupMethodsChecked.add(beanName);
    		}
    
    		// Quick check on the concurrent map first, with minimal locking.
    		Constructor<?>[] candidateConstructors = this.candidateConstructorsCache.get(beanClass);
    		if (candidateConstructors == null) {
    			// Fully synchronized resolution now...
    			synchronized (this.candidateConstructorsCache) {
    				candidateConstructors = this.candidateConstructorsCache.get(beanClass);
    				if (candidateConstructors == null) {
    					Constructor<?>[] rawCandidates;
    					try {
    						//获取bean对应的所有构造器
    						rawCandidates = beanClass.getDeclaredConstructors();
    					}
    					catch (Throwable ex) {
    						throw new BeanCreationException(beanName,
    								"Resolution of declared constructors on bean Class [" + beanClass.getName() +
    								"] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
    					}
    					List<Constructor<?>> candidates = new ArrayList<>(rawCandidates.length);
    					Constructor<?> requiredConstructor = null;
    					Constructor<?> defaultConstructor = null;
    					Constructor<?> primaryConstructor = BeanUtils.findPrimaryConstructor(beanClass);
    					int nonSyntheticConstructors = 0;
    					for (Constructor<?> candidate : rawCandidates) {
    						if (!candidate.isSynthetic()) {
    							nonSyntheticConstructors++;
    						}
    						else if (primaryConstructor != null) {
    							continue;
    						}
    						//获取到构造函数上的@Autowired注解信息,这个方法可以不看
    						MergedAnnotation<?> ann = findAutowiredAnnotation(candidate);
    						if (ann == null) {
    							Class<?> userClass = ClassUtils.getUserClass(beanClass);
    							if (userClass != beanClass) {
    								try {
    									Constructor<?> superCtor =
    											userClass.getDeclaredConstructor(candidate.getParameterTypes());
    									ann = findAutowiredAnnotation(superCtor);
    								}
    								catch (NoSuchMethodException ex) {
    									// Simply proceed, no equivalent superclass constructor found...
    								}
    							}
    						}
    						if (ann != null) {
                                //遍历第二个构造函数时，其不为空，就报错
    							if (requiredConstructor != null) {
    								throw new BeanCreationException(beanName,
    										"Invalid autowire-marked constructor: " + candidate +
    										". Found constructor with 'required' Autowired annotation already: " +
    										requiredConstructor);
    							}
    							//获取到@Autowired里面的required方法的值，此处默认true,
    							boolean required = determineRequiredStatus(ann);
    							if (required) {
    								if (!candidates.isEmpty()) {
    									throw new BeanCreationException(beanName,
    											"Invalid autowire-marked constructors: " + candidates +
    											". Found constructor with 'required' Autowired annotation: " +
    											candidate);
    								}
                                   //如果required=true 首次遍历就赋值
    								requiredConstructor = candidate;
    							}
    							candidates.add(candidate);
    						}
    						else if (candidate.getParameterCount() == 0) {
    							defaultConstructor = candidate;
    						}
    					}
    					if (!candidates.isEmpty()) {
    						// Add default constructor to list of optional constructors, as fallback.
    						if (requiredConstructor == null) {
    							if (defaultConstructor != null) {
    								candidates.add(defaultConstructor);
    							}
    							else if (candidates.size() == 1 && logger.isInfoEnabled()) {
    								logger.info("Inconsistent constructor declaration on bean with name '" + beanName +
    										"': single autowire-marked constructor flagged as optional - " +
    										"this constructor is effectively required since there is no " +
    										"default constructor to fall back to: " + candidates.get(0));
    							}
    						}
    						candidateConstructors = candidates.toArray(new Constructor<?>[0]);
    					}
    					else if (rawCandidates.length == 1 && rawCandidates[0].getParameterCount() > 0) {
    						candidateConstructors = new Constructor<?>[] {rawCandidates[0]};
    					}
    					else if (nonSyntheticConstructors == 2 && primaryConstructor != null &&
    							defaultConstructor != null && !primaryConstructor.equals(defaultConstructor)) {
    						candidateConstructors = new Constructor<?>[] {primaryConstructor, defaultConstructor};
    					}
    					else if (nonSyntheticConstructors == 1 && primaryConstructor != null) {
    						candidateConstructors = new Constructor<?>[] {primaryConstructor};
    					}
    					else {
    						candidateConstructors = new Constructor<?>[0];
    					}
    					this.candidateConstructorsCache.put(beanClass, candidateConstructors);
    				}
    			}
    		}
    		return (candidateConstructors.length > 0 ? candidateConstructors : null);
    	}

遍历两个构造函数：

![d4c3d5d9db834d27a1bfa6fe9c9dfe02.png][] 循环第二个构造函数时，即将抛异常，原因时不允许有两个带有@Autowired注解的构造函数：

![0ee2b3bd18c044e7aaed4ca55309f281.png][]

报错信息如下：

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'autowiredConstructorBean': Invalid autowire-marked constructor: public com.enjoy.jack.bean.AutowiredConstructorBean(com.enjoy.jack.designPattern.strategy.CQ). Found constructor with 'required' Autowired annotation already: public com.enjoy.jack.bean.AutowiredConstructorBean(com.enjoy.jack.designPattern.strategy.SC,com.enjoy.jack.designPattern.strategy.CQ)
    
    	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.determineCandidateConstructors(AutowiredAnnotationBeanPostProcessor.java:342)
    	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.determineConstructorsFromBeanPostProcessors(AbstractAutowireCapableBeanFactory.java:1311)
    	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBeanInstance(AbstractAutowireCapableBeanFactory.java:1224)
    	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:567)
    	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:526)
    	at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:333)
    	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:244)
    	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:331)
    	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:202)
    	at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:905)
    	at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:944)
    	at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:611)
    	at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:145)
    	at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:86)
    	at com.enjoy.jack.test.MyTest.test1(MyTest.java:18)
    	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    	at java.lang.reflect.Method.invoke(Method.java:498)
    	at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:59)
    	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
    	at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:56)
    	at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
    	at org.junit.runners.ParentRunner$3.evaluate(ParentRunner.java:306)
    	at org.junit.runners.BlockJUnit4ClassRunner$1.evaluate(BlockJUnit4ClassRunner.java:100)
    	at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:366)
    	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:103)
    	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:63)
    	at org.junit.runners.ParentRunner$4.run(ParentRunner.java:331)
    	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:79)
    	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:329)
    	at org.junit.runners.ParentRunner.access$100(ParentRunner.java:66)
    	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:293)
    	at org.junit.runners.ParentRunner$3.evaluate(ParentRunner.java:306)
    	at org.junit.runners.ParentRunner.run(ParentRunner.java:413)
    	at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
    	at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
    	at com.intellij.rt.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:33)
    	at com.intellij.rt.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:230)
    	at com.intellij.rt.junit.JUnitStarter.main(JUnitStarter.java:58)

通过报错信息可以发现：required为true 时抛异常，而且即使加上无参构造函数也是抛同样的异常，如果设置为false时不抛异常， 测试如下：

@Autowired(required = false)
        public AutowiredConstructorBean(SC sc,CQ cq) {
            System.out.println(sc);
            System.out.println(cq);
        }
    
        @Autowired(required = false)
        public AutowiredConstructorBean(CQ cq) {
            System.out.println(cq);
        }

2、设置为false后，不在走下图的逻辑：也就不会报错

![64e22f9beec445ac8e0e17460da0f800.png][]

最后返回两个构造函数：

![e17971a5a2204f8cb84ab435cee38644.png][]

如果多个构造函数会排序，参数多的排前面：源码如下

public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
    			@Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {
    
    		BeanWrapperImpl bw = new BeanWrapperImpl();
    		this.beanFactory.initBeanWrapper(bw);
    
    		Constructor<?> constructorToUse = null;
    		ArgumentsHolder argsHolderToUse = null;
    		Object[] argsToUse = null;
    
    		if (explicitArgs != null) {
    			argsToUse = explicitArgs;
    		}
    		else {
    			Object[] argsToResolve = null;
    			synchronized (mbd.constructorArgumentLock) {
    				constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
    				if (constructorToUse != null && mbd.constructorArgumentsResolved) {
    					// Found a cached constructor...
    					argsToUse = mbd.resolvedConstructorArguments;
    					if (argsToUse == null) {
    						argsToResolve = mbd.preparedConstructorArguments;
    					}
    				}
    			}
    			if (argsToResolve != null) {
    				argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve, true);
    			}
    		}
    
    		if (constructorToUse == null || argsToUse == null) {
    			// Take specified constructors, if any.
    			Constructor<?>[] candidates = chosenCtors;
    			if (candidates == null) {
    				Class<?> beanClass = mbd.getBeanClass();
    				try {
    					candidates = (mbd.isNonPublicAccessAllowed() ?
    							beanClass.getDeclaredConstructors() : beanClass.getConstructors());
    				}
    				catch (Throwable ex) {
    					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    							"Resolution of declared constructors on bean Class [" + beanClass.getName() +
    							"] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
    				}
    			}
    
    			if (candidates.length == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
    				Constructor<?> uniqueCandidate = candidates[0];
    				if (uniqueCandidate.getParameterCount() == 0) {
    					synchronized (mbd.constructorArgumentLock) {
    						mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
    						mbd.constructorArgumentsResolved = true;
    						mbd.resolvedConstructorArguments = EMPTY_ARGS;
    					}
    					bw.setBeanInstance(instantiate(beanName, mbd, uniqueCandidate, EMPTY_ARGS));
    					return bw;
    				}
    			}
    
    			// Need to resolve the constructor.
    			boolean autowiring = (chosenCtors != null ||
    					mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
    			ConstructorArgumentValues resolvedValues = null;
    
    			int minNrOfArgs;
    			if (explicitArgs != null) {
    				minNrOfArgs = explicitArgs.length;
    			}
    			else {
    				ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
    				resolvedValues = new ConstructorArgumentValues();
    				minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
    			}
                //构造函数排序入口
    			AutowireUtils.sortConstructors(candidates);
    			int minTypeDiffWeight = Integer.MAX_VALUE;
    			Set<Constructor<?>> ambiguousConstructors = null;
    			LinkedList<UnsatisfiedDependencyException> causes = null;
    
    			for (Constructor<?> candidate : candidates) {
    				int parameterCount = candidate.getParameterCount();
    
    				//如果之前的构造器已经有一个被处理过，则后面的构造器就不用处理了
    				if (constructorToUse != null && argsToUse != null && argsToUse.length > parameterCount) {
    					// Already found greedy constructor that can be satisfied ->
    					// do not look any further, there are only less greedy constructors left.
    					break;
    				}
    				if (parameterCount < minNrOfArgs) {
    					continue;
    				}
    
    				ArgumentsHolder argsHolder;
    				Class<?>[] paramTypes = candidate.getParameterTypes();
    				if (resolvedValues != null) {
    					try {
    						String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, parameterCount);
    						if (paramNames == null) {
    							ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
    							if (pnd != null) {
    								paramNames = pnd.getParameterNames(candidate);
    							}
    						}
    						//这里会触发构造函数中参数的getBean操作，会实例化参数的值
    						argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,
    								getUserDeclaredConstructor(candidate), autowiring, candidates.length == 1);
    					}
    					catch (UnsatisfiedDependencyException ex) {
    						if (logger.isTraceEnabled()) {
    							logger.trace("Ignoring constructor [" + candidate + "] of bean '" + beanName + "': " + ex);
    						}
    						// Swallow and try next constructor.
    						if (causes == null) {
    							causes = new LinkedList<>();
    						}
    						causes.add(ex);
    						continue;
    					}
    				}
    				else {
    					// Explicit arguments given -> arguments length must match exactly.
    					if (parameterCount != explicitArgs.length) {
    						continue;
    					}
    					argsHolder = new ArgumentsHolder(explicitArgs);
    				}
    
    				int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
    						argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
    				// Choose this constructor if it represents the closest match.
    				if (typeDiffWeight < minTypeDiffWeight) {
    					constructorToUse = candidate;
    					argsHolderToUse = argsHolder;
    					argsToUse = argsHolder.arguments;
    					minTypeDiffWeight = typeDiffWeight;
    					ambiguousConstructors = null;
    				}
    				else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
    					if (ambiguousConstructors == null) {
    						ambiguousConstructors = new LinkedHashSet<>();
    						ambiguousConstructors.add(constructorToUse);
    					}
    					ambiguousConstructors.add(candidate);
    				}
    			}
    
    			if (constructorToUse == null) {
    				if (causes != null) {
    					UnsatisfiedDependencyException ex = causes.removeLast();
    					for (Exception cause : causes) {
    						this.beanFactory.onSuppressedException(cause);
    					}
    					throw ex;
    				}
    				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    						"Could not resolve matching constructor " +
    						"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
    			}
    			else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) {
    				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    						"Ambiguous constructor matches found in bean '" + beanName + "' " +
    						"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
    						ambiguousConstructors);
    			}
    
    			if (explicitArgs == null && argsHolderToUse != null) {
    				argsHolderToUse.storeCache(mbd, constructorToUse);
    			}
    		}
    
    		Assert.state(argsToUse != null, "Unresolved constructor arguments");
    		bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
    		return bw;
    	}

点击AutowireUtils.sortConstructors(candidates);

public static void sortConstructors(Constructor<?>[] constructors) {
    		Arrays.sort(constructors, EXECUTABLE_COMPARATOR);
    	}

点击 EXECUTABLE\_COMPARATOR，发现参数多的构造函数排在最前面。

public static final Comparator<Executable> EXECUTABLE_COMPARATOR = (e1, e2) -> {
    		int result = Boolean.compare(Modifier.isPublic(e2.getModifiers()), Modifier.isPublic(e1.getModifiers()));
    		return result != 0 ? result : Integer.compare(e2.getParameterCount(), e1.getParameterCount());
    	};

但是最后只初始化了一个构造函数，即首个构造函数。 如图：

![5675dc404b4f48fda167a8a917d94bd5.png][]

这里就拿着构造函数的方法名，参数等信息取初始化对象：

![e6d28c11c66c40b896da3a75f8cb3e17.png][]

通过这两篇文章我们发现 有参构造函数加不加注解都可以实例化，那么他们有什么区别呢？spring的目的是通过 @Autowired(required = false) 可以实例化多个构造函数？如果不加注解只能实例化一个？这个问题大家可以详细思考一下！！！

到此、实例化有参构造函数分享完毕。

[d4c3d5d9db834d27a1bfa6fe9c9dfe02.png]: https://img-blog.csdnimg.cn/d4c3d5d9db834d27a1bfa6fe9c9dfe02.png
[0ee2b3bd18c044e7aaed4ca55309f281.png]: https://img-blog.csdnimg.cn/0ee2b3bd18c044e7aaed4ca55309f281.png
[64e22f9beec445ac8e0e17460da0f800.png]: https://img-blog.csdnimg.cn/64e22f9beec445ac8e0e17460da0f800.png
[e17971a5a2204f8cb84ab435cee38644.png]: https://img-blog.csdnimg.cn/e17971a5a2204f8cb84ab435cee38644.png
[5675dc404b4f48fda167a8a917d94bd5.png]: https://img-blog.csdnimg.cn/5675dc404b4f48fda167a8a917d94bd5.png
[e6d28c11c66c40b896da3a75f8cb3e17.png]: https://img-blog.csdnimg.cn/e6d28c11c66c40b896da3a75f8cb3e17.png