spring源码阅读-推断构造方法

如何构造一个对象?

1、默认情况下,或者只有一个构造方法的情况下,就会使用默认构造方法或者唯一的一个构造方法

2、由程序员指定构造方法入参值,通过getBean()的方式获取,可以指定参数类型以及个数,但是该bean需要为LazyBean或者原型bean,否则在spring启动的时候就已经创建好存入单例池中,getBean()也只会取到单例池种的bean。

		UserService userService = applicationContext.getBean("userService", UserService.class);

3、由程序员自己注册Bean然后指定参数个数以及类型

public static void main(String[] args) {
		AnnotationConfigApplicationContext applicationContext =
				new AnnotationConfigApplicationContext(BeanNameAutoProxyCreatorDemo.class);

		AbstractBeanDefinition rawBeanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getRawBeanDefinition();
		rawBeanDefinition.setBeanClass(UserService.class);
		rawBeanDefinition.getConstructorArgumentValues().addGenericArgumentValue(new User());
		applicationContext.registerBeanDefinition("userService",rawBeanDefinition);
		applicationContext.refresh();
		UserService userService = (UserService)applicationContext.getBean("userService");

4、由程序员自己指定第N+1个参数的类型或bean名字

类型

public static void main(String[] args) {
		AnnotationConfigApplicationContext applicationContext =
				new AnnotationConfigApplicationContext(BeanNameAutoProxyCreatorDemo.class);

		AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getRawBeanDefinition();
		rawBeanDefinition.setBeanClass(UserService.class);
        //指定第二个参数的类型是User
		beanDefinition .getConstructorArgumentValues().addIndexedArgumentValue(1,new User());

		applicationContext.registerBeanDefinition("userService",beanDefinition );
		applicationContext.refresh();
		UserService userService = (UserService)applicationContext.getBean("userService");

名字

AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getRawBeanDefinition();
		beanDefinition.setBeanClass(UserService.class);
		beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(1,new RuntimeBeanNameReference("orderService"));

5、通过指定spring自己选择构造方法

<bean id="userService" class="com.tuling.UserService" autowire="constructor"></bean>

6、通过程序员添加@autowire注解选择指定的构造方法

@Autowired
	public UserService(User user) {
		this.user = user;
	}

7、(这一点功能比较鸡肋,但是在推断构造方法中有用到,就顺带提一下)注册bean的时候可以直接指定返回的实例对象

AbstractBeanDefinition rawBeanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getRawBeanDefinition();
		rawBeanDefinition.setBeanClass(UserService.class);
		rawBeanDefinition.setInstanceSupplier(new Supplier<Object>() {
			@Override
			public Object get() {
				return new User();
			}
		});
		applicationContext.registerBeanDefinition("userService",rawBeanDefinition);
		applicationContext.refresh();
		User userService = (User)applicationContext.getBean("userService");

8.

核心代码

createBeanInstance

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		// 加载beanName所对应的类
		Class<?> beanClass = resolveBeanClass(mbd, beanName);
		//这个bean不是公共类或者没有开启访问私有成员的权限,则抛出异常
		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());
		}

		// BeanDefinition中添加了Supplier,则调用Supplier来得到对象
		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}

		// @Bean对应的BeanDefinition
		if (mbd.getFactoryMethodName() != null) {
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		// Shortcut when re-creating the same bean...
		// 一个原型BeanDefinition,会多次来创建Bean,那么就可以把该BeanDefinition所要使用的构造方法缓存起来,避免每次都进行构造方法推断
		boolean resolved = false;
		boolean autowireNecessary = false;
		//当getBean的方式没有传入参数,则尝试走缓存
		if (args == null) {
			//doublecheck加锁
			synchronized (mbd.constructorArgumentLock) {
				//resolvedConstructorOrFactoryMethod代表缓存的构造方法
				if (mbd.resolvedConstructorOrFactoryMethod != null) {
					resolved = true;
					// autowireNecessary表示有没有必要要进行注入,比如当前BeanDefinition用的是无参构造方法
					// 那么autowireNecessary为false,否则为true,表示需要给构造方法参数注入值
					autowireNecessary = mbd.constructorArgumentsResolved;
				}
			}
		}
		if (resolved) {
			// 如果确定了当前BeanDefinition的构造方法,那么看是否需要进行对构造方法进行参数的依赖注入(构造方法注入)
			if (autowireNecessary) {
				// 方法内会拿到缓存好的构造方法的入参
				return autowireConstructor(beanName, mbd, null, null);
			}
			else {
				// 构造方法已经找到了,但是没有参数,那就表示是无参,直接进行实例化
				return instantiateBean(beanName, mbd);
			}
		}
		/**推断构造方法*/
		// 提供一个扩展点,可以利用SmartInstantiationAwareBeanPostProcessor来控制用beanClass中的哪些构造方法
		// 比如AutowiredAnnotationBeanPostProcessor会把加了@Autowired注解的构造方法找出来,具体看代码实现会更复杂一点
		//下面有详细代码
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);

		// 如果推断出来了构造方法,则需要给构造方法赋值,也就是给构造方法参数赋值,也就是构造方法注入
		// 如果没有推断出来构造方法,但是autowiremode为AUTOWIRE_CONSTRUCTOR,则也可能需要给构造方法赋值,因为不确定是用无参的还是有参的构造方法
		// 如果通过BeanDefinition指定了构造方法参数值,那肯定就是要进行构造方法注入了
		// 如果调用getBean的时候传入了构造方法参数值,那肯定就是要进行构造方法注入了
		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			//下面有详细代码
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		// Preferred constructors for default construction?
		ctors = mbd.getPreferredConstructors();
		if (ctors != null) {
			return autowireConstructor(beanName, mbd, ctors, null);
		}

		// 不匹配以上情况,则直接使用无参构造方法,如果没有找到无参构造方法,则抛出异常
		return instantiateBean(beanName, mbd);
	}

