03-finishBFInitialization
explicit 英 /ɪkˈsplɪsɪt/ adj. 明确的;详述的;直言的, 坦率的;一目了然的
disposable [dɪˈspəʊzəbl] 一次性
ambiguous 英 /æmˈbɪɡjuəs/ adj.不明确的;模棱两可的;含混不清的
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
public abstract class AbstractApplicationContext extends DefaultResourceLoader
implements ConfigurableApplicationContext {
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
// 1. 设置conversionService
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) && // conversionService
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
// Register a default embedded value resolver if no bean post-processor
// (such as a PropertyPlaceholderConfigurer bean) registered any before:
// at this point, primarily for resolution in annotation attribute values.
/*
* 2. EmbeddedValueResolver
* -----------------------------------------------------
* 1. <嵌入式值解析器>，用于属性值解析
* 2. <context:property-placeholder/>
* 3. PlaceholderConfigurerSupport.doProcessProperties()
*/
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
/*
* 3. LoadTimeWeaverAware
* -----------------------------------------------------------
* 1. prepareBeanFactory()有处理
* 2. 织入（AOP）相关处理
* 3. 尽早初始化loadTimeWeaverAware_bean，以便尽早注册它们的转换器
*/
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// Stop using the temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(null);
// Allow for caching all bean definition metadata, not expecting further changes.
// 冻结BD，注册BD不再被修改或处理
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
// 4. 实例化剩下的非懒加载单例对象（BFPP、BPP实现类已实例化）
beanFactory.preInstantiateSingletons();
}
}
1. ConversionService
- 上新了Spring，全新一代类型转换机制
- 转换服务 => 从一个类型到另一个类型 => 转换器来实现
1. Converter
- Converter<S, T>：一对一
T convert(S source);
- ConverterFactory<S, R>：一对多（对象S转换为R的所有子类型）
<T extends R> Converter<S, T> getConverter(Class<T> targetType);
- GenericConverter：多对多
Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType);
/**
* ---------------- StringToBooleanConverter ---------------
* true
* true
* false
* false
* null
* ---------------- StringToCharsetConverter ---------------
* UTF-8
* UTF-8
* ---------------- StringToNumberConverterFactory ---------------
* cf1 = 1
* cf2 = 1.0
* cf3 = 1
* ---------------- CollectionToCollectionConverter ---------------
* [java.util.Collection -> java.util.Collection]
* matches => true
* class java.util.LinkedHashSet
* [1, 2, 3, 4]
*/
class T8_Converter {
public static void main(String[] args) {
System.out.println("---------------- StringToBooleanConverter ---------------");
Converter<String, Boolean> c = new StringToBooleanConverter();
// true, on, yes, 1
System.out.println(c.convert("true"));
System.out.println(c.convert("1"));
// false, off, no, 0
System.out.println(c.convert("FalSe"));
System.out.println(c.convert("off"));
// 注意：空串返回的是null
System.out.println(c.convert(""));
System.out.println("---------------- StringToCharsetConverter ---------------");
Converter<String, Charset> c2 = new StringToCharsetConverter();
// 中间横杠非必须，但强烈建议写上。不区分大小写
System.out.println(c2.convert("uTf-8"));
System.out.println(c2.convert("utF8"));
System.out.println("---------------- StringToNumberConverterFactory ---------------");
// ConverterFactory，一对多（对象S转换为R的所有子类型）
ConverterFactory<String, Number> cf = new StringToNumberConverterFactory();
// 注意：这里不能写基本数据类型。如int.class将抛错
Integer cf1 = cf.getConverter(Integer.class).convert("1");
System.out.println("cf1 = " + cf1);
Double cf2 = cf.getConverter(Double.class).convert("1");
System.out.println("cf2 = " + cf2);
Byte cf3 = cf.getConverter(Byte.class).convert("1");
System.out.println("cf3 = " + cf3);
System.out.println("---------------- CollectionToCollectionConverter ---------------");
ConditionalGenericConverter cgc = new CollectionToCollectionConverter(new DefaultConversionService());
// 将Collection转为Collection（注意：没有指定泛型类型）
System.out.println(cgc.getConvertibleTypes()); // [java.util.Collection -> java.util.Collection]
TypeDescriptor sourceTypeDesp = TypeDescriptor.collection(List.class, TypeDescriptor.valueOf(String.class));
TypeDescriptor targetTypeDesp = TypeDescriptor.collection(Set.class, TypeDescriptor.valueOf(Integer.class));
System.out.println("matches => " + cgc.matches(sourceTypeDesp, targetTypeDesp)); // matches => true
List<String> sourceList = Arrays.asList("1", "2", "2", "3", "4");
Object convert = cgc.convert(sourceList, sourceTypeDesp, targetTypeDesp);
System.out.println(convert.getClass());
System.out.println(convert); // [1, 2, 3, 4]
}
}
2. ConversionServiceFB
public class ConversionServiceFactoryBean implements FactoryBean<ConversionService>, InitializingBean {
// 自定义转换器
@Nullable
private Set<?> converters;
// 默认DefaultConversionService
@Nullable
private GenericConversionService conversionService;
public void setConverters(Set<?> converters) {
this.converters = converters;
}
@Override
public void afterPropertiesSet() {
// 1.. DefaultConversionService，内置默认Converter
this.conversionService = createConversionService();
// 2. MyConverter => DefaultConversionService，
ConversionServiceFactory.registerConverters(this.converters, this.conversionService);
}
protected GenericConversionService createConversionService() {
// 1.
return new DefaultConversionService();
}
/**
* implementing FactoryBean
*/
@Override
@Nullable
public ConversionService getObject() {
return this.conversionService;
}
@Override
public Class<? extends ConversionService> getObjectType() {
return GenericConversionService.class;
}
@Override
public boolean isSingleton() {
return true;
}
}
1. ConversionServiceFactory
public final class ConversionServiceFactory {
public static void registerConverters(@Nullable Set<?> converters, ConverterRegistry registry) {
if (converters != null) {
for (Object converter : converters) {
if (converter instanceof GenericConverter) {
registry.addConverter((GenericConverter) converter);
} else if (converter instanceof Converter<?, ?>) {
// 1. DefaultConversionService
registry.addConverter((Converter<?, ?>) converter);
} else if (converter instanceof ConverterFactory<?, ?>) {
registry.addConverterFactory((ConverterFactory<?, ?>) converter);
} else {
throw new IllegalArgumentException("Each converter object must implement one of the " +
"Converter, ConverterFactory, or GenericConverter interfaces");
}
}
}
}
}
2. DefaultConversionService
- 初始化：
new DefaultConversionService() - 类型转化：
GenericConversionService#convert()
public class DefaultConversionService extends GenericConversionService {
@Nullable
private static volatile DefaultConversionService sharedInstance;
public DefaultConversionService() {
// 1.
addDefaultConverters(this);
}
public static void addDefaultConverters(ConverterRegistry converterRegistry) {
// ScalarConverters ...
addScalarConverters(converterRegistry);
// CollectionConverters ...
addCollectionConverters(converterRegistry);
// 1... GenericConversionService
converterRegistry.addConverter(new ByteBufferConverter((ConversionService) converterRegistry));
converterRegistry.addConverter(new StringToTimeZoneConverter());
converterRegistry.addConverter(new ZoneIdToTimeZoneConverter());
converterRegistry.addConverter(new ZonedDateTimeToCalendarConverter());
converterRegistry.addConverter(new ObjectToObjectConverter());
converterRegistry.addConverter(new IdToEntityConverter((ConversionService) converterRegistry));
converterRegistry.addConverter(new FallbackObjectToStringConverter());
converterRegistry.addConverter(new ObjectToOptionalConverter((ConversionService) converterRegistry));
}
// 单例设计模式
public static ConversionService getSharedInstance() {
DefaultConversionService cs = sharedInstance;
if (cs == null) {
synchronized (DefaultConversionService.class) {
cs = sharedInstance;
if (cs == null) {
cs = new DefaultConversionService();
sharedInstance = cs;
}
}
}
return cs;
}
}
1. GenericConversionService
public class GenericConversionService implements ConfigurableConversionService {
// 100. 转换器最终都存在这里（默认 + 自定义）
private final Converters converters = new Converters();
// 自定义Converter添加
@Override
public void addConverter(Converter<?, ?> converter) {
// 1.. 获取对应的source、target类型
ResolvableType[] typeInfo = getRequiredTypeInfo(converter.getClass(), Converter.class);
// 如果对应的类型为空并且converter是代理，再次尝试获取
if (typeInfo == null && converter instanceof DecoratingProxy) {
typeInfo = getRequiredTypeInfo(((DecoratingProxy) converter).getDecoratedClass(), Converter.class);
}
// 如果target为null，那么抛出异常
if (typeInfo == null) {
throw new IllegalArgumentException("Unable to determine source type <S> and target type <T> for your " +
"Converter [" + converter.getClass().getName() + "]; does the class parameterize those types?");
}
// 2.. ConverterAdapter 添加到内部类Converters里面进行管理
addConverter(new ConverterAdapter(converter, typeInfo[0], typeInfo[1]));
}
private ResolvableType[] getRequiredTypeInfo(Class<?> converterClass, Class<?> genericIfc) {
ResolvableType resolvableType = ResolvableType.forClass(converterClass).as(genericIfc);
// 1.
ResolvableType[] generics = resolvableType.getGenerics();
if (generics.length < 2) {
return null;
}
Class<?> sourceType = generics[0].resolve();
Class<?> targetType = generics[1].resolve();
if (sourceType == null || targetType == null) {
return null;
}
return generics;
}
// ------------------------------------------------------------------------------------
@SuppressWarnings("unchecked")
private final class ConverterAdapter implements ConditionalGenericConverter {
private final Converter<Object, Object> converter;
private final ConvertiblePair typeInfo;
private final ResolvableType targetType;
public ConverterAdapter(Converter<?, ?> converter, ResolvableType sourceType, ResolvableType targetType) {
this.converter = (Converter<Object, Object>) converter;
// 1... GenericConverter$ConvertersForPair
this.typeInfo = new ConvertiblePair(sourceType.toClass(), targetType.toClass());
this.targetType = targetType;
}
@Override
public Set<ConvertiblePair> getConvertibleTypes() {
return Collections.singleton(this.typeInfo);
}
}
@Override
public void addConverter(GenericConverter converter) {
// 1... GenericConversionService$Converters 加到GenericConversionService自定义类Converters里面
this.converters.add(converter);
// 将缓存清空
invalidateCache();
}
// ------------------------------------------------------------------------------------
private static class Converters {
private final Set<GenericConverter> globalConverters = new LinkedHashSet<>();
// 100. myConverter
private final Map<ConvertiblePair, ConvertersForPair> converters = new LinkedHashMap<>(36);
// new ConverterAdapter(converter, typeInfo[0], typeInfo[1])
public void add(GenericConverter converter) {
Set<ConvertiblePair> convertibleTypes = converter.getConvertibleTypes();
if (convertibleTypes == null) {
Assert.state(converter instanceof ConditionalConverter,
"Only conditional converters may return null convertible types");
this.globalConverters.add(converter);
} else {
for (ConvertiblePair convertiblePair : convertibleTypes) {
// 1..
ConvertersForPair convertersForPair = getMatchableConverters(convertiblePair);
// 2... GenericConversionService$ConvertersForPair 添加Converter
convertersForPair.add(converter);
}
}
}
private ConvertersForPair getMatchableConverters(ConvertiblePair convertiblePair) {
// 1. 添加Converter
return this.converters.computeIfAbsent(convertiblePair, k -> new ConvertersForPair());
}
// ------------------------------------------------------------------------------------
@Nullable
public GenericConverter find(TypeDescriptor sourceType, TypeDescriptor targetType) {
// Search the full type hierarchy
// 获取所有的target、source的层次结构
List<Class<?>> sourceCandidates = getClassHierarchy(sourceType.getType());
List<Class<?>> targetCandidates = getClassHierarchy(targetType.getType());
for (Class<?> sourceCandidate : sourceCandidates) {
for (Class<?> targetCandidate : targetCandidates) {
// 1. 构建convertiblePair对象
ConvertiblePair convertiblePair = new ConvertiblePair(sourceCandidate, targetCandidate);
// 2.. 获取已经注册的converter
GenericConverter converter = getRegisteredConverter(sourceType, targetType, convertiblePair);
if (converter != null) {
return converter;
}
}
}
return null;
}
@Nullable
private GenericConverter getRegisteredConverter(TypeDescriptor sourceType,
TypeDescriptor targetType, ConvertiblePair convertiblePair) {
// 1. Check specifically registered converters
ConvertersForPair convertersForPair = this.converters.get(convertiblePair);
if (convertersForPair != null) {
// 2... GenericConversionService$ConvertersForPair
GenericConverter converter = convertersForPair.getConverter(sourceType, targetType);
if (converter != null) {
return converter;
}
}
// Check ConditionalConverters for a dynamic match
for (GenericConverter globalConverter : this.globalConverters) {
if (((ConditionalConverter) globalConverter).matches(sourceType, targetType)) {
return globalConverter;
}
}
return null;
}
}
// ------------------------------------------------------------------------------------
private static class ConvertersForPair {
private final LinkedList<GenericConverter> converters = new LinkedList<>();
public void add(GenericConverter converter) {
// 1.
this.converters.addFirst(converter);
}
@Nullable
public GenericConverter getConverter(TypeDescriptor sourceType, TypeDescriptor targetType) {
for (GenericConverter converter : this.converters) {
if (!(converter instanceof ConditionalGenericConverter) ||
((ConditionalGenericConverter) converter).matches(sourceType, targetType)) {
// 1.
return converter;
}
}
return null;
}
}
// ------------------------------------------- 能否转化 -------------------------------------------
@Override
public boolean canConvert(@Nullable TypeDescriptor sourceType, TypeDescriptor targetType) {
Assert.notNull(targetType, "Target type to convert to cannot be null");
if (sourceType == null) {
return true;
}
// 1..
GenericConverter converter = getConverter(sourceType, targetType);
return (converter != null);
}
@Nullable
protected GenericConverter getConverter(TypeDescriptor sourceType, TypeDescriptor targetType) {
// 根据sourceType,targetType获取对应的key
// 1. ConverterCacheKey 重写了equals、hashCode ，这样比较时，就是 比较的 sourceType 和 targetType 是否一致
ConverterCacheKey key = new ConverterCacheKey(sourceType, targetType);
// 2. 从缓存中获取
GenericConverter converter = this.converterCache.get(key);
// 如果converter不为空，是no_match,就返回null
if (converter != null) {
return (converter != NO_MATCH ? converter : null);
}
// 3. 从converters中查找converter
converter = this.converters.find(sourceType, targetType);
// 如果为null，则返回默认的设置
if (converter == null) {
// 4.
converter = getDefaultConverter(sourceType, targetType);
}
// 将converter放入到缓存中
if (converter != null) {
// 5.
this.converterCache.put(key, converter);
return converter;
}
this.converterCache.put(key, NO_MATCH);
return null;
}
/**
* General NO-OP converter used when conversion is not required.
*/
private static final GenericConverter NO_OP_CONVERTER = new NoOpConverter("NO_OP");
@Nullable
protected GenericConverter getDefaultConverter(TypeDescriptor sourceType, TypeDescriptor targetType) {
return (sourceType.isAssignableTo(targetType) ? NO_OP_CONVERTER : null);
}
// ------------------------------------------- 进行转化 -------------------------------------------
@Override
@SuppressWarnings("unchecked")
@Nullable
public <T> T convert(@Nullable Object source, Class<T> targetType) {
Assert.notNull(targetType, "Target type to convert to cannot be null");
// 1..
return (T) convert(source, TypeDescriptor.forObject(source), TypeDescriptor.valueOf(targetType));
}
@Override
@Nullable
public Object convert(@Nullable Object source, @Nullable TypeDescriptor sourceType, TypeDescriptor targetType) {
Assert.notNull(targetType, "Target type to convert to cannot be null");
// sourceType为空，限制source也必须为空，并对null进行处理
if (sourceType == null) {
Assert.isTrue(source == null, "Source must be [null] if source type == [null]");
return handleResult(null, targetType, convertNullSource(null, targetType));
}
// source和sourceType不匹配
if (source != null && !sourceType.getObjectType().isInstance(source)) {
throw new IllegalArgumentException("Source to convert from must be an instance of [" +
sourceType + "]; instead it was a [" + source.getClass().getName() + "]");
}
// 2.. 获取Converter
GenericConverter converter = getConverter(sourceType, targetType);
if (converter != null) {
// 3... ConversionUtils 进行转换
Object result = ConversionUtils.invokeConverter(converter, source, sourceType, targetType);
// 处理结果
return handleResult(sourceType, targetType, result);
}
// 处理没查找到转化器的结果
return handleConverterNotFound(source, sourceType, targetType);
}
}
3. GenericConverter
public interface GenericConverter {
final class ConvertiblePair {
private final Class<?> sourceType;
private final Class<?> targetType;
/**
* Create a new source-to-target pair.
* @param sourceType the source type
* @param targetType the target type
*/
public ConvertiblePair(Class<?> sourceType, Class<?> targetType) {
this.sourceType = sourceType;
this.targetType = targetType;
}
}
}
4. ConversionUtils
abstract class ConversionUtils {
@Nullable
public static Object invokeConverter(GenericConverter converter, @Nullable Object source,
TypeDescriptor sourceType, TypeDescriptor targetType) {
try {
// 1... MyConverter
return converter.convert(source, sourceType, targetType);
}
catch (ConversionFailedException ex) {
throw ex;
}
catch (Throwable ex) {
throw new ConversionFailedException(sourceType, targetType, source, ex);
}
}
}
2. MyConverter
// Initialize conversion service for this context.
// 1. 设置conversionService
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) && // conversionService
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
public class T8_MyConverter {
public static void main(String[] args) {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("x7_myConverter.xml");
System.out.println("------------------- ac.over -------------------");
Target target = ac.getBean(Target.class);
System.out.println("target = " + target);
ac.close();
}
}
<bean id="target" class="com.listao.myConverter.Target">
<property name="id" value="listao"/>
<!-- private Ooxx ooxx; -->
<property name="ooxx" value="131_邯郸市"/>
</bean>
<bean id="myConverter" class="com.listao.myConverter.MyConverter"/>
<!-- @Bean进行注解实现 -->
<bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
<property name="converters">
<set>
<ref bean="myConverter"/>
</set>
</property>
</bean>
public class MyConverter implements Converter<String, Ooxx> {
@Override
public Ooxx convert(String str) {
System.out.println("MyConverter.convert()");
Ooxx ooxx = new Ooxx();
String[] splits = str.split("_");
ooxx.setId(Integer.parseInt(splits[0]));
ooxx.setName(splits[1]);
return ooxx;
}
}
public class Target {
private String id;
private Ooxx ooxx;
}
1. isTypeMatch()
- IOC中有
beanName = conversionService，一定会在第一个业务对象实例化前getBean() - 实例化并缓存FactoryBean
FactoryBean.getObjectType()的类型为GenericConversionService- 缓存
BF.factoryBeanInstanceCache填充
AbstractAutowireCapableBeanFactory#getSingletonFactoryBeanForTypeCheck()
ConversionServiceFactoryBean#getObjectType()
2. getBean()
BF.factoryBeanInstanceCache取出缓存FactoryBean，进行初始化（填充属性值myConverter）initializeBean()创建DefaultConversionService并将通用Converter及MyConverter => 父类GenericConversionService.convertersConversionServiceFactoryBean implements InitializingBean
- 将
getObject()返回的DefaultConversionService=> BF.conversionService
AbstractAutowireCapableBeanFactory#doCreateBean()
ConversionServiceFactoryBean#afterPropertiesSet()
GenericConversionService$Converters#getMatchableConverters()
3. BeanWrapper
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
protected void initBeanWrapper(BeanWrapper bw) {
// BF.conversionService => bw.conversionService
bw.setConversionService(getConversionService());
// BF.propertyEditor => bw
registerCustomEditors(bw);
}
4. populateBean()
- 2. TypeConverterDelegate
- BW中获取匹配的myConverter，进行
convert()
MyConverter#convert()
2. EmbeddedValueResolver
- 嵌入式值解析器
- 2. EmbeddedValueResolver
// Register a default embedded value resolver if no bean post-processor
// (such as a PropertyPlaceholderConfigurer bean) registered any before:
// at this point, primarily for resolution in annotation attribute values.
/*
* 2. EmbeddedValueResolver
* -----------------------------------------------------
* 1. <嵌入式值解析器>，用于属性值解析
* 2. <context:property-placeholder/>
* 3. PlaceholderConfigurerSupport.doProcessProperties()
*/
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
3. LoadTimeWeaverAware
// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
/*
* 3. LoadTimeWeaverAware
* -----------------------------------------------------------
* 1. prepareBeanFactory()有处理
* 2. 织入（AOP）相关处理
* 3. 尽早初始化loadTimeWeaverAware_bean，以便尽早注册它们的转换器
*/
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
4. preInstantiateSingletons()
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
// 一级缓存。已经实例化的对象
public final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// 二级缓存。三级lambda生成的对象
public final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
// 三级缓存。动态生成对象lambda
public final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
}
public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry {
// FactoryBean缓存
private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap<>(16);
}
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
/**
* beanName映射RootBeanDefinition
* Map from bean name to merged RootBeanDefinition.
*/
private final Map<String, RootBeanDefinition> mergedBeanDefinitions = new ConcurrentHashMap<>(256);
}
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
// 总实例化的BD
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
// 总实例化的BD_Name
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
@Override
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
// Iterate over a copy to allow for init methods which in turn register new bean definitions.
// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
for (String beanName : beanNames) {
// 1. BD => RBD（BD中整合parent_BD）
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 2. FB, `implements FactoryBean`
if (isFactoryBean(beanName)) {
// beanName => &beanName
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
FactoryBean<?> factory = (FactoryBean<?>) bean;
// FB是否立即初始化
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(
(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
} else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
// 3. genericBean
else {
getBean(beanName);
}
}
}
// 4. Trigger post-initialization callback for all applicable beans...
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
} else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
}
1. getMergedLocalBD()
- 在实例化之前，所有GBD => RBD，缓存到
BF.mergedBeanDefinitions - RBD中包含parent_BD，
<bean parent="ooxx">递归将parent_BD => RBD invokeBFPP()和registerBPP()只转化了部分的，剩下的现在转化getBeanNamesForType()将xml_bean => RootBD
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
// Quick check on the concurrent map first, with minimal locking.
RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
if (mbd != null && !mbd.stale) {
return mbd;
}
return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}
AbstractBeanFactory#getMergedBeanDefinition(String, BeanDefinition, BeanDefinition)
2. isFactoryBean()
- 7. getObjectForBeanInstance
isEagerInit是否立即初始化
BF与FB区别：（都是接口）
- 都是对象工厂，用来创建对象
- BF接口，严格遵守SpringBean的生命周期接口
- 实例化、初始化、invokeAwareMethod、invokeInitMethod、before、after，流程非常复杂且麻烦
- FB接口，不需要遵循BF创建顺序，便捷简单创建
- BF接口，严格遵守SpringBean的生命周期接口
- Spring管理吗？
- BF全由Spring管理
- FB_bean由Spring管理
- 存放对象的缓存集合不同
- MyFactoryBean在
BF.singletonObjects - Ooxx为调用
getObject()获取的对象，缓存到BF.factoryBeanObjectCache
- MyFactoryBean在
if (isFactoryBean(beanName)) {
// beanName => &beanName
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
FactoryBean<?> factory = (FactoryBean<?>) bean;
// FB是否立即初始化
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(
(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
} else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
public boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException {
// 1. 去除'&'，获取name最终的规范名称【最终别名 || 全类名】
String beanName = transformedBeanName(name);
// 2. singletonObjects, earlySingletonObjects
Object beanInstance = getSingleton(beanName, false);
if (beanInstance != null) {
return (beanInstance instanceof FactoryBean);
}
// No singleton instance found -> check bean definition.
// 3. 尝试ParentBeanFactory判断FB
if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
// No bean definition found in this factory -> delegate to parent.
return ((ConfigurableBeanFactory) getParentBeanFactory()).isFactoryBean(name);
}
// 4.. 获取mbd判断
return isFactoryBean(beanName, getMergedLocalBeanDefinition(beanName));
}
protected boolean isFactoryBean(String beanName, RootBeanDefinition mbd) {
// FactoryBean标记
Boolean result = mbd.isFactoryBean;
if (result == null) {
// beanType，并设置
Class<?> beanType = predictBeanType(beanName, mbd, FactoryBean.class);
// 1.
result = (beanType != null && FactoryBean.class.isAssignableFrom(beanType));
mbd.isFactoryBean = result;
}
return result;
}
}
invokeBFPP()
3. getBean() => doGetBean()
getBean()一系列的重载，来调用doGetBean()
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
public Object getBean(String name) throws BeansException {
/*
* 1. doOOXX是实际干活的方法
* 2. doGetBean()实际获取bean的方法，也是触发DI的方法
*/
return doGetBean(name, null, null, false);
}
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
/*
* 1. FactoryBean接口实现类，&beanName => beanName
* 2. 别名进行转换
*/
String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
// 单例缓存查找，解决循环依赖
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
} else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
// 处理FB。入参(MyFactoryBean, &myFactoryBean, myFactoryBean, null)
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
} else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
/*
* 1. 单例尝试解决循环依赖问题
* 2. 原型模式下循环依赖，直接抛异常
*/
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
// Spring不存在父子容器，所有parent都为null。SpringMVC有父子容器
BeanFactory parentBeanFactory = getParentBeanFactory();
// BD_Map中不包含beanName，尝试从父容器获取
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
/*
* 1. 获取name对应的规范名称【全类名】
* 2. name前面有'&'，则会返回'&'+规范名称【全类名】
*/
String nameToLookup = originalBeanName(name);
// 递归parentBF获取bean
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
} else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
} else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
} else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
// 类型检查
if (!typeCheckOnly) {
// 标志位：alreadyCreated
markBeanAsCreated(beanName);
}
try {
// GenericBD + parent_BD => RootBD, mbd
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// mbd是否抽象
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
// 存在依赖bean，优先创建，`<bean depends-on="ooxx"/>`
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
// Circular depends-on
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
// 注册bean依赖关系，方便销毁
registerDependentBean(dep, beanName);
try {
// recursion
getBean(dep);
}
// DependentBean创建异常
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// Create bean instance.
if (mbd.isSingleton()) {
// ObjectFactory<?>
sharedInstance = getSingleton(beanName, () -> {
try {
// RBD + args => bean实例
return createBean(beanName, mbd, args);
} catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
/*
* 1. 显示地从单例缓存中删除实例。它可能是由创建过程急切地放在那里，以允许循环引用解析
* 2. 还要删除，接收到该Bean临时引用的任何Bean
* 3. 销毁给定的bean。如果找到相应的一次性Bean实例，则委托给destroyBean
*/
destroySingleton(beanName);
throw ex;
}
});
// FactoryBean，则调用getObject()
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// bean_prototype
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
// 添加`this.prototypesCurrentlyInCreation`集合
beforePrototypeCreation(beanName);
// 直接createBean()，不进行getSingleton()，没有缓存
prototypeInstance = createBean(beanName, mbd, args);
} finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
// <bean scope="request || session">
else {
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
}
Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
} finally {
afterPrototypeCreation(beanName);
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
} catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
} catch (BeansException ex) {
// 异常缓存清理
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// Check if required type matches the type of the actual bean instance.
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
// 获取TypeConverter，将bean转换为requiredType
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
} catch (TypeMismatchException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
}
1. transformedBeanName()
/*
* 1. FactoryBean接口实现类，&beanName => beanName
* 2. 别名进行转换
*/
String beanName = transformedBeanName(name);
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
protected String transformedBeanName(String name) {
// 1. 删除开头的'&'字符
// 2. Handle aliasing...
return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}
/**
* Handle aliasing...
*/
public String canonicalName(String name) {
String canonicalName = name;
// Handle aliasing...
String resolvedName;
do {
resolvedName = this.aliasMap.get(canonicalName);
if (resolvedName != null) {
canonicalName = resolvedName;
}
}
while (resolvedName != null);
return canonicalName;
}
}
public abstract class BeanFactoryUtils {
public static String transformedBeanName(String name) {
Assert.notNull(name, "'name' must not be null");
// 1. 不以'&'开头，直接返回
if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
return name;
}
// 2. 去掉name中，开头的'&'
return transformedBeanNameCache.computeIfAbsent(name, beanName -> {
do {
beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length()); // &
}
while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
return beanName;
});
}
}
public interface BeanFactory {
String FACTORY_BEAN_PREFIX = "&";
}
2. getSingleton(String)
// Eagerly check singleton cache for manually registered singletons.
/*
* 单例缓存查找，解决循环依赖
*/
Object sharedInstance = getSingleton(beanName);
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
// 一级缓存。已经实例化的对象
public final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// 二级缓存。三级lambda生成的对象
public final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
// 三级缓存。动态生成对象lambda
public final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
@Override
@Nullable
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
/**
* 缓存中获取beanName单例对象。允许早期引用。三级缓存中动态获取对象（原始对象、代理对象）
*/
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// Quick check for existing instance without full singleton lock
// 1. 一级缓存
Object singletonObject = this.singletonObjects.get(beanName);
// 2. 二级缓存 (单例 & bean`创建中`)
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
// 二级都是三级创建出来的
singletonObject = this.earlySingletonObjects.get(beanName);
// allowEarlyReference，允许早期引用
if (singletonObject == null && allowEarlyReference) {
synchronized (this.singletonObjects) {
// Consistent creation of early reference within full singleton lock
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
// 3. 三级 => 二级
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
}
}
return singletonObject;
}
}
3. ParentBF
- Spring不存在父子容器，所有parent都为null。SpringMVC有父子容器
- 递归parentBF获取bean
// Check if bean definition exists in this factory.
// Spring不存在父子容器，所有parent都为null。SpringMVC有父子容器
BeanFactory parentBeanFactory = getParentBeanFactory();
// BD_Map中不包含beanName，尝试从父容器获取
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
/*
* 1. 获取name对应的规范名称【全类名】
* 2. name前面有'&'，则会返回'&'+规范名称【全类名】
*/
String nameToLookup = originalBeanName(name);
// 递归parentBF获取bean
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
} else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
} else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
} else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
4. markBeanAsCreated()
alreadyCreated集合标志位
// 类型检查
if (!typeCheckOnly) {
// 标志位：alreadyCreated
markBeanAsCreated(beanName);
}
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256));
protected void markBeanAsCreated(String beanName) {
if (!this.alreadyCreated.contains(beanName)) {
synchronized (this.mergedBeanDefinitions) {
if (!this.alreadyCreated.contains(beanName)) {
// Let the bean definition get re-merged now that we're actually creating
// the bean... just in case some of its metadata changed in the meantime.
// 1.. 重新合并BD，期间某些元数据可能发生了变化
clearMergedBeanDefinition(beanName);
this.alreadyCreated.add(beanName);
}
}
}
}
protected void clearMergedBeanDefinition(String beanName) {
RootBeanDefinition bd = this.mergedBeanDefinitions.get(beanName);
if (bd != null) {
// 1. 将bd标记为需要重新合并定义
bd.stale = true; // 不新鲜的
}
}
}
5. getDependsOn()
<bean depends-on="ooxx"/>存在依赖bean，优先创建
// GenericBD + parent_BD => RootBD, mbd
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// mbd是否抽象
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
// 存在依赖bean，优先创建，`<bean depends-on="ooxx"/>`
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
// Circular depends-on
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
// 注册bean依赖关系，方便销毁
registerDependentBean(dep, beanName);
try {
// 99. recursion
getBean(dep);
}
// DependentBean创建异常
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
6. getSingleton(lambda)
// Create bean instance.
if (mbd.isSingleton()) {
// ObjectFactory<?>
sharedInstance = getSingleton(beanName, () -> {
try {
// RBD + args => bean实例
return createBean(beanName, mbd, args);
} catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
/*
* 1. 显示地从单例缓存中删除实例。它可能是由创建过程急切地放在那里，以允许循环引用解析
* 2. 还要删除，接收到该Bean临时引用的任何Bean
* 3. 销毁给定的bean。如果找到相应的一次性Bean实例，则委托给destroyBean
*/
destroySingleton(beanName);
throw ex;
}
});
// FactoryBean，则调用getObject()
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
- 单例对象创建
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
/**
* 1. 返回以beanName注册的（原始）单例对象
* 2. 如果尚未注册，则创建并注册一个对象
* <p>
* Return the (raw) singleton object registered under the given name,
* creating and registering a new one if none registered yet.
*
* @param beanName the name of the bean
* @param singletonFactory the ObjectFactory to lazily create the singleton
* with, if necessary
* @return the registered singleton object
*/
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
// 1. 一级缓存
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
// 2. 添加singletonsCurrentlyInCreation集合
beforeSingletonCreation(beanName);
// 新单例标记位，默认false
boolean newSingleton = false;
// 抑制异常记录标记，没有为true，否则为false
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
// 3. 从单例工厂中获取对象
singletonObject = singletonFactory.getObject();
newSingleton = true;
} catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->
// if yes, proceed with it since the exception indicates that state.
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
} catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
} finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
// 4. 移除singletonsCurrentlyInCreation集合
afterSingletonCreation(beanName);
}
if (newSingleton) {
// 5. 一级缓存添加bean
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
}
1. beforeSingletonCreation()
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
protected void beforeSingletonCreation(String beanName) {
// `singletonsCurrentlyInCreation` 单例对象正在创建集合
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}
}
2. getObject => #createBean
3. afterSingletonCreation()
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
protected void afterSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
}
}
}
4. addSingleton()
- java_bean添加一级缓存。二、三级缓存移除
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
// 1. 一级缓存添加
this.singletonObjects.put(beanName, singletonObject);
// 2. 二、三级缓存移除
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
// 3. 已注册单例集合
this.registeredSingletons.add(beanName);
}
}
}
7. getObjectForBeanInstance()
- 2. isFactoryBean()
- FactoryBean处理
- name以
&开头，FactoryBean - 普通Bean实例
- FactoryBean，获取
getObject()
- name以
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
// MyFactoryBean, &myFactoryBean, myFactoryBean, null
// ----------------------- 1. implements FactoryBean，beanName以'&'开头 -----------------------
// Don't let calling code try to dereference the factory if the bean isn't a factory.
// beanName是以'&'开头，为FB的解引用
if (BeanFactoryUtils.isFactoryDereference(name)) {
if (beanInstance instanceof NullBean) {
return beanInstance;
}
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
}
if (mbd != null) {
mbd.isFactoryBean = true;
}
return beanInstance;
}
// ----------------------- 2. 普通Bean实例 -----------------------
// Now we have the bean instance, which may be a normal bean or a FactoryBean.
// If it's a FactoryBean, we use it to create a bean instance, unless the
// caller actually wants a reference to the factory.
if (!(beanInstance instanceof FactoryBean)) {
return beanInstance;
}
// ----------------------- 3. implements FactoryBean，获取getObject -----------------------
Object object = null;
if (mbd != null) {
mbd.isFactoryBean = true;
} else {
// FB_cache获取
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
// Return bean instance from factory.
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// Caches object obtained from FactoryBean if it is a singleton.
if (mbd == null && containsBeanDefinition(beanName)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
// 4... FactoryBeanRegistrySupport
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
}
1. FactoryBeanRegistrySupport
- 1. ConversionServiceFactoryBean
FactoryBeanRegistrySupport.factoryBeanObjectCache缓存集合
public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry {
private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap<>(16);
@Nullable
protected Object getCachedObjectForFactoryBean(String beanName) {
// 1.
return this.factoryBeanObjectCache.get(beanName);
}
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
// 1. BF_bean为singleton
if (factory.isSingleton() && containsSingleton(beanName)) {
// this.singletonObjects加锁
synchronized (getSingletonMutex()) {
Object object = this.factoryBeanObjectCache.get(beanName);
if (object == null) {
// 2.. factory.getObject();
object = doGetObjectFromFactoryBean(factory, beanName);
// Only post-process and store if not put there already during getObject() call above
// (e.g. because of circular reference processing triggered by custom getBean calls)
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
if (alreadyThere != null) {
object = alreadyThere;
} else {
// 进行后处理
if (shouldPostProcess) {
if (isSingletonCurrentlyInCreation(beanName)) {
// Temporarily return non-post-processed object, not storing it yet..
return object;
}
beforeSingletonCreation(beanName);
try {
// 3... AbstractAutowireCapableBeanFactory FB_bean进行后处理 => applyBPPAfterInitialization
object = postProcessObjectFromFactoryBean(object, beanName);
} catch (Throwable ex) {
throw new BeanCreationException(beanName,
"Post-processing of FactoryBean's singleton object failed", ex);
} finally {
afterSingletonCreation(beanName);
}
}
if (containsSingleton(beanName)) {
// 4. 添加FB_cache
this.factoryBeanObjectCache.put(beanName, object);
}
}
}
return object;
}
}
// 5. FB_bean为protoType
else {
// 6.. factory.getObject();
Object object = doGetObjectFromFactoryBean(factory, beanName);
if (shouldPostProcess) {
try {
// 7. FB_bean进行后处理 => applyBPPAfterInitialization
object = postProcessObjectFromFactoryBean(object, beanName);
} catch (Throwable ex) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
}
}
return object;
}
}
private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
Object object;
try {
if (System.getSecurityManager() != null) {
AccessControlContext acc = getAccessControlContext();
try {
object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
} catch (PrivilegedActionException pae) {
throw pae.getException();
}
} else {
// 1. 获取FB_bean
object = factory.getObject();
}
} catch (FactoryBeanNotInitializedException ex) {
throw new BeanCurrentlyInCreationException(beanName, ex.toString());
} catch (Throwable ex) {
throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
}
// Do not accept a null value for a FactoryBean that's not fully
// initialized yet: Many FactoryBeans just return null then.
if (object == null) {
if (isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
object = new NullBean();
}
return object;
}
}
2. postProcessObjectFromFB(BPP)
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();
@Override
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
// 1. 初始化后的后处理
return applyBeanPostProcessorsAfterInitialization(object, beanName);
}
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
// 1.
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
public List<BeanPostProcessor> getBeanPostProcessors() {
return this.beanPostProcessors;
}
}
3. MyFactoryBean
public class T9_MyFactoryBean {
public static void main(String[] args) {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("x9_myFactoryBean.xml");
System.out.println("------------------- ac.over -------------------");
MyFactoryBean byClass = ac.getBean(MyFactoryBean.class);
System.out.println("byType = " + byClass);
// 地址符。transformedBeanName(name)将(&myFactoryBean => myFactoryBean)
MyFactoryBean myFactoryBean = ac.getBean("&myFactoryBean", MyFactoryBean.class);
System.out.println("&myFactoryBean = " + myFactoryBean);
/*
* debug
* isSingleton()可以设置Ooxx是否为singleton
*/
Ooxx ooxx = ac.getBean("myFactoryBean", Ooxx.class);
System.out.println("ooxx = " + ooxx.hashCode());
Ooxx ooxx2 = ac.getBean("myFactoryBean", Ooxx.class);
System.out.println("ooxx2 = " + ooxx2.hashCode());
ac.close();
}
}
<bean id="myFactoryBean" class="com.listao.myFactoryBean.MyFactoryBean"/>
public class MyFactoryBean implements FactoryBean<Ooxx> {
@Override
public Ooxx getObject() throws Exception {
// 任何创建对象的操作
return new Ooxx(1, "ooxx");
}
@Override
public Class<?> getObjectType() {
return Ooxx.class;
}
/**
* 1. true：ooxx为单例，Spring管理，factoryBeanObjectCache缓存
* 2. false：ooxx不为单例，每次getObject()
*/
@Override
public boolean isSingleton() {
return true;
}
}
MyFactoryBean#getObject()
8. scope_prototype
- 原型对象创建。直接
createBean()，不进行getSingleton()，没有缓存
// bean_prototype
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
// 添加`this.prototypesCurrentlyInCreation`集合
beforePrototypeCreation(beanName);
// 直接createBean()，不进行getSingleton()，没有缓存
prototypeInstance = createBean(beanName, mbd, args);
} finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
9. scope_request_session
// <bean scope="request || session">
else {
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
}
Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
} finally {
afterPrototypeCreation(beanName);
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
} catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
10. requiredType
requiredType == null目前不执行
// Check if required type matches the type of the actual bean instance.
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
// 获取TypeConverter，将bean转换为requiredType
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
} catch (TypeMismatchException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
#1. createBean()
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
// 1... AbstractBeanFactory beanClass属性字符串 => Class。本质上`Class.forName(name, false, clToUse);`
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
// 重新赋值RBD，并设置BeanClass
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// 2. Prepare method overrides.
// 设置标志位`setOverloaded(false)`，<lookup-method> <replace-method>
try {
mbdToUse.prepareMethodOverrides();
} catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// 3. Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
} catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
// 4. 核心方法
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
} catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// A previously detected exception with proper bean creation context already,
// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
throw ex;
} catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
}
1. resolveBeanClass()
- 获取beanName的Class对象
- 本质
Class.forName(name, false, clToUse);
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
// 1. beanClass属性字符串 => Class。本质上`Class.forName(name, false, clToUse);`
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
1. SecurityManager
- 安全管理器，权限赋予。native方法
- 不用看，关注其调用方法即可
// 安全管理器，权限赋予。native方法
if (System.getSecurityManager() != null) {
return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>)
() -> doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
}
2. doResolveBeanClass()
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
@Nullable
protected Class<?> resolveBeanClass(RootBeanDefinition mbd, String beanName, Class<?>... typesToMatch)
throws CannotLoadBeanClassException {
try {
// mbd是否包含beanClass，并且是Class类型的
if (mbd.hasBeanClass()) {
return mbd.getBeanClass();
}
// 安全管理器，权限赋予。native
if (System.getSecurityManager() != null) {
return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>)
() -> doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
} else {
// 1..
return doResolveBeanClass(mbd, typesToMatch);
}
} catch (PrivilegedActionException pae) {
ClassNotFoundException ex = (ClassNotFoundException) pae.getException();
throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
} catch (ClassNotFoundException ex) {
throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
} catch (LinkageError err) {
throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), err);
}
}
@Nullable
private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch)
throws ClassNotFoundException {
// 获取该工厂的加载bean用的类加载器
ClassLoader beanClassLoader = getBeanClassLoader();
/*
* 初始化动态类加载器为该工厂的加载bean用的类加载器
* 如果该工厂有临时类加载器器时，该动态类加载器就是该工厂的临时类加载器
*/
ClassLoader dynamicLoader = beanClassLoader;
// 表示mdb的配置的bean类名需要重新被dynameicLoader加载的标记，默认不需要
boolean freshResolve = false;
// 如果有传入要匹配的类型
if (!ObjectUtils.isEmpty(typesToMatch)) {
// When just doing type checks (i.e. not creating an actual instance yet),
// use the specified temporary class loader (e.g. in a weaving scenario).
// 仅进行类型检查时（即尚未创建实际实例），请使用指定的临时类加载器
// 获取该工厂的临时类加载器，该临时类加载器专门用于类型匹配
ClassLoader tempClassLoader = getTempClassLoader();
// 如果成功获取到临时类加载器
if (tempClassLoader != null) {
// 以该工厂的临时类加载器作为动态类加载器
dynamicLoader = tempClassLoader;
// 标记mdb的配置的bean类名需要重新被dynameicLoader加载
freshResolve = true;
// DecoratingClassLoader:装饰ClassLoader的基类,提供对排除的包和类的通用处理
// 如果临时类加载器是DecoratingClassLoader的基类
if (tempClassLoader instanceof DecoratingClassLoader) {
// 将临时类加载器强转为DecoratingClassLoader实例
DecoratingClassLoader dcl = (DecoratingClassLoader) tempClassLoader;
// 对要匹配的类型进行在装饰类加载器中的排除，以交由父ClassLoader以常规方式处理
for (Class<?> typeToMatch : typesToMatch) {
dcl.excludeClass(typeToMatch.getName());
}
}
}
}
// 从mbd中获取配置的bean类名
String className = mbd.getBeanClassName();
// 如果能成功获得配置的bean类名
if (className != null) {
// 评估benaDefinition中包含的className,如果className是可解析表达式，会对其进行解析，否则直接返回className:
Object evaluated = evaluateBeanDefinitionString(className, mbd);
// 判断className是否等于计算出的表达式的结果，如果不等于，那么判断evaluated的类型
if (!className.equals(evaluated)) {
// A dynamically resolved expression, supported as of 4.2...
// 如果evaluated属于Class实例
if (evaluated instanceof Class) {
// 强转evaluatedw为Class对象并返回出去
return (Class<?>) evaluated;
}
// 如果evaluated属于String实例
else if (evaluated instanceof String) {
// 将evaluated作为className的值
className = (String) evaluated;
// 标记mdb的配置的bean类名需要重新被dynameicLoader加载
freshResolve = true;
} else {
// 抛出非法状态异常：无效的类名表达式结果：evaluated
throw new IllegalStateException("Invalid class name expression result: " + evaluated);
}
}
// 如果mdb的配置的bean类名需要重新被dynameicLoader加载
if (freshResolve) {
// When resolving against a temporary class loader, exit early in order
// to avoid storing the resolved Class in the bean definition.
// 当使用临时类加载器进行解析时，请尽早退出以避免将已解析的类存储在BeanDefinition中
// 如果动态类加载器不为null
if (dynamicLoader != null) {
try {
// 使用dynamicLoader加载className对应的类型，并返回加载成功的Class对象
return dynamicLoader.loadClass(className);
}
// 捕捉未找到类异常，
catch (ClassNotFoundException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Could not load class [" + className + "] from " + dynamicLoader + ": " + ex);
}
}
}
// 使用classLoader加载name对应的Class对象,该方式是Spring用于代替Class.forName()的方法，支持返回原始的类实例(如'int')
// 和数组类名 (如'String[]')。此外，它还能够以Java source样式解析内部类名(如:'java.lang.Thread.State'
// 而不是'java.lang.Thread$State')
// 1.
return ClassUtils.forName(className, dynamicLoader);
}
}
// Resolve regularly, caching the result in the BeanDefinition...
// 定期解析，将结果缓存在BeanDefinition中...
// 使用classLoader加载当前BeanDefinitiond对象所配置的Bean类名的Class对象（每次调用都会重新加载,可通过
// AbstractBeanDefinition#getBeanClass 获取缓存）
return mbd.resolveBeanClass(beanClassLoader);
}
}
2. prepareMethodOverrides()
// 2. Prepare method overrides.
// 设置标志位`setOverloaded(false)`，<lookup-method> <replace-method>
mbdToUse.prepareMethodOverrides();
1. setOverloaded()
- 创建代理对象时会使用，
MethodOverride.overloaded无需关心
public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
implements BeanDefinition, Cloneable {
/**
* 方法重写的持有者，记录lookup-method, replaced-method元素
*/
private MethodOverrides methodOverrides = new MethodOverrides();
public void prepareMethodOverrides() throws BeanDefinitionValidationException {
// Check that lookup methods exist and determine their overloaded status.
if (hasMethodOverrides()) {
// 1..
getMethodOverrides().getOverrides().forEach(this::prepareMethodOverride);
}
}
public MethodOverrides getMethodOverrides() {
return this.methodOverrides;
}
protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {
// 1. 获取对应类中对应方法名个数
int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());
if (count == 0) {
throw new BeanDefinitionValidationException(
"Invalid method override: no method with name '" + mo.getMethodName() +
"' on class [" + getBeanClassName() + "]");
} else if (count == 1) {
// Mark override as not overloaded, to avoid the overhead of arg type checking.
// methodOverride暂未被覆盖，避免参数类型检查的开销
mo.setOverloaded(false);
}
}
}
2. MethodOverride
public class T10_MethodOverride {
/*
* 1. Spring中默认bean为singleton，在一级缓存中持有该对象，方便下次直接获取
* 2. prototype作用域，每次会创建一个新对象
* 3. singleton_bean引用prototype_bean，怎么办？（<lookup-method>标签来解决）
* 通过拦截器方式每次需要去创建最新的对象，不会把原型对象缓存起来
*/
public static void main(String[] args) {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("x10_1_lookup_method.xml");
System.out.println("--------------------- ac.over ---------------------");
FruitMethod fm = ac.getBean("fruitMethod", FruitMethod.class);
/*
* 1. debug
* 2. <lookup-method>：CglibSubclassingInstantiationStrategy.intercept() => getBean()
* 3. <bean scope="prototype"/>调用时，无缓存，创建两个不同对象
*/
System.out.println(fm.toString() + " => fm1.1\n => " + fm.getFruit().toString());
System.out.println(fm.toString() + " => fm1.2\n => " + fm.getFruit().toString());
ac.close();
}
}
<bean id="apple" class="com.listao.methodOverride.lookup.Apple" scope="prototype"/>
<!--
1. FruitMethod是抽象类，理论上Spring无法创建对象`<bean abstract="true">`
2. CGLib产生的代理对象
3. <lookup-method>作用
1. 通知Spring当前类需要产生代理对象
2. <lookup-method>方法返回值为bean属性指定的对象
-->
<bean id="fruitMethod" class="com.listao.methodOverride.lookup.FruitMethod">
<lookup-method name="getFruit" bean="apple"/>
</bean>
public abstract class FruitMethod {
// <lookup-method>方法返回值为Fruit实现类
public abstract Apple getFruit();
}
3. ReplacedMethod
class T10_ReplacedMethod {
public static void main(String[] args) {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("x10_2_replaced-method.xml");
System.out.println("--------------------- ac.over ---------------------");
Ooxx ooxx = ac.getBean("ooxx", Ooxx.class);
// setName()被ReplaceOoxx.reimplement()替代
ooxx.setName("hello ooxx");
ac.close();
}
}
<bean id="replaceOoxx" class="com.listao.methodOverride.replace.ReplaceOoxx"/>
<bean id="ooxx" class="com.listao.Ooxx">
<replaced-method name="setName" replacer="replaceOoxx">
<arg-type match="java.lang.String"/>
</replaced-method>
</bean>
public class ReplaceOoxx implements MethodReplacer {
@Override
public Object reimplement(Object obj, Method method, Object[] args) throws Throwable {
System.out.println("==>> ReplaceOoxx.reimplement()");
Arrays.stream(args).forEach(str -> System.out.println("参数: " + str));
return obj;
}
}
4. LookupMethod
/*
* 1. Spring中默认bean为singleton，在一级缓存中持有该对象，方便下次直接获取
* 2. prototype作用域，每次会创建一个新对象
* 3. singleton_bean引用prototype_bean，怎么办？（<lookup-method>标签来解决）
* 通过拦截器方式每次需要去创建最新的对象，不会把原型对象缓存起来
*/
/*
* 1. 即使<bean id="apple" scope="prototype"/>，banana中apple仍是单例
* 2. 用<lookup-method>解决singleton引用prototype
*/
class T10_LookupMethod {
public static void main(String[] args) {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("x10_1_lookup_method.xml");
System.out.println("--------------------- ac.over ---------------------");
String beanName = "_banana";
// String beanName = "banana";
Banana b1 = ac.getBean(beanName, Banana.class);
System.out.println(b1.toString() + " => b1.1\n => " + b1.getApple().toString());
Banana b2 = ac.getBean(beanName, Banana.class);
System.out.println(b2.toString() + " => b1.2\n => " + b2.getApple().toString());
ac.close();
}
}
<bean id="apple" class="com.listao.methodOverride.lookup.Apple" scope="prototype"/>
<bean id="banana" class="com.listao.methodOverride.lookup.Banana">
<property name="apple" ref="apple"/>
</bean>
<bean id="apple" class="com.listao.methodOverride.lookup.Apple" scope="prototype"/>
<bean id="_banana" class="com.listao.methodOverride.lookup.Banana">
<lookup-method name="getApple" bean="apple"/>
</bean>
public class Banana {
private Apple apple;
public Banana() {
System.out.println("Banana()");
}
public Apple getApple() {
return apple;
}
public void setApple(Apple apple) {
this.apple = apple;
}
}
3. resolveBeforeInstantiation(BPP)
registerBeanPostProcessors()已经将bpp进行IOC，并添加到AbstractBeanFactory.beanPostProcessors缓存中
// 3. Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) { // 实例化前解决标记
// Make sure bean class is actually resolved at this point.
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
// 1. 获取类型
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
// 2.. 实例前操作
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
// 3.. 自定义实例化，进行初始化后操作
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
@Nullable
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 99.
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
}
return null;
}
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
// 99.
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
}
1. MyBeforeInstantiation
public class T11_InstantiationAwareBPP {
public static void main(String[] args) {
ApplicationContext ac = new ClassPathXmlApplicationContext("x11_MyInstantiationAwareBPP.xml");
System.out.println("---------------------------------- ac.over ----------------------------------");
Ooxx ooxx = ac.getBean("ooxx", Ooxx.class);
System.out.println("---------------------------------- getName() ----------------------------------");
String name = ooxx.getName();
}
}
<bean id="ooxx" class="com.listao.Ooxx"/>
<bean id="myInstantiationAwareBPP"
class="com.listao.postProcessor.bpp.resolveBeforeInstantiation.MyInstantiationAwareBPP"/>
/*
* registerBPP(beanFactory); 进行IOC
*/
public class MyInstantiationAwareBPP implements InstantiationAwareBeanPostProcessor {
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
System.out.println("====> beanName: " + beanName + " => BeforeInstantiation()");
// 手写cglib创建代理对象
if (beanClass == Ooxx.class) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(beanClass);
enhancer.setCallback(new MyMethodInterceptor());
Ooxx beforeInstantiation = (Ooxx) enhancer.create();
System.out.println("创建代理对象：" + beforeInstantiation);
return beforeInstantiation;
// return new BeforeInstantiation();
}
return null;
}
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
System.out.println("====> beanName: " + beanName + " => AfterInstantiation()");
return false;
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("====> beanName: " + beanName + " => BeforeInitialization()");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("====> beanName: " + beanName + " => AfterInitialization()");
return bean;
}
// 注解，完成属性的注入
@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
System.out.println("====> beanName: " + beanName + " => postProcessProperties()");
return pvs;
}
}
public class MyMethodInterceptor implements MethodInterceptor {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("-----------> MyMethodInterceptor.before(): " + method);
Object obj = methodProxy.invokeSuper(o, objects);
System.out.println("-----------> MyMethodInterceptor.after(): " + method);
return obj;
}
}
4. #doCreateBean
#2. doCreateBean()
// 4. 核心方法
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
// 1. FactoryBean可能被提前创建
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 2. supplier, factoryMethod, autowiredCtor, noArgsCtor
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// -----------------------------------------------------------------------------------------------
// 注解解析
// -----------------------------------------------------------------------------------------------
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
/*
* 3.1. InitDestroyAnnotationBeanPostProcessor => @PostConstruct, @PreDestroy
* 3.2. CommonAnnotationBeanPostProcessor => @Resource, @WebServiceRef, @EJB
* 3.3. AutowiredAnnotationBeanPostProcessor => @Autowired, @Value, @Inject
*/
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
} catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
// 4. addSingletonFactory，三级缓存
// 构造器的循环依赖，无解。setter()，实例化、初始化分开
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
// 5. DI，递归初始化依赖的bean
populateBean(beanName, mbd, instanceWrapper);
/*
* 6.1. invokeAwareMethods()，Aware属性DI
* 6.2. applyBeanPostProcessorsBeforeInitialization()
* 6.3. invokeInitMethods()
* 6.4. applyBeanPostProcessorsAfterInitialization()
*/
exposedObject = initializeBean(beanName, exposedObject, mbd);
} catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
} else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
if (earlySingletonExposure) {
// 1. 正常bean。singletonObjects, earlySingletonObjects不存在，直接跳过
// 2. circular_bean，即`创建中`的bean。singletonFactories => earlySingletonObjects
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
// 进行了singletonFactories执行。1. 原实例 2. aop实例
exposedObject = earlySingletonReference;
}
// log记录
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
// 循环依赖中，bean的依赖还没全部创建好。找出并log记录
for (String dependentBean : dependentBeans) {
if (!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 " +
"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// Register bean as disposable.
try {
// 7. 在容器销毁时，销毁bean
registerDisposableBeanIfNecessary(beanName, bean, mbd);
} catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
}
1. factoryBeanInstanceCache
// 1. FactoryBean可能被提前创建
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
2. createBeanInstance()
创建对象方式
- 自定义BPP
- 生成对象
BPP.postProcessBeforeInstantiation() - 3. resolveBeforeInstantiation(BPP)
- 生成对象
- Supplier
- 随便定义创建对象的方法，不止局限于
getObject()=> 只是BD的一个属性值
- 随便定义创建对象的方法，不止局限于
- FactoryMethod
<!-- 实例工厂，静态工厂 --> <bean id="user" class="com.listao.supplier.User" factory-bean="" factory-method=""/> FactoryBean- 抽象出一个接口规范，通过
getObject()创建
- 抽象出一个接口规范，通过
- 通过反射（有参、无参）
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// Make sure bean class is actually resolved at this point.
Class<?> beanClass = resolveBeanClass(mbd, beanName);
// class不为空 & 访问权限为public
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());
}
// 1. Supplier_instantiate
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
// 2. FactoryMethod_instantiate
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// -----------------------------------------------------------------------------------------------
// Reflect_instantiate （参数个数、类型selCtor => ctor_cache）
// -----------------------------------------------------------------------------------------------
// Shortcut when re-creating the same bean...
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
// 3. ctor_cache不为null
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
if (resolved) {
if (autowireNecessary) {
return autowireConstructor(beanName, mbd, null, null);
} else {
return instantiateBean(beanName, mbd);
}
}
// Candidate constructors for autowiring?
// 4. @Autowired_ctor
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
/*
* 5.1. @Autowired_ctor有值
* 5.2. 自动装配模型 => 构造函数自动装配
* 5.3. xml具备<constructor-arg>
*/
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(); // Kotlin代码，忽略
if (ctors != null) {
return autowireConstructor(beanName, mbd, ctors, null);
}
// 6. No special handling: simply use no-arg constructor.
return instantiateBean(beanName, mbd);
}
}
1. Supplier_bean
// 1. Supplier_instantiate
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
protected BeanWrapper obtainFromSupplier(Supplier<?> instanceSupplier, String beanName) {
Object instance;
String outerBean = this.currentlyCreatedBean.get();
this.currentlyCreatedBean.set(beanName);
try {
// 1. supplier实例化
instance = instanceSupplier.get();
} finally {
if (outerBean != null) {
this.currentlyCreatedBean.set(outerBean);
} else {
this.currentlyCreatedBean.remove();
}
}
if (instance == null) {
instance = new NullBean();
}
BeanWrapper bw = new BeanWrapperImpl(instance);
initBeanWrapper(bw);
return bw;
}
}
public class T12_Supplier {
public static void main(String[] args) {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("x12_supplier.xml");
System.out.println("------------------- ac.over -------------------");
Object ooxx = ac.getBean("ooxx");
// Person{id=1, name='ooxx'}
System.out.println(ooxx);
}
}
<bean id="ooxx" class="com.listao.Ooxx"/>
<bean class="com.listao.postProcessor.bfpp.SupplierBFPP"/>
invokeBFPP()修改BD。将Ooxx => PersonCreateSupplier::ooxxToPerson调用，返回对象
public class SupplierBFPP implements BeanFactoryPostProcessor {
/**
* 任意修改BD。将Ooxx => Person
*/
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
BeanDefinition ooxx = beanFactory.getBeanDefinition("ooxx");
// 1. GenericBeanDefinition才有setInstanceSupplier()
GenericBeanDefinition genericBeanDefinition = (GenericBeanDefinition) ooxx;
// 2... CreateSupplier
genericBeanDefinition.setInstanceSupplier(CreateSupplier::ooxxToPerson);
genericBeanDefinition.setBeanClass(Person.class);
}
}
class CreateSupplier {
public static Person ooxxToPerson() {
return new Person(1, "person");
}
}
2. FactoryMethod
public class T13_FactoryMethod {
public static void main(String[] args) {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("x13_factoryMethod.xml");
System.out.println("------------------- ac.over -------------------");
Ooxx sf_ooxx = ac.getBean("staticFactory_ooxx", Ooxx.class);
System.out.println("sf_ooxx = " + sf_ooxx);
Ooxx if_ooxx = ac.getBean("instanceFactory_ooxx", Ooxx.class);
System.out.println("if_ooxx = " + if_ooxx);
ac.close();
}
}
factory-bean- 有该属性。实例工厂方法创建；否则静态工厂方法创建
- 方法匹配筛选比较复杂。形参的个数、类型、顺序进行匹配
<!--
1. static_factory
1. class: 指定工厂类
2. factory-method: 指定工厂static方法
-->
<bean id="staticFactory_ooxx" class="com.listao.factoryMethod.StaticFactory" factory-method="getOoxx">
<!-- constructor-arg: 方法指定参数 -->
<!-- <constructor-arg index="0" value="ooxx"/> -->
<!-- <constructor-arg name="id" value="ooxx"/> -->
<!-- <constructor-arg type="java.lang.String" value="ooxx"/> -->
<constructor-arg value="StaticFactory"/>
</bean>
<!--
2. instance_factory
1. factory-bean: 指定工厂类
2. factory-method: 指定工厂实例方法
-->
<bean id="instanceFactory" class="com.listao.factoryMethod.InstanceFactory"/>
<bean id="instanceFactory_ooxx" factory-bean="instanceFactory" factory-method="getOoxx">
<constructor-arg value="InstanceFactory"/>
</bean>
public class StaticFactory {
public static Ooxx getOoxx() {
return new Ooxx();
}
public static Ooxx getOoxx(String name) {
return new Ooxx(1, name);
}
public static Ooxx getOoxx(String name, int id) {
return new Ooxx(id, name);
}
public static Ooxx getOoxx(int id, String name) {
return new Ooxx(id, name);
}
}
public class InstanceFactory {
public Ooxx getOoxx(String name) {
return new Ooxx(1, "InstanceFactory");
}
}
// 2. FactoryMethod_instantiate
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
protected BeanWrapper instantiateUsingFactoryMethod(
String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
// 创建ConstructorResolver，使用factoryMethod进行实例化
return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
}
}
3. ConstructorResolver
class ConstructorResolver {
public BeanWrapper instantiateUsingFactoryMethod(
String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
BeanWrapperImpl bw = new BeanWrapperImpl();
this.beanFactory.initBeanWrapper(bw);
Object factoryBean;
Class<?> factoryClass;
boolean isStatic;
// 1. <factory-bean="instanceFactory">
String factoryBeanName = mbd.getFactoryBeanName();
// instance_factory
if (factoryBeanName != null) {
if (factoryBeanName.equals(beanName)) {
throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
"factory-bean reference points back to the same bean definition");
}
factoryBean = this.beanFactory.getBean(factoryBeanName);
if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
// beanName已经在一级缓存中
throw new ImplicitlyAppearedSingletonException();
}
// 获取factoryBean的Class对象
factoryClass = factoryBean.getClass();
isStatic = false;
}
// static_factory
else {
// It's a static factory method on the bean class.
if (!mbd.hasBeanClass()) {
throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
"bean definition declares neither a bean class nor a factory-bean reference");
}
factoryBean = null;
factoryClass = mbd.getBeanClass();
isStatic = true;
}
Method factoryMethodToUse = null;
ArgumentsHolder argsHolderToUse = null;
Object[] argsToUse = null;
// 明确实参处理
if (explicitArgs != null) {
argsToUse = explicitArgs;
}
// 2. 无明确实参。cache中获取factoryMethodToUse、argsToUse
else {
Object[] argsToResolve = null;
synchronized (mbd.constructorArgumentLock) {
factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;
if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) {
// Found a cached factory method...
argsToUse = mbd.resolvedConstructorArguments;
if (argsToUse == null) {
argsToResolve = mbd.preparedConstructorArguments;
}
}
}
// 2.1. 方法缓存，入参没缓存。需用原始入参，重新处理
if (argsToResolve != null) {
argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve, true);
}
}
if (factoryMethodToUse == null || argsToUse == null) {
// Need to determine the factory method...
// Try all methods with this name to see if they match the given arguments.
factoryClass = ClassUtils.getUserClass(factoryClass);
// 可用method筛选
List<Method> candidates = null;
if (mbd.isFactoryMethodUnique) {
if (factoryMethodToUse == null) {
factoryMethodToUse = mbd.getResolvedFactoryMethod();
}
if (factoryMethodToUse != null) {
// 新建单一元素集合
candidates = Collections.singletonList(factoryMethodToUse);
}
}
if (candidates == null) {
candidates = new ArrayList<>();
// 3. factoryClass所有方法
Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
for (Method candidate : rawCandidates) {
// 3.1. 筛选factoryMethod (isStatic && `factory-method="getOoxx"`)
if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
candidates.add(candidate);
}
}
}
// 只有一个factoryMethod，且无参。直接使用
if (candidates.size() == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
Method uniqueCandidate = candidates.get(0);
if (uniqueCandidate.getParameterCount() == 0) {
// mbd缓存
mbd.factoryMethodToIntrospect = uniqueCandidate;
synchronized (mbd.constructorArgumentLock) {
mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
mbd.constructorArgumentsResolved = true;
mbd.resolvedConstructorArguments = EMPTY_ARGS;
}
bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, uniqueCandidate, EMPTY_ARGS));
return bw;
}
}
// 多个factoryMethod排序
if (candidates.size() > 1) { // explicitly skip immutable singletonList
candidates.sort(AutowireUtils.EXECUTABLE_COMPARATOR);
}
// 处理过xml实参
ConstructorArgumentValues resolvedValues = null;
// 自动装配标记
boolean autowiring = (mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
// 最小类型差异权重
int minTypeDiffWeight = Integer.MAX_VALUE;
Set<Method> ambiguousFactoryMethods = null;
// xml最少参数个数
int minNrOfArgs;
if (explicitArgs != null) {
minNrOfArgs = explicitArgs.length;
} else {
// We don't have arguments passed in programmatically, so we need to resolve the
// arguments specified in the constructor arguments held in the bean definition.
if (mbd.hasConstructorArgumentValues()) {
ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
resolvedValues = new ConstructorArgumentValues();
// 4.1. xml_cargs解析值 => resolveValues
// 4.2. minNrOfArgs实参个数（索引实参个数 || 泛型实参个数）
minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
} else {
// 无实参，minNrOfArgs为0
minNrOfArgs = 0;
}
}
LinkedList<UnsatisfiedDependencyException> causes = null;
for (Method candidate : candidates) {
int parameterCount = candidate.getParameterCount();
// 形参 >= 实参
if (parameterCount >= minNrOfArgs) {
ArgumentsHolder argsHolder;
// 5.1. 形参type
Class<?>[] paramTypes = candidate.getParameterTypes();
if (explicitArgs != null) {
// Explicit arguments given -> arguments length must match exactly.
if (paramTypes.length != explicitArgs.length) {
continue;
}
argsHolder = new ArgumentsHolder(explicitArgs);
} else {
// Resolved constructor arguments: type conversion and/or autowiring necessary.
try {
String[] paramNames = null;
ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
if (pnd != null) {
// 5.2. 形参name
paramNames = pnd.getParameterNames(candidate);
}
// 5.3. 实参、形参匹配。(resolvedValues => ArgumentsHolder) 不匹配，抛异常。下一个method
// 独立且重要分支，有兴趣研究一下
argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw,
paramTypes, paramNames, candidate, autowiring, candidates.size() == 1);
} catch (UnsatisfiedDependencyException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Ignoring factory method [" + candidate + "] of bean '" + beanName + "': " + ex);
}
// Swallow and try next overloaded factory method.
if (causes == null) {
causes = new LinkedList<>();
}
causes.add(ex);
continue;
}
}
// 6. 类型差异权重
int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
// ctor解析模式，默认宽松模式。严格模式
// Choose this factory method if it represents the closest match.
if (typeDiffWeight < minTypeDiffWeight) {
factoryMethodToUse = candidate;
argsHolderToUse = argsHolder;
argsToUse = argsHolder.arguments;
minTypeDiffWeight = typeDiffWeight;
ambiguousFactoryMethods = null;
}
// Find out about ambiguity: In case of the same type difference weight
// for methods with the same number of parameters, collect such candidates
// and eventually raise an ambiguity exception.
// However, only perform that check in non-lenient constructor resolution mode,
// and explicitly ignore overridden methods (with the same parameter signature).
// 严格模式。权重相等，添加<模糊FactoryMethod>
else if (factoryMethodToUse != null && typeDiffWeight == minTypeDiffWeight &&
!mbd.isLenientConstructorResolution() &&
paramTypes.length == factoryMethodToUse.getParameterCount() &&
!Arrays.equals(paramTypes, factoryMethodToUse.getParameterTypes())) {
// 添加<模糊FactoryMethod>
if (ambiguousFactoryMethods == null) {
ambiguousFactoryMethods = new LinkedHashSet<>();
ambiguousFactoryMethods.add(factoryMethodToUse);
}
ambiguousFactoryMethods.add(candidate);
}
}
}
// 7. 无可用方法，无可用实参 => 异常处理
if (factoryMethodToUse == null || argsToUse == null) {
// 抛出cause中最新UnsatisfiedDependencyException
if (causes != null) {
UnsatisfiedDependencyException ex = causes.removeLast();
for (Exception cause : causes) {
// cause => BF抑制异常列表
this.beanFactory.onSuppressedException(cause);
}
throw ex;
}
// 定义一个用于存放参数类型的简单类名的ArrayList对象，长度为minNrOfArgs
List<String> argTypes = new ArrayList<>(minNrOfArgs);
if (explicitArgs != null) {
for (Object arg : explicitArgs) {
argTypes.add(arg != null ? arg.getClass().getSimpleName() : "null");
}
}
// 无明确实参
else if (resolvedValues != null) {
// 异常信息拼接
Set<ValueHolder> valueHolders = new LinkedHashSet<>(resolvedValues.getArgumentCount());
valueHolders.addAll(resolvedValues.getIndexedArgumentValues().values());
valueHolders.addAll(resolvedValues.getGenericArgumentValues());
for (ValueHolder value : valueHolders) {
String argType = (value.getType() != null ? ClassUtils.getShortName(value.getType()) :
(value.getValue() != null ? value.getValue().getClass().getSimpleName() : "null"));
argTypes.add(argType);
}
}
// ","隔开元素
String argDesc = StringUtils.collectionToCommaDelimitedString(argTypes);
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"No matching factory method found: " +
(mbd.getFactoryBeanName() != null ?
"factory bean '" + mbd.getFactoryBeanName() + "'; " : "") +
"factory method '" + mbd.getFactoryMethodName() + "(" + argDesc + ")'. " +
"Check that a method with the specified name " +
(minNrOfArgs > 0 ? "and arguments " : "") +
"exists and that it is " +
(isStatic ? "static" : "non-static") + ".");
}
// returnType == null
else if (void.class == factoryMethodToUse.getReturnType()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Invalid factory method '" + mbd.getFactoryMethodName() +
"': needs to have a non-void return type!");
}
// 添加<模糊FactoryMethod>，只在严格模式下非空
else if (ambiguousFactoryMethods != null) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Ambiguous factory method matches found in bean '" + beanName + "' " +
"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
ambiguousFactoryMethods);
}
// 8. 添加cache
if (explicitArgs == null && argsHolderToUse != null) {
mbd.factoryMethodToIntrospect = factoryMethodToUse;
argsHolderToUse.storeCache(mbd, factoryMethodToUse);
}
}
bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, factoryMethodToUse, argsToUse));
return bw;
}
private Object instantiate(String beanName, RootBeanDefinition mbd,
@Nullable Object factoryBean, Method factoryMethod, Object[] args) {
try {
if (System.getSecurityManager() != null) {
return AccessController.doPrivileged((PrivilegedAction<Object>) () ->
this.beanFactory.getInstantiationStrategy().instantiate(
mbd, beanName, this.beanFactory, factoryBean, factoryMethod, args),
this.beanFactory.getAccessControlContext());
}
else {
return this.beanFactory.getInstantiationStrategy().instantiate(
mbd, beanName, this.beanFactory, factoryBean, factoryMethod, args);
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Bean instantiation via factory method failed", ex);
}
}
}
1. factoryClass
- 获取
FactoryMethod的factoryClass factory-bean="instanceFactory"来区分是instanceFactory还是staticFactory
// 1. <factory-bean="instanceFactory">
String factoryBeanName = mbd.getFactoryBeanName();
// instance_factory
if (factoryBeanName != null) {
if (factoryBeanName.equals(beanName)) {
throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
"factory-bean reference points back to the same bean definition");
}
factoryBean = this.beanFactory.getBean(factoryBeanName);
if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
// beanName已经在一级缓存中
throw new ImplicitlyAppearedSingletonException();
}
// 获取factoryBean的Class对象
factoryClass = factoryBean.getClass();
isStatic = false;
}
// static_factory
else {
// It's a static factory method on the bean class.
if (!mbd.hasBeanClass()) {
throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
"bean definition declares neither a bean class nor a factory-bean reference");
}
factoryBean = null;
factoryClass = mbd.getBeanClass();
isStatic = true;
}
2. resolvePreparedArguments()
- 方法缓存，入参没缓存。需用原始入参，重新处理
// 明确实参处理
if (explicitArgs != null) {
argsToUse = explicitArgs;
}
// 2. 无明确实参。cache中获取factoryMethodToUse、argsToUse
else {
Object[] argsToResolve = null;
synchronized (mbd.constructorArgumentLock) {
factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;
if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) {
// Found a cached factory method...
argsToUse = mbd.resolvedConstructorArguments;
if (argsToUse == null) {
argsToResolve = mbd.preparedConstructorArguments;
}
}
}
// 2.1. 方法缓存，入参没缓存。需用原始入参，重新处理
if (argsToResolve != null) {
argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve, true);
}
}
BeanDefinitionValueResolver#resolveValueIfNecessary()BeanWrapper#convertIfNecessary()
private Object[] resolvePreparedArguments(String beanName, RootBeanDefinition mbd, BeanWrapper bw,
Executable executable, Object[] argsToResolve, boolean fallback) {
// 1. bw
TypeConverter customConverter = this.beanFactory.getCustomTypeConverter();
TypeConverter converter = (customConverter != null ? customConverter : bw);
// 2.
BeanDefinitionValueResolver valueResolver =
new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, converter);
// 3. 形参type
Class<?>[] paramTypes = executable.getParameterTypes();
Object[] resolvedArgs = new Object[argsToResolve.length];
for (int argIndex = 0; argIndex < argsToResolve.length; argIndex++) {
Object argValue = argsToResolve[argIndex]; // DB中的value
MethodParameter methodParam = MethodParameter.forExecutable(executable, argIndex); // setter()
if (argValue == autowiredArgumentMarker) {
// 解析自动装配Arg
argValue = resolveAutowiredArgument(methodParam, beanName, null, converter, fallback);
}
// BeanMetadataElement: 由包含配置源对象的bean元数据元素实现的接口，BeanDefinition的父接口
else if (argValue instanceof BeanMetadataElement) {
// 4. BeanDefinitionValueResolver 解析
argValue = valueResolver.resolveValueIfNecessary("constructor argument", argValue);
}
// String
else if (argValue instanceof String) {
// argValue是可解析表达式，对其进行解析
argValue = this.beanFactory.evaluateBeanDefinitionString((String) argValue, mbd);
}
Class<?> paramType = paramTypes[argIndex];
try {
// 5. TypeConverter 实参value => 形参value
resolvedArgs[argIndex] = converter.convertIfNecessary(argValue, paramType, methodParam);
}
// 类型不匹配异常。即该ctor不合适
catch (TypeMismatchException ex) {
throw new UnsatisfiedDependencyException(
mbd.getResourceDescription(), beanName, new InjectionPoint(methodParam),
"Could not convert argument value of type [" + ObjectUtils.nullSafeClassName(argValue) +
"] to required type [" + paramType.getName() + "]: " + ex.getMessage());
}
}
return resolvedArgs;
}
3. JB_candidates
- 方法无缓存，入参无缓存
- 符合
factory-method="getOoxx"的method筛选出来
if (factoryMethodToUse == null || argsToUse == null) {
// Need to determine the factory method...
// Try all methods with this name to see if they match the given arguments.
factoryClass = ClassUtils.getUserClass(factoryClass);
// 可用method筛选
List<Method> candidates = null;
if (mbd.isFactoryMethodUnique) {
if (factoryMethodToUse == null) {
factoryMethodToUse = mbd.getResolvedFactoryMethod();
}
if (factoryMethodToUse != null) {
// 新建单一元素集合
candidates = Collections.singletonList(factoryMethodToUse);
}
}
if (candidates == null) {
candidates = new ArrayList<>();
// 1.. factoryClass所有方法
Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
for (Method candidate : rawCandidates) {
// 2. 筛选factoryMethod (isStatic && `factory-method="getOoxx"`)
if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
candidates.add(candidate);
}
}
}
// 3. 只有一个factoryMethod，且无参。直接使用
if (candidates.size() == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
Method uniqueCandidate = candidates.get(0);
if (uniqueCandidate.getParameterCount() == 0) {
// mbd缓存
mbd.factoryMethodToIntrospect = uniqueCandidate;
synchronized (mbd.constructorArgumentLock) {
mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
mbd.constructorArgumentsResolved = true;
mbd.resolvedConstructorArguments = EMPTY_ARGS;
}
bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, uniqueCandidate, EMPTY_ARGS));
return bw;
}
}
// 多个factoryMethod排序
if (candidates.size() > 1) { // explicitly skip immutable singletonList
candidates.sort(AutowireUtils.EXECUTABLE_COMPARATOR);
}
private Method[] getCandidateMethods(Class<?> factoryClass, RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
return AccessController.doPrivileged((PrivilegedAction<Method[]>) () ->
(mbd.isNonPublicAccessAllowed() ?
ReflectionUtils.getAllDeclaredMethods(factoryClass) : factoryClass.getMethods()));
} else {
/*
* mbd是否允许访问非公共构造函数和方法
* 1. 返回factoryClass子类和其父类的所有声明方法
* 2. 只获取factoryClass的public方法
*/
return (mbd.isNonPublicAccessAllowed() ?
ReflectionUtils.getAllDeclaredMethods(factoryClass) : factoryClass.getMethods());
}
}
4. minNrOfArgs
minNrOfArgs：xml最少参数个数，index可以很大resolvedValues：实参值转化
// 处理过xml实参
ConstructorArgumentValues resolvedValues = null;
// 自动装配标记
boolean autowiring = (mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
// 最小类型差异权重
int minTypeDiffWeight = Integer.MAX_VALUE;
Set<Method> ambiguousFactoryMethods = null;
// xml最少参数个数
int minNrOfArgs;
if (explicitArgs != null) {
minNrOfArgs = explicitArgs.length;
} else {
// We don't have arguments passed in programmatically, so we need to resolve the
// arguments specified in the constructor arguments held in the bean definition.
if (mbd.hasConstructorArgumentValues()) {
ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
// 1.
resolvedValues = new ConstructorArgumentValues();
// 2.1. xml_cargs解析值 => resolveValues
// 3.2. minNrOfArgs实参个数（索引实参个数 || 泛型实参个数）
minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
} else {
// 无实参，minNrOfArgs为0
minNrOfArgs = 0;
}
}
- 1. BeanDefinitionValueResolver
BeanDefinitionValueResolver#resolveValueIfNecessary()
private int resolveConstructorArguments(String beanName, RootBeanDefinition mbd, BeanWrapper bw,
ConstructorArgumentValues cargs, ConstructorArgumentValues resolvedValues) {
TypeConverter customConverter = this.beanFactory.getCustomTypeConverter();
TypeConverter converter = (customConverter != null ? customConverter : bw);
// 1. (BD_value => java_bean_value)解析器
BeanDefinitionValueResolver valueResolver =
new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, converter);
// (索引参数值数 + 泛型参数值数)
int minNrOfArgs = cargs.getArgumentCount();
// 2.1. <constructor-arg index="0" value="ooxx_value"/> 索引实参处理
for (Map.Entry<Integer, ConstructorArgumentValues.ValueHolder> entry : cargs.getIndexedArgumentValues().entrySet()) {
int index = entry.getKey();
if (index + 1 > minNrOfArgs) {
minNrOfArgs = index + 1;
}
ConstructorArgumentValues.ValueHolder valueHolder = entry.getValue();
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);
}
// 2.2. <constructor-arg name="id" value="1"/> 非索引实参处理
for (ConstructorArgumentValues.ValueHolder valueHolder : cargs.getGenericArgumentValues()) {
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;
}
// ConstructorArgumentValues, <= ctor参数
{
"indexedArgumentValues": { // index实参
"0": {
"value": "0",
"source": {
"converted": false
},
"converted": false
}
},
"genericArgumentValues": [ // 通用实参
{
"value": "ooxx",
"name": "name",
"source": {
"name": "name",
"converted": false
},
"converted": false
}
]
}
5. factoryMethodToUse
- 可用的method中，筛选匹配xml的
createArgumentArray()=> #3.5.1. createArgumentArraygetTypeDifferenceWeight()=> #3.5.2. typeDiffWeight
LinkedList<UnsatisfiedDependencyException> causes = null;
for (Method candidate : candidates) {
int parameterCount = candidate.getParameterCount();
// 0. (形参 >= 实参)。否则直接不匹配
if (parameterCount >= minNrOfArgs) {
ArgumentsHolder argsHolder;
// 1. 形参type
Class<?>[] paramTypes = candidate.getParameterTypes();
if (explicitArgs != null) {
// Explicit arguments given -> arguments length must match exactly.
if (paramTypes.length != explicitArgs.length) {
continue;
}
argsHolder = new ArgumentsHolder(explicitArgs);
} else {
// Resolved constructor arguments: type conversion and/or autowiring necessary.
try {
String[] paramNames = null;
ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
if (pnd != null) {
// 2. 形参name
paramNames = pnd.getParameterNames(candidate);
}
// 3.. 实参、形参匹配。(resolvedValues => ArgumentsHolder) 不匹配，抛异常。下一个method
// 独立且重要分支，有兴趣研究一下
argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw,
paramTypes, paramNames, candidate, autowiring, candidates.size() == 1);
} catch (UnsatisfiedDependencyException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Ignoring factory method [" + candidate + "] of bean '" + beanName + "': " + ex);
}
// Swallow and try next overloaded factory method.
if (causes == null) {
causes = new LinkedList<>();
}
causes.add(ex);
continue;
}
}
// 4... 类型差异权重
int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
// ctor解析模式，默认宽松模式。严格模式
// Lenient, ˈliːniənt, adj. (惩罚或执法时)宽大的，宽容的，仁慈的
// Choose this factory method if it represents the closest match.
if (typeDiffWeight < minTypeDiffWeight) {
// 5.
factoryMethodToUse = candidate;
argsHolderToUse = argsHolder;
// 6.
argsToUse = argsHolder.arguments;
minTypeDiffWeight = typeDiffWeight;
ambiguousFactoryMethods = null;
}
// Find out about ambiguity: In case of the same type difference weight
// for methods with the same number of parameters, collect such candidates
// and eventually raise an ambiguity exception.
// However, only perform that check in non-lenient constructor resolution mode,
// and explicitly ignore overridden methods (with the same parameter signature).
// 严格模式。权重相等，添加<模糊FactoryMethod>
else if (factoryMethodToUse != null && typeDiffWeight == minTypeDiffWeight &&
!mbd.isLenientConstructorResolution() &&
paramTypes.length == factoryMethodToUse.getParameterCount() &&
!Arrays.equals(paramTypes, factoryMethodToUse.getParameterTypes())) {
// 添加<模糊FactoryMethod>
if (ambiguousFactoryMethods == null) {
ambiguousFactoryMethods = new LinkedHashSet<>();
ambiguousFactoryMethods.add(factoryMethodToUse);
}
ambiguousFactoryMethods.add(candidate);
}
}
}
6. Exception
// 7. 无可用方法，无可用实参 => 异常处理
if (factoryMethodToUse == null || argsToUse == null) {
// 抛出cause中最新UnsatisfiedDependencyException
if (causes != null) {
UnsatisfiedDependencyException ex = causes.removeLast();
for (Exception cause : causes) {
// cause => BF抑制异常列表
this.beanFactory.onSuppressedException(cause);
}
throw ex;
}
// 定义一个用于存放参数类型的简单类名的ArrayList对象，长度为minNrOfArgs
List<String> argTypes = new ArrayList<>(minNrOfArgs);
if (explicitArgs != null) {
for (Object arg : explicitArgs) {
argTypes.add(arg != null ? arg.getClass().getSimpleName() : "null");
}
}
// 无明确实参
else if (resolvedValues != null) {
// 异常信息拼接
Set<ValueHolder> valueHolders = new LinkedHashSet<>(resolvedValues.getArgumentCount());
valueHolders.addAll(resolvedValues.getIndexedArgumentValues().values());
valueHolders.addAll(resolvedValues.getGenericArgumentValues());
for (ValueHolder value : valueHolders) {
String argType = (value.getType() != null ? ClassUtils.getShortName(value.getType()) :
(value.getValue() != null ? value.getValue().getClass().getSimpleName() : "null"));
argTypes.add(argType);
}
}
// ","隔开元素
String argDesc = StringUtils.collectionToCommaDelimitedString(argTypes);
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"No matching factory method found: " +
(mbd.getFactoryBeanName() != null ?
"factory bean '" + mbd.getFactoryBeanName() + "'; " : "") +
"factory method '" + mbd.getFactoryMethodName() + "(" + argDesc + ")'. " +
"Check that a method with the specified name " +
(minNrOfArgs > 0 ? "and arguments " : "") +
"exists and that it is " +
(isStatic ? "static" : "non-static") + ".");
}
// returnType == null
else if (void.class == factoryMethodToUse.getReturnType()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Invalid factory method '" + mbd.getFactoryMethodName() +
"': needs to have a non-void return type!");
}
// 添加<模糊FactoryMethod>，只在严格模式下非空
else if (ambiguousFactoryMethods != null) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Ambiguous factory method matches found in bean '" + beanName + "' " +
"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
ambiguousFactoryMethods);
}
7. storeCache
// 8. 添加cache
if (explicitArgs == null && argsHolderToUse != null) {
mbd.factoryMethodToIntrospect = factoryMethodToUse;
argsHolderToUse.storeCache(mbd, factoryMethodToUse);
}
mbd.resolvedConstructorOrFactoryMethod = ooxx;mbd.constructorArgumentsResolved = true;
public void storeCache(RootBeanDefinition mbd, Executable constructorOrFactoryMethod) {
synchronized (mbd.constructorArgumentLock) {
mbd.resolvedConstructorOrFactoryMethod = constructorOrFactoryMethod;
mbd.constructorArgumentsResolved = true;
if (this.resolveNecessary) {
mbd.preparedConstructorArguments = this.preparedArguments;
} else {
mbd.resolvedConstructorArguments = this.arguments;
}
}
}
#3.5.1. createArgumentArray()
- 5. factoryMethodToUse
- method形参遍历、实参按顺序匹配。类型不匹配抛异常。即该method不合适
// ConstructorArgumentValues, <= ctor参数
{
"indexedArgumentValues": { // index实参
"0": {
"value": "0",
"source": {
"converted": false
},
"converted": false
}
},
"genericArgumentValues": [ // 通用实参
{
"value": "ooxx",
"name": "name",
"source": {
"name": "name",
"converted": false
},
"converted": false
}
]
}
- 实参类型转化、重组
// ArgumentsHolder, <= createArgumentArray
{
"rawArguments": [ // BD_value
"0",
"ooxx"
],
"arguments": [ // JB_value
0,
"ooxx"
],
"preparedArguments": [
],
"resolveNecessary": true
}
BeanWrapper#convertIfNecessary()
- 直接匹配，自动装配（type一致）
- 在
resolvedValues实参集合中，匹配符合条件的形参
class ConstructorResolver {
/**
* @param resolvedValues 实参
* @param paramTypes 形参类型
* @param paramNames 形参名
*/
private ArgumentsHolder createArgumentArray(
String beanName, RootBeanDefinition mbd, @Nullable ConstructorArgumentValues resolvedValues,
BeanWrapper bw, Class<?>[] paramTypes, @Nullable String[] paramNames, Executable executable,
boolean autowiring, boolean fallback) throws UnsatisfiedDependencyException {
// 1. bw
TypeConverter customConverter = this.beanFactory.getCustomTypeConverter();
TypeConverter converter = (customConverter != null ? customConverter : bw);
// 保存解析后的参数值
ArgumentsHolder args = new ArgumentsHolder(paramTypes.length);
// 已经解析的ValueHolder
Set<ConstructorArgumentValues.ValueHolder> usedValueHolders = new HashSet<>(paramTypes.length);
Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
for (int paramIndex = 0; paramIndex < paramTypes.length; paramIndex++) {
// 2. 形参类型
Class<?> paramType = paramTypes[paramIndex];
String paramName = (paramNames != null ? paramNames[paramIndex] : "");
// Try to find matching constructor argument value, either indexed or generic.
ConstructorArgumentValues.ValueHolder valueHolder = null;
// 形参遍历，能否在实参resolvedValues集合匹配
if (resolvedValues != null) {
// 3. 直接匹配，自动装配（type一致）
valueHolder = resolvedValues.getArgumentValue(paramIndex, paramType, paramName, usedValueHolders);
// If we couldn't find a direct match and are not supposed to autowire,
// let's try the next generic, untyped argument value as fallback:
// it could match after type conversion (for example, String -> int).
// 4. 类型转换后可匹配（eg：String -> int）
if (valueHolder == null && (!autowiring || paramTypes.length == resolvedValues.getArgumentCount())) {
valueHolder = resolvedValues.getGenericArgumentValue(null, null, usedValueHolders);
}
}
if (valueHolder != null) {
// We found a potential match - let's give it a try.
// Do not consider the same value definition multiple times!
usedValueHolders.add(valueHolder);
Object originalValue = valueHolder.getValue();
Object convertedValue;
if (valueHolder.isConverted()) {
convertedValue = valueHolder.getConvertedValue();
args.preparedArguments[paramIndex] = convertedValue;
} else {
// 方法形参封装。executable为Method对象，paramIndex形参下标
MethodParameter methodParam = MethodParameter.forExecutable(executable, paramIndex);
try {
// 5. 实参value => 形参value
convertedValue = converter.convertIfNecessary(originalValue, paramType, methodParam);
}
// 类型不匹配抛异常。即该method不合适
catch (TypeMismatchException ex) {
throw new UnsatisfiedDependencyException(
mbd.getResourceDescription(), beanName, new InjectionPoint(methodParam),
"Could not convert argument value of type [" +
ObjectUtils.nullSafeClassName(valueHolder.getValue()) +
"] to required type [" + paramType.getName() + "]: " + ex.getMessage());
}
Object sourceHolder = valueHolder.getSource();
if (sourceHolder instanceof ConstructorArgumentValues.ValueHolder) {
Object sourceValue = ((ConstructorArgumentValues.ValueHolder) sourceHolder).getValue();
// 表示args.preparedArguments需要解析
args.resolveNecessary = true;
args.preparedArguments[paramIndex] = sourceValue; // bd_value
}
}
// 6. 赋值
args.arguments[paramIndex] = convertedValue; // JB_value
args.rawArguments[paramIndex] = originalValue; // BD_value
}
// 目前不清楚
else {
MethodParameter methodParam = MethodParameter.forExecutable(executable, paramIndex);
// No explicit match found: we're either supposed to autowire or
// have to fail creating an argument array for the given constructor.
if (!autowiring) {
throw new UnsatisfiedDependencyException(
mbd.getResourceDescription(), beanName, new InjectionPoint(methodParam),
"Ambiguous argument values for parameter of type [" + paramType.getName() +
"] - did you specify the correct bean references as arguments?");
}
try {
// 解析自动装配Arg
Object autowiredArgument = resolveAutowiredArgument(
methodParam, beanName, autowiredBeanNames, converter, fallback);
args.rawArguments[paramIndex] = autowiredArgument;
args.arguments[paramIndex] = autowiredArgument;
args.preparedArguments[paramIndex] = autowiredArgumentMarker;
args.resolveNecessary = true;
} catch (BeansException ex) {
throw new UnsatisfiedDependencyException(
mbd.getResourceDescription(), beanName, new InjectionPoint(methodParam), ex);
}
}
}
for (String autowiredBeanName : autowiredBeanNames) {
this.beanFactory.registerDependentBean(autowiredBeanName, beanName);
if (logger.isDebugEnabled()) {
logger.debug("Autowiring by type from bean name '" + beanName +
"' via " + (executable instanceof Constructor ? "constructor" : "factory method") +
" to bean named '" + autowiredBeanName + "'");
}
}
return args;
}
}
1. ConstructorArgumentValues
public class ConstructorArgumentValues {
private final Map<Integer, ValueHolder> indexedArgumentValues = new LinkedHashMap<>();
private final List<ValueHolder> genericArgumentValues = new ArrayList<>();
@Nullable
public ValueHolder getArgumentValue(int index, @Nullable Class<?> requiredType, @Nullable String requiredName, @Nullable Set<ValueHolder> usedValueHolders) {
Assert.isTrue(index >= 0, "Index must not be negative");
// 1.. index匹配
ValueHolder valueHolder = getIndexedArgumentValue(index, requiredType, requiredName);
if (valueHolder == null) {
// 2.. byName, byType
valueHolder = getGenericArgumentValue(requiredType, requiredName, usedValueHolders);
}
return valueHolder;
}
}
1. getIndexedArgumentValue()
- index匹配
/**
* Get argument value for the given index in the constructor argument list.
*
* @param index the index in the constructor argument list
* @param requiredType the type to match (can be {@code null} to match
* untyped values only)
* @param requiredName the type to match (can be {@code null} to match
* unnamed values only, or empty String to match any name)
* @return the ValueHolder for the argument, or {@code null} if none set
*/
public ValueHolder getIndexedArgumentValue(int index, @Nullable Class<?> requiredType, @Nullable String requiredName) {
Assert.isTrue(index >= 0, "Index must not be negative");
ValueHolder valueHolder = this.indexedArgumentValues.get(index); // 1. index
if (valueHolder != null &&
(valueHolder.getType() == null || (requiredType != null && // 2. type匹配
ClassUtils.matchesTypeName(requiredType, valueHolder.getType()))) &&
(valueHolder.getName() == null || (requiredName != null && // 3. name匹配
(requiredName.isEmpty() || requiredName.equals(valueHolder.getName()))))) {
return valueHolder;
}
return null;
}
2. getGenericArgumentValue()
- 通用匹配 byName, byType
/**
* Look for the next generic argument value that matches the given type,
* ignoring argument values that have already been used in the current
* resolution process.
*
* @param requiredType the type to match (can be {@code null} to find
* an arbitrary next generic argument value)
* @param requiredName the name to match (can be {@code null} to not
* match argument values by name, or empty String to match any name)
* @param usedValueHolders a Set of ValueHolder objects that have already been used
* in the current resolution process and should therefore not be returned again
* @return the ValueHolder for the argument, or {@code null} if none found
*/
@Nullable
public ValueHolder getGenericArgumentValue(@Nullable Class<?> requiredType, @Nullable String requiredName,
@Nullable Set<ValueHolder> usedValueHolders) {
for (ValueHolder valueHolder : this.genericArgumentValues) {
if (usedValueHolders != null && usedValueHolders.contains(valueHolder)) {
continue;
}
// 1. 实参byName不匹配
if (valueHolder.getName() != null && (requiredName == null ||
(!requiredName.isEmpty() && !requiredName.equals(valueHolder.getName())))) {
continue;
}
// 2. 实参byType不匹配
if (valueHolder.getType() != null && (requiredType == null ||
!ClassUtils.matchesTypeName(requiredType, valueHolder.getType()))) {
continue;
}
// 3. 实参（无type，无name）。(valueHolder.getValue() < requiredType)不匹配
if (requiredType != null && valueHolder.getType() == null && valueHolder.getName() == null &&
!ClassUtils.isAssignableValue(requiredType, valueHolder.getValue())) {
continue;
}
return valueHolder;
}
return null;
}
#3.5.2. typeDiffWeight
// 6. 类型差异权重
int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
- 宽松模式 =>
getTypeDifferenceWeight() - 严格模式 =>
getAssignabilityWeight()
class ConstructorResolver {
private static class ArgumentsHolder {
// 原始参数值数组
public final Object[] rawArguments;
// 经过转换后参数值数组
public final Object[] arguments;
/**
* 获取类型差异权重，宽容模式下使用
* 1. 获取表示paramTypes和arguments之间的类层次结构差异的权重【变量 typeDiffWeight】
* 2. 获取表示paramTypes和rawArguments之间的类层次结构差异的权重【变量 rawTypeDiffWeight】
* 3. 比较typeDiffWeight和rawTypeDiffWeight取最小权重并返回出去，但是还是以原始类型优先，因为差异值还-1024
*/
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.
// 1... MethodInvoker this.arguments JB_value类型差异权重
int typeDiffWeight = MethodInvoker.getTypeDifferenceWeight(paramTypes, this.arguments);
// 2... MethodInvoker this.rawArguments BD_value类型差异权重，优于typeDiffWeight
int rawTypeDiffWeight = MethodInvoker.getTypeDifferenceWeight(paramTypes, this.rawArguments) - 1024;
// 取最小权重
return Math.min(rawTypeDiffWeight, typeDiffWeight);
}
/**
* 获取Assignabliity权重，严格模式下使用
*/
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;
}
}
// 最终的转换后值和原始值都匹配，paramTypes所对应的method非常可以接受
return Integer.MAX_VALUE - 1024;
}
}
}
1. MethodInvoker
public class MethodInvoker {
public static int getTypeDifferenceWeight(Class<?>[] paramTypes, Object[] args) {
int result = 0;
for (int i = 0; i < paramTypes.length; i++) {
// 1. 参数类型不匹配直接返回最大差异
if (!ClassUtils.isAssignableValue(paramTypes[i], args[i])) {
return Integer.MAX_VALUE;
}
// 2. 通过superClass来计算TypeDifferenceWeight
if (args[i] != null) {
Class<?> paramType = paramTypes[i];
Class<?> superClass = args[i].getClass().getSuperclass();
while (superClass != null) {
if (paramType.equals(superClass)) {
result = result + 2;
superClass = null;
}
// superClass extents paramType
else if (ClassUtils.isAssignable(paramType, superClass)) {
result = result + 2;
superClass = superClass.getSuperclass();
} else {
superClass = null;
}
}
if (paramType.isInterface()) {
result = result + 1;
}
}
}
return result;
}
}
4. ctor_cache
- noArgsCtor_cache
- argsCtor_cache
- ctor_cache存于
mbd.resolvedConstructorOrFactoryMethod
// Shortcut when re-creating the same bean...
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
// 3. ctor_cache不为null
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
// 已经处理的bean
if (resolved) {
if (autowireNecessary) {
return autowireConstructor(beanName, mbd, null, null);
} else {
return instantiateBean(beanName, mbd);
}
}
public class T14_Reflect {
public static void main(String[] args) {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("x14_1_ctorCache.xml");
System.out.println("------------------- ac.over -------------------");
/*
* 1. scope="prototype"
* 2. 对象ctor进行缓存 => BD.resolvedConstructorOrFactoryMethod
* 3. ooxx2直接用缓存的ctor_cache创建对象
*/
Ooxx ooxx = ac.getBean("ooxx", Ooxx.class);
System.out.println("ooxx = " + Integer.toHexString(ooxx.hashCode()));
Ooxx ooxx2 = ac.getBean("ooxx", Ooxx.class);
System.out.println("ooxx2 = " + Integer.toHexString(ooxx2.hashCode()));
}
}
<!--
1. scope="prototype"
2. 对象Constructor进行构造器缓存，resolvedConstructorOrFactoryMethod
-->
<bean id="ooxx" class="com.listao.Ooxx" scope="prototype">
<property name="id" value="1"/>
<property name="name" value="ooxx"/>
</bean>
5. determineCtorsFromBPP(BPP)
- 预判构造器，BPP寻找
@Autowired修饰的ctor - 通过构造函数实例化对象
// Candidate constructors for autowiring?
// 4. @Autowired_ctor
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
@Nullable
protected Constructor<?>[] determineConstructorsFromBeanPostProcessors(@Nullable Class<?> beanClass, String beanName)
throws BeansException {
if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
// 1. 从SmartInstantiationAwareBeanPostProcessor判断
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
Constructor<?>[] ctors = ibp.determineCandidateConstructors(beanClass, beanName);
if (ctors != null) {
return ctors;
}
}
}
}
return null;
}
}
class T14_autowiredAnnoBPP {
public static void main(String[] args) {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("x14_2_autowiredAnnoBPP.xml");
System.out.println("------------------- ac.over -------------------");
SelCtor selCtor = ac.getBean("selCtor", SelCtor.class);
System.out.println("selCtor = " + selCtor);
ac.close();
}
}
<bean id="autowiredAnnotationBPP"
class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>
<bean id="selCtor" class="com.listao.ooxx.autowired.SelCtor">
<constructor-arg name="id" value="1"/>
<constructor-arg name="name" value="ooxx"/>
</bean>
public class SelCtor {
private Integer id;
private String name;
public SelCtor() {
}
// @Autowired(required = true)
public SelCtor(Integer id) {
this.id = id;
}
@Autowired(required = true)
public SelCtor(Integer id, String name) {
this.id = id;
this.name = name;
}
public SelCtor(String name, Integer id) {
this.name = name;
this.id = id;
}
}
- @Lookup ==
<lookup-method>=> BD AutowiredAnnotationBeanPostProcessor处理@Autowired@Autowired(required = true)有且只有一个，否则异常。互斥其他@Autowired- 多个
@Autowired(required = false)构造函数集合，有noArgCtor则会被添加。一个false且无noArgCtor，logger.info() - 有且只有一个没有被
@Autowired的argsCtor - >2个没注解的ctor，就返回null
public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter
implements MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware {
// 该处理器支持解析的注解们，默认支持的是3个
private final Set<Class<? extends Annotation>> autowiredAnnotationTypes = new LinkedHashSet<>(4);
public AutowiredAnnotationBeanPostProcessor() {
// 1. @Autowired, @Value
this.autowiredAnnotationTypes.add(Autowired.class);
this.autowiredAnnotationTypes.add(Value.class);
try {
// @Inject
this.autowiredAnnotationTypes.add((Class<? extends Annotation>)
ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
logger.trace("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring");
} catch (ClassNotFoundException ex) {
// JSR-330 API not available - simply skip.
}
}
/**
* ctor但凡有一个注解，就立马返回
*/
@Nullable
private MergedAnnotation<?> findAutowiredAnnotation(AccessibleObject ao) {
// 1.
MergedAnnotations annotations = MergedAnnotations.from(ao);
for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) {
MergedAnnotation<?> annotation = annotations.get(type);
if (annotation.isPresent()) {
return annotation;
}
}
return null;
}
/**
* // @Autowired_ctor
* --------------------------------------------------------------------
* 1. `@Autowired(required = true)`有且只有一个，否则异常。互斥其他@Autowired
* 2. 多个`@Autowired(required = false)`构造函数集合，有noArgCtor则会被添加。一个false且无noArgCtor，`logger.info()`
* 3. 有且只有一个没有被@Autowired的argsCtor
* 4. >2个没注解的ctor，就返回null
*/
@Override
@Nullable
public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, final String beanName)
throws BeanCreationException {
// Let's check for lookup methods here...
// 1. @Lookup == <lookup-method> => BD
if (!this.lookupMethodsChecked.contains(beanName)) {
if (AnnotationUtils.isCandidateClass(beanClass, Lookup.class)) {
try {
Class<?> targetClass = beanClass;
do {
// 2. 遍历class及superClass，@Lookup方法 => BD
ReflectionUtils.doWithLocalMethods(targetClass, method -> {
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);
// AbstractBeanDefinition.MethodOverrides.Set<MethodOverride>
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);
}
}
// 3. 检查过集合
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 {
// 4. 所有java_bean_ctor
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);
// @Autowired(required = true)
Constructor<?> requiredConstructor = null;
// noArgsCtor
Constructor<?> defaultConstructor = null;
// 有关Kotlin，非Kotlin为null
Constructor<?> primaryConstructor = BeanUtils.findPrimaryConstructor(beanClass);
// 非合成ctor数量。合成ctor => 有方法参数并对实例进行赋值的构造函数
int nonSyntheticConstructors = 0;
for (Constructor<?> candidate : rawCandidates) {
// 非Synthetic
if (!candidate.isSynthetic()) {
nonSyntheticConstructors++;
} else if (primaryConstructor != null) {
continue;
}
// 5.. @Autowired, @Value, @Inject 修饰ctor
MergedAnnotation<?> ann = findAutowiredAnnotation(candidate);
if (ann == null) {
// 注解不存在。（CGLIB_CLASS返回其父类）
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) {
// 5.1. `@Autowired(required = true)` 有且只有一个
if (requiredConstructor != null) {
throw new BeanCreationException(beanName,
"Invalid autowire-marked constructor: " + candidate +
". Found constructor with 'required' Autowired annotation already: " +
requiredConstructor);
}
boolean required = determineRequiredStatus(ann);
if (required) {
if (!candidates.isEmpty()) {
// 已经(required = false)，再来(required = true)报异常
throw new BeanCreationException(beanName,
"Invalid autowire-marked constructors: " + candidates +
". Found constructor with 'required' Autowired annotation: " +
candidate);
}
requiredConstructor = candidate;
}
candidates.add(candidate);
}
// 无参构造
else if (candidate.getParameterCount() == 0) {
defaultConstructor = candidate;
}
}
// 5.2. @Autowired(required = false) 添加noArgCtor
if (!candidates.isEmpty()) {
// Add default constructor to list of optional constructors, as fallback.
if (requiredConstructor == null) {
if (defaultConstructor != null) {
candidates.add(defaultConstructor);
}
// @Autowired(required = false) && 没有noArgCtor
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]);
}
// 5.3. argsCtor唯一
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 {
// 5.4. >2个没注解的ctor，就返回null
candidateConstructors = new Constructor<?>[0];
}
// 6.
this.candidateConstructorsCache.put(beanClass, candidateConstructors);
}
}
}
return (candidateConstructors.length > 0 ? candidateConstructors : null);
}
}
6. autowireConstructor()
/*
* 5.1. @Autowired_ctor有值
* 5.2. 自动装配模型 => 构造函数自动装配
* 5.3. xml具备<constructor-arg>
*/
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
protected BeanWrapper autowireConstructor(
String beanName, RootBeanDefinition mbd, @Nullable Constructor<?>[] ctors, @Nullable Object[] explicitArgs) {
return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
}
}
class T14_autowireCtor {
public static void main(String[] args) {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("x14_3_autowireCtor.xml");
System.out.println("------------------- ac.over -------------------");
// 核心方法：autowireConstructor()
Ooxx ooxxCtor = ac.getBean("ooxxCtor", Ooxx.class);
System.out.println("ooxxCtor = " + ooxxCtor);
ac.close();
}
}
<bean id="ooxxCtor" class="com.listao.Ooxx">
<constructor-arg index="0" value="0"/>
<constructor-arg name="name" value="ooxx"/>
</bean>
与FactoryMethod处理几乎一样。 2. FactoryMethod => 3. ConstructorResolver
- cache处理
- 获取public_ctor，并处理（唯一 && noArgCtor）
- minNrOfArgs（实参处理）
- BD_cargs => resolveValues
- 形参type，形参name
createArgumentArray()不匹配异常，跳下一ctor- typeDiffWeight类型差异权重
- storeCache
class ConstructorResolver {
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) {
// 1. ctor_cache
constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
if (constructorToUse != null && mbd.constructorArgumentsResolved) {
// Found a cached constructor...
argsToUse = mbd.resolvedConstructorArguments; // jb_ctor_args
if (argsToUse == null) {
argsToResolve = mbd.preparedConstructorArguments; // bd_ctor_args
}
}
}
// 缓存了原始实参，没有缓存已处理实参
if (argsToResolve != null) {
// 1.1. 原始实参 => 已处理实参
argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve, true);
}
}
if (constructorToUse == null || argsToUse == null) {
// 2.1. Take specified constructors, if any.
Constructor<?>[] candidates = chosenCtors;
if (candidates == null) {
Class<?> beanClass = mbd.getBeanClass();
try {
// 2.2. public_ctor
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);
}
}
// 2.3. 唯一 && noArgCtor
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();
// 3.1. BD_cargs解析值 => resolveValues
// 3.2. minNrOfArgs实参个数（索引实参个数 || 泛型实参个数）
minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
}
// public_ctor按形参个数排序（倒序）
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;
// 4.1. 形参type
Class<?>[] paramTypes = candidate.getParameterTypes();
if (resolvedValues != null) {
try {
// @ConstructorProperties解析
String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, parameterCount);
if (paramNames == null) {
ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
if (pnd != null) {
// 4.2. 形参name
paramNames = pnd.getParameterNames(candidate);
}
}
// 4.3. 实参、形参匹配。(resolvedValues => ArgumentsHolder) 不匹配，抛异常。下一个method
// 独立且重要分支，有兴趣研究一下
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);
}
// 5. 类型差异权重。越小差异越小，匹配程度越高
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;
}
// 权重相等，添加<模糊ctor>
else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
if (ambiguousConstructors == null) {
ambiguousConstructors = new LinkedHashSet<>();
ambiguousConstructors.add(constructorToUse);
}
ambiguousConstructors.add(candidate);
}
}
// 6.1. 没有ctor匹配
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)");
}
// 6.2. <模糊ctor>非空 && 不允许模糊
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);
}
// 7. ctor_cache => BD
if (explicitArgs == null && argsHolderToUse != null) {
argsHolderToUse.storeCache(mbd, constructorToUse);
}
}
Assert.state(argsToUse != null, "Unresolved constructor arguments");
// 8. instantiate() 实例化
bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
return bw;
}
}
1. TypedStringValue
// InvocationTargetRuntimeException: Typed String value does not carry a resolved target type
// 只有指定了targetType类型，才可以打印json
TypedStringValue tsv = new TypedStringValue("ooxx");
tsv.setTargetType(String.class);
System.out.println("tsv = " + JSONUtil.toJsonPrettyStr(tsv));
7. instantiateBean()
- noArgsCtor实例化
// No special handling: simply use no-arg constructor.
return instantiateBean(beanName, mbd);
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
try {
Object beanInstance;
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged(
(PrivilegedAction<Object>) () -> getInstantiationStrategy().instantiate(mbd, beanName, this),
getAccessControlContext());
} else {
// 1. 实例化策略 => 默认：CglibSubclassingInstantiationStrategy => 进行实例化操作
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
}
/*
* 2.1. CustomEditors to bw:
* `registerDefaultEditors(), registerCustomEditors()`
* 2.2. BF_ConversionService to bw
* refresh() => finishBeanFactoryInitialization() ConversionService to BF
*/
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
} catch (Throwable ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
}
}
}
1. InstantiationStrategy
Simple实例化策略- noArgsCtor实例化
- argsCtor实例化
- factory_method实例化
Cglib实例化策略（动态代理对象）- proxy_noArgsCtor
- proxy_argsCtor
// 实例化策略接口，子类根据RBD创建实例对象
public interface InstantiationStrategy {
// 1. noArgsCtor
Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner)
throws BeansException;
// 2. argsCtor
Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
Constructor<?> ctor, Object... args) throws BeansException;
// 3. FactoryMethod
Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
@Nullable Object factoryBean, Method factoryMethod, Object... args)
throws BeansException;
}
1. SimpleInstantiationStrategy
public class SimpleInstantiationStrategy implements InstantiationStrategy {
// FactoryMethod的ThreadLocal对象
private static final ThreadLocal<Method> currentlyInvokedFactoryMethod = new ThreadLocal<>();
/**
* 返回当前现成所有的FactoryMethod变量值
* <p>
* Return the factory method currently being invoked or {@code null} if none.
* <p>Allows factory method implementations to determine whether the current
* caller is the container itself as opposed to user code.
*/
@Nullable
public static Method getCurrentlyInvokedFactoryMethod() {
return currentlyInvokedFactoryMethod.get();
}
/**
* 1.1. noArgsCtor
*/
@Override
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
// Don't override the class with CGLIB if no overrides.
if (!bd.hasMethodOverrides()) {
Constructor<?> constructorToUse;
synchronized (bd.constructorArgumentLock) {
// ctor_cache
constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
if (constructorToUse == null) {
final Class<?> clazz = bd.getBeanClass();
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
// 系统安全管理器
if (System.getSecurityManager() != null) {
constructorToUse = AccessController.doPrivileged(
(PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
} else {
// 1.2. noArgsCtor
constructorToUse = clazz.getDeclaredConstructor();
}
// 1.3. ctor_cache
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
} catch (Throwable ex) {
throw new BeanInstantiationException(clazz, "No default constructor found", ex);
}
}
}
// 1.4. noArgsCtor实例化
return BeanUtils.instantiateClass(constructorToUse);
}
// 1.5. <lookup-method>, <replaced-method>
else {
// Must generate CGLIB subclass.
return instantiateWithMethodInjection(bd, beanName, owner);
}
}
protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
throw new UnsupportedOperationException("Method Injection not supported in SimpleInstantiationStrategy");
}
/**
* 2.1. argsCtor
*/
@Override
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
final Constructor<?> ctor, Object... args) {
// 检查bd对象是否有MethodOverrides对象，没有的话则直接实例化对象
if (!bd.hasMethodOverrides()) {
if (System.getSecurityManager() != null) {
// use own privileged to change accessibility (when security is on)
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
ReflectionUtils.makeAccessible(ctor);
return null;
});
}
// 2.2. 通过反射实例化对象
return BeanUtils.instantiateClass(ctor, args);
}
// 2.3.
else {
// 如果有methodOverride对象，则调用方法来进行实现
return instantiateWithMethodInjection(bd, beanName, owner, ctor, args);
}
}
protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName,
BeanFactory owner, @Nullable Constructor<?> ctor, Object... args) {
throw new UnsupportedOperationException("Method Injection not supported in SimpleInstantiationStrategy");
}
/**
* 3.1. FactoryMethod
*/
@Override
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
@Nullable Object factoryBean, final Method factoryMethod, Object... args) {
try {
// 是否包含系统安全管理器
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
ReflectionUtils.makeAccessible(factoryMethod);
return null;
});
} else {
// 3.2. 通过反射工具类设置访问权限
ReflectionUtils.makeAccessible(factoryMethod);
}
// 获取原有的Method对象
Method priorInvokedFactoryMethod = currentlyInvokedFactoryMethod.get();
try {
// 设置当前的Method
currentlyInvokedFactoryMethod.set(factoryMethod);
// 3.3. factoryMethod实例化对象
Object result = factoryMethod.invoke(factoryBean, args);
if (result == null) {
result = new NullBean();
}
return result;
} finally {
// 实例化完成后回复现场
if (priorInvokedFactoryMethod != null) {
currentlyInvokedFactoryMethod.set(priorInvokedFactoryMethod);
} else {
currentlyInvokedFactoryMethod.remove();
}
}
} catch (IllegalArgumentException ex) {
throw new BeanInstantiationException(factoryMethod,
"Illegal arguments to factory method '" + factoryMethod.getName() + "'; " +
"args: " + StringUtils.arrayToCommaDelimitedString(args), ex);
} catch (IllegalAccessException ex) {
throw new BeanInstantiationException(factoryMethod,
"Cannot access factory method '" + factoryMethod.getName() + "'; is it public?", ex);
} catch (InvocationTargetException ex) {
String msg = "Factory method '" + factoryMethod.getName() + "' threw exception";
if (bd.getFactoryBeanName() != null && owner instanceof ConfigurableBeanFactory &&
((ConfigurableBeanFactory) owner).isCurrentlyInCreation(bd.getFactoryBeanName())) {
msg = "Circular reference involving containing bean '" + bd.getFactoryBeanName() + "' - consider " +
"declaring the factory method as static for independence from its containing instance. " + msg;
}
throw new BeanInstantiationException(factoryMethod, msg, ex.getTargetException());
}
}
}
2. CglibSubclassingIS
public class CglibSubclassingInstantiationStrategy extends SimpleInstantiationStrategy {
private static final int PASSTHROUGH = 0;
private static final int LOOKUP_OVERRIDE = 1;
private static final int METHOD_REPLACER = 2;
// 1. cglib_noArgsCtor
@Override
protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
return instantiateWithMethodInjection(bd, beanName, owner, null);
}
// 2. cglib_argsCtor
@Override
protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
@Nullable Constructor<?> ctor, Object... args) {
// Must generate CGLIB subclass...
return new CglibSubclassCreator(bd, owner).instantiate(ctor, args);
}
// ------------------------------------------------------------------------------------------
private static class CglibSubclassCreator {
// callback_types，MethodOverrideCallbackFilter通过指定下标获取对应的拦截
private static final Class<?>[] CALLBACK_TYPES = new Class<?>[]
{NoOp.class, LookupOverrideMethodInterceptor.class, ReplaceOverrideMethodInterceptor.class};
private final RootBeanDefinition beanDefinition;
private final BeanFactory owner;
CglibSubclassCreator(RootBeanDefinition beanDefinition, BeanFactory owner) {
this.beanDefinition = beanDefinition;
this.owner = owner;
}
public Object instantiate(@Nullable Constructor<?> ctor, Object... args) {
// 1.. BD => Cglib子类Class对象
Class<?> subclass = createEnhancedSubclass(this.beanDefinition);
Object instance;
if (ctor == null) {
// 2.1. 无参构造反射
instance = BeanUtils.instantiateClass(subclass);
} else {
try {
// 2.2. 有参构造反射
Constructor<?> enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
instance = enhancedSubclassConstructor.newInstance(args);
} catch (Exception ex) {
throw new BeanInstantiationException(this.beanDefinition.getBeanClass(),
"Failed to invoke constructor for CGLIB enhanced subclass [" + subclass.getName() + "]", ex);
}
}
Factory factory = (Factory) instance;
// 3. Callback拦截器
// CglibSubclassingInstantiationStrategy$LookupOverrideMethodInterceptor
// CglibSubclassingInstantiationStrategy$ReplaceOverrideMethodInterceptor
factory.setCallbacks(new Callback[]{NoOp.INSTANCE,
new LookupOverrideMethodInterceptor(this.beanDefinition, this.owner),
new ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)});
return instance;
}
private Class<?> createEnhancedSubclass(RootBeanDefinition beanDefinition) {
// 1. Cglib规定用法。对原始Class进行增强，并设置Callback
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(beanDefinition.getBeanClass());
enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
if (this.owner instanceof ConfigurableBeanFactory) {
ClassLoader cl = ((ConfigurableBeanFactory) this.owner).getBeanClassLoader();
enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(cl));
}
// 2... CglibSubclassingInstantiationStrategy$MethodOverrideCallbackFilter CallbackFilter，自定义逻辑确定Callback[]_index
enhancer.setCallbackFilter(new MethodOverrideCallbackFilter(beanDefinition));
// 3. (Callback拦截器, CallbackTypes)一一对应
enhancer.setCallbackTypes(CALLBACK_TYPES);
return enhancer.createClass();
}
}
// ------------------------------------------------------------------------------------------
private static class MethodOverrideCallbackFilter extends CglibIdentitySupport implements CallbackFilter {
public MethodOverrideCallbackFilter(RootBeanDefinition beanDefinition) {
super(beanDefinition);
}
@Override
public int accept(Method method) {
// BD筛选Callbacks[]_index
MethodOverride methodOverride = getBeanDefinition().getMethodOverrides().getOverride(method);
if (logger.isTraceEnabled()) {
logger.trace("MethodOverride for " + method + ": " + methodOverride);
}
if (methodOverride == null) {
return PASSTHROUGH; // 0
} else if (methodOverride instanceof LookupOverride) {
return LOOKUP_OVERRIDE; // 1
} else if (methodOverride instanceof ReplaceOverride) {
return METHOD_REPLACER; // 2
}
throw new UnsupportedOperationException("Unexpected MethodOverride subclass: " +
methodOverride.getClass().getName());
}
}
// ------------------------------------------------------------------------------------------
private static class LookupOverrideMethodInterceptor extends CglibIdentitySupport implements MethodInterceptor {
private final BeanFactory owner;
public LookupOverrideMethodInterceptor(RootBeanDefinition beanDefinition, BeanFactory owner) {
super(beanDefinition);
this.owner = owner;
}
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy mp) throws Throwable {
// Cast is safe, as CallbackFilter filters are used selectively.
LookupOverride lo = (LookupOverride) getBeanDefinition().getMethodOverrides().getOverride(method);
Object[] argsToUse = (args.length > 0 ? args : null); // if no-arg, don't insist on args at all
if (StringUtils.hasText(lo.getBeanName())) {
return (argsToUse != null ? this.owner.getBean(lo.getBeanName(), argsToUse) :
this.owner.getBean(lo.getBeanName()));
} else {
return (argsToUse != null ? this.owner.getBean(method.getReturnType(), argsToUse) :
this.owner.getBean(method.getReturnType()));
}
}
}
// ------------------------------------------------------------------------------------------
private static class ReplaceOverrideMethodInterceptor extends CglibIdentitySupport implements MethodInterceptor {
private final BeanFactory owner;
public ReplaceOverrideMethodInterceptor(RootBeanDefinition beanDefinition, BeanFactory owner) {
super(beanDefinition);
this.owner = owner;
}
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy mp) throws Throwable {
ReplaceOverride ro = (ReplaceOverride) getBeanDefinition().getMethodOverrides().getOverride(method);
// TODO could cache if a singleton for minor performance optimization
MethodReplacer mr = this.owner.getBean(ro.getMethodReplacerBeanName(), MethodReplacer.class);
return mr.reimplement(obj, method, args);
}
}
}
CglibSubclassingInstantiationStrategy$CglibSubclassCreator#createEnhancedSubclass()
instantiate()进行代理对象的创建，一个Filter，两个MethodInterceptorMethodOverrideCallbackFilter extends CglibIdentitySupport implements CallbackFilterLookupOverrideMethodInterceptor extends CglibIdentitySupport implements MethodInterceptorReplaceOverrideMethodInterceptor extends CglibIdentitySupport implements MethodInterceptor
MethodInterceptor.intercept()拦截器的调用执行。进行BF.getBean()获取apple对象
2. BeanWrapper
- 属性编辑器：
BF.conversionService=>bw.conversionService - 类型转化器：
BF.propertyEditorRegistrars, BF.customEditors=>bw.customEditors
/*
* 1. CustomEditors to bw:
* `registerDefaultEditors(), registerCustomEditors()`
* 2. BF_ConversionService to bw
* refresh() => finishBeanFactoryInitialization() ConversionService to BF
*/
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
protected void initBeanWrapper(BeanWrapper bw) {
// BF.conversionService => bw.conversionService
bw.setConversionService(getConversionService());
// BF.propertyEditorRegistrars, BF.customEditors => bw.customEditors
registerCustomEditors(bw);
}
}
3. applyMergedBDPPs(BPP)
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
/*
* 3.1. InitDestroyAnnotationBeanPostProcessor => @PostConstruct, @PreDestroy
* 3.2. CommonAnnotationBeanPostProcessor => @Resource, @WebServiceRef, @EJB
* 3.3. AutowiredAnnotationBeanPostProcessor => @Autowired, @Value, @Inject
*/
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
} catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof MergedBeanDefinitionPostProcessor) {
MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
}
}
}
}
// 初始化前冻结BD。这里要进行modify，从而进行实例化
finishBeanFactoryInitialization() => beanFactory.freezeConfiguration();
public class T15_applyMergedBDPP {
/*
* init-method == @PostConstruct
* destroy-method == @PreDestroy
* @Resource
* @Autowired
*/
public static void main(String[] args) {
// annotation
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("x15_1_applyMergedBDPP.xml");
System.out.println("------------------- ac.over -------------------");
Ooxx ooxx = ac.getBean("ooxx", Ooxx.class);
System.out.println("ooxx = " + ooxx);
ac.close();
}
}
<!--<bean id="initDestroyAnnotationBPP"-->
<!--class="org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor"/>-->
<bean id="commonAnnoBPP"
class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor"/>
<bean id="autowiredAnnoBPP"
class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>
<bean id="ooxx" class="com.listao.ooxx.bpp.Ooxx"/>
<bean id="ox" class="com.listao.ooxx.bpp.Ox"/>
MergedBeanDefinitionPostProcessor实现类皆为AnnoBPP，处理注解CommonAnnotationBeanPostProcessor，jdk提供- @Resource =>
injectionMetadataCache
- @Resource =>
InitDestroyAnnotationBeanPostProcessor父类- @PostConstruct =>
lifecycleMetadataCache - @PreDestroy
- @PostConstruct =>
AutowiredAnnotationBeanPostProcessor，Spring提供- @Autowired =>
injectionMetadataCache - @Value
- @Autowired =>
1. InitDestroyAnnoBPP
@PostConstruct=<init-method>=>BD.externallyManagedInitMethods@PreDestroy=<destroy-method>=>BD.externallyManagedDestroyMethodsInitDestroyAnnotationBeanPostProcessor.lifecycleMetadataCache.put(clazz, LifecycleMetadata);- 3. InitDestroyAnnotationBPP
public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
// 向父类 `InitDestroyAnnotationBeanPostProcessor()` 注入@PostConstruct, @PreDestroy
public CommonAnnotationBeanPostProcessor() {
setOrder(Ordered.LOWEST_PRECEDENCE - 3);
// 1. @PostConstruct, @PreDestroy
setInitAnnotationType(PostConstruct.class);
setDestroyAnnotationType(PreDestroy.class);
ignoreResourceType("javax.xml.ws.WebServiceContext");
}
}
class T15_Xml {
public static void main(String[] args) {
// xml
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("x15_2_init_destroy.xml");
System.out.println("------------------- ac.over -------------------");
Ooxx ooxx = ac.getBean("ooxx", Ooxx.class);
System.out.println("ooxx = " + ooxx);
ac.close();
}
}
<bean id="ooxx"
class="com.listao.ooxx.bpp.Ooxx"
init-method="postConstruct"
destroy-method="preDestroy"
/>
@Component
public class Ooxx implements InitializingBean {
@PostConstruct
public void postConstruct() {
System.out.println("===>>> postConstruct()...");
}
public void initMethod() {
System.out.println("===>>> initMethod()...");
}
@PreDestroy
public void preDestroy() {
System.out.println("===>>> preDestroy()...");
}
}
InitDestroyAnnotationBeanPostProcessor#postProcessMergedBeanDefinition()
1. findLifecycleMetadata()
public class InitDestroyAnnotationBeanPostProcessor
implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
// CommonAnnotationBeanPostProcessor初始化时，放置了@PostConstruct注解
@Nullable
private Class<? extends Annotation> initAnnotationType;
// CommonAnnotationBeanPostProcessor初始化时，放置了@PreDestory注解
@Nullable
private Class<? extends Annotation> destroyAnnotationType;
// 生命周期的元数据缓存
@Nullable
private final transient Map<Class<?>, LifecycleMetadata> lifecycleMetadataCache = new ConcurrentHashMap<>(256);
/*
* @PostConstruct, @PreDestroy
*/
@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
// 1.. @PostConstruct, @PreDestroy => LifecycleMetadata
LifecycleMetadata metadata = findLifecycleMetadata(beanType);
// 2... InitDestroyAnnotationBeanPostProcessor$LifecycleMetadata => BD
metadata.checkConfigMembers(beanDefinition);
}
/**
* lifecycleMetadataCache处理
*/
private LifecycleMetadata findLifecycleMetadata(Class<?> clazz) {
if (this.lifecycleMetadataCache == null) {
// Happens after deserialization, during destruction...
return buildLifecycleMetadata(clazz);
}
// 1.1. Quick check on the concurrent map first, with minimal locking.
LifecycleMetadata metadata = this.lifecycleMetadataCache.get(clazz);
if (metadata == null) {
synchronized (this.lifecycleMetadataCache) {
metadata = this.lifecycleMetadataCache.get(clazz);
if (metadata == null) {
// 1.2.. 核心方法
metadata = buildLifecycleMetadata(clazz);
// 1.3.
this.lifecycleMetadataCache.put(clazz, metadata);
}
return metadata;
}
}
return metadata;
}
/**
* 构造LifecycleMetadata（解析、缓存@PostConstruct和@PreDestroy方法）
*/
private LifecycleMetadata buildLifecycleMetadata(final Class<?> clazz) {
if (!AnnotationUtils.isCandidateClass(clazz, Arrays.asList(this.initAnnotationType, this.destroyAnnotationType))) {
return this.emptyLifecycleMetadata;
}
List<LifecycleElement> initMethods = new ArrayList<>();
List<LifecycleElement> destroyMethods = new ArrayList<>();
Class<?> targetClass = clazz;
do {
final List<LifecycleElement> currInitMethods = new ArrayList<>();
final List<LifecycleElement> currDestroyMethods = new ArrayList<>();
// 1. 反射targetClass所有方法，并筛选出@PostConstruct、@PreDestroy修饰的
ReflectionUtils.doWithLocalMethods(targetClass, method -> {
// 1.1. @PostConstruct => InitDestroyAnnotationBeanPostProcessor$LifecycleElement
if (this.initAnnotationType != null && method.isAnnotationPresent(this.initAnnotationType)) {
LifecycleElement element = new LifecycleElement(method);
currInitMethods.add(element);
if (logger.isTraceEnabled()) {
logger.trace("Found init method on class [" + clazz.getName() + "]: " + method);
}
}
// 1.2. @PreDestroy => InitDestroyAnnotationBeanPostProcessor$LifecycleElement
if (this.destroyAnnotationType != null && method.isAnnotationPresent(this.destroyAnnotationType)) {
currDestroyMethods.add(new LifecycleElement(method));
if (logger.isTraceEnabled()) {
logger.trace("Found destroy method on class [" + clazz.getName() + "]: " + method);
}
}
});
// 1.3.
initMethods.addAll(0, currInitMethods);
destroyMethods.addAll(currDestroyMethods);
targetClass = targetClass.getSuperclass();
}
while (targetClass != null && targetClass != Object.class);
// 2. 封装LifecycleMetadata对象
return (initMethods.isEmpty() && destroyMethods.isEmpty() ? this.emptyLifecycleMetadata :
new LifecycleMetadata(clazz, initMethods, destroyMethods));
}
// -------------------------------------------------------------------------------------
/**
* Class representing information about annotated init and destroy methods.
*/
private class LifecycleMetadata {
private final Class<?> targetClass;
private final Collection<LifecycleElement> initMethods;
private final Collection<LifecycleElement> destroyMethods;
private volatile Set<LifecycleElement> checkedInitMethods;
private volatile Set<LifecycleElement> checkedDestroyMethods;
public LifecycleMetadata(Class<?> targetClass, Collection<LifecycleElement> initMethods,
Collection<LifecycleElement> destroyMethods) {
this.targetClass = targetClass;
this.initMethods = initMethods;
this.destroyMethods = destroyMethods;
}
/**
* 1. @PostConstruct、@PreDestroy方法 => BD
* 2. 处理过放入LifecycleElement.checkedInitMethods、LifecycleElement.checkDestroyMethods集合
*/
public void checkConfigMembers(RootBeanDefinition beanDefinition) {
Set<LifecycleElement> checkedInitMethods = new LinkedHashSet<>(this.initMethods.size());
for (LifecycleElement element : this.initMethods) {
String methodIdentifier = element.getIdentifier();
if (!beanDefinition.isExternallyManagedInitMethod(methodIdentifier)) {
// 1. initMethods => BD.externallyManagedInitMethods
beanDefinition.registerExternallyManagedInitMethod(methodIdentifier);
checkedInitMethods.add(element);
if (logger.isTraceEnabled()) {
logger.trace("Registered init method on class [" + this.targetClass.getName() + "]: " + element);
}
}
}
Set<LifecycleElement> checkedDestroyMethods = new LinkedHashSet<>(this.destroyMethods.size());
for (LifecycleElement element : this.destroyMethods) {
String methodIdentifier = element.getIdentifier();
if (!beanDefinition.isExternallyManagedDestroyMethod(methodIdentifier)) {
// 2. destroyMethods => BD.externallyManagedDestroyMethods
beanDefinition.registerExternallyManagedDestroyMethod(methodIdentifier);
checkedDestroyMethods.add(element);
if (logger.isTraceEnabled()) {
logger.trace("Registered destroy method on class [" + this.targetClass.getName() + "]: " + element);
}
}
}
this.checkedInitMethods = checkedInitMethods;
this.checkedDestroyMethods = checkedDestroyMethods;
}
// postProcessBeforeInitialization调用
public void invokeInitMethods(Object target, String beanName) throws Throwable {
Collection<LifecycleElement> checkedInitMethods = this.checkedInitMethods;
Collection<LifecycleElement> initMethodsToIterate =
(checkedInitMethods != null ? checkedInitMethods : this.initMethods);
if (!initMethodsToIterate.isEmpty()) {
for (LifecycleElement element : initMethodsToIterate) {
if (logger.isTraceEnabled()) {
logger.trace("Invoking init method on bean '" + beanName + "': " + element.getMethod());
}
// 99.1... InitDestroyAnnotationBeanPostProcessor$LifecycleElement
element.invoke(target);
}
}
}
public void invokeDestroyMethods(Object target, String beanName) throws Throwable {
Collection<LifecycleElement> checkedDestroyMethods = this.checkedDestroyMethods;
Collection<LifecycleElement> destroyMethodsToUse =
(checkedDestroyMethods != null ? checkedDestroyMethods : this.destroyMethods);
if (!destroyMethodsToUse.isEmpty()) {
for (LifecycleElement element : destroyMethodsToUse) {
if (logger.isTraceEnabled()) {
logger.trace("Invoking destroy method on bean '" + beanName + "': " + element.getMethod());
}
// 1.
element.invoke(target);
}
}
}
}
// -------------------------------------------------------------------------------------
private static class LifecycleElement {
private final Method method;
private final String identifier;
// 99.2.
public void invoke(Object target) throws Throwable {
ReflectionUtils.makeAccessible(this.method);
this.method.invoke(target, (Object[]) null);
}
}
}
2. CommonAnnoBPP
- JDK提供
@Resource，属性和方法 =>BD.externallyManagedConfigMembers@WebServiceRef, @EJBCommonAnnotationBeanPostProcessor.injectionMetadataCache.put(cacheKey, InjectionMetadata);- 1. CommonAnnotationBPP
@Component
public class Ooxx implements InitializingBean {
@Resource
private Ox resourceFile;
@Resource
public void resource(Ox ox) {
System.out.println("===>>> Resource()...");
}
}
CommonAnnotationBeanPostProcessor#postProcessMergedBeanDefinition()
1. findResourceMetadata()
buildResourceMetadata()将clazz上@Resource修饰的Fields、Methods封装为InjectionMetadata，并缓存injectionMetadataCache
public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
static {
webServiceRefClass = loadAnnotationType("javax.xml.ws.WebServiceRef");
ejbClass = loadAnnotationType("javax.ejb.EJB");
// 1.1. @Resource注解
resourceAnnotationTypes.add(Resource.class);
if (webServiceRefClass != null) {
// 1.2. @WebServiceRef注解
resourceAnnotationTypes.add(webServiceRefClass);
}
if (ejbClass != null) {
// 1.3. @EJB注解
resourceAnnotationTypes.add(ejbClass);
}
}
private final transient Map<String, InjectionMetadata> injectionMetadataCache = new ConcurrentHashMap<>(256);
private static final Set<Class<? extends Annotation>> resourceAnnotationTypes = new LinkedHashSet<>(4);
/**
* 设置@PostConstruct, @PreDestroy注解
*/
public CommonAnnotationBeanPostProcessor() {
setOrder(Ordered.LOWEST_PRECEDENCE - 3);
// 2. @PostConstruct, @PreDestroy
setInitAnnotationType(PostConstruct.class);
setDestroyAnnotationType(PreDestroy.class);
ignoreResourceType("javax.xml.ws.WebServiceContext");
}
@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
// @PostConstruct => RBD.externallyManagedInitMethods
// @PreDestroy => RBD.externallyManagedDestroyMethods
super.postProcessMergedBeanDefinition(beanDefinition, beanType, beanName);
// 1.. @Resource，属性和方法 => RBD.externallyManagedConfigMembers
InjectionMetadata metadata = findResourceMetadata(beanName, beanType, null);
// 2... InjectionMetadata
metadata.checkConfigMembers(beanDefinition);
}
/**
* `@Resource`注解
*/
private InjectionMetadata findResourceMetadata(String beanName, final Class<?> clazz, @Nullable PropertyValues pvs) {
// Fall back to class name as cache key, for backwards compatibility with custom callers.
String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
// 1.1. Quick check on the concurrent map first, with minimal locking.
InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
synchronized (this.injectionMetadataCache) {
metadata = this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
if (metadata != null) {
metadata.clear(pvs);
}
// 1.2.. 构建@Resource的属性、方法InjectionMetadata
metadata = buildResourceMetadata(clazz);
// 1.3.
this.injectionMetadataCache.put(cacheKey, metadata);
}
}
}
return metadata;
}
private InjectionMetadata buildResourceMetadata(final Class<?> clazz) {
// 1. 注解在java类上，直接忽略
if (!AnnotationUtils.isCandidateClass(clazz, resourceAnnotationTypes)) {
return InjectionMetadata.EMPTY;
}
List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
Class<?> targetClass = clazz;
/*
* do_while查找父类
* @Resource, @WebService, @Ejb注解，不支持static
*/
do {
final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
// 2.1. 属性处理
ReflectionUtils.doWithLocalFields(targetClass, field -> {
if (webServiceRefClass != null && field.isAnnotationPresent(webServiceRefClass)) {
if (Modifier.isStatic(field.getModifiers())) {
throw new IllegalStateException("@WebServiceRef annotation is not supported on static fields");
}
currElements.add(new WebServiceRefElement(field, field, null));
} else if (ejbClass != null && field.isAnnotationPresent(ejbClass)) {
if (Modifier.isStatic(field.getModifiers())) {
throw new IllegalStateException("@EJB annotation is not supported on static fields");
}
currElements.add(new EjbRefElement(field, field, null));
}
// 2.2. @Resource
else if (field.isAnnotationPresent(Resource.class)) {
// static_filed不支持
if (Modifier.isStatic(field.getModifiers())) {
throw new IllegalStateException("@Resource annotation is not supported on static fields");
}
// 忽略某一type属性
if (!this.ignoredResourceTypes.contains(field.getType().getName())) {
// 2.3. CommonAnnotationBeanPostProcessor$ResourceElement
currElements.add(new ResourceElement(field, field, null));
}
}
});
// 3.1. 方法处理
ReflectionUtils.doWithLocalMethods(targetClass, method -> {
// 获取自定义方法，非编译器生成方法
Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
return;
}
// 重写了父类方法，则使用子类的
if (method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
if (webServiceRefClass != null && bridgedMethod.isAnnotationPresent(webServiceRefClass)) {
if (Modifier.isStatic(method.getModifiers())) {
throw new IllegalStateException("@WebServiceRef annotation is not supported on static methods");
}
if (method.getParameterCount() != 1) {
throw new IllegalStateException("@WebServiceRef annotation requires a single-arg method: "
+ method);
}
PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
currElements.add(new WebServiceRefElement(method, bridgedMethod, pd));
} else if (ejbClass != null && bridgedMethod.isAnnotationPresent(ejbClass)) {
if (Modifier.isStatic(method.getModifiers())) {
throw new IllegalStateException("@EJB annotation is not supported on static methods");
}
if (method.getParameterCount() != 1) {
throw new IllegalStateException("@EJB annotation requires a single-arg method: " + method);
}
PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
currElements.add(new EjbRefElement(method, bridgedMethod, pd));
}
// 3.2. @Resource
else if (bridgedMethod.isAnnotationPresent(Resource.class)) {
// 不支持static_method
if (Modifier.isStatic(method.getModifiers())) {
throw new IllegalStateException("@Resource annotation is not supported on static methods");
}
Class<?>[] paramTypes = method.getParameterTypes();
if (paramTypes.length != 1) {
throw new IllegalStateException("@Resource annotation requires a single-arg method: " + method);
}
if (!this.ignoredResourceTypes.contains(paramTypes[0].getName())) {
PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
// 3.3. CommonAnnotationBeanPostProcessor$ResourceElement
currElements.add(new ResourceElement(method, bridgedMethod, pd));
}
}
}
});
// 4. superClass放第一位，需要最先完成依赖注入
elements.addAll(0, currElements);
targetClass = targetClass.getSuperclass();
}
while (targetClass != null && targetClass != Object.class);
// 5... InjectionMetadata
return InjectionMetadata.forElements(elements, clazz);
}
// -------------------------------------------------------------------------------------
protected Object getResource(LookupElement element, @Nullable String requestingBeanName)
throws NoSuchBeanDefinitionException {
if (StringUtils.hasLength(element.mappedName)) {
return this.jndiFactory.getBean(element.mappedName, element.lookupType);
}
if (this.alwaysUseJndiLookup) {
return this.jndiFactory.getBean(element.name, element.lookupType);
}
if (this.resourceFactory == null) {
throw new NoSuchBeanDefinitionException(element.lookupType,
"No resource factory configured - specify the 'resourceFactory' property");
}
// 1..
return autowireResource(this.resourceFactory, element, requestingBeanName);
}
protected Object autowireResource(BeanFactory factory, LookupElement element, @Nullable String requestingBeanName)
throws NoSuchBeanDefinitionException {
// 自动装配的对象
Object resource;
// 自动装配的名字
Set<String> autowiredBeanNames;
// 依赖的属性名
String name = element.name;
if (factory instanceof AutowireCapableBeanFactory) {
AutowireCapableBeanFactory beanFactory = (AutowireCapableBeanFactory) factory;
// 创建依赖描述
DependencyDescriptor descriptor = element.getDependencyDescriptor();
// 99.1. IOC是否包含beanName
if (this.fallbackToDefaultTypeMatch && element.isDefaultName && !factory.containsBean(name)) {
//如果容器中还没有此bean，则会使用resolveDependency()方法将符合bean type的bean definetion调用一次getBean()
// 从这些bean选出符合requestingBeanName的bean
autowiredBeanNames = new LinkedHashSet<>();
// 99.2. byType
resource = beanFactory.resolveDependency(descriptor, requestingBeanName, autowiredBeanNames, null);
if (resource == null) {
throw new NoSuchBeanDefinitionException(element.getLookupType(), "No resolvable resource object");
}
}
// 99.3. byName
else {
// 如果容器中有此bean则取出这个bean对象作为属性值
resource = beanFactory.resolveBeanByName(name, descriptor);
autowiredBeanNames = Collections.singleton(name);
}
} else {
resource = factory.getBean(name, element.lookupType);
autowiredBeanNames = Collections.singleton(name);
}
if (factory instanceof ConfigurableBeanFactory) {
ConfigurableBeanFactory beanFactory = (ConfigurableBeanFactory) factory;
for (String autowiredBeanName : autowiredBeanNames) {
if (requestingBeanName != null && beanFactory.containsBean(autowiredBeanName)) {
// 注册依赖关系
beanFactory.registerDependentBean(autowiredBeanName, requestingBeanName);
}
}
}
return resource;
}
// -------------------------------------------------------------------------------------
private class ResourceElement extends LookupElement {
private final boolean lazyLookup;
public ResourceElement(Member member, AnnotatedElement ae, @Nullable PropertyDescriptor pd) {
super(member, pd);
Resource resource = ae.getAnnotation(Resource.class);
String resourceName = resource.name();
Class<?> resourceType = resource.type();
this.isDefaultName = !StringUtils.hasLength(resourceName);
if (this.isDefaultName) {
// 如果没有设置@Resource name属性就用字段名称作为bean name
resourceName = this.member.getName();
// 如果member是setter方法，则取setXXX的XXX部分为bean name
if (this.member instanceof Method && resourceName.startsWith("set") && resourceName.length() > 3) {
resourceName = Introspector.decapitalize(resourceName.substring(3));
}
} else if (embeddedValueResolver != null) {
// 如果设置了@Resource name的属性，则使用EmbeddedValueResolver对象先做一次SpringEL解析得到真正的bean name
resourceName = embeddedValueResolver.resolveStringValue(resourceName);
}
if (Object.class != resourceType) {
// 确保字段或setter方法类型与resourceType一致
checkResourceType(resourceType);
} else {
// No resource type specified... check field/method.
resourceType = getResourceType();
}
this.name = (resourceName != null ? resourceName : "");
this.lookupType = resourceType;
String lookupValue = resource.lookup();
// 如果使用jndi查找名字
this.mappedName = (StringUtils.hasLength(lookupValue) ? lookupValue : resource.mappedName());
Lazy lazy = ae.getAnnotation(Lazy.class);
// 是否延迟注入
this.lazyLookup = (lazy != null && lazy.value());
}
/**
* 首先判断注释元数据有没有@Lazy注解，有的话就创建一个代理类，内部是用AOP代理工厂做的
*
* @param target
* @param requestingBeanName
* @return
*/
@Override
protected Object getResourceToInject(Object target, @Nullable String requestingBeanName) {
return (this.lazyLookup ? buildLazyResourceProxy(this, requestingBeanName) :
// 1... CommonAnnotationBeanPostProcessor 如果懒加载则使用一个代理对象
getResource(this, requestingBeanName));
}
}
// -------------------------------------------------------------------------------------
protected abstract static class LookupElement extends InjectionMetadata.InjectedElement {
protected String name = "";
protected boolean isDefaultName = false;
protected Class<?> lookupType = Object.class;
@Nullable
protected String mappedName;
public LookupElement(Member member, @Nullable PropertyDescriptor pd) {
super(member, pd);
}
}
}
2. InjectionMetadata
public class InjectionMetadata {
private final Class<?> targetClass;
private final Collection<InjectedElement> injectedElements;
@Nullable
private volatile Set<InjectedElement> checkedElements;
public static InjectionMetadata forElements(Collection<InjectedElement> elements, Class<?> clazz) {
// 1.
return (elements.isEmpty() ? InjectionMetadata.EMPTY : new InjectionMetadata(clazz, elements));
}
public InjectionMetadata(Class<?> targetClass, Collection<InjectedElement> elements) {
this.targetClass = targetClass;
this.injectedElements = elements;
}
public void checkConfigMembers(RootBeanDefinition beanDefinition) {
Set<InjectedElement> checkedElements = new LinkedHashSet<>(this.injectedElements.size());
for (InjectedElement element : this.injectedElements) {
// 1.
Member member = element.getMember();
if (!beanDefinition.isExternallyManagedConfigMember(member)) {
// 2. BD.externallyManagedConfigMembers
beanDefinition.registerExternallyManagedConfigMember(member);
// 3.
checkedElements.add(element);
if (logger.isTraceEnabled()) {
logger.trace("Registered injected element on class [" + this.targetClass.getName() + "]: " + element);
}
}
}
this.checkedElements = checkedElements;
}
/**
* 遍历前面注册的InjectedElement，然后进行注入
*/
public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
Collection<InjectedElement> checkedElements = this.checkedElements;
Collection<InjectedElement> elementsToIterate =
(checkedElements != null ? checkedElements : this.injectedElements);
if (!elementsToIterate.isEmpty()) {
for (InjectedElement element : elementsToIterate) {
if (logger.isTraceEnabled()) {
logger.trace("Processing injected element of bean '" + beanName + "': " + element);
}
// 1... InjectionMetadata$InjectedElement
element.inject(target, beanName, pvs);
}
}
}
/**
* A single injected element.
*/
public abstract static class InjectedElement {
protected final Member member;
protected final boolean isField;
@Nullable
protected final PropertyDescriptor pd;
@Nullable
protected volatile Boolean skip;
protected InjectedElement(Member member, @Nullable PropertyDescriptor pd) {
this.member = member;
this.isField = (member instanceof Field);
this.pd = pd;
}
/**
* 进行属性或者方法注入，但是方法注入前会判断是否已经有设置值了，有设置就不会注入，直接返回
* <p>
* Either this or {@link #getResourceToInject} needs to be overridden.
*/
protected void inject(Object target, @Nullable String requestingBeanName, @Nullable PropertyValues pvs)
throws Throwable {
// 1.1. 属性注入
if (this.isField) {
Field field = (Field) this.member;
ReflectionUtils.makeAccessible(field);
// 1.2.. CommonAnnotationBeanPostProcessor$ResourceElement 如果是使用字段形式的注入，getResourceToInject由子类@ResourceElement实现
field.set(target, getResourceToInject(target, requestingBeanName));
} else {
// 此步骤检测如果bean已经显示的设置一个对象依赖引用则跳过使用setter方法再次赋值
if (checkPropertySkipping(pvs)) {
return;
}
try {
// 2.1. 方法注入
Method method = (Method) this.member;
// 2.2.. CommonAnnotationBeanPostProcessor$ResourceElement 支持私有方法
ReflectionUtils.makeAccessible(method);
method.invoke(target, getResourceToInject(target, requestingBeanName));
} catch (InvocationTargetException ex) {
throw ex.getTargetException();
}
}
}
}
}
public class RootBeanDefinition extends AbstractBeanDefinition {
@Nullable
private Set<Member> externallyManagedConfigMembers;
public void registerExternallyManagedConfigMember(Member configMember) {
synchronized (this.postProcessingLock) {
if (this.externallyManagedConfigMembers == null) {
this.externallyManagedConfigMembers = new HashSet<>(1);
}
// 1.
this.externallyManagedConfigMembers.add(configMember);
}
}
}
3. AutowiredAnnBPP
@Autowired=>BD.externallyManagedConfigMembers@Value, @InjectAutowiredAnnotationBeanPostProcessor.injectionMetadataCache.put(cacheKey, InjectionMetadata);- 2. AutowiredAnnotationBPP
AutowiredAnnotationBeanPostProcessor#postProcessMergedBeanDefinition()
1. findAutowiringMetadata()
- 通过
buildAutowiringMetadata()将clazz上的被@Autowired修饰的Fields和Methods封装为InjectionMetadata，并缓存起来
public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter
implements MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware {
private final Set<Class<? extends Annotation>> autowiredAnnotationTypes = new LinkedHashSet<>(4);
private final Map<String, InjectionMetadata> injectionMetadataCache = new ConcurrentHashMap<>(256);
public AutowiredAnnotationBeanPostProcessor() {
// 1. @Autowired, @Value
this.autowiredAnnotationTypes.add(Autowired.class);
this.autowiredAnnotationTypes.add(Value.class);
try {
// @Inject
this.autowiredAnnotationTypes.add((Class<? extends Annotation>)
ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
logger.trace("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring");
} catch (ClassNotFoundException ex) {
// JSR-330 API not available - simply skip.
}
}
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
// 1.. @Autowired，属性和方法 => RBD.externallyManagedConfigMembers
InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
// 2... InjectionMetadata
metadata.checkConfigMembers(beanDefinition);
}
/**
* `@Autowired`注解
*/
private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
// Fall back to class name as cache key, for backwards compatibility with custom callers.
String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
// 1.1. Quick check on the concurrent map first, with minimal locking.
InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
synchronized (this.injectionMetadataCache) {
metadata = this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
if (metadata != null) {
metadata.clear(pvs);
}
// 1.2.. 构建@Autowired属性、方法的InjectionMetadata
metadata = buildAutowiringMetadata(clazz);
// 1.3.
this.injectionMetadataCache.put(cacheKey, metadata);
}
}
}
return metadata;
}
private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
// 1. 注解在java类上，直接忽略
if (!AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) {
return InjectionMetadata.EMPTY;
}
List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
Class<?> targetClass = clazz;
/*
* do_while查找父类
* @Autowired 注解，不支持static
*/
do {
final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
// 2.1. 属性处理
ReflectionUtils.doWithLocalFields(targetClass, field -> {
// 2.2..
MergedAnnotation<?> ann = findAutowiredAnnotation(field);
if (ann != null) {
// static_filed不支持
if (Modifier.isStatic(field.getModifiers())) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation is not supported on static fields: " + field);
}
return;
}
// 2.3.. @Autowired(required = true)
boolean required = determineRequiredStatus(ann);
// 2.4. AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement
currElements.add(new AutowiredFieldElement(field, required));
}
});
// 3.1. 方法处理
ReflectionUtils.doWithLocalMethods(targetClass, method -> {
// 获取自定义方法，非编译器生成方法
Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
return;
}
// 3.2..
MergedAnnotation<?> ann = findAutowiredAnnotation(bridgedMethod);
// 重写了父类方法，则使用子类的
if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
if (Modifier.isStatic(method.getModifiers())) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation is not supported on static methods: " + method);
}
return;
}
// 无形参，不做处理
if (method.getParameterCount() == 0) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation should only be used on methods with parameters: " +
method);
}
}
// 3.3..
boolean required = determineRequiredStatus(ann);
PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
// AutowiredMethodElement里封装了一个PropertyDescriptor（比Field多一个参数）
// 3.4. AutowiredAnnotationBeanPostProcessor$AutowiredMethodElement
currElements.add(new AutowiredMethodElement(method, required, pd));
}
});
// 4. superClass放第一位，需要最先完成依赖注入
elements.addAll(0, currElements);
targetClass = targetClass.getSuperclass();
}
while (targetClass != null && targetClass != Object.class);
// 5... InjectionMetadata
return InjectionMetadata.forElements(elements, clazz);
}
/**
* 方法、属性上但凡有一个注解，就立马返回
*/
@Nullable
private MergedAnnotation<?> findAutowiredAnnotation(AccessibleObject ao) {
// 1.
MergedAnnotations annotations = MergedAnnotations.from(ao);
for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) {
MergedAnnotation<?> annotation = annotations.get(type);
// 2.
if (annotation.isPresent()) {
return annotation;
}
}
return null;
}
@SuppressWarnings({"deprecation", "cast"})
protected boolean determineRequiredStatus(MergedAnnotation<?> ann) {
// 1.. The following (AnnotationAttributes) cast is required on JDK 9+.
return determineRequiredStatus((AnnotationAttributes)
ann.asMap(mergedAnnotation -> new AnnotationAttributes(mergedAnnotation.getType())));
}
@Deprecated
protected boolean determineRequiredStatus(AnnotationAttributes ann) {
// 1..
return (!ann.containsKey(this.requiredParameterName) || // required
this.requiredParameterValue == ann.getBoolean(this.requiredParameterName));
}
// -------------------------------------------------------------------------------------------------
/**
* Class representing injection information about an annotated field.
*/
private class AutowiredFieldElement extends InjectionMetadata.InjectedElement {
private volatile Object cachedFieldValue;
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) {
Field field = (Field) this.member;
Object value;
if (this.cached) {
// `cachedFieldValue instanceof DependencyDescriptor`。则调用resolveDependency()重新加载
value = resolvedCachedArgument(beanName, this.cachedFieldValue);
} else {
// @Autowired、@Inject默认按照type注入的
DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
desc.setContainingClass(bean.getClass());
Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
Assert.state(beanFactory != null, "No BeanFactory available");
TypeConverter typeConverter = beanFactory.getTypeConverter();
try {
// 1. type匹配bean
value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
} catch (BeansException ex) {
throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
}
// 2. 进行缓存
synchronized (this) {
if (!this.cached) {
if (value != null || this.required) {
this.cachedFieldValue = desc;
// 注册依赖bean
registerDependentBeans(beanName, autowiredBeanNames);
// 可能有别名
if (autowiredBeanNames.size() == 1) {
String autowiredBeanName = autowiredBeanNames.iterator().next();
if (beanFactory.containsBean(autowiredBeanName) &&
beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
this.cachedFieldValue = new ShortcutDependencyDescriptor(
desc, autowiredBeanName, field.getType());
}
}
} else {
this.cachedFieldValue = null;
}
this.cached = true;
}
}
}
if (value != null) {
// 3. @Autowired通过反射`Field.set()`给属性赋值
ReflectionUtils.makeAccessible(field);
field.set(bean, value);
}
}
}
private class AutowiredMethodElement extends InjectionMetadata.InjectedElement {
private volatile Object[] cachedMethodArguments;
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) {
if (checkPropertySkipping(pvs)) {
return;
}
Method method = (Method) this.member;
Object[] arguments;
if (this.cached) {
// Shortcut for avoiding synchronization...
arguments = resolveCachedArguments(beanName);
} else {
// 获取方法的参数，从Spring容器中获取(缓存中没有则尝试创建)
int argumentCount = method.getParameterCount();
arguments = new Object[argumentCount];
DependencyDescriptor[] descriptors = new DependencyDescriptor[argumentCount];
Set<String> autowiredBeans = new LinkedHashSet<>(argumentCount);
Assert.state(beanFactory != null, "No BeanFactory available");
TypeConverter typeConverter = beanFactory.getTypeConverter();
// 1. 遍历形参，从容器中匹配获取
for (int i = 0; i < arguments.length; i++) {
MethodParameter methodParam = new MethodParameter(method, i);
DependencyDescriptor currDesc = new DependencyDescriptor(methodParam, this.required);
currDesc.setContainingClass(bean.getClass());
descriptors[i] = currDesc;
try {
// 2. type匹配bean
Object arg = beanFactory.resolveDependency(currDesc, beanName, autowiredBeans, typeConverter);
if (arg == null && !this.required) {
arguments = null;
break;
}
arguments[i] = arg;
} catch (BeansException ex) {
throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(methodParam), ex);
}
}
// 3. 进行缓存
synchronized (this) {
if (!this.cached) {
if (arguments != null) {
DependencyDescriptor[] cachedMethodArguments = Arrays.copyOf(descriptors, arguments.length);
registerDependentBeans(beanName, autowiredBeans);
if (autowiredBeans.size() == argumentCount) {
Iterator<String> it = autowiredBeans.iterator();
Class<?>[] paramTypes = method.getParameterTypes();
for (int i = 0; i < paramTypes.length; i++) {
String autowiredBeanName = it.next();
if (beanFactory.containsBean(autowiredBeanName) &&
beanFactory.isTypeMatch(autowiredBeanName, paramTypes[i])) {
cachedMethodArguments[i] = new ShortcutDependencyDescriptor(
descriptors[i], autowiredBeanName, paramTypes[i]);
}
}
}
this.cachedMethodArguments = cachedMethodArguments;
} else {
this.cachedMethodArguments = null;
}
this.cached = true;
}
}
}
if (arguments != null) {
try {
// 4. @Autowired通过反射`setter()`给属性赋值
ReflectionUtils.makeAccessible(method);
method.invoke(bean, arguments);
} catch (InvocationTargetException ex) {
throw ex.getTargetException();
}
}
}
}
}
2. InjectionMetadata
4. addSingletonFactory
- AOP是BPP实现，不管当前对象是否被代理，添加三级缓存
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
// 4. addSingletonFactory，三级缓存
// 构造器的循环依赖，无解。setter()，实例化、初始化分开
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
5. populateBean()
// 5. DI，递归初始化依赖的bean
populateBean(beanName, mbd, instanceWrapper);
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
/**
* BD_<property>填充BeanWrapper实例属性
* <p>
* Populate the bean instance in the given BeanWrapper with the property values
* from the bean definition.
*
* @param beanName the name of the bean
* @param mbd the bean definition for the bean
* @param bw the BeanWrapper with bean instance
*/
@SuppressWarnings("deprecation") // for postProcessPropertyValues
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
if (bw == null) {
if (mbd.hasPropertyValues()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
} else {
// Skip property population phase for null instance.
return;
}
}
// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
// state of the bean before properties are set. This can be used, for example,
// to support styles of field injection.
/*
* 1. InstantiationAwareBPP.postProcessAfterInstantiation()
* 只有AOP相关的pointCut配置或者Advice配置才会将synthetic设置为true
*/
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 默认ibp无任何操作，可自定义
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
}
// `<property name="province" value="河北"/>` => pvs
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
/*
* 2. 自动装配模式 `<bean id="person" autowire="byName"/>`
* AUTOWIRE_NO = 0; default
* AUTOWIRE_BY_NAME = 1;
* AUTOWIRE_BY_TYPE = 2;
* AUTOWIRE_CONSTRUCTOR = 3;
* AUTOWIRE_AUTODETECT = 4;
*/
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
// `MutablePropertyValues implements PropertyValues`
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
// mbd.getDependencyCheck()，默认不检查DEPENDENCY_CHECK_NONE
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
// 经过筛选的PropertyDescriptor数组，存放着排除忽略依赖项、忽略项上定义的属性
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 3.1. CommonAnnotationBeanPostProcessor => @Resource
// 3.2. AutowiredAnnotationBeanPostProcessor => @Autowired
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
// @Deprecated，取而代之的是 `postProcessProperties()`
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
}
if (needsDepCheck) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
// 检查依赖项：pd的setter()需要赋值时，pvs中有没有满足的属性值可供其赋值
checkDependencies(beanName, mbd, filteredPds, pvs);
}
if (pvs != null) {
// 4. `<property name="id" value="1"/>`属性值。使用深拷贝，不会永久地修改这个属性
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
}
1. postProcessAfterInstantiation(BPP)
- Spring_bpp无任何操作，可自定义
// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
// state of the bean before properties are set. This can be used, for example,
// to support styles of field injection.
/*
* 1. InstantiationAwareBPP.postProcessAfterInstantiation()
* 只有AOP相关的pointCut配置或者Advice配置才会将synthetic设置为true
*/
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 默认ibp无任何操作，可自定义
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
}
InstantiationAwareBPP#postProcessAfterInstantiation()
public class T16_PopulateBean {
public static void main(String[] args) {
// MyInstantiationAwareBPP
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("x17_1_MyInstantiationAwareBPP.xml");
System.out.println("------------------- ac.over -------------------");
Ooxx bean = ac.getBean("ooxx", Ooxx.class);
System.out.println("bean = " + bean);
ac.close();
}
}
<bean id="ooxx" class="com.listao.Ooxx"/>
<bean id="myInstantiationAwareBPP" class="com.listao.populateBean.MyInstantiationAwareBPP"/>
- 可阻止接下来进行的初始化
public class MyInstantiationAwareBPP implements InstantiationAwareBeanPostProcessor {
/**
* 可阻止接下来进行的初始化
*/
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
System.out.println("====>>>> MyInstantiationAwareBPP.postProcessAfterInstantiation()");
Ooxx ooxx;
if (bean instanceof Ooxx) {
ooxx = (Ooxx) bean;
ooxx.setId(100);
ooxx.setName("MyInstantiationAwareBPP");
return false;
} else {
return true;
}
}
}
2. autowireByName
class T16_xml_autowire {
public static void main(String[] args) {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("x17_2_autowire.xml");
System.out.println("------------------- ac.over -------------------");
ac.close();
}
}
<bean id="byName" class="com.listao.populateBean.AutowireBean" autowire="byName"/>
<bean id="byType" class="com.listao.populateBean.AutowireBean" autowire="byType"/>
<bean id="ooxx" class="com.listao.Ooxx"/>
public class AutowireBean {
private Integer id;
private String mobile;
private String name = "list";
private Integer age;
private String gender;
private String[] hobbies;
// findAutowireCandidates()
private Ooxx[] ooxxAs;
private Properties properties;
// resolveMultipleBeans()
private Ooxx ooxx;
private List<Ooxx> ooxxLs;
private Set<Integer> sets;
private Map<String, Object> maps;
@PostConstruct
public void init() {
System.out.println("init() => AutowireBean");
}
@PreDestroy
public void destroy() {
System.out.println("destroy() => AutowireBean");
}
public AutowireBean() {
System.out.println("AutowireBean()");
}
public AutowireBean(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
System.out.println("Age");
}
public AutowireBean(int id, String name, String gender) {
this.id = id;
this.name = name;
this.gender = gender;
System.out.println("gender");
}
public AutowireBean(int id, String name, int age, String gender) {
this.id = id;
this.name = name;
this.age = age;
this.gender = gender;
System.out.println("有参构造器");
}
}
<bean autowire="no"/>
<bean autowire="default"/>
<bean autowire="byName"/>
<bean autowire="byType"/>
<bean autowire="constructor"/>
// `<property name="province" value="河北"/>` => pvs
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
/*
* 2. 自动装配模式 `<bean id="person" autowire="byName"/>`
* AUTOWIRE_NO = 0; default
* AUTOWIRE_BY_NAME = 1;
* AUTOWIRE_BY_TYPE = 2;
* AUTOWIRE_CONSTRUCTOR = 3;
* AUTOWIRE_AUTODETECT = 4;
*/
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
// `MutablePropertyValues implements PropertyValues`
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
/**
* 通过bw的PropertyDescriptor属性名，查找出对应的Bean对象，将其添加到pvs中
*/
protected void autowireByName(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
// 1. 获取非简单属性，即引用类型属性
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
for (String propertyName : propertyNames) {
// propertyName == beanName
if (containsBean(propertyName)) {
// 2. 创建propertyName对应bean对象，并添加到pvs
Object bean = getBean(propertyName);
pvs.add(propertyName, bean);
// 3. 注册(propertyName, beanName)依赖关系
registerDependentBean(propertyName, beanName);
if (logger.isTraceEnabled()) {
logger.trace("Added autowiring by name from bean name '" + beanName +
"' via property '" + propertyName + "' to bean named '" + propertyName + "'");
}
} else {
if (logger.isTraceEnabled()) {
logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
"' by name: no matching bean found");
}
}
}
}
}
1. unsatisfiedNonSimpleProperties()
- 获取非简单属性，即引用类型属性
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
/**
* (bw - mbd) 引用类型
* <p>
* 1. bw有setter()
* 2. mbd的pvs不包含该java_fileName
* 3. 非基本类型
*/
protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {
// TreeSet：底层二叉树，对象元素进行排序
Set<String> result = new TreeSet<>();
// xml中bean的<property>
PropertyValues pvs = mbd.getPropertyValues();
// java类属性描述对象
PropertyDescriptor[] pds = bw.getPropertyDescriptors();
for (PropertyDescriptor pd : pds) {
if (pd.getWriteMethod() != null // pd有setter()
&& !isExcludedFromDependencyCheck(pd) // pd没有被排除在依赖项检查之外
&& !pvs.contains(pd.getName()) // pvs没有该pd的属性名
&& !BeanUtils.isSimpleProperty(pd.getPropertyType()) // pd不是基本类型
) {
// 引用类型集合
result.add(pd.getName());
}
}
return StringUtils.toStringArray(result);
}
}
2. registerDependentBean()
BF.dependentBeanMapBF.dependenciesForBeanMap
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
/**
* 存储 bean名到该bean名所要依赖的bean名 的Map
* Map between dependent bean names: bean name to Set of dependent bean names.
*/
private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);
/**
* 存储 bean名到依赖于该bean名的bean名 的Map
* Map between depending bean names: bean name to Set of bean names for the bean's dependencies.
*/
private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);
/**
* 注册beanName与dependentBeanNamed的依赖关系
*/
public void registerDependentBean(String beanName, String dependentBeanName) {
// beanName最终别名 || 全类名
String canonicalName = canonicalName(beanName);
// a -> b
synchronized (this.dependentBeanMap) {
Set<String> dependentBeans =
this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
// 已经存在则跳过
if (!dependentBeans.add(dependentBeanName)) {
return;
}
}
// b -> a
synchronized (this.dependenciesForBeanMap) {
Set<String> dependenciesForBean =
this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
dependenciesForBean.add(canonicalName);
}
}
}
3. autowireByType
T16_xml_autowire
- 核心方法：
resolveDependency()
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
/**
* 定义 "按类型自动装配" (按类型bean属性)行为的抽象方法
* <p>
* Abstract method defining "autowire by type" (bean properties by type) behavior.
* <p>This is like PicoContainer default, in which there must be exactly one bean
* of the property type in the bean factory. This makes bean factories simple to
* configure for small namespaces, but doesn't work as well as standard Spring
* behavior for bigger applications.
*
* @param beanName the name of the bean to autowire by type
* @param mbd the merged bean definition to update through autowiring
* @param bw the BeanWrapper from which we can obtain information about the bean
* @param pvs the PropertyValues to register wired objects with
*/
protected void autowireByType(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
// 1. BF自定义类型转换器
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
// 2. 获取引用类型属性，(bw - mbd) 引用类型
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
// maps, ooxx, ooxxAs, ooxxLs, ooxxStream, properties, sets
for (String propertyName : propertyNames) {
try {
// 3. 属性描述对象。包含`getter(), setter()`
PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
// Don't try autowiring by type for type Object: never makes sense,
// even if it technically is a unsatisfied, non-simple property.
if (Object.class != pd.getPropertyType()) {
// 4. setter()方法包装对象
MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
// Do not allow eager init for type matching in case of a prioritized post-processor.
// `eager = true`导致初始化lazy-init单例和由FactoryBeans（或带有"factory-bean"引用的工厂方法）创建的对象进行类型检查
boolean eager = !(bw.getWrappedInstance() instanceof PriorityOrdered);
// 5. MethodParameter进行包装
DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
// 6... DefaultListableBeanFactory 通过Type在BD_maps中找出beanName
Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
// 7. `private Map<String, Object> maps;` 比较特殊，会将容器中的键值对都注入进来。Map不要byType
if (autowiredArgument != null) {
pvs.add(propertyName, autowiredArgument);
}
// 8. 注册依赖关系
for (String autowiredBeanName : autowiredBeanNames) {
registerDependentBean(autowiredBeanName, beanName);
if (logger.isTraceEnabled()) {
logger.trace("Autowiring by type from bean name '" + beanName + "' via property '" +
propertyName + "' to bean named '" + autowiredBeanName + "'");
}
}
autowiredBeanNames.clear();
}
} catch (BeansException ex) {
throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
}
}
}
}
1. DependencyDescriptor
setter()=> executable- methodName
- parameterTypes
{
"declaringClass": "class com.listao.populateBean.AutowireBean",
"methodName": "setOoxx", // 2.
"parameterTypes": [
"class com.listao.Ooxx"
],
"parameterIndex": 0,
"required": false,
"eager": true,
"nestingLevel": 1,
"containingClass": "class com.listao.populateBean.AutowireBean",
"methodParameter": {
"executable": "public void com.listao.populateBean.AutowireBean.setOoxx(com.listao.Ooxx)", // 1. setter()
"parameterIndex": 0,
"parameter": "com.listao.Ooxx arg0",
"nestingLevel": 1,
"typeIndexesPerLevel": {
},
"containingClass": "class com.listao.populateBean.AutowireBean",
"parameterType": "class com.listao.Ooxx", // 3. descriptor.getDependencyType();
"genericParameterType": "class com.listao.Ooxx",
"parameterAnnotations": [
]
}
}
public class DependencyDescriptor extends InjectionPoint implements Serializable {
/**
* beanName => java_bean
* <p>
* Resolve the specified bean name, as a candidate result of the matching
* algorithm for this dependency, to a bean instance from the given factory.
* <p>The default implementation calls {@link BeanFactory#getBean(String)}.
* Subclasses may provide additional arguments or other customizations.
*
* @param beanName the bean name, as a candidate result for this dependency
* @param requiredType the expected type of the bean (as an assertion)
* @param beanFactory the associated factory
* @return the bean instance (never {@code null})
* @throws BeansException if the bean could not be obtained
* @see BeanFactory#getBean(String)
* @since 4.3.2
*/
public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)
throws BeansException {
// 1.
return beanFactory.getBean(beanName);
}
}
2. resolveDependency()
- 获取descriptor的依赖类型
- 复杂引用类型
[Stream, Array, Collection, Map]，进行解析 - 简单引用类型。valueType获取bean
- @Value
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) {
descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
// 1. Optional
if (Optional.class == descriptor.getDependencyType()) {
return createOptionalDependency(descriptor, requestingBeanName);
}
// 2. ObjectFactory || ObjectProvider
else if (ObjectFactory.class == descriptor.getDependencyType() ||
ObjectProvider.class == descriptor.getDependencyType()) {
return new DependencyObjectProvider(descriptor, requestingBeanName);
}
// 3. javax.inject.Provider
else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
}
// 4. genericType
else {
// 延迟加载代理对象<lazy-init>
Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, requestingBeanName);
if (result == null) {
// 4.1. 核心方法
result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
}
return result;
}
}
/**
* 1. 获取descriptor依赖类型
* 2. 复杂引用类型 [Stream, Array, Collection, Map]，进行解析
* 3. 简单引用类型。valueType获取bean
*/
@Nullable
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) {
// AOP相关。设置新切入点，获取旧切入点
InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
try {
// 考虑一些预先情况，默认null
Object shortcut = descriptor.resolveShortcut(this);
if (shortcut != null) {
return shortcut;
}
// 1. DependencyType
Class<?> type = descriptor.getDependencyType();
// 2.1... QualifierAnnotationAutowireCandidateResolver => `@Value("ooxx")`表达式解析
Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
if (value != null) {
if (value instanceof String) {
// 2.2.. `@Value("${p1.name}")`表达式，进行解析
String strVal = resolveEmbeddedValue((String) value);
BeanDefinition bd = (beanName != null && containsBean(beanName) ?
getMergedBeanDefinition(beanName) : null);
value = evaluateBeanDefinitionString(strVal, bd);
}
TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
try {
// 将value转换为type的实例对象
return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());
} catch (UnsupportedOperationException ex) {
// A custom TypeConverter which does not support TypeDescriptor resolution...
return (descriptor.getField() != null ?
converter.convertIfNecessary(value, type, descriptor.getField()) :
converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
}
}
// 3. 复杂引用类型[Stream, Array, Collection, Map]，进行解析
Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
if (multipleBeans != null) {
return multipleBeans;
}
// 4. 简单引用类型。valueType获取bean
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
if (matchingBeans.isEmpty()) {
if (isRequired(descriptor)) {
raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
}
return null;
}
String autowiredBeanName;
Object instanceCandidate;
// 5.1. 匹配Bean不止一个
if (matchingBeans.size() > 1) {
// 确定autowire最佳候选beanName
autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
if (autowiredBeanName == null) {
if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
} else {
// In case of an optional Collection/Map, silently ignore a non-unique case:
// possibly it was meant to be an empty collection of multiple regular beans
// (before 4.3 in particular when we didn't even look for collection beans).
return null;
}
}
instanceCandidate = matchingBeans.get(autowiredBeanName);
}
// 5.2. 匹配Bean唯一
else {
// We have exactly one match.
Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
autowiredBeanName = entry.getKey();
instanceCandidate = entry.getValue();
}
if (autowiredBeanNames != null) {
autowiredBeanNames.add(autowiredBeanName);
}
if (instanceCandidate instanceof Class) {
// beanFactory.getBean(beanName);
instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
}
// 6.
Object result = instanceCandidate;
if (result instanceof NullBean) {
// descriptor必需
if (isRequired(descriptor)) {
raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
}
result = null;
}
if (!ClassUtils.isAssignableValue(type, result)) {
throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
}
return result;
} finally {
// 设置上一个切入点对象
ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
}
}
}
1. findAutowireCandidates()
BeanFactoryUtils#beanNamesForTypeIncludingAncestors()根据type从BF中获取beanNames
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
protected Map<String, Object> findAutowireCandidates(
@Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {
// 1. 获取BF、parent_BF中(beanType == requiredType)的beanName
String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
this, requiredType, true, descriptor.isEager());
Map<String, Object> result = new LinkedHashMap<>(candidateNames.length);
// 2. [ApplicationContext, BeanFactory, ResourceLoader, ApplicationEventPublisher]
for (Map.Entry<Class<?>, Object> classObjectEntry : this.resolvableDependencies.entrySet()) {
Class<?> autowiringType = classObjectEntry.getKey();
if (autowiringType.isAssignableFrom(requiredType)) {
Object autowiringValue = classObjectEntry.getValue();
autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
if (requiredType.isInstance(autowiringValue)) {
// (obj全类名 + '@' + obj.hashCode十六进制字符串)。obj为null，返回空字符串
result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
break;
}
}
}
// 3. 常规匹配候选
for (String candidate : candidateNames) {
// 3.1. 不是selfRef && candidate默认可自动注入（略）
if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {
// 3.2.. BF.getBean(beanName);
addCandidateEntry(result, candidate, descriptor, requiredType);
}
}
// 回退模式尽可能的匹配到候选，一般情况下不会出现回退情况，除非代码非常糟糕
if (result.isEmpty()) {
// 数组/集合类型
boolean multiple = indicatesMultipleBeans(requiredType);
// Consider fallback matches if the first pass failed to find anything...
// 在允许回退的情况下，候选Bean具有无法解析的泛型 || 候选Bean的Class对象是Properties类对象
DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();
for (String candidate : candidateNames) {
// (type不是数组/集合类型 || desciptor有@Qualifier注解或qualifier标准修饰)
if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, fallbackDescriptor) &&
(!multiple || getAutowireCandidateResolver().hasQualifier(descriptor))) {
addCandidateEntry(result, candidate, descriptor, requiredType);
}
}
if (result.isEmpty() && !multiple) {
// Consider self references as a final pass...
// but in the case of a dependency collection, not the very same bean itself.
for (String candidate : candidateNames) {
if (isSelfReference(beanName, candidate) &&
(!(descriptor instanceof MultiElementDescriptor) || !beanName.equals(candidate)) &&
isAutowireCandidate(candidate, fallbackDescriptor)) {
addCandidateEntry(result, candidate, descriptor, requiredType);
}
}
}
}
return result;
}
/**
* 在候选映射中添加一个条目：一个bean实例(如果可用)或仅一个已解析的类型，以防止在选择主要候选对象之前太早初始化bean
* <p>
* Add an entry to the candidate map: a bean instance if available or just the resolved
* type, preventing early bean initialization ahead of primary candidate selection.
*/
private void addCandidateEntry(Map<String, Object> candidates, String candidateName,
DependencyDescriptor descriptor, Class<?> requiredType) {
// MultiElementDescriptor: 具有嵌套元素的多元素声明的依赖描述符，表示集合/数组依赖
if (descriptor instanceof MultiElementDescriptor) {
Object beanInstance = descriptor.resolveCandidate(candidateName, requiredType, this);
if (!(beanInstance instanceof NullBean)) {
candidates.put(candidateName, beanInstance);
}
}
// 一级缓存
// StreamDependencyDescriptor: 用于访问多个元素的流依赖项描述符标记，即属性依赖是stream类型
else if (containsSingleton(candidateName) || (descriptor instanceof StreamDependencyDescriptor &&
((StreamDependencyDescriptor) descriptor).isOrdered())) {
// 1... DependencyDescriptor => beanFactory.getBean(beanName);
Object beanInstance = descriptor.resolveCandidate(candidateName, requiredType, this);
candidates.put(candidateName, (beanInstance instanceof NullBean ? null : beanInstance));
}
// 未一级缓存
else {
candidates.put(candidateName, getType(candidateName));
}
}
}
private Map<String, Object> maps;会将BD_map值都匹配上
DefaultListableBeanFactory#findAutowireCandidates()
2. resolveMultipleBeans()
StreamArrayList, SetMap
内层调用 findAutowireCandidates()
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
private Object resolveMultipleBeans(DependencyDescriptor descriptor, @Nullable String beanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) {
// DependencyType
Class<?> type = descriptor.getDependencyType();
// 1. Stream
if (descriptor instanceof StreamDependencyDescriptor) {
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
if (autowiredBeanNames != null) {
autowiredBeanNames.addAll(matchingBeans.keySet());
}
Stream<Object> stream = matchingBeans.keySet().stream()
.map(name -> descriptor.resolveCandidate(name, type, this)) // 单一类型调用
.filter(bean -> !(bean instanceof NullBean)); // bean对象不为NullBean
if (((StreamDependencyDescriptor) descriptor).isOrdered()) {
stream = stream.sorted(adaptOrderComparator(matchingBeans));
}
// beanName对应Bean的stream
return stream;
}
// 2. Array
else if (type.isArray()) {
Class<?> componentType = type.getComponentType();
ResolvableType resolvableType = descriptor.getResolvableType();
Class<?> resolvedArrayType = resolvableType.resolve(type);
if (resolvedArrayType != type) {
componentType = resolvableType.getComponentType().resolve();
}
if (componentType == null) {
return null;
}
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType, // 单一类型调用
new MultiElementDescriptor(descriptor));
if (matchingBeans.isEmpty()) {
return null;
}
if (autowiredBeanNames != null) {
autowiredBeanNames.addAll(matchingBeans.keySet());
}
TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
Object result = converter.convertIfNecessary(matchingBeans.values(), resolvedArrayType);
if (result instanceof Object[]) {
// 构建依赖比较器
Comparator<Object> comparator = adaptDependencyComparator(matchingBeans);
if (comparator != null) {
// 使用comparator对bean排序
Arrays.sort((Object[]) result, comparator);
}
}
return result;
}
// 3. List, Set
else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {
// 泛型Class
Class<?> elementType = descriptor.getResolvableType().asCollection().resolveGeneric();
if (elementType == null) {
return null;
}
// (valueType, bean)
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, elementType, // 单一类型调用
new MultiElementDescriptor(descriptor));
if (matchingBeans.isEmpty()) {
return null;
}
if (autowiredBeanNames != null) {
autowiredBeanNames.addAll(matchingBeans.keySet());
}
TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
Object result = converter.convertIfNecessary(matchingBeans.values(), type);
if (result instanceof List) {
if (((List<?>) result).size() > 1) {
// 构建依赖比较器
Comparator<Object> comparator = adaptDependencyComparator(matchingBeans);
if (comparator != null) {
// 使用comparator对bean排序
((List<?>) result).sort(comparator);
}
}
}
return result;
}
// 4. Map
else if (Map.class == type) {
ResolvableType mapType = descriptor.getResolvableType().asMap();
Class<?> keyType = mapType.resolveGeneric(0);
if (String.class != keyType) {
return null;
}
Class<?> valueType = mapType.resolveGeneric(1);
if (valueType == null) {
return null;
}
// valueType匹配的bean对象
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, valueType, // 单一类型调用
new MultiElementDescriptor(descriptor));
if (matchingBeans.isEmpty()) {
return null;
}
// 注册依赖关系集合
if (autowiredBeanNames != null) {
autowiredBeanNames.addAll(matchingBeans.keySet());
}
return matchingBeans;
} else {
return null;
}
}
}
3. @Value
class T6_Value {
public static void main(String[] args) {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("x6_3_Value.xml");
System.out.println("------------------- ac.over -------------------");
MyPropertySources myPropertySources = ac.getBean("myPropertySources", MyPropertySources.class);
System.out.println("myPropertySources = " + myPropertySources);
ac.close();
}
}
<bean id="configClassPP" class="org.springframework.context.annotation.ConfigurationClassPostProcessor"/>
<bean id="myPropertySources" class="com.listao.annotation.configClassParser.MyPropertySources"/>
<bean id="aabpp" class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>
<bean class="com.listao.postProcessor.bfpp.MyBFPP"/>
public class MyBFPP implements BeanFactoryPostProcessor, PriorityOrdered {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
System.out.println("===>>> MyBFPP.postProcessBeanFactory()");
// 1. @Value解析 => QualifierAnnotationAutowireCandidateResolver
DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory)beanFactory;
defaultListableBeanFactory.setAutowireCandidateResolver(new QualifierAnnotationAutowireCandidateResolver());
}
@Override
public int getOrder() {
return 0;
}
}
/**
* 1. 获取descriptor的依赖类型
* 2. 复杂引用类型[Stream, Array, Collection, Map]，进行解析
* 3. 简单引用类型。valueType获取bean
*/
@Nullable
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
// AOP相关。设置新切入点，获取旧切入点
InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
try {
// 考虑一些预先情况，默认null
Object shortcut = descriptor.resolveShortcut(this);
if (shortcut != null) {
return shortcut;
}
// DependencyType
Class<?> type = descriptor.getDependencyType();
// 1... QualifierAnnotationAutowireCandidateResolver
Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
if (value != null) {
if (value instanceof String) {
// 2. `@Value("${p1.name}")` 表达式，进行解析
String strVal = resolveEmbeddedValue((String) value);
BeanDefinition bd = (beanName != null && containsBean(beanName) ?
getMergedBeanDefinition(beanName) : null);
value = evaluateBeanDefinitionString(strVal, bd);
}
TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
try {
// 将value转换为type的实例对象
return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());
} catch (UnsupportedOperationException ex) {
// A custom TypeConverter which does not support TypeDescriptor resolution...
return (descriptor.getField() != null ?
converter.convertIfNecessary(value, type, descriptor.getField()) :
converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
}
}
1. QualifierAnnoAutoCddateRsv
public class QualifierAnnotationAutowireCandidateResolver extends GenericTypeAwareAutowireCandidateResolver {
// 1.
private Class<? extends Annotation> valueAnnotationType = Value.class;
/**
* Determine whether the given dependency declares a value annotation.
* @see Value
*/
@Override
@Nullable
public Object getSuggestedValue(DependencyDescriptor descriptor) {
// 2..
Object value = findValue(descriptor.getAnnotations());
if (value == null) {
MethodParameter methodParam = descriptor.getMethodParameter();
if (methodParam != null) {
value = findValue(methodParam.getMethodAnnotations());
}
}
return value;
}
/**
* Determine a suggested value from any of the given candidate annotations.
*/
@Nullable
protected Object findValue(Annotation[] annotationsToSearch) {
if (annotationsToSearch.length > 0) { // qualifier annotations have to be local
AnnotationAttributes attr = AnnotatedElementUtils.getMergedAnnotationAttributes(
AnnotatedElementUtils.forAnnotations(annotationsToSearch), this.valueAnnotationType); // Value.class
if (attr != null) {
// 3..
return extractValue(attr);
}
}
return null;
}
/**
* Extract the value attribute from the given annotation.
* @since 4.3
*/
protected Object extractValue(AnnotationAttributes attr) {
// 4.
Object value = attr.get(AnnotationUtils.VALUE);
if (value == null) {
throw new IllegalStateException("Value annotation must have a value attribute");
}
return value;
}
}
2. EmbeddedValueResolver
- 2. EmbeddedValueResolver
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
/**
* 字符串解析器适用于注解属性值
* <p>
* String resolvers to apply e.g. to annotation attribute values.
*/
private final List<StringValueResolver> embeddedValueResolvers = new CopyOnWriteArrayList<>();
/**
* 解析嵌套的值(如果value是表达式会解析出该表达式的值)
*/
@Override
@Nullable
public String resolveEmbeddedValue(@Nullable String value) {
// 如果value为null，返回null
if (value == null) {
return null;
}
// 定义返回结果，默认引用value
String result = value;
// SpringBoot默认存放一个PropertySourcesPlaceholderConfigurer，该类注意用于针对当前
// Spring Environment 及其PropertySource解析bean定义属性值和@Value注释中的${...}占位符
// 遍历该工厂的所有字符串解析器
for (StringValueResolver resolver : this.embeddedValueResolvers) {
// 99. 解析result，将解析后的值重新赋值给result
result = resolver.resolveStringValue(result);
// 如果result为null,结束该循环，并返回null
if (result == null) {
return null;
}
}
// 将解析后的结果返回出去
return result;
}
}
4. postProcessProperties(BPP)
class T16_Ctl_Svc {
public static void main(String[] args) {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("x17_3_AnnoDI.xml");
System.out.println("------------------- ac.over -------------------");
OoxxCtl ooxxCtl = ac.getBean("ooxxCtl", OoxxCtl.class);
System.out.println("ooxxCtl = " + ooxxCtl);
ac.close();
}
}
<!--
1. internalConfigurationAnnotationProcessor -> ConfigurationClassPostProcessor
2. internalAutowiredAnnotationProcessor -> AutowiredAnnotationBeanPostProcessor
3. internalCommonAnnotationProcessor -> CommonAnnotationBeanPostProcessor
4. internalEventListenerProcessor -> EventListenerMethodProcessor
5. internalEventListenerFactory -> DefaultEventListenerFactory
-->
<!--<context:component-scan base-package="com.listao.populateBean.annotation"/>-->
<bean id="aabpp" class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>
<bean id="ooxxCtl" class="com.listao.populateBean.annotation.OoxxCtl"/>
<bean id="ooxxSvc" class="com.listao.populateBean.annotation.OoxxSvc"/>
<bean id="ooxxDao" class="com.listao.populateBean.annotation.OoxxDao"/>
InstantiationAwareBeanPostProcessor#postProcessProperties()
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 1. CommonAnnotationBeanPostProcessor => @Resource
// 2. AutowiredAnnotationBeanPostProcessor => @Autowired
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
// 3. @Deprecated，取而代之的是 `postProcessProperties()`
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
}
AutowiredAnnotationBeanPostProcessor处理@AutowiredCommonAnnotationBeanPostProcessor处理@Resources
1. CommonAnnotationBPP
InjectionMetadata#inject() => InjectionMetadata$InjectedElement#inject()
public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
// 1. InjectionMetadata
InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass(), pvs);
try {
// 2. InjectionMetadata
metadata.inject(bean, beanName, pvs);
} catch (Throwable ex) {
throw new BeanCreationException(beanName, "Injection of resource dependencies failed", ex);
}
return pvs;
}
}
2. AutowiredAnnotationBPP
InjectionMetadata#inject() => AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement#inject()
InjectionMetadata#inject() => AutowiredAnnotationBeanPostProcessor$AutowiredMethodElement#inject()
public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter
implements MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware {
/**
* 注解@Autowired, @Inject, @Value解析并注入
*/
@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
// 1. InjectionMetadata
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
try {
// 2... InjectionMetadata => @Autowired属性注入
metadata.inject(bean, beanName, pvs);
} catch (BeanCreationException ex) {
throw ex;
} catch (Throwable ex) {
throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
}
return pvs;
}
}
5. applyPropertyValues()
BeanDefinitionValueResolver#resolveValueIfNecessary()BeanWrapper#convertIfNecessary()
class T16_ApplyPropertyValues {
public static void main(String[] args) {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("x17_4_applyPropertyValues.xml");
System.out.println("------------------- ac.over -------------------");
AutowireBean ab1 = ac.getBean("autowireBean1", AutowireBean.class);
System.out.println(JSONUtil.toJsonPrettyStr(ab1));
System.out.println("---------------------------------------------------");
AutowireBean ab2 = ac.getBean("autowireBean2", AutowireBean.class);
System.out.println(JSONUtil.toJsonPrettyStr(ab2));
ac.close();
}
}
<!-- 复杂类型赋值，<property>标签进行 -->
<bean id="autowireBean1" class="com.listao.populateBean.AutowireBean">
<property name="id" value="101"/>
<!-- SpEL -->
<property name="mobile" value="#{ooxx1.id}"/>
<property name="name" value="~_~"/>
<property name="age">
<!-- 赋空值 -->
<null/>
</property>
<property name="gender">
<!--
注入bean的id，并对id进行验证
等同于`<value>ooxx1</value>`
-->
<idref bean="ooxx1"/>
</property>
<!-- ref引用外部bean -->
<property name="ooxx" ref="ooxx1"/>
<!-- String[] -->
<property name="hobbies">
<array>
<value>book</value>
<value>movie</value>
<value>game</value>
</array>
</property>
<!-- List<Ooxx> -->
<property name="ooxxLs">
<list>
<!-- 内部bean -->
<bean id="ooxx2" class="com.listao.Ooxx">
<property name="id" value="2"/>
<property name="name" value="ooxx2"/>
</bean>
<!-- 外部bean -->
<ref bean="ooxx1"/>
</list>
</property>
<!-- Set<Integer> -->
<property name="sets">
<set>
<value>111</value>
<value>222</value>
<value>222</value>
</set>
</property>
<!-- Map<String, Object> -->
<property name="maps" ref="mapUtil"/>
<!-- Properties -->
<property name="properties">
<props>
<prop key="aaa">aaa</prop>
<prop key="bbb">222</prop>
</props>
</property>
</bean>
<bean id="ooxx1" class="com.listao.Ooxx">
<property name="id" value="1"/>
<property name="name" value="ooxx1"/>
</bean>
<!-- util名称空间，集合类型的bean -->
<util:map id="mapUtil">
<entry key="key1" value="value1"/>
<entry key="key2" value-ref="ooxx1"/>
<entry key="key3">
<bean class="com.listao.Ooxx">
<property name="id" value="3"/>
<property name="name" value="ooxx3"/>
</bean>
</entry>
</util:map>
<!-- 级联属性 -->
<bean id="autowireBean2" class="com.listao.populateBean.AutowireBean">
<property name="ooxx" ref="ooxx1"/>
<property name="ooxx.name" value="ooxx.name"/>
</bean>
public class AutowireBean {
private Integer id;
private String mobile;
private String name = "list";
private Integer age;
private String gender;
private String[] hobbies;
// findAutowireCandidates()
private Ooxx[] ooxxAs;
private Properties properties;
// resolveMultipleBeans()
private Ooxx ooxx;
private List<Ooxx> ooxxLs;
private Set<Integer> sets;
private Map<String, Object> maps;
}
pvs => <property></property>
if (pvs != null) {
// 4. `<property name="id" value="1"/>`属性值。使用深拷贝，不会永久地修改这个属性
applyPropertyValues(beanName, mbd, bw, pvs);
}
- 自定义类型转换器
- 解析BD_value
- 目标type转换
- deepCopy构造新的
MutablePropertyValues => bw
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
if (pvs.isEmpty()) {
return;
}
// 安全管理器
if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
}
// PropertyValues接口的默认实现
MutablePropertyValues mpvs = null;
List<PropertyValue> original;
if (pvs instanceof MutablePropertyValues) {
mpvs = (MutablePropertyValues) pvs;
// 已经处理，直接赋值
if (mpvs.isConverted()) {
// Shortcut: use the pre-converted values as-is.
try {
bw.setPropertyValues(mpvs);
return;
} catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
original = mpvs.getPropertyValueList();
} else {
// 1.
original = Arrays.asList(pvs.getPropertyValues());
}
// 2. 自定义类型转换器
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
// -----------------------------------------------------------------------------------------------
// xml_BD对象<property>值 => java_bean属性值
// -----------------------------------------------------------------------------------------------
// 3.
BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
// Create a deep copy, resolving any references for values.
List<PropertyValue> deepCopy = new ArrayList<>(original.size());
boolean resolveNecessary = false;
for (PropertyValue pv : original) {
if (pv.isConverted()) {
deepCopy.add(pv);
} else {
// 4.
String propertyName = pv.getName();
Object originalValue = pv.getValue();
// AutowiredPropertyMarker.INSTANCE：自动生成标记的规范实例
if (originalValue == AutowiredPropertyMarker.INSTANCE) {
// 5. setter()
Method writeMethod = bw.getPropertyDescriptor(propertyName).getWriteMethod();
if (writeMethod == null) {
throw new IllegalArgumentException("Autowire marker for property without write method: " + pv);
}
originalValue = new DependencyDescriptor(new MethodParameter(writeMethod, 0), true);
}
// 6. BeanDefinitionValueResolver解析BD_value
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
Object convertedValue = resolvedValue;
// setter() && 不是索引属性、嵌套属性（propertyName中有'.' || '['）
boolean convertible = bw.isWritableProperty(propertyName) &&
!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
if (convertible) {
// 7. 目标type转换
convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
}
// Possibly store converted value in merged bean definition,
// in order to avoid re-conversion for every created bean instance.
if (resolvedValue == originalValue) {
if (convertible) {
pv.setConvertedValue(convertedValue);
}
deepCopy.add(pv);
}
// String && 不是表达式 && 集合、数组
else if (convertible && originalValue instanceof TypedStringValue &&
!((TypedStringValue) originalValue).isDynamic() && // 不是表达式
!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) // 集合、数组
{
pv.setConvertedValue(convertedValue);
deepCopy.add(pv);
}
// 8. 标记仍需要解析
else {
resolveNecessary = true;
deepCopy.add(new PropertyValue(pv, convertedValue));
}
}
}
if (mpvs != null && !resolveNecessary) {
// 已经转换标记
mpvs.setConverted();
}
// Set our (possibly massaged) deep copy.
try {
// 9. deepCopy构造新的MutablePropertyValues => bw
bw.setPropertyValues(new MutablePropertyValues(deepCopy));
} catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
}
1. BeanDefinitionValueResolver
- 解析
<property>内层嵌套 => Java_bean
1. <property name="ooxx" ref="ooxx1"/>
2. <idref bean="ooxx1"/>
3. BeanDefinitionHolder包含beanName
4. 内部匿名bean，BD不包含beanName
5. DependencyDescriptor
6. <array> => Object[]
7. <list> => List<Object>
8. <set> => Set<Object>
9. <map> => Map<Object, Object>
10. <props>
11. <null/>
12. NullBean
13. String/String[]类型尝试表达式解析
1. resolveValueIfNecessary()
BeanDefinitionValueResolver#resolveValueIfNecessary()
class BeanDefinitionValueResolver {
private final AbstractAutowireCapableBeanFactory beanFactory;
// 要使用的bean名称
private final String beanName;
// beanName对应的BeanDefinition
private final BeanDefinition beanDefinition;
// 用于解析TypeStringValues的TypeConverter
private final TypeConverter typeConverter;
/**
* <property name="name"></property>处理
* <p>
* Given a PropertyValue, return a value, resolving any references to other
* beans in the factory if necessary. The value could be:
* <li>A BeanDefinition, which leads to the creation of a corresponding
* new bean instance. Singleton flags and names of such "inner beans"
* are always ignored: Inner beans are anonymous prototypes.
* <li>A RuntimeBeanReference, which must be resolved.
* <li>A ManagedList. This is a special collection that may contain
* RuntimeBeanReferences or Collections that will need to be resolved.
* <li>A ManagedSet. May also contain RuntimeBeanReferences or
* Collections that will need to be resolved.
* <li>A ManagedMap. In this case the value may be a RuntimeBeanReference
* or Collection that will need to be resolved.
* <li>An ordinary object or {@code null}, in which case it's left alone.
*
* @param argName the name of the argument that the value is defined for
* @param value the value object to resolve
* @return the resolved object
*/
@Nullable
public Object resolveValueIfNecessary(Object argName, @Nullable Object value) {
// 1. <property name="ooxx" ref="ooxx1"/>
if (value instanceof RuntimeBeanReference) {
RuntimeBeanReference ref = (RuntimeBeanReference) value;
// 解析ref_Bean
return resolveReference(argName, ref);
}
// 2. <idref bean="ooxx1"/>
else if (value instanceof RuntimeBeanNameReference) {
// bean.id
String refName = ((RuntimeBeanNameReference) value).getBeanName();
refName = String.valueOf(doEvaluate(refName));
// 校验BF是否包含该bean.id
if (!this.beanFactory.containsBean(refName)) {
throw new BeanDefinitionStoreException(
"Invalid bean name '" + refName + "' in bean reference for " + argName);
}
return refName;
}
// 3.. BeanDefinitionHolder包含beanName
else if (value instanceof BeanDefinitionHolder) {
// Resolve BeanDefinitionHolder: contains BeanDefinition with name and aliases.
BeanDefinitionHolder bdHolder = (BeanDefinitionHolder) value;
return resolveInnerBean(argName, bdHolder.getBeanName(), bdHolder.getBeanDefinition());
}
// 4.. 内部匿名bean，BD不包含beanName
else if (value instanceof BeanDefinition) {
// Resolve plain BeanDefinition, without contained name: use dummy name.
BeanDefinition bd = (BeanDefinition) value;
// innerBeanName = "(inner bean)#" + bd十六进制哈希码
String innerBeanName = "(inner bean)" + BeanFactoryUtils.GENERATED_BEAN_NAME_SEPARATOR +
ObjectUtils.getIdentityHexString(bd);
return resolveInnerBean(argName, innerBeanName, bd);
}
// 5. DependencyDescriptor
else if (value instanceof DependencyDescriptor) {
Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
// 根据DependencyDescriptor依赖类型解析出匹配autowiredBeanNames
Object result = this.beanFactory.resolveDependency(
(DependencyDescriptor) value, this.beanName, autowiredBeanNames, this.typeConverter);
for (String autowiredBeanName : autowiredBeanNames) {
if (this.beanFactory.containsBean(autowiredBeanName)) {
// 注册依赖关系
this.beanFactory.registerDependentBean(autowiredBeanName, this.beanName);
}
}
return result;
}
// 6. <array>
else if (value instanceof ManagedArray) {
// May need to resolve contained runtime references.
ManagedArray array = (ManagedArray) value;
// 获取array已解析元素类型
Class<?> elementType = array.resolvedElementType;
if (elementType == null) {
String elementTypeName = array.getElementTypeName();
if (StringUtils.hasText(elementTypeName)) {
try {
// elementTypeName => Class
elementType = ClassUtils.forName(elementTypeName, this.beanFactory.getBeanClassLoader());
array.resolvedElementType = elementType;
} catch (Throwable ex) {
// Improve the message by showing the context.
throw new BeanCreationException(
this.beanDefinition.getResourceDescription(), this.beanName,
"Error resolving array type for " + argName, ex);
}
} else {
// 默认Object类型
elementType = Object.class;
}
}
// 数组元素，遍历解析
return resolveManagedArray(argName, (List<?>) value, elementType);
}
// 7. <list>
else if (value instanceof ManagedList) {
// May need to resolve contained runtime references.
return resolveManagedList(argName, (List<?>) value);
}
// 8. <set>
else if (value instanceof ManagedSet) {
// May need to resolve contained runtime references.
return resolveManagedSet(argName, (Set<?>) value);
}
// 9. <map>
else if (value instanceof ManagedMap) {
// May need to resolve contained runtime references.
return resolveManagedMap(argName, (Map<?, ?>) value);
}
// 10. <props>
else if (value instanceof ManagedProperties) {
Properties original = (Properties) value;
Properties copy = new Properties();
/*
* <props>
* <prop key="aaa">aaa</prop>
* <prop key="bbb">222</prop>
* </props>
*/
original.forEach((propKey, propValue) -> {
if (propKey instanceof TypedStringValue) {
propKey = evaluate((TypedStringValue) propKey);
}
if (propValue instanceof TypedStringValue) {
propValue = evaluate((TypedStringValue) propValue);
}
if (propKey == null || propValue == null) {
throw new BeanCreationException(
this.beanDefinition.getResourceDescription(), this.beanName,
"Error converting Properties key/value pair for " + argName + ": resolved to null");
}
copy.put(propKey, propValue);
});
return copy;
}
// 11. TypedStringValue <null/>
else if (value instanceof TypedStringValue) {
// Convert value to target type here.
TypedStringValue typedStringValue = (TypedStringValue) value;
// 11.1. 表达式解析SpEL
Object valueObject = evaluate(typedStringValue);
try {
// TypedStringValue提前进行TargetType解析。一般为null
Class<?> resolvedTargetType = resolveTargetType(typedStringValue);
if (resolvedTargetType != null) {
return this.typeConverter.convertIfNecessary(valueObject, resolvedTargetType);
} else {
return valueObject;
}
} catch (Throwable ex) {
// Improve the message by showing the context.
throw new BeanCreationException(
this.beanDefinition.getResourceDescription(), this.beanName,
"Error converting typed String value for " + argName, ex);
}
}
// 12. NullBean
else if (value instanceof NullBean) {
// 直接返回null
return null;
}
// 13. String/String[]类型尝试表达式解析
else {
return evaluate(value);
}
}
/**
* Resolve an inner bean definition.
* @param argName the name of the argument that the inner bean is defined for
* @param innerBeanName the name of the inner bean
* @param innerBd the bean definition for the inner bean
* @return the resolved inner bean instance
*/
@Nullable
private Object resolveInnerBean(Object argName, String innerBeanName, BeanDefinition innerBd) {
RootBeanDefinition mbd = null;
try {
mbd = this.beanFactory.getMergedBeanDefinition(innerBeanName, innerBd, this.beanDefinition);
// Check given bean name whether it is unique. If not already unique,
// add counter - increasing the counter until the name is unique.
String actualInnerBeanName = innerBeanName;
if (mbd.isSingleton()) {
actualInnerBeanName = adaptInnerBeanName(innerBeanName);
}
this.beanFactory.registerContainedBean(actualInnerBeanName, this.beanName);
// Guarantee initialization of beans that the inner bean depends on.
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dependsOnBean : dependsOn) {
this.beanFactory.registerDependentBean(dependsOnBean, actualInnerBeanName);
this.beanFactory.getBean(dependsOnBean);
}
}
// Actually create the inner bean instance now...
Object innerBean = this.beanFactory.createBean(actualInnerBeanName, mbd, null);
if (innerBean instanceof FactoryBean) {
boolean synthetic = mbd.isSynthetic();
innerBean = this.beanFactory.getObjectFromFactoryBean(
(FactoryBean<?>) innerBean, actualInnerBeanName, !synthetic);
}
if (innerBean instanceof NullBean) {
innerBean = null;
}
return innerBean;
}
catch (BeansException ex) {
throw new BeanCreationException(
this.beanDefinition.getResourceDescription(), this.beanName,
"Cannot create inner bean '" + innerBeanName + "' " +
(mbd != null && mbd.getBeanClassName() != null ? "of type [" + mbd.getBeanClassName() + "] " : "") +
"while setting " + argName, ex);
}
}
}
- 集合拆解、封装
@Nullable
private Object resolveReference(Object argName, RuntimeBeanReference ref) {
try {
Object bean;
Class<?> beanType = ref.getBeanType();
// 来自parent_BF
if (ref.isToParent()) {
BeanFactory parent = this.beanFactory.getParentBeanFactory();
if (parent == null) {
throw new BeanCreationException(
this.beanDefinition.getResourceDescription(), this.beanName,
"Cannot resolve reference to bean " + ref +
" in parent factory: no parent factory available");
}
if (beanType != null) {
bean = parent.getBean(beanType);
} else {
bean = parent.getBean(String.valueOf(doEvaluate(ref.getBeanName())));
}
} else {
String resolvedName;
if (beanType != null) {
// beanType解析出bean
NamedBeanHolder<?> namedBean = this.beanFactory.resolveNamedBean(beanType);
bean = namedBean.getBeanInstance();
resolvedName = namedBean.getBeanName();
} else {
// 99. <property name="ooxx" ref="ooxx1"/>
resolvedName = String.valueOf(doEvaluate(ref.getBeanName()));
bean = this.beanFactory.getBean(resolvedName);
}
// 注册依赖关系
this.beanFactory.registerDependentBean(resolvedName, this.beanName);
}
if (bean instanceof NullBean) {
bean = null;
}
return bean;
} catch (BeansException ex) {
throw new BeanCreationException(
this.beanDefinition.getResourceDescription(), this.beanName,
"Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " + argName, ex);
}
}
// -------------------------------------------------------------------------------------------
/**
* 解析ManagedArray对象，以得到解析后的数组对象
* For each element in the managed array, resolve reference if necessary.
*/
private Object resolveManagedArray(Object argName, List<?> ml, Class<?> elementType) {
Object resolved = Array.newInstance(elementType, ml.size());
for (int i = 0; i < ml.size(); i++) {
// 将数组中的元素遍历解析
Array.set(resolved, i, resolveValueIfNecessary(new KeyedArgName(argName, i), ml.get(i)));
}
return resolved;
}
// -------------------------------------------------------------------------------------------
/**
* 解析ManagedList对象，以得到解析后的List对象
* For each element in the managed list, resolve reference if necessary.
*/
private List<?> resolveManagedList(Object argName, List<?> ml) {
List<Object> resolved = new ArrayList<>(ml.size());
for (int i = 0; i < ml.size(); i++) {
// 遍历解析List元素
resolved.add(resolveValueIfNecessary(new KeyedArgName(argName, i), ml.get(i)));
}
return resolved;
}
// -------------------------------------------------------------------------------------------
/**
* 解析ManagedSet对象，以得到解析后的Set对象
* For each element in the managed set, resolve reference if necessary.
*/
private Set<?> resolveManagedSet(Object argName, Set<?> ms) {
// 定义一个用于存放解析后的实例对象的LinkedHashSet，初始容量为ml大小
Set<Object> resolved = new LinkedHashSet<>(ms.size());
// 定义一个遍历时的偏移量i
int i = 0;
//遍历ms，元素为m
for (Object m : ms) {
// 解析出该m的实例对象然后添加到resolved中
resolved.add(resolveValueIfNecessary(new KeyedArgName(argName, i), m));
// 偏移量+1
i++;
}
// 返回resolved
return resolved;
}
// -------------------------------------------------------------------------------------------
/**
* 解析ManagedMap对象，以得到解析后的Map对象
* For each element in the managed map, resolve reference if necessary.
*/
private Map<?, ?> resolveManagedMap(Object argName, Map<?, ?> mm) {
// 定义用于存储解析后的key实例对象和value实例对象的LinkedHashMap,长度为mm的大小
Map<Object, Object> resolved = new LinkedHashMap<>(mm.size());
// 遍历mm
mm.forEach((key, value) -> {
// 解析mm的key的实例对象
Object resolvedKey = resolveValueIfNecessary(argName, key);
// 解析mm的value的实例对象
Object resolvedValue = resolveValueIfNecessary(new KeyedArgName(argName, key), value);
// 将解析出来的key和value的实例对象添加到resolved中
resolved.put(resolvedKey, resolvedValue);
});
// 返回resolved
return resolved;
}
2. SPEL
<bean id="autowireBean1" class="com.listao.populateBean.AutowireBean">
<property name="id" value="101"/>
<!-- SpEL -->
<property name="mobile" value="#{ooxx1.id}"/>
</bean>
<bean id="ooxx1" class="com.listao.Ooxx">
<property name="id" value="1"/>
<property name="name" value="ooxx1"/>
</bean>
// 11. TypedStringValue <null/>
else if (value instanceof TypedStringValue) {
// Convert value to target type here.
TypedStringValue typedStringValue = (TypedStringValue) value;
// 11.1. 表达式解析SpEL
Object valueObject = evaluate(typedStringValue);
try {
// TypedStringValue提前进行TargetType解析。一般为null
Class<?> resolvedTargetType = resolveTargetType(typedStringValue);
if (resolvedTargetType != null) {
return this.typeConverter.convertIfNecessary(valueObject, resolvedTargetType);
} else {
return valueObject;
}
} catch (Throwable ex) {
// Improve the message by showing the context.
throw new BeanCreationException(
this.beanDefinition.getResourceDescription(), this.beanName,
"Error converting typed String value for " + argName, ex);
}
}
AbstractBeanFactory#evaluateBeanDefinitionString()
2. convertForProperty()
- 单字段进行类型转化
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
/**
* 给定的值转换为指定的目标属性对象
* <p>
* Convert the given value for the specified target property.
*/
@Nullable
private Object convertForProperty(
@Nullable Object value, String propertyName, BeanWrapper bw, TypeConverter converter) {
if (converter instanceof BeanWrapperImpl) {
// 1... BeanWrapperImpl
return ((BeanWrapperImpl) converter).convertForProperty(value, propertyName);
} else {
PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
// setter()
MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
// BD_value => jb_value
return converter.convertIfNecessary(value, pd.getPropertyType(), methodParam);
}
}
}
1. BeanWrapperImpl
public class BeanWrapperImpl extends AbstractNestablePropertyAccessor implements BeanWrapper {
@Nullable
public Object convertForProperty(@Nullable Object value, String propertyName) throws TypeMismatchException {
CachedIntrospectionResults cachedIntrospectionResults = getCachedIntrospectionResults();
PropertyDescriptor pd = cachedIntrospectionResults.getPropertyDescriptor(propertyName);
if (pd == null) {
throw new InvalidPropertyException(getRootClass(), getNestedPath() + propertyName,
"No property '" + propertyName + "' found");
}
TypeDescriptor td = cachedIntrospectionResults.getTypeDescriptor(pd);
if (td == null) {
td = cachedIntrospectionResults.addTypeDescriptor(pd, new TypeDescriptor(property(pd)));
}
// 1... AbstractNestablePropertyAccessor
return convertForProperty(propertyName, null, value, td);
}
}
1.1. PropertyEditorRegistrySupport
public class PropertyEditorRegistrySupport implements PropertyEditorRegistry {
@Nullable
private Map<Class<?>, PropertyEditor> defaultEditors;
// 自定义属性编辑器集合
@Nullable
private Map<Class<?>, PropertyEditor> customEditors;
// 转换服务
@Nullable
private ConversionService conversionService;
@Nullable
public ConversionService getConversionService() {
return this.conversionService;
}
// ---------------------------------------------------------------------------------------------------------
@Override
@Nullable
public PropertyEditor findCustomEditor(@Nullable Class<?> requiredType, @Nullable String propertyPath) {
Class<?> requiredTypeToUse = requiredType;
if (propertyPath != null) {
if (this.customEditorsForPath != null) {
// Check property-specific editor first.
PropertyEditor editor = getCustomEditor(propertyPath, requiredType);
if (editor == null) {
List<String> strippedPaths = new ArrayList<>();
addStrippedPropertyPaths(strippedPaths, "", propertyPath);
for (Iterator<String> it = strippedPaths.iterator(); it.hasNext() && editor == null; ) {
String strippedPath = it.next();
editor = getCustomEditor(strippedPath, requiredType);
}
}
if (editor != null) {
return editor;
}
}
if (requiredType == null) {
requiredTypeToUse = getPropertyType(propertyPath);
}
}
// 1.. No property-specific editor -> check type-specific editor.
return getCustomEditor(requiredTypeToUse);
}
@Nullable
private PropertyEditor getCustomEditor(@Nullable Class<?> requiredType) {
if (requiredType == null || this.customEditors == null) {
return null;
}
// 1. Check directly registered editor for type.
PropertyEditor editor = this.customEditors.get(requiredType);
if (editor == null) {
// Check cached editor for type, registered for superclass or interface.
if (this.customEditorCache != null) {
editor = this.customEditorCache.get(requiredType);
}
if (editor == null) {
// Find editor for superclass or interface.
for (Iterator<Class<?>> it = this.customEditors.keySet().iterator(); it.hasNext() && editor == null; ) {
Class<?> key = it.next();
if (key.isAssignableFrom(requiredType)) {
editor = this.customEditors.get(key);
// Cache editor for search type, to avoid the overhead
// of repeated assignable-from checks.
if (this.customEditorCache == null) {
this.customEditorCache = new HashMap<>();
}
this.customEditorCache.put(requiredType, editor);
}
}
}
}
return editor;
}
// ---------------------------------------------------------------------------------------------------------
@Nullable
public PropertyEditor getDefaultEditor(Class<?> requiredType) {
if (!this.defaultEditorsActive) {
return null;
}
if (this.overriddenDefaultEditors != null) {
PropertyEditor editor = this.overriddenDefaultEditors.get(requiredType);
if (editor != null) {
return editor;
}
}
if (this.defaultEditors == null) {
// 1..
createDefaultEditors();
}
return this.defaultEditors.get(requiredType);
}
/**
* 2. 默认编辑器
* <p>
* Actually register the default editors for this registry instance.
*/
private void createDefaultEditors() {
this.defaultEditors = new HashMap<>(64);
// Simple editors, without parameterization capabilities.
// The JDK does not contain a default editor for any of these target types.
this.defaultEditors.put(Charset.class, new CharsetEditor());
this.defaultEditors.put(Class.class, new ClassEditor());
// ...
}
}
PropertyEditorRegistrySupport#createDefaultEditors()
1.2. TypeConverterSupport
public abstract class TypeConverterSupport extends PropertyEditorRegistrySupport implements TypeConverter {
// 委托给TypeConverterDelegate来转换
@Nullable
TypeConverterDelegate typeConverterDelegate;
}
1.3. AbsNestablePropertyAccessor
public abstract class AbstractNestablePropertyAccessor extends AbstractPropertyAccessor {
public void setWrappedInstance(Object object, @Nullable String nestedPath, @Nullable Object rootObject) {
this.wrappedObject = ObjectUtils.unwrapOptional(object);
Assert.notNull(this.wrappedObject, "Target object must not be null");
this.nestedPath = (nestedPath != null ? nestedPath : "");
this.rootObject = (!this.nestedPath.isEmpty() ? rootObject : this.wrappedObject);
this.nestedPropertyAccessors = null;
// 1... bw => TypeConverterDelegate
this.typeConverterDelegate = new TypeConverterDelegate(this, this.wrappedObject);
}
@Nullable
protected Object convertForProperty(
String propertyName, @Nullable Object oldValue, @Nullable Object newValue, TypeDescriptor td)
throws TypeMismatchException {
// 1..
return convertIfNecessary(propertyName, oldValue, newValue, td.getType(), td);
}
@Nullable
private Object convertIfNecessary(@Nullable String propertyName, @Nullable Object oldValue,
@Nullable Object newValue, @Nullable Class<?> requiredType, @Nullable TypeDescriptor td)
throws TypeMismatchException {
Assert.state(this.typeConverterDelegate != null, "No TypeConverterDelegate");
try {
// 1.
return this.typeConverterDelegate.convertIfNecessary(propertyName, oldValue, newValue, requiredType, td);
} catch (ConverterNotFoundException | IllegalStateException ex) {
PropertyChangeEvent pce =
new PropertyChangeEvent(getRootInstance(), this.nestedPath + propertyName, oldValue, newValue);
throw new ConversionNotSupportedException(pce, requiredType, ex);
} catch (ConversionException | IllegalArgumentException ex) {
PropertyChangeEvent pce =
new PropertyChangeEvent(getRootInstance(), this.nestedPath + propertyName, oldValue, newValue);
throw new TypeMismatchException(pce, requiredType, ex);
}
}
}
2. TypeConverterDelegate
- MyEditor
- GenericConversionService
DefaultConversionService#canConvert(), convert()=> 1. GenericConversionService
class TypeConverterDelegate {
// BeanWrapperImpl
private final PropertyEditorRegistrySupport propertyEditorRegistry;
public TypeConverterDelegate(PropertyEditorRegistrySupport propertyEditorRegistry, @Nullable Object targetObject) {
this.propertyEditorRegistry = propertyEditorRegistry;
this.targetObject = targetObject;
}
/**
* 将指定属性的值转换为所需的类型(如果需要从字符串)
* <p>
* Convert the value to the required type (if necessary from a String),
* for the specified property.
*
* @param propertyName name of the property
* @param oldValue the previous value, if available (may be {@code null})
* @param newValue the proposed new value
* @param requiredType the type we must convert to
* (or {@code null} if not known, for example in case of a collection element)
* @param typeDescriptor the descriptor for the target property or field
* @return the new value, possibly the result of type conversion
* @throws IllegalArgumentException if type conversion failed
*/
@SuppressWarnings("unchecked")
@Nullable
public <T> T convertIfNecessary(@Nullable String propertyName, @Nullable Object oldValue, @Nullable Object newValue,
@Nullable Class<T> requiredType, @Nullable TypeDescriptor typeDescriptor) throws IllegalArgumentException {
// 1... Custom editor for this type? => MyEditor
// PropertyEditorRegistrySupport customEditors中获取自定义Editor
PropertyEditor editor = this.propertyEditorRegistry.findCustomEditor(requiredType, propertyName);
// ConversionService转换失败后抛出的异常
ConversionFailedException conversionAttemptEx = null;
// No custom editor but custom ConversionService specified?
// 2.1... PropertyEditorRegistrySupport 类型转换服务
ConversionService conversionService = this.propertyEditorRegistry.getConversionService();
if (editor == null && conversionService != null && newValue != null && typeDescriptor != null) {
TypeDescriptor sourceTypeDesc = TypeDescriptor.forObject(newValue);
// 2.2. canConvert()
if (conversionService.canConvert(sourceTypeDesc, typeDescriptor)) {
try {
// 2.3. MyConverter
return (T) conversionService.convert(newValue, sourceTypeDesc, typeDescriptor);
} catch (ConversionFailedException ex) {
// fallback to default conversion logic below
conversionAttemptEx = ex;
}
}
}
// 默认转换后的值为newValue
Object convertedValue = newValue;
// Value not of required type?
// 3.1. !ClassUtils.isAssignableValue(requiredType, convertedValue) => (value != required type) 类型不直接对应进入
if (editor != null || (requiredType != null && !ClassUtils.isAssignableValue(requiredType, convertedValue))) {
if (typeDescriptor != null && requiredType != null && Collection.class.isAssignableFrom(requiredType) &&
convertedValue instanceof String) {
TypeDescriptor elementTypeDesc = typeDescriptor.getElementTypeDescriptor();
if (elementTypeDesc != null) {
Class<?> elementType = elementTypeDesc.getType();
if (Class.class == elementType || Enum.class.isAssignableFrom(elementType)) {
// convertedValue强转为String，以逗号分割convertedValue返回空字符串
convertedValue = StringUtils.commaDelimitedListToStringArray((String) convertedValue);
}
}
}
if (editor == null) {
// 3.2.. 获取DefaultEditor。requiredType => 编辑器
editor = findDefaultEditor(requiredType);
}
// 3.3.. Integer, String[]
convertedValue = doConvertValue(oldValue, convertedValue, requiredType, editor);
}
// 标准转换标记，convertedValue是Collection类型，Map类型，数组类型，可转换成Enum类型的String对象，Number类型并成功进行转换后即为true
boolean standardConversion = false;
if (requiredType != null) {
// Try to apply some standard type conversion rules if appropriate.
if (convertedValue != null) {
if (Object.class == requiredType) {
return (T) convertedValue;
}
// 数组
else if (requiredType.isArray()) {
// Array required -> apply appropriate conversion of elements.
// convertedValue是String && requiredType的元素类型是Enum的子类或实现
if (convertedValue instanceof String && Enum.class.isAssignableFrom(requiredType.getComponentType())) {
// 将逗号分割的列表(例如 csv 文件中的一行)转换为字符串数组
convertedValue = StringUtils.commaDelimitedListToStringArray((String) convertedValue);
}
return (T) convertToTypedArray(convertedValue, propertyName, requiredType.getComponentType());
}
// Collection对象
else if (convertedValue instanceof Collection) {
// Convert elements to target type, if determined.
convertedValue = convertToTypedCollection(
(Collection<?>) convertedValue, propertyName, requiredType, typeDescriptor);
standardConversion = true;
}
// Map对象
else if (convertedValue instanceof Map) {
// Convert keys and values to respective target type, if determined.
convertedValue = convertToTypedMap(
(Map<?, ?>) convertedValue, propertyName, requiredType, typeDescriptor);
standardConversion = true;
}
if (convertedValue.getClass().isArray() && Array.getLength(convertedValue) == 1) {
convertedValue = Array.get(convertedValue, 0);
standardConversion = true;
}
// convertedValue是基本类型或者装箱类型，直接toString
if (String.class == requiredType && ClassUtils.isPrimitiveOrWrapper(convertedValue.getClass())) {
// We can stringify any primitive value...
return (T) convertedValue.toString();
}
// convertedValue不是requiredType类型
else if (convertedValue instanceof String && !requiredType.isInstance(convertedValue)) {
// conversionAttemptEx为null意味着自定义ConversionService转换newValue转换失败或者没有自定义ConversionService
if (conversionAttemptEx == null && !requiredType.isInterface() && !requiredType.isEnum()) {
try {
// 获取requiredType的接收一个String类型参数的构造函数对象
Constructor<T> strCtor = requiredType.getConstructor(String.class);
// 使用strCtor构造函数，传入convertedValue实例化对象并返回出去
return BeanUtils.instantiateClass(strCtor, convertedValue);
} catch (NoSuchMethodException ex) {
// proceed with field lookup
if (logger.isTraceEnabled()) {
logger.trace("No String constructor found on type [" + requiredType.getName() + "]", ex);
}
} catch (Exception ex) {
if (logger.isDebugEnabled()) {
logger.debug("Construction via String failed for type [" + requiredType.getName() + "]", ex);
}
}
}
String trimmedValue = ((String) convertedValue).trim();
if (requiredType.isEnum() && trimmedValue.isEmpty()) {
// It's an empty enum identifier: reset the enum value to null.
return null;
}
convertedValue = attemptToConvertStringToEnum(requiredType, trimmedValue, convertedValue);
standardConversion = true;
}
// Number && requiredType是Number的实现或子类
else if (convertedValue instanceof Number && Number.class.isAssignableFrom(requiredType)) {
convertedValue = NumberUtils.convertNumberToTargetClass(
(Number) convertedValue, (Class<Number>) requiredType);
standardConversion = true;
}
}
// convertedValue == null
else {
if (requiredType == Optional.class) {
convertedValue = Optional.empty();
}
}
if (!ClassUtils.isAssignableValue(requiredType, convertedValue)) {
// conversionAttemptEx：尝试使用自定义ConversionService转换newValue转换失败后抛出的异常
if (conversionAttemptEx != null) {
// Original exception from former ConversionService call above...
// 从前面的ConversionService调用的原始异常
throw conversionAttemptEx;
}
// 如果conversionService不为null&&typeDescriptor不为null
else if (conversionService != null && typeDescriptor != null) {
// ConversionService not tried before, probably custom editor found
// but editor couldn't produce the required type...
// ConversionService之前没有尝试过，可能找到了自定义编辑器，但编辑器不能产生所需的类型获取newValue的类型描述符
TypeDescriptor sourceTypeDesc = TypeDescriptor.forObject(newValue);
// 如果sourceTypeDesc的对象能被转换成typeDescriptor
if (conversionService.canConvert(sourceTypeDesc, typeDescriptor)) {
// 将newValue转换为typeDescriptor对应类型的对象
return (T) conversionService.convert(newValue, sourceTypeDesc, typeDescriptor);
}
}
// Definitely doesn't match: throw IllegalArgumentException/IllegalStateException
// 拼接异常信息
StringBuilder msg = new StringBuilder();
msg.append("Cannot convert value of type '").append(ClassUtils.getDescriptiveType(newValue));
msg.append("' to required type '").append(ClassUtils.getQualifiedName(requiredType)).append("'");
if (propertyName != null) {
msg.append(" for property '").append(propertyName).append("'");
}
if (editor != null) {
msg.append(": PropertyEditor [").append(editor.getClass().getName()).append(
"] returned inappropriate value of type '").append(
ClassUtils.getDescriptiveType(convertedValue)).append("'");
throw new IllegalArgumentException(msg.toString());
} else {
msg.append(": no matching editors or conversion strategy found");
throw new IllegalStateException(msg.toString());
}
}
}
if (conversionAttemptEx != null) {
// editor：requiredType和propertyName对应一个自定义属性编辑器
// standardConversion:标准转换标记，convertedValue是Collection类型，Map类型，数组类型，
// 可转换成Enum类型的String对象，Number类型并成功进行转换后即为true
if (editor == null && !standardConversion && requiredType != null && Object.class != requiredType) {
throw conversionAttemptEx;
}
logger.debug("Original ConversionService attempt failed - ignored since " +
"PropertyEditor based conversion eventually succeeded", conversionAttemptEx);
}
// 4. 直接对应的类型，不进行任何处理，原值返回
return (T) convertedValue;
}
@Nullable
private PropertyEditor findDefaultEditor(@Nullable Class<?> requiredType) {
PropertyEditor editor = null;
if (requiredType != null) {
// No custom editor -> check BeanWrapperImpl's default editors.
// 1... PropertyEditorRegistrySupport 没有自定义编辑器 -> 检查BeanWrapperImpl默认编辑器
editor = this.propertyEditorRegistry.getDefaultEditor(requiredType);
if (editor == null && String.class != requiredType) {
// No BeanWrapper default editor -> check standard JavaBean editor.
editor = BeanUtils.findEditorByConvention(requiredType);
}
}
return editor;
}
/**
* 使用给定的属性编辑器将值转换为所需的类型(如果需要从String)
* <p>
* Convert the value to the required type (if necessary from a String),
* using the given property editor.
*
* @param oldValue the previous value, if available (may be {@code null})
* @param newValue the proposed new value
* @param requiredType the type we must convert to
* (or {@code null} if not known, for example in case of a collection element)
* @param editor the PropertyEditor to use
* @return the new value, possibly the result of type conversion
* @throws IllegalArgumentException if type conversion failed
*/
@Nullable
private Object doConvertValue(@Nullable Object oldValue, @Nullable Object newValue,
@Nullable Class<?> requiredType, @Nullable PropertyEditor editor) {
Object convertedValue = newValue;
if (editor != null && !(convertedValue instanceof String)) {
// Not a String -> use PropertyEditor's setValue.
// With standard PropertyEditors, this will return the very same object;
// we just want to allow special PropertyEditors to override setValue
// for type conversion from non-String values to the required type.
try {
editor.setValue(convertedValue);
Object newConvertedValue = editor.getValue();
if (newConvertedValue != convertedValue) {
convertedValue = newConvertedValue;
// Reset PropertyEditor: It already did a proper conversion.
// Don't use it again for a setAsText call.
editor = null;
}
} catch (Exception ex) {
if (logger.isDebugEnabled()) {
logger.debug("PropertyEditor [" + editor.getClass().getName() + "] does not support setValue call", ex);
}
// Swallow and proceed.
}
}
Object returnValue = convertedValue;
if (requiredType != null && !requiredType.isArray() && convertedValue instanceof String[]) {
// Convert String array to a comma-separated String.
// Only applies if no PropertyEditor converted the String array before.
// The CSV String will be passed into a PropertyEditor's setAsText method, if any.
if (logger.isTraceEnabled()) {
logger.trace("Converting String array to comma-delimited String [" + convertedValue + "]");
}
convertedValue = StringUtils.arrayToCommaDelimitedString((String[]) convertedValue);
}
if (convertedValue instanceof String) {
if (editor != null) {
// Use PropertyEditor's setAsText in case of a String value.
if (logger.isTraceEnabled()) {
logger.trace("Converting String to [" + requiredType + "] using property editor [" + editor + "]");
}
String newTextValue = (String) convertedValue;
// 1.. 使用editor转换newTextValue，并将转换后的值返回出去
return doConvertTextValue(oldValue, newTextValue, editor);
} else if (String.class == requiredType) {
returnValue = convertedValue;
}
}
return returnValue;
}
private Object doConvertTextValue(@Nullable Object oldValue, String newTextValue, PropertyEditor editor) {
try {
editor.setValue(oldValue);
} catch (Exception ex) {
if (logger.isDebugEnabled()) {
logger.debug("PropertyEditor [" + editor.getClass().getName() + "] does not support setValue call", ex);
}
// Swallow and proceed.
}
// 1... MyEditor
editor.setAsText(newTextValue);
return editor.getValue();
}
}
3. setAsText()
public class CustomNumberEditor extends PropertyEditorSupport {
private final Class<? extends Number> numberClass;
@Nullable
private final NumberFormat numberFormat;
private final boolean allowEmpty;
/**
* Parse the Number from the given text, using the specified NumberFormat.
*/
@Override
public void setAsText(String text) throws IllegalArgumentException {
if (this.allowEmpty && !StringUtils.hasText(text)) {
// Treat empty String as null value.
setValue(null);
} else if (this.numberFormat != null) {
// Use given NumberFormat for parsing text.
setValue(NumberUtils.parseNumber(text, this.numberClass, this.numberFormat));
} else {
// 1.. Use default valueOf methods for parsing text.
setValue(NumberUtils.parseNumber(text, this.numberClass));
}
}
/**
* Coerce a Number value into the required target class, if necessary.
*/
@Override
public void setValue(@Nullable Object value) {
if (value instanceof Number) {
// 1.
super.setValue(NumberUtils.convertNumberToTargetClass((Number) value, this.numberClass));
} else {
super.setValue(value);
}
}
}
3. setPropertyValues()
// 4. deepCopy构造新的MutablePropertyValues => bw
bw.setPropertyValues(new MutablePropertyValues(deepCopy));
AutowireBean#setId()
public class BeanWrapperImpl extends AbstractNestablePropertyAccessor implements BeanWrapper {
private class BeanPropertyHandler extends PropertyHandler {
private final PropertyDescriptor pd;
@Override
public void setValue(@Nullable Object value) throws Exception {
// 1. setter()
Method writeMethod = (this.pd instanceof GenericTypeAwarePropertyDescriptor ?
((GenericTypeAwarePropertyDescriptor) this.pd).getWriteMethodForActualAccess() :
this.pd.getWriteMethod());
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
ReflectionUtils.makeAccessible(writeMethod);
return null;
});
try {
AccessController.doPrivileged((PrivilegedExceptionAction<Object>)
() -> writeMethod.invoke(getWrappedInstance(), value), acc);
} catch (PrivilegedActionException ex) {
throw ex.getException();
}
}
// 2. 通过反射设置属性值
else {
ReflectionUtils.makeAccessible(writeMethod);
writeMethod.invoke(getWrappedInstance(), value);
}
}
}
}
6. initializeBean()
public class T17_InitializeBean {
public static void main(String[] args) {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("x18_initializeBean.xml");
System.out.println("------------------- ac.over -------------------");
Ooxx bean = ac.getBean("ooxx", Ooxx.class);
System.out.println("bean = " + bean);
ac.close();
}
}
<!-- Spring内置BPP -->
<!--<bean id="acAwareProcessor" class="org.springframework.context.support.ApplicationContextAwareProcessor"/>-->
<!--<bean id="importAwareBPP"-->
<!-- class="org.springframework.context.annotation.ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor"/>-->
<bean id="commonAnnoBpp" class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor"/>
<bean id="ooxx" class="com.listao.ooxx.bpp.Ooxx" init-method="initMethod"/>
<bean id="ox" class="com.listao.ooxx.bpp.Ox"/>
/*
* 6.1. invokeAwareMethods()，Aware属性DI
* 6.2. applyBeanPostProcessorsBeforeInitialization()
* 6.3. invokeInitMethods()
* 6.4. applyBeanPostProcessorsAfterInitialization()
*/
exposedObject = initializeBean(beanName, exposedObject, mbd);
@PostConstruct和invokeCustomInitMethod()中的<init_method>只会执行一次，mbd.externallyManagedInitMethods来保证
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
// 安全管理器
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
} else {
// 1. BeanNameAware, BeanClassLoaderAware, BeanFactoryAware
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
// AOP的pointCut配置、Advice配置，synthetic设置为true
if (mbd == null || !mbd.isSynthetic()) {
// 2. 初始化前增强
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 3.1. InitializingBean.afterPropertiesSet();
// 3.2. invokeCustomInitMethod(beanName, bean, mbd);
invokeInitMethods(beanName, wrappedBean, mbd);
} catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
// 4. 初始化后增强
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
}
1. invokeAwareMethods()
class T1_Aware {
public static void main(String[] args) {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("x1_2_Aware.xml");
System.out.println("------------------- ac.over -------------------");
MyAware a = ac.getBean("myAware", MyAware.class);
System.out.println("---------------------------------------------");
System.out.println("a.getApplicationContext() = " + a.getApplicationContext());
System.out.println("a.getEnvironment() = " + a.getEnvironment());
System.out.println("a.getBeanName() = " + a.getBeanName());
ac.close();
}
}
<bean id="myAware" class="com.listao.postProcessor.bpp.MyAware"/>
/**
* 开发很少用Aware，没必要
*/
public class MyAware implements ApplicationContextAware, EnvironmentAware, BeanNameAware {
private ApplicationContext applicationContext;
private Environment environment;
private String beanName;
}
// 安全管理器
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
} else {
// 1.. BeanNameAware, BeanClassLoaderAware, BeanFactoryAware
invokeAwareMethods(beanName, bean);
}
1. BeanFactory类别
AbstractAutowireCapableBeanFactory()构造方法
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
/**
* 1. 构造方法，忽略`BeanNameAware, BeanFactoryAware, BeanClassLoaderAware`
*/
public AbstractAutowireCapableBeanFactory() {
super();
// 忽略进行IOC的接口现实类，由invokeAwareMethod()统一处理
ignoreDependencyInterface(BeanNameAware.class);
ignoreDependencyInterface(BeanFactoryAware.class);
ignoreDependencyInterface(BeanClassLoaderAware.class);
}
/**
* 2.1. `BeanNameAware, BeanClassLoaderAware, BeanFactoryAware`
* 2.2. AbstractAutowireCapableBeanFactory()构造方法，忽略这三个接口
*/
private void invokeAwareMethods(String beanName, Object bean) {
if (bean instanceof Aware) {
if (bean instanceof BeanNameAware) {
((BeanNameAware) bean).setBeanName(beanName);
}
if (bean instanceof BeanClassLoaderAware) {
ClassLoader bcl = getBeanClassLoader();
if (bcl != null) {
((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
}
}
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}
}
2. ApplicationContext类别
// AbstractApplicationContext.prepareBeanFactory()
public abstract class AbstractApplicationContext extends DefaultResourceLoader
implements ConfigurableApplicationContext {
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
/*
* 1. 忽略自动装配的接口，这些接口由ApplicationContextAwareProcessor处理
* 2. @Autowired注入时进行忽略
* 3. 其他忽略接口，AbstractAutowireCapableBeanFactory()
* 4. `ignoredDependencyInterfaces, ignoredDependencyTypes`
*/
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
}
}
3. BF、AC
ConfigurableBeanFactory- DefaultListableBeanFactory
ApplicationContext- FileSystemXmlApplicationContext
- ClassPathXmlApplicationContext
- AnnotationConfigApplicationContext
2. applyBPPBeforeInitialization(BPP)
Object wrappedBean = bean;
// AOP的pointCut配置、Advice配置，synthetic设置为true
if (mbd == null || !mbd.isSynthetic()) {
// 2. 初始化前增强
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
/*
* 0. ApplicationContextAwareProcessor => 对Aware接口进行值设置
* 1. ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor => BFPP内部类，解析@Import
* 2. PostProcessorRegistrationDelegate$BeanPostProcessorChecker => 日志记录
* 3. CommonAnnotationBeanPostProcessor => `@PostConstruct, @PreDestroy, @Resource`
* 4. AutowiredAnnotationBeanPostProcessor => `@Autowired`
* 5. ApplicationListenerDetector => 加监听器
*/
Object current = processor.postProcessBeforeInitialization(result, beanName);
if (current == null) {
// 直接返回result，中断其后续的BeanPostProcessor处理
return result;
}
// 让result引用processor的返回结果,使其经过所有BeanPostProcess对象的后置处理的层层包装
result = current;
}
// 返回经过所有BeanPostProcess对象的后置处理的层层包装后的result
return result;
}
}
- Spring内置BPP
- ApplicationContextAwareProcessor
- ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor
- CommonAnnotationBeanPostProcessor
- do_nothing
- PostProcessorRegistrationDelegate$BeanPostProcessorChecker
- AutowiredAnnotationBPP
- ApplicationListenerDetector
1. ACAwareProcessor
class ApplicationContextAwareProcessor implements BeanPostProcessor {
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
return bean;
}
AccessControlContext acc = null;
if (System.getSecurityManager() != null) {
acc = this.applicationContext.getBeanFactory().getAccessControlContext();
}
if (acc != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
// bean实现了某个aware接口，并进行相关设置
invokeAwareInterfaces(bean);
return null;
}, acc);
} else {
// 1.. 核心方法
invokeAwareInterfaces(bean);
}
return bean;
}
/**
* Aware实现类处理
*/
private void invokeAwareInterfaces(Object bean) {
if (bean instanceof EnvironmentAware) {
((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
}
if (bean instanceof EmbeddedValueResolverAware) {
((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
}
if (bean instanceof ResourceLoaderAware) {
((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
}
if (bean instanceof ApplicationEventPublisherAware) {
((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
}
if (bean instanceof MessageSourceAware) {
((MessageSourceAware) bean).setMessageSource(this.applicationContext);
}
if (bean instanceof ApplicationContextAware) {
((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
}
}
}
2. ImportAwareBPP
- 内部类
ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor
public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor,
PriorityOrdered, ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware {
private static final String IMPORT_REGISTRY_BEAN_NAME =
ConfigurationClassPostProcessor.class.getName() + ".importRegistry";
private static class ImportAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter {
/**
* bean为ImportAware实现类，设置AnnotationMetadata
*/
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) {
if (bean instanceof ImportAware) {
ImportRegistry ir = this.beanFactory.getBean(IMPORT_REGISTRY_BEAN_NAME, ImportRegistry.class);
AnnotationMetadata importingClass = ir.getImportingClassFor(ClassUtils.getUserClass(bean).getName());
if (importingClass != null) {
((ImportAware) bean).setImportMetadata(importingClass);
}
}
return bean;
}
}
}
3. InitDestroyAnnotationBPP
public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor {
}
public class InitDestroyAnnotationBeanPostProcessor
implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
/**
* LifecycleMetadata开始调用
*/
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
try {
// 1... InitDestroyAnnotationBeanPostProcessor$LifecycleMetadata
metadata.invokeInitMethods(bean, beanName);
} catch (InvocationTargetException ex) {
throw new BeanCreationException(beanName, "Invocation of init method failed", ex.getTargetException());
} catch (Throwable ex) {
throw new BeanCreationException(beanName, "Failed to invoke init method", ex);
}
return bean;
}
}
1. @PostConstruct
Ooxx#postConstruct()
3. invokeInitMethods()
try {
// 3.1. InitializingBean.afterPropertiesSet();
// 3.2. invokeCustomInitMethod(beanName, bean, mbd);
invokeInitMethods(beanName, wrappedBean, mbd);
} catch (Throwable ex) {
throw new BeanCreationException((mbd != null ? mbd.getResourceDescription() : null), beanName, "Invocation of init method failed", ex);
}
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
/**
* 1. 调用InitializingBean.afterPropertiesSet()
* 2. 调用init-method() => invokeCustomInitMethod()
*
* <p>
* Give a bean a chance to react now all its properties are set,
* and a chance to know about its owning bean factory (this object).
* This means checking whether the bean implements InitializingBean or defines
* a custom init method, and invoking the necessary callback(s) if it does.
*
* @param beanName the bean name in the factory (for debugging purposes)
* @param bean the new bean instance we may need to initialize
* @param mbd the merged bean definition that the bean was created with
* (can also be {@code null}, if given an existing bean instance)
* @throws Throwable if thrown by init methods or by the invocation process
* @see #invokeCustomInitMethod
*/
protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
throws Throwable {
// 1.1. `Ooxx implements InitializingBean`
boolean isInitializingBean = (bean instanceof InitializingBean);
if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
if (logger.isTraceEnabled()) {
logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
}
if (System.getSecurityManager() != null) {
try {
AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
((InitializingBean) bean).afterPropertiesSet();
return null;
}, getAccessControlContext());
} catch (PrivilegedActionException pae) {
throw pae.getException();
}
} else {
// 1.2. `InitializingBean#afterPropertiesSet()`
((InitializingBean) bean).afterPropertiesSet();
}
}
if (mbd != null && bean.getClass() != NullBean.class) {
String initMethodName = mbd.getInitMethodName();
// 判断isExternallyManagedInitMethod() => @PostConstruct与不冲突
if (StringUtils.hasLength(initMethodName) &&
!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
!mbd.isExternallyManagedInitMethod(initMethodName)) {
// 2. 执行<bean init-method=""/>
invokeCustomInitMethod(beanName, bean, mbd);
}
}
}
protected void invokeCustomInitMethod(String beanName, Object bean, RootBeanDefinition mbd)
throws Throwable {
// 1. initMethodName
String initMethodName = mbd.getInitMethodName();
Assert.state(initMethodName != null, "No init method set");
// 2. 反射获取initMethod
Method initMethod = (mbd.isNonPublicAccessAllowed() ?
BeanUtils.findMethod(bean.getClass(), initMethodName) :
ClassUtils.getMethodIfAvailable(bean.getClass(), initMethodName));
if (initMethod == null) {
if (mbd.isEnforceInitMethod()) {
throw new BeanDefinitionValidationException("Could not find an init method named '" +
initMethodName + "' on bean with name '" + beanName + "'");
} else {
if (logger.isTraceEnabled()) {
logger.trace("No default init method named '" + initMethodName +
"' found on bean with name '" + beanName + "'");
}
// Ignore non-existent default lifecycle methods.
return;
}
}
if (logger.isTraceEnabled()) {
logger.trace("Invoking init method '" + initMethodName + "' on bean with name '" + beanName + "'");
}
// 3. 处理initMethod
Method methodToInvoke = ClassUtils.getInterfaceMethodIfPossible(initMethod);
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
ReflectionUtils.makeAccessible(methodToInvoke);
return null;
});
try {
AccessController.doPrivileged((PrivilegedExceptionAction<Object>)
() -> methodToInvoke.invoke(bean), getAccessControlContext());
} catch (PrivilegedActionException pae) {
InvocationTargetException ex = (InvocationTargetException) pae.getException();
throw ex.getTargetException();
}
} else {
try {
// 4. 执行initMethod
ReflectionUtils.makeAccessible(methodToInvoke);
methodToInvoke.invoke(bean);
} catch (InvocationTargetException ex) {
throw ex.getTargetException();
}
}
}
}
1. InitializingBean()
- 进入wrappedBean进行最后的属性检查及调整。执行
InitializingBean#afterPropertiesSet() - MyConverter
2. invokeCustomInitMethod()
- 反射调用自定义
<bean init-method=""/>
public class T17_InitializeBean {
public static void main(String[] args) {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("x18_initializeBean.xml");
System.out.println("------------------- ac.over -------------------");
Ooxx bean = ac.getBean("ooxx", Ooxx.class);
System.out.println("bean = " + bean);
ac.close();
}
}
<bean id="ooxx" class="com.listao.ooxx.bpp.Ooxx" init-method="initMethod"/>
@Component
public class Ooxx implements InitializingBean {
/*
* AbstractAutowireCapableBeanFactory.invokeInitMethods()
*/
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("====>>>> Ooxx.afterPropertiesSet()");
if (this.id == null) {
this.id = 1;
this.name = "afterPropertiesSet";
}
}
public void initMethod() {
System.out.println("===>>> initMethod()...");
}
}
4. applyBPPAfterInitialization(BPP)
- AOP实现地方
if (mbd == null || !mbd.isSynthetic()) {
// 4. 初始化后增强
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
/**
* 对existingBean进行初始化后的后处理:
*
* @param existingBean the existing bean instance
* @param beanName the name of the bean, to be passed to it if necessary
* (only passed to {@link BeanPostProcessor BeanPostProcessors};
* can follow the {@link #ORIGINAL_INSTANCE_SUFFIX} convention in order to
* enforce the given instance to be returned, i.e. no proxies etc)
* @return
* @throws BeansException
*/
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
}
1. BeanPostProcessorChecker
final class PostProcessorRegistrationDelegate {
private static final class BeanPostProcessorChecker implements BeanPostProcessor {
/**
* 后置处理器的after方法，用来判断哪些是不需要检测的bean
*
* @param bean the new bean instance
* @param beanName the name of the bean
*/
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
if (!(bean instanceof BeanPostProcessor) && !isInfrastructureBean(beanName) &&
this.beanFactory.getBeanPostProcessorCount() < this.beanPostProcessorTargetCount) {
if (logger.isInfoEnabled()) {
logger.info("Bean '" + beanName + "' of type [" + bean.getClass().getName() +
"] is not eligible for getting processed by all BeanPostProcessors " +
"(for example: not eligible for auto-proxying)");
}
}
return bean;
}
}
}
2. ApplicationListenerDetector
class ApplicationListenerDetector implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor {
/**
* 将自定义的监听器添加到applicationEventMulticaster里
*
* @param bean the new bean instance
* @param beanName the name of the bean
* @return
*/
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
if (bean instanceof ApplicationListener) {
// potentially not detected as a listener by getBeanNamesForType retrieval
Boolean flag = this.singletonNames.get(beanName);
if (Boolean.TRUE.equals(flag)) {
// singleton bean (top-level or inner): register on the fly
this.applicationContext.addApplicationListener((ApplicationListener<?>) bean);
}
// 非单例的，为嵌套的bean。日志，提示inner_bean只有在单例的情况下才能作为事件监听器
else if (Boolean.FALSE.equals(flag)) {
if (logger.isWarnEnabled() && !this.applicationContext.containsBean(beanName)) {
// inner bean with other scope - can't reliably process events
logger.warn("Inner bean '" + beanName + "' implements ApplicationListener interface " +
"but is not reachable for event multicasting by its containing ApplicationContext " +
"because it does not have singleton scope. Only top-level listener beans are allowed " +
"to be of non-singleton scope.");
}
this.singletonNames.remove(beanName);
}
}
return bean;
}
}
7. registerDisposableBeanIfNecessary()
// Register bean as disposable.
try {
// 7. 在容器销毁时，销毁bean
registerDisposableBeanIfNecessary(beanName, bean, mbd);
} catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
/*
* <p>On shutdown of a bean factory, the following lifecycle methods apply:
* <ol>
* <li>{@code postProcessBeforeDestruction} methods of DestructionAwareBeanPostProcessors
* <li>DisposableBean's {@code destroy}
* <li>a custom destroy-method definition
* </ol>
*/
public interface BeanFactory {
}
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
// 1..
if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
if (mbd.isSingleton()) {
// Register a DisposableBean implementation that performs all destruction
// work for the given bean: DestructionAwareBeanPostProcessors,
// DisposableBean interface, custom destroy method.
// 2... DefaultSingletonBeanRegistry
registerDisposableBean(beanName,
new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
} else {
// A bean with a custom scope...
Scope scope = this.scopes.get(mbd.getScope());
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
}
scope.registerDestructionCallback(beanName,
new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
}
}
}
protected boolean requiresDestruction(Object bean, RootBeanDefinition mbd) {
// DestructionAwareBeanPostProcessor，BPP将在关闭时应用于singleton_bean
return (bean.getClass() != NullBean.class &&
(DisposableBeanAdapter.hasDestroyMethod(bean, mbd) || (hasDestructionAwareBeanPostProcessors() &&
DisposableBeanAdapter.hasApplicableProcessors(bean, getBeanPostProcessors()))));
}
}
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
public void registerDisposableBean(String beanName, DisposableBean bean) {
synchronized (this.disposableBeans) {
this.disposableBeans.put(beanName, bean);
}
}
}
#Bean_lifecycle
#Circular_DI
实例化、初始化
- 初始化、填充属性阶段不能改变当前对象的地址空间
- Spring使用时，配置AOP生成具体代理对象
- 生成代理对象之前，要生成普通对象
- 不能确定何时调用具体对象，无论是普通对象还是代理对象
- Spring中同一个beanName的普通对象、代理对象分别存储，创建两个缓存
- 代理对象中包含了普通对象的所有功能。只要代理对象即可。调用对象时，如果检测对象需要被代理，那么直接创建代理对象覆盖
- 随时创建代理对象，缓存一个生成代理对象的匿名内部类。当调用时，直接调用匿名类（lambda）来生成，类似于回调机制
- 将所有bean的代理lambda放到三级缓存中。不需要代理，生成完整对象之后清除lambda（往一级缓存中放成品对象时就可以清除）
- 什么时候要生成具体的代理对象
- 属性注入，如果需要被代理。直接创建代理对象
- 生成最终的完整对象之前生成代理对象即可
BPP.after()
- 单纯解决循环依赖，使用二级缓存足矣，三级缓存是为了代理
- 如何解决循环依赖问题？
- 实例化、初始化分开处理。实例化即可被其他对象引用，后续继续当前对象创建
- 直接获取半成品对象引用地址，保证对象能够被找到，而半成品对象在堆空间中是否有设置的属性值，无所谓
- 提前暴露，指的是二级缓存对象——半成品对象
- 所谓的IOC容器。即：
DefaultSingletonBeanRegistry.singletonObjects属性
public class T18_Circular_DI {
public static void main(String[] args) {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("x19_1_cycle.xml");
System.out.println("------------------- ac.over -------------------");
A a = ac.getBean("a", A.class);
System.out.println("a.getB() = " + a.getB());
B b = ac.getBean("b", B.class);
System.out.println("b.getA() = " + b.getA());
ac.close();
}
}
<bean id="a" class="com.listao.cycle.A">
<property name="b" ref="b"/>
</bean>
<bean id="b" class="com.listao.cycle.B">
<property name="a" ref="a"/>
</bean>
/**
* 循环依赖AOP
*/
class T18_CD_AOP {
public static void main(String[] args) {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("x19_2_cycle.xml");
System.out.println("------------------- ac.over -------------------");
A a = ac.getBean("a", A.class);
a.getB();
System.out.println("-------------------------------------");
// B b = ac.getBean("b", B.class);
// b.getA();
ac.close();
}
}
<bean id="a" class="com.listao.cycle.A">
<property name="b" ref="b"/>
</bean>
<bean id="b" class="com.listao.cycle.B">
<property name="a" ref="a"/>
</bean>
<bean id="aspect_cd" class="com.listao.cycle.Aspect_CD"/>
<!-- 切面：切入点和通知 -->
<aop:config>
<aop:aspect id="aspect" ref="aspect_cd">
<aop:pointcut expression="execution(* com.listao.cycle.*.*(..)))" id="pointcut"/>
<aop:before method="before" pointcut-ref="pointcut"/>
</aop:aspect>
</aop:config>
public class Aspect_CD {
public void before() {
System.out.println("-->> before()");
}
public void after() {
System.out.println("-->> after()");
}
}
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
// 一级缓存
public final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// 二级缓存
public final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
// 三级缓存
public final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
}
- 循环依赖，二级缓存足矣
- 三级缓存解决代理
RuntimeBeanReference引用类型- 提前暴露对象（一、二、三级缓存）
- 对象的创建分为实例化、初始化。将已经实例化但未初始化对象的ref暴露出去，给其他对象引用，完成闭环操作
1. InstanceA
- A设置《创建中》标志位
DefaultSingletonBeanRegistry#getSingleton(String, ObjectFactory<?>)
beforeSingletonCreation(beanName);
// inCreationCheckExclusions, singletonsCurrentlyInCreation（三级缓存用）
protected void beforeSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}
- A实例化
// bean使用的策略创建新实例。eg: 工厂方法、构造函数主动注入、简单初始化
instanceWrapper = createBeanInstance(beanName, mbd, args);
- A添加三级缓存
// 实例化后。添加三级缓存
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
synchronized (this.singletonObjects) {
// 一级缓存没有
if (!this.singletonObjects.containsKey(beanName)) {
// 三级缓存 `put()`
this.singletonFactories.put(beanName, singletonFactory);
// 二级缓存 `remove()`
this.earlySingletonObjects.remove(beanName);
// 已注册单例集合
this.registeredSingletons.add(beanName);
}
}
}
1. getEarlyBeanReference(BPP)
- 三级缓存中lambda作用：动态返回原始对象A，或者创建aop_A
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
// 默认暴露普通对象
Object exposedObject = bean;
// isSynthetic()需要代理，AOP进if()
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
return exposedObject;
}
1. AbstractAutoProxyCreator
public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
private final Map<Object, Object> earlyProxyReferences = new ConcurrentHashMap<>(16);
/**
* 1. earlyAop
*/
@Override
public Object getEarlyBeanReference(Object bean, String beanName) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
// 标志位`已AOP`
this.earlyProxyReferences.put(cacheKey, bean);
return wrapIfNecessary(bean, beanName, cacheKey);
}
/**
* 2. genericAop
*/
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
/**
* 1. beanName不为空，key = beanName
* 2. FactoryBean类型，添加&符号
* 3. beanName为空，key = bean_Class
*/
protected Object getCacheKey(Class<?> beanClass, @Nullable String beanName) {
if (StringUtils.hasLength(beanName)) {
return (FactoryBean.class.isAssignableFrom(beanClass) ?
BeanFactory.FACTORY_BEAN_PREFIX + beanName : beanName);
} else {
return beanClass;
}
}
}
2. populateA
populateBean(beanName, mbd, instanceWrapper);
if (value instanceof RuntimeBeanReference) {
RuntimeBeanReference ref = (RuntimeBeanReference) value;
// 解析ref_A所对应的Bean
return resolveReference(argName, ref);
}
this.beanFactory.getBean(resolvedName);
3. InstanceB
- B设置《创建中》标志位
beforeSingletonCreation(beanName);
- B实例化
// bean使用的策略创建新实例。eg: 工厂方法、构造函数主动注入、简单初始化
instanceWrapper = createBeanInstance(beanName, mbd, args);
- B添加三级缓存
// 实例化后。添加三级缓存
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
4. populateB
// 获取resolvedName的Bean对象
bean = this.beanFactory.getBean(resolvedName);
- B引用A，A处于《创建中》
// 判断beanName是否`创建中`
public boolean isSingletonCurrentlyInCreation(String beanName) {
return this.singletonsCurrentlyInCreation.contains(beanName);
}
- A三级 => aop_A二级
allowEarlyReference = true- 调用三级缓存中的lambda，
getEarlyBeanReference()创建代理对象 - 1. getEarlyBeanReference(BPP)
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// Quick check for existing instance without full singleton lock
// 1. 一级缓存
Object singletonObject = this.singletonObjects.get(beanName);
// 2. 二级缓存 (单例 & bean`创建中`)
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
// 二级都是三级创建出来的
singletonObject = this.earlySingletonObjects.get(beanName);
// allowEarlyReference，允许早期引用
if (singletonObject == null && allowEarlyReference) {
synchronized (this.singletonObjects) {
// Consistent creation of early reference within full singleton lock
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
// 3. 三级 => 二级
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 99... getEarlyBeanReference()
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
}
}
return singletonObject;
}
5. initializeBeanB
- genericAop创建aop_B代替B
- 1. getEarlyBeanReference(BPP)
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
// 1... AbstractAutoProxyCreator#postProcessAfterInitialization()
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
6. completeB
- aop_B删除
创建中
protected void afterSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
}
}
- aop_B添加一级缓存。清除B二、三级缓存。完成B创建
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
// 一级缓存添加
this.singletonObjects.put(beanName, singletonObject);
// 二、三级缓存移除
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
// 已注册单例集合
this.registeredSingletons.add(beanName);
}
}
7. initializeBeanA
- 1. getEarlyBeanReference(BPP)
- cacheAop已经处理，genericAop不再进行处理。通过
earlyProxyReferences集合来实现
if (earlySingletonExposure) {
// 1. 正常bean。singletonObjects, earlySingletonObjects不存在。即：earlySingletonReference == null
// 2. circular_bean，即`创建中`的bean。singletonFactories => earlySingletonObjects
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
// 3. 进行了singletonFactories执行。1. 原实例 2. aop实例
exposedObject = earlySingletonReference;
}
// log记录
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
// 循环依赖中，bean的依赖还没全部创建好。找出并log记录
for (String dependentBean : dependentBeans) {
if (!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 " +
"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
8. completeA
- aop_A添加一级缓存。清除A二、三级缓存。完成A创建
- 6. completeB