如何构造一个对象？
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。
1173
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
