目錄
1. 注冊BeanDefinition
2. 預初始化單例Bean
????2.1 AbstractBeanFactory獲取或者創(chuàng)建Bean實例
????2.2 AbstractAutowireCapableBeanFactory#createBean創(chuàng)建bean
3. SimpleInstantiationStrategy#instantiate 實例化策略
????3.1 CglibSubclassingInstantiationStrategy cglib實例化策略
DefaultListableBeanFactory類繼承關系
1. 注冊BeanDefinition
首先驗證BeanDefinition, 驗證通過之后, 判斷BeanDefinition是否已經(jīng)存在
- 存在的話, 判斷是否重寫和優(yōu)先級, 然后將BeanDefinition維護到beanDefinitionMap中
- 不存在的話, 直接維護到beanDefinitionNames中
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
//驗證beanDefinition
//方法重寫和bean重名
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
}
//bean定義已經(jīng)存在
BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
if (existingDefinition != null) {
//bean定義不允許重寫,則拋出異常
if (!isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
}
else if (existingDefinition.getRole() < beanDefinition.getRole()) {
//BeanDefinition的role
//ROLE_APPLICATION = 0, 整個application重要組成部分, 通常是用戶自定義Bean的ROLE
//ROLE_SUPPORT = 1, 一個大的配置的支撐部分, springboot引入的外部BeanDefinition
//ROLE_INFRASTRUCTURE = 2, springboot底層的BeanDefinition
if (logger.isInfoEnabled()) {
logger.info("Overriding user-defined bean definition for bean '" + beanName +
"' with a framework-generated bean definition: replacing [" +
existingDefinition + "] with [" + beanDefinition + "]");
}
}
else if (!beanDefinition.equals(existingDefinition)) {
if (logger.isDebugEnabled()) {
logger.debug("Overriding bean definition for bean '" + beanName +
"' with a different definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
else {
if (logger.isTraceEnabled()) {
logger.trace("Overriding bean definition for bean '" + beanName +
"' with an equivalent definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
//將新的BeanDefinition放入到map中
this.beanDefinitionMap.put(beanName, beanDefinition);
}
else {
//已經(jīng)開始創(chuàng)建bean
if (hasBeanCreationStarted()) {
//保證beanDefinitionNames線程安全
synchronized (this.beanDefinitionMap) {
//重新賦值beanDefinitionNames
this.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
//beanName已經(jīng)被手動維護了
if (this.manualSingletonNames.contains(beanName)) {
//則更新manualSingletonNames
//使用注冊的BeanDefinition替換手動維護的beanDefinition
Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
updatedSingletons.remove(beanName);
this.manualSingletonNames = updatedSingletons;
}
}
}
else {
//bean還沒有開始創(chuàng)建
//仍然處于BeanDefinition注冊階段
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
this.manualSingletonNames.remove(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if (existingDefinition != null || containsSingleton(beanName)) {
//如果beanDefinition已經(jīng)存在
//遞歸重置BeanDefinition以及其父BeanDefinition
resetBeanDefinition(beanName);
}
}
}
2. 預初始化單例Bean
在refreshContext()刷新應用上下文 finishBeanFactoryInitialization方法中, 執(zhí)行了beanFactory.preInstantiateSingletons方法, 預初始化了非延時加載bean
首先從beanDefinitionNames中獲取BeanDefinition列表, 遞歸將parent和child BeanDefinition合并成一個RootBeanDefinition, 然后判斷BeanDefinition是否為factoryBean
- 如果是factoryBean, 先判斷是否立即加載, 然后通過getBean()方法獲取或生成bean
- 如果不是factoryBean, 直接通過getBean()方法獲取或生成bean
如果beanSmartInitializingSingleton的子類, 那么在初始化之后執(zhí)行SmartInitializingSingleton#afterSingletonsInstantiated方法
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
//預初始化單例Bean
@Override
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
//開辟一個新的List, 存儲this.beanDefinitionNames
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
//觸發(fā)單例bean的實例化
for (String beanName : beanNames) {
//xml定義的bean中有parent屬性,
//getMergedLocalBeanDefinition會遞歸將parent和child BeanDefinition合并成一個RootBeanDefinition
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//非抽象類, 單例的, 非延遲加載的才執(zhí)行代碼
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//FactoryBean工廠bean, 并不是直接返回一個Bean, 而是通過getObject()方法, 返回一個bean實例
if (isFactoryBean(beanName)) {
//獲取factoryBean
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
//立即加載
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) {
//如果立即加載
//那么調(diào)用getBean方法
getBean(beanName);
}
}
}
else {
//不是工廠Bean
//立即調(diào)用getBean方法
getBean(beanName);
}
}
}
//觸發(fā)SmartInitializingSingleton類型bean實例化之后的回調(diào)
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
//SmartInitializingSingleton的子類
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
//回調(diào)
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
//回調(diào)
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
}
2.1 AbstractBeanFactory獲取或者創(chuàng)建Bean實例
先判斷是否為factoryBean, 如果是的話, 那么會調(diào)用其getObject方法, 獲取bean, 之后檢查bean是否循環(huán)依賴, 如果當前beanFactory中獲取不到bean, 會嘗試遞歸從父factory中加載bean, 之后把bean標記為已創(chuàng)建, 然后先去實例化依賴的bean, 最后判斷bean的scope并實例化bean
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
//獲取Bean實例
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
//實際獲取Bean實例的方法
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
final String beanName = transformedBeanName(name);
Object bean;
//是否手工注冊的單例Bean
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 + "'");
}
}
//如果是factoryBean的話, 那么會調(diào)用其getObject方法, 獲取bean
//不是factoryBean的話, 直接返回當前bean
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
//檢查是否循環(huán)依賴
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
//檢查當前beanFactory中是否包含bean
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
//當前beanFactory中不包含bean
//遞歸從parent beanFactory中獲取
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
//父beanFactory 獲取bean
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// 父beanFactory 獲取bean
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
//父beanFactory 獲取bean
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
if (!typeCheckOnly) {
//標記bean已創(chuàng)建
markBeanAsCreated(beanName);
}
try {
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// 先加載被依賴的bean
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
//...
}
registerDependentBean(dep, beanName);
try {
//遞歸實例化被依賴的bean
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
//...
}
}
}
// 創(chuàng)建bean實例
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
//...
}
});
//如果是factoryBean, 那么通過其getObject()方法獲取bean
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
//beanDefinition的scope設置為prototype
//每次都獲取新的實例
Object prototypeInstance = null;
try {
//bean創(chuàng)建之前的回調(diào)
beforePrototypeCreation(beanName);
//創(chuàng)建bean
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
//bean創(chuàng)建之后的回調(diào)
afterPrototypeCreation(beanName);
}
//如果是factoryBean, 那么調(diào)用其getObject方法獲取bean
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
//獲取scope
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
//...
}
try {
Object scopedInstance = scope.get(beanName, () -> {
//bean創(chuàng)建之前的回調(diào)
beforePrototypeCreation(beanName);
try {
//創(chuàng)建bean
return createBean(beanName, mbd, args);
}
finally {
//bean創(chuàng)建之后的回調(diào)
afterPrototypeCreation(beanName);
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
//...
}
}
}
catch (BeansException ex) {
//創(chuàng)建出現(xiàn)異常, 清空緩存
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// requiredType和要創(chuàng)建bean類型一致
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
//類型不一致進行轉(zhuǎn)換
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
//...
}
}
//返回bean
return (T) bean;
}
}
2.2 AbstractAutowireCapableBeanFactory#createBean
先解析beanClass, 嘗試重寫方法, 執(zhí)行InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation方法, 可以使用代理生成新的bean
創(chuàng)建bean的過程中, 先執(zhí)行MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition, 然后執(zhí)行BeanPostProcessor#postProcessBeforeInitialization, 再判斷要采取的實例化策略, 一種是反射, 另一種是cglib動態(tài)代理, 然后使用策略實例化bean, 再執(zhí)行BeanPostProcessor#postProcessAfterInitialization, 對bean進行增強處理
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
//創(chuàng)建bean
@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;
// 解析BeanClass
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
//復制BeanDefinition
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
//方法重寫
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
//...
}
try {
//執(zhí)行InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation方法
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
//...
}
try {
//創(chuàng)建bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
//...
}
catch (Throwable ex) {
//...
}
}
//實際創(chuàng)建bean的方法
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// 初始化bean
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
//bean不是factoryBean
if (instanceWrapper == null) {
//創(chuàng)建bean實例
//使用對應的策略模式簡單的創(chuàng)建新實例
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
//執(zhí)行MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition方法
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
//...
}
mbd.postProcessed = true;
}
}
//循環(huán)依賴處理
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");
}
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// 實例化bean
Object exposedObject = bean;
try {
//執(zhí)行InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation
//并處理autowireByName和autowireByType
//然后處理InstantiationAwareBeanPostProcessor#postProcessProperties
populateBean(beanName, mbd, instanceWrapper);
//實例化bean
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
//...
}
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
//依賴bean
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
//...
}
}
}
}
// 注冊bean銷毀方法
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
//...
}
return exposedObject;
}
//創(chuàng)建bean實例的方法
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 解析beanClass
Class<?> beanClass = resolveBeanClass(mbd, beanName);
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());
}
//使用Supplier#get()獲取實例
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
//設置了factoryMethodName
//自定義factory生成bean實例
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
//簡單實例化bean
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
if (resolved) {
if (autowireNecessary) {
//構造函數(shù)解析
//調(diào)用ConstructorResolver#autowireConstructor
//先解析構造函數(shù), 然后使用實例化策略實例化對象
return autowireConstructor(beanName, mbd, null, null);
}
else {
//簡單實例化
//使用實例化策略實例化對象
return instantiateBean(beanName, mbd);
}
}
//判斷是否通過構造函數(shù)實例化
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
//構造函數(shù)實例化
//傳入了參數(shù)
return autowireConstructor(beanName, mbd, ctors, args);
}
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
return autowireConstructor(beanName, mbd, ctors, null);
}
//無須特殊處理, 簡單實例化bean
return instantiateBean(beanName, mbd);
}
//使用默認構造函數(shù)實例化bean
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
try {
Object beanInstance;
final BeanFactory parent = this;
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
getInstantiationStrategy().instantiate(mbd, beanName, parent),
getAccessControlContext());
}
else {
//獲取bean初始化策略
//然后調(diào)用CglibSubclassingInstantiationStrategy#instantiate實例化bean
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
}
}
//繼續(xù)初始化bean實例, 設置Aware對象, 設置init方法
//執(zhí)行BeanPostProcessor#postProcessBeforeInitialization方法
//執(zhí)行BeanPostProcessor#postProcessAfterInitialization方法
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
//如果是Aware類型的bean
//那么在bean中注入相應的對象
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
//如果是InitializingBean類型的bean
//那么執(zhí)行afterPropertiesSet方法
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()) {
//執(zhí)行BeanPostProcessor#postProcessAfterInitialization方法
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
}
3. SimpleInstantiationStrategy#instantiate
默認策略, 實例化對象, 如果有Override方法, 那么使用cglib實例化對象, 否則使用反射
public class SimpleInstantiationStrategy implements InstantiationStrategy {
@Override
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
//沒有Override方法, 那么不使用cglib
if (!bd.hasMethodOverrides()) {
Constructor<?> constructorToUse;
synchronized (bd.constructorArgumentLock) {
constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
if (constructorToUse == null) {
final Class<?> clazz = bd.getBeanClass();
if (clazz.isInterface()) {
//接口肯定有override方法
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
if (System.getSecurityManager() != null) {
constructorToUse = AccessController.doPrivileged(
(PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
}
else {
constructorToUse = clazz.getDeclaredConstructor();
}
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
}
catch (Throwable ex) {
throw new BeanInstantiationException(clazz, "No default constructor found", ex);
}
}
}
//通過反射實例化對象
return BeanUtils.instantiateClass(constructorToUse);
}
else {
//有Override方法,那么使用cglib
return instantiateWithMethodInjection(bd, beanName, owner);
}
}
}
3.1 CglibSubclassingInstantiationStrategy#instantiateWithMethodInjection
cglib實例化對象
//Cglib實例化策略
public class CglibSubclassingInstantiationStrategy extends SimpleInstantiationStrategy {
@Override
protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
@Nullable Constructor<?> ctor, Object... args) {
//內(nèi)部類CglibSubclassCreator實例化對象
return new CglibSubclassCreator(bd, owner).instantiate(ctor, args);
}
//靜態(tài)內(nèi)部類
private static class CglibSubclassCreator {
//實例化
public Object instantiate(@Nullable Constructor<?> ctor, Object... args) {
Class<?> subclass = createEnhancedSubclass(this.beanDefinition);
Object instance;
if (ctor == null) {
//構造函數(shù)為空
//反射實例化
instance = BeanUtils.instantiateClass(subclass);
}
else {
try {
//通過構造函數(shù)實例化
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;
//設置回調(diào)
factory.setCallbacks(new Callback[] {NoOp.INSTANCE,
new LookupOverrideMethodInterceptor(this.beanDefinition, this.owner),
new ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)});
return instance;
}
//cglib創(chuàng)建類
private Class<?> createEnhancedSubclass(RootBeanDefinition beanDefinition) {
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));
}
enhancer.setCallbackFilter(new MethodOverrideCallbackFilter(beanDefinition));
enhancer.setCallbackTypes(CALLBACK_TYPES);
//創(chuàng)建類
return enhancer.createClass();
}
}
}