determineConstructorsFromBeanPostProcessors 获取构造方法

protected Constructor<?>[] determineConstructorsFromBeanPostProcessors(@Nullable Class<?> beanClass, String beanName)
			throws BeansException {

		if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {
			for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
				Constructor<?>[] ctors = bp.determineCandidateConstructors(beanClass, beanName);
				if (ctors != null) {
					return ctors;
				}
			}
		}
		return null;
	}

determineCandidateConstructors,获取构造方法

//推断构造方法
	public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, final String beanName)
			throws BeanCreationException {

		// Let's check for lookup methods here...
		if (!this.lookupMethodsChecked.contains(beanName)) {
			// 判断beanClass是不是java.开头的类,比如String
			if (AnnotationUtils.isCandidateClass(beanClass, Lookup.class)) {

				try {
					Class<?> targetClass = beanClass;
					do {
						// 遍历targetClass中的method,查看是否写了@Lookup方法
						ReflectionUtils.doWithLocalMethods(targetClass, method -> {
							Lookup lookup = method.getAnnotation(Lookup.class);
							if (lookup != null) {
								Assert.state(this.beanFactory != null, "No BeanFactory available");

								// 将当前method封装成LookupOverride并设置到BeanDefinition的methodOverrides中
								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);
		}

		//从缓存中拿出构造方法
		Constructor<?>[] candidateConstructors = this.candidateConstructorsCache.get(beanClass);
		if (candidateConstructors == null) {
			synchronized (this.candidateConstructorsCache) {
				candidateConstructors = this.candidateConstructorsCache.get(beanClass);
				if (candidateConstructors == null) {
					Constructor<?>[] rawCandidates;
					try {
						// 拿到所有的构造方法
						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);

					// 用来记录required为true的构造方法,一个类中只能有一个required为true的构造方法
					Constructor<?> requiredConstructor = null;
					// 用来记录默认无参的构造方法
					Constructor<?> defaultConstructor = null;
					// kotlin相关,不用管
					Constructor<?> primaryConstructor = BeanUtils.findPrimaryConstructor(beanClass);
					int nonSyntheticConstructors = 0;

					// 遍历每个构造方法
					for (Constructor<?> candidate : rawCandidates) {
						if (!candidate.isSynthetic()) {
							// kotlin相关,不用管
							nonSyntheticConstructors++;
						}
						else if (primaryConstructor != null) {
							continue;
						}

						// 当前遍历的构造方法是否写了@Autowired
						MergedAnnotation<?> ann = findAutowiredAnnotation(candidate);
						if (ann == null) {
							// 如果beanClass是代理类,则得到被代理的类的类型
							Class<?> userClass = ClassUtils.getUserClass(beanClass);
							//如果getUserClass获取到的calss对象不等于beanClass
							//说明beanClass是代理类,则需要找到被代理类的所有的方法,再去看是有Autowrire注解
							if (userClass != beanClass) {
								try {
									Constructor<?> superCtor =
											userClass.getDeclaredConstructor(candidate.getParameterTypes());
									ann = findAutowiredAnnotation(superCtor);
								}
								catch (NoSuchMethodException ex) {
									// Simply proceed, no equivalent superclass constructor found...
								}
							}
						}

						// 当前构造方法上加了@Autowired
						if (ann != null) {
							// 整个类中如果有一个required为true的构造方法,那就不能有其他的加了@Autowired的构造方法
							if (requiredConstructor != null) {
								throw new BeanCreationException(beanName,
										"Invalid autowire-marked constructor: " + candidate +
										". Found constructor with 'required' Autowired annotation already: " +
										requiredConstructor);
							}
								//校验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;
							}
							// 记录所有加了@Autowired的构造方法,不管required是true还是false
							// 如果默认无参的构造方法上也加了@Autowired,那么也会加到candidates中
							candidates.add(candidate);

							// 从上面代码可以得到一个结论,在一个类中,要么只能有一个required为true的构造方法,要么只能有一个或多个required为false的方法
						}
						else if (candidate.getParameterCount() == 0) {
							// 记录唯一一个无参的构造方法
							defaultConstructor = candidate;
						}

						// 有可能存在有参、并且没有添加@Autowired的构造方法
					}

					//第一中情况,如果candidates 不是空的,那么如果不存在required为true的构造方法,再将默认构造方法加入集合后返回
					//否则直接返回required为true的构造方法
					if (!candidates.isEmpty()) {
						// 如果不存在一个required为true的构造方法,则所有required为false的构造方法和无参构造方法都是合格的,都加入集合中
						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]);
					}
					//第二种情况,没有添加了@Autowired注解的构造方法,并且类中只有一个构造方法,并且是有参的
					else if (rawCandidates.length == 1 && rawCandidates[0].getParameterCount() > 0) {
						candidateConstructors = new Constructor<?>[] {rawCandidates[0]};
					}
					// primaryConstructor不用管
					else if (nonSyntheticConstructors == 2 && primaryConstructor != null &&
							defaultConstructor != null && !primaryConstructor.equals(defaultConstructor)) {
						candidateConstructors = new Constructor<?>[] {primaryConstructor, defaultConstructor};
					}
					// primaryConstructor不用管
					else if (nonSyntheticConstructors == 1 && primaryConstructor != null) {
						candidateConstructors = new Constructor<?>[] {primaryConstructor};
					}
					else {
						//其他情况:
						//有多个不加Autowired注解的构造方法,返回null
						//只有一个无参的默认构造方法,返回null
						
						candidateConstructors = new Constructor<?>[0];
					}
					this.candidateConstructorsCache.put(beanClass, candidateConstructors);
				}
			}
		}
		return (candidateConstructors.length > 0 ? candidateConstructors : null);
	}

详解 

针对determineCandidateConstructors做了一个小的总结

特别说明,此处返回null不是代表最终无法获取构造方法,只是与下一段代码衔接

autowireConstructor  推断构造方法

经过上面的筛选已经拿到了一个或多个构造方法,这时候通过autowireConstructor进行推断构造方法

	public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
			@Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {
		//chosenCtors 筛选出来的构造方法集合
		//explicitArgs getBean()传入的参数数组

		BeanWrapperImpl bw = new BeanWrapperImpl();
		this.beanFactory.initBeanWrapper(bw);

		Constructor<?> constructorToUse = null;
		ArgumentsHolder argsHolderToUse = null;
		Object[] argsToUse = null;

		// 如果getBean()传入了args,那构造方法要用的入参就直接确定好了
		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);
			}
		}

		// 如果没有确定要使用的构造方法,或者确定了构造方法但是所要传入的参数值没有确定
		if (constructorToUse == null || argsToUse == null) {

			// Take specified constructors, if any.
			// 如果没有指定构造方法,那就获取beanClass中的所有构造方法所谓候选者
			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;
				}
			}

			//此处是判断构造方法是否添加了@Autowire注解或者该类的注入方式为构造器注入。只有满足条件才支持自动注入
			boolean autowiring = (chosenCtors != null ||
					mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
			ConstructorArgumentValues resolvedValues = null;

			// 确定要选择的构造方法的参数个数的最小值,后续判断候选构造方法的参数个数如果小于minNrOfArgs,则直接pass掉
			int minNrOfArgs;
			if (explicitArgs != null) {
				// 如果直接传了构造方法参数值,那么所用的构造方法的参数个数肯定不能少于
				minNrOfArgs = explicitArgs.length;
			}
			else {
				// 如果通过beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue()传了构造方法参数值,
				// 因为有可能是通过下标指定了,比如0位置的值,2位置的值,虽然只指定了2个值,但是构造方法的参数个数至少得是3个
				ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
				resolvedValues = new ConstructorArgumentValues();
				// 处理RuntimeBeanReference
				/*找出构造方法中最小的参数个数*/
				//下面有详细代码
				minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
			}

			// 对候选构造方法进行排序,public的方法排在最前面,都是public的情况下参数个数越多越靠前
			/*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());
			};*/
			AutowireUtils.sortConstructors(candidates);
			int minTypeDiffWeight = Integer.MAX_VALUE;
			Set<Constructor<?>> ambiguousConstructors = null;
			Deque<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;
				}
				// 如果参数个数小于所要求的参数个数,则遍历下一个,这里考虑的是同时存在public和非public的构造方法
				if (parameterCount < minNrOfArgs) {
					continue;
				}

				ArgumentsHolder argsHolder;
				Class<?>[] paramTypes = candidate.getParameterTypes();
				// 没有通过getBean()指定构造方法参数值
				if (resolvedValues != null) {
					try {
						// 如果在构造方法上使用了@ConstructorProperties,那么就直接取定义的值作为构造方法的参数名
						String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, parameterCount);

						// 获取构造方法参数名
						if (paramNames == null) {
							ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
							if (pnd != null) {
								paramNames = pnd.getParameterNames(candidate);
							}
						}

						// 根据参数类型、参数名找到对应的bean对象
						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 ArrayDeque<>(1);
						}
						causes.add(ex);
						continue;
					}
				}
				else {
					// Explicit arguments given -> arguments length must match exactly.
					// 在调getBean方法时传入了参数值,那就表示只能用对应参数个数的构造方法
					if (parameterCount != explicitArgs.length) {
						continue;
					}
					// 不用再去BeanFactory中查找bean对象了,已经有了,同时当前正在遍历的构造方法就是可用的构造方法
					argsHolder = new ArgumentsHolder(explicitArgs);
				}

				// 当前遍历的构造方法所需要的入参对象都找到了,根据参数类型和找到的参数对象计算出来一个匹配值,值越小越匹配
				// isLenientConstructorResolution为true表示宽松模式
				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;
				}
				// 值相等的情况下,记录一下匹配值相同的构造方法,将构造方法加入ambiguousConstructors
				//用于后面根据是否宽松模式决定是否抛出异常
				else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
					if (ambiguousConstructors == null) {
						ambiguousConstructors = new LinkedHashSet<>();
						ambiguousConstructors.add(constructorToUse);
					}
					ambiguousConstructors.add(candidate);
				}
			}
			// 遍历结束   x

			// 如果没有可用的构造方法,就取记录的最后一个异常并抛出
			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 on bean class [" + mbd.getBeanClassName() + "] " +
						"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
			}
			// 如果有可用的构造方法,但是有多个构造方法,如果是宽松模式,则不报错,取选到的第一个,如果不是宽松模式,则抛出异常
			//isLenientConstructorResolution为true代表宽松模式
			else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) {
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Ambiguous constructor matches found on bean class [" + mbd.getBeanClassName() + "] " +
						"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
						ambiguousConstructors);
			}

			// 如果没有通过getBean方法传入参数,并且找到了构造方法以及要用的入参对象则缓存
			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;
	}

resolveConstructorArguments 找出最小参数个数

//找出最小入参个数,并且对程序员手动指定的参数进行覆盖
	private int resolveConstructorArguments(String beanName, RootBeanDefinition mbd, BeanWrapper bw,
			ConstructorArgumentValues cargs, ConstructorArgumentValues resolvedValues) {

		TypeConverter customConverter = this.beanFactory.getCustomTypeConverter();
		TypeConverter converter = (customConverter != null ? customConverter : bw);
		BeanDefinitionValueResolver valueResolver =
				new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, converter);
		//手动注册bean的时候指定的参数
		int minNrOfArgs = cargs.getArgumentCount();
		//这里对所有制定了下表入参的集合进行循环 rawBeanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(1,new User());
		for (Map.Entry<Integer, ConstructorArgumentValues.ValueHolder> entry : cargs.getIndexedArgumentValues().entrySet()) {
			int index = entry.getKey();
			if (index < 0) {
				//如果指定的下表小于0 说明是错误数据,抛出异常
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Invalid constructor argument index: " + index);
			}
			//下表是从0开始的,假如minNrOfArgs=3,而程序员指定了index=3,实际代表的参数个数是4,所以最小参数格式改为4
			if (index + 1 > minNrOfArgs) {
				minNrOfArgs = index + 1;
			}
			ConstructorArgumentValues.ValueHolder valueHolder = entry.getValue();
			//当程序员手动指定了对应下标对象,则以程序员指定的为主,进行覆盖
			if (valueHolder.isConverted()) {
				resolvedValues.addIndexedArgumentValue(index, valueHolder);
			}
			else {
				// 会处理RuntimeBeanReference
				Object resolvedValue =
						valueResolver.resolveValueIfNecessary("constructor argument", valueHolder.getValue());
				ConstructorArgumentValues.ValueHolder resolvedValueHolder =
						new ConstructorArgumentValues.ValueHolder(resolvedValue, valueHolder.getType(), valueHolder.getName());
				resolvedValueHolder.setSource(valueHolder);
				resolvedValues.addIndexedArgumentValue(index, resolvedValueHolder);
			}
		}

		for (ConstructorArgumentValues.ValueHolder valueHolder : cargs.getGenericArgumentValues()) {
			if (valueHolder.isConverted()) {
				resolvedValues.addGenericArgumentValue(valueHolder);
			}
			else {
				Object resolvedValue =
						valueResolver.resolveValueIfNecessary("constructor argument", valueHolder.getValue());
				ConstructorArgumentValues.ValueHolder resolvedValueHolder = new ConstructorArgumentValues.ValueHolder(
						resolvedValue, valueHolder.getType(), valueHolder.getName());
				resolvedValueHolder.setSource(valueHolder);
				resolvedValues.addGenericArgumentValue(resolvedValueHolder);
			}
		}

		return minNrOfArgs;
	}

分值比较

//宽松模式,需要根据类型、父类、接口进行比较
public int getTypeDifferenceWeight(Class<?>[] paramTypes) {
			// If valid arguments found, determine type difference weight.
			// Try type difference weight on both the converted arguments and
			// the raw arguments. If the raw weight is better, use it.
			// Decrease raw weight by 1024 to prefer it over equal converted weight.

			// 最终值和类型的匹配程度
			int typeDiffWeight = MethodInvoker.getTypeDifferenceWeight(paramTypes, this.arguments);
			// 原始值和类型的匹配程度,并减掉1024,使得原始值的匹配值更优先,意思就是优先根据原始值来算匹配值
			int rawTypeDiffWeight = MethodInvoker.getTypeDifferenceWeight(paramTypes, this.rawArguments) - 1024;
			// 取最小值
			return Math.min(rawTypeDiffWeight, typeDiffWeight);
		}


public int getTypeDifferenceWeight(Class<?>[] paramTypes) {
			// If valid arguments found, determine type difference weight.
			// Try type difference weight on both the converted arguments and
			// the raw arguments. If the raw weight is better, use it.
			// Decrease raw weight by 1024 to prefer it over equal converted weight.

			// 最终值和类型的匹配程度
			int typeDiffWeight = MethodInvoker.getTypeDifferenceWeight(paramTypes, this.arguments);
			// 原始值和类型的匹配程度,并减掉1024,使得原始值的匹配值更优先,意思就是优先根据原始值来算匹配值
			int rawTypeDiffWeight = MethodInvoker.getTypeDifferenceWeight(paramTypes, this.rawArguments) - 1024;
			// 取最小值
			return Math.min(rawTypeDiffWeight, typeDiffWeight);
		}

==========================================================
 //严格模式只需要判断类型即可

		public int getAssignabilityWeight(Class<?>[] paramTypes) {
			for (int i = 0; i < paramTypes.length; i++) {
				//类型转换后的值进行匹配
				if (!ClassUtils.isAssignableValue(paramTypes[i], this.arguments[i])) {
					return Integer.MAX_VALUE;
				}
			}
			for (int i = 0; i < paramTypes.length; i++) {
				//类型转换前的值进行匹配
				if (!ClassUtils.isAssignableValue(paramTypes[i], this.rawArguments[i])) {
					return Integer.MAX_VALUE - 512;
				}
			}
			return Integer.MAX_VALUE - 1024;
		}

关于@Bean

在springXml文件中创建一个bean可以用以下的工厂方法

//getUserService为非静态方法
<bean id="userService" factory-bean="userService" factory-method="getUserService"></bean>
//getUserService为静态方法,是没有factory-bean的,只有class
<bean id="userService" class="com.jjs.userService" factory-method="getUserService"></bean>

而@Bean就等同于上面两个方式

首先,Spring会把@Bean修饰的方法解析成BeanDefinition:

1. 如果方法是static的,那么解析出来的BeanDefinition中:

i. factoryBeanName为AppConfig所对应的beanName,比如"appConfig"

ii. factoryMethodName为对应的方法名,比如"aService"

iii. factoryClass为AppConfig.class

2. 如果方法不是static的,那么解析出来的BeanDefinition中:

i. factoryBeanName为null

ii. factoryMethodName为对应的方法名,比如"aService"

iii. factoryClass也为AppConfig.class


在由@Bean生成的BeanDefinition中,有一个重要的属性isFactoryMethodUnique,表示 factoryMethod是不是唯一的,在普通情况下@Bean生成的BeanDefinition的 isFactoryMethodUnique为true,但是如果出现了方法重载,那么就是特殊的情况,比如:

@Bean 
public static AService aService(){ 
return new AService();  } 

@Bean 
public AService aService(BService bService){
  return new AService();  } 

虽然有两个@Bean,但是肯定只会生成一个aService的Bean,那么Spring在处理@Bean时,也只会 生成一个aService的BeanDefinition,比如Spring先解析到第一个@Bean,会生成一个 BeanDefinition,此时isFactoryMethodUnique为true,但是解析到第二个@Bean时,会判断出来 beanDefinitionMap中已经存在一个aService的BeanDefinition了,那么会把之前的这个 BeanDefinition的isFactoryMethodUnique修改为false,并且不会生成新的BeanDefinition了。   并且后续在根据BeanDefinition创建Bean时,会根据isFactoryMethodUnique来操作,如果为 true,那就表示当前BeanDefinition只对应了一个方法,那也就是只能用这个方法来创建Bean了, 但是如果isFactoryMethodUnique为false,那就表示当前BeanDefition对应了多个方法,需要和推断构造方法的逻辑一样,去选择用哪个方法来创建Bean。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值