spring之InstantiationStrategy分析

淩亂°似流年 2023-01-16 06:45 96阅读 0赞

## 1：回顾 ##

在[这篇文章][Link 1]中我分析了spring bean的生命周期，为了方便本文的讲解，再来贴下生命周期的流程图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70]  
第一步的`创建bean实例`，而bean的创建主要依赖的是`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean`,该方法完成了`bean实例的创建`,`属性的填充`,`bean的初始化`三个关键步骤，其中的bean实例的创建过程如下：

1：如果是单例bean，则从单例bean的BeanWrapper缓存factoryBeanInstanceCache中获取，如果不是则到2，否则结束
    2：通过createBeanInstance方法获取，具体分为如下情况
    	2.1:如果是Supplier，则通过Supplier#get创建bean实例，如果不是则到2.2
    	2.2:如果是FactoryBean，则通过FactoryBean的FactoryMethod方法获取
    	，如果不是则到3
    3:通过instantiateBean方法创建bean实例

以上过程中的`2`,`3`最终都会调用到`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#instantiateBean`方法，在该方法中完成bean的实例化是通过`org.springframework.beans.factory.support.InstantiationStrategy#instantiate(...)`方法，InstantiationStrategy也正是本文要分析的API接口。

## 2：InstantiationStrategy ##

初始化策略是通过接口`org.springframework.beans.factory.support.InstantiationStrategy`来定义的，源码如下：

// 根据对应的root bean definition来创建bean实例，即进行bean的实例化，具体实例化策略可以通过很多方式
    // 来实现
    public interface InstantiationStrategy { 
    
    	// 基于无参构造函数创建bean实例
    	Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner)
    			throws BeansException;
    
    	// 基于指定构造函数创建bean实例
    	Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
    			Constructor<?> ctor, Object... args) throws BeansException;
    
    	// 基于工厂方法创建bean实例
    	Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
    			@Nullable Object factoryBean, Method factoryMethod, Object... args)
    			throws BeansException;
    
    }

子类有2个，分别是`org.springframework.beans.factory.support.SimpleInstantiationStrategy`和`org.springframework.beans.factory.support.CglibSubclassingInstantiationStrategy`，类图如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 1]

接下来分别分析。

## 3：SimpleInstantiationStrategy ##

### 3.1：基于工厂bean实例化方法 ###

org.springframework.beans.factory.support.SimpleInstantiationStrategy#instantiate(org.springframework.beans.factory.support.RootBeanDefinition, java.lang.String, org.springframework.beans.factory.BeanFactory, java.lang.Object, java.lang.reflect.Method, java.lang.Object...)
    public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
    			@Nullable Object factoryBean, final Method factoryMethod, Object... args) { 
    	try { 
    		// 设置factory-method对应方法可访问
    		if (System.getSecurityManager() != null) { 
    			AccessController.doPrivileged((PrivilegedAction<Object>) () -> { 
    				ReflectionUtils.makeAccessible(factoryMethod);
    				return null;
    			});
    		}
    		else { 
    			ReflectionUtils.makeAccessible(factoryMethod);
    		}
    		// 从ThreadLocal中获取原来的Method对象
    		Method priorInvokedFactoryMethod = currentlyInvokedFactoryMethod.get();
    		try { 
    			// 设置当前方法到ThreadLocal中
    			currentlyInvokedFactoryMethod.set(factoryMethod);
    			// 通过反射调用factory-bean的factory-method方法获取结果bean
    			Object result = factoryMethod.invoke(factoryBean, args);
    			// 若为空，则使用NullBean，代表没有获取到
    			if (result == null) { 
    				result = new NullBean();
    			}
    			// 返回结果
    			return result;
    		}
    		finally { 
    			// 如果是有之前的factory-method则设置回去，否则清空threadlocal
    			if (priorInvokedFactoryMethod != null) { 
    				currentlyInvokedFactoryMethod.set(priorInvokedFactoryMethod);
    			}
    			else { 
    				currentlyInvokedFactoryMethod.remove();
    			}
    		}
    	}
    	...snip ex...
    	}
    }

### 3.2：基于默认构造函数实例化方法 ###

分为两种情况，如果是有MethodOverride，则使用CGLIB来生成子类，否则直接返回，其中有两种情况会存在MethodOverride，第一种是使用了[lookup-method][],这种方式因为定了抽象类的抽象方法来返回bean，所以会动态生成抽象类的子类，并实现抽象方法。第二种是使用了[replaced-method][],这种方式是通过`MethodReplacer`接口动态替换的某个方法，因此也需要动态生成子类。

org.springframework.beans.factory.support.SimpleInstantiationStrategy#instantiate(org.springframework.beans.factory.support.RootBeanDefinition, java.lang.String, org.springframework.beans.factory.BeanFactory)
    public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) { 
    	// 如果是没有MethodOverride
    	if (!bd.hasMethodOverrides()) { 
    		Constructor<?> constructorToUse;
    		synchronized (bd.constructorArgumentLock) { 
    			// 获取构造函数
    			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 { 
    						// 获取无参数构造函数，这里不传入参数，就是获取无参数的构造函数
    						constructorToUse = clazz.getDeclaredConstructor();
    					}
    					// 设置无参数构造函数到db中
    					bd.resolvedConstructorOrFactoryMethod = constructorToUse;
    				}
    				catch (Throwable ex) { 
    					throw new BeanInstantiationException(clazz, "No default constructor found", ex);
    				}
    			}
    		}
    		// 直接反射创建实例对象
    		return BeanUtils.instantiateClass(constructorToUse);
    	}
    	else { 
    		// 使用CGLIB生成子类
    		return instantiateWithMethodInjection(bd, beanName, owner);
    	}
    }

### 3.2：基于指定构造函数实例化方法 ###

org.springframework.beans.factory.support.SimpleInstantiationStrategy#instantiate(org.springframework.beans.factory.support.RootBeanDefinition, java.lang.String, org.springframework.beans.factory.BeanFactory, java.lang.reflect.Constructor<?>, java.lang.Object...)
    public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
    			final Constructor<?> ctor, Object... args) { 
    	// 不存在MethodOverride
    	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;
    			});
    		}
    		// 反射创建bean实例对象
    		return BeanUtils.instantiateClass(ctor, args);
    	}
    	else { 
    		// 存在MethodOverride，使用CGLIB创建动态子类
    		return instantiateWithMethodInjection(bd, beanName, owner, ctor, args);
    	}
    }

## 4：CglibSubclassingInstantiationStrategy ##

### 4.1：debug准备 ###

*  bean

public class ReplacedMethodBean { 
    
        public void sayHi() { 
            System.out.println("ReplacedMethodBean.sayHi say hi");;
        }
    }

*  MethodReplacer

public class ReplacedMethodBeanSayHiMethodReplacer implements MethodReplacer { 
    
        @Override
        public Object reimplement(Object obj, Method method, Object[] args) throws Throwable { 
            System.out.println("ReplacedMethodBeanSayHiMethodReplacer.reimplement say hi");
            return null;
        }
    }

*  xml

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
        <bean class="yudaosourcecode.instantiationstrategytest.ReplacedMethodBeanSayHiMethodReplacer" id="sayHiReplacer"/>
    
        <bean class="yudaosourcecode.instantiationstrategytest.ReplacedMethodBean" id="replacedMethodBean">
            <replaced-method replacer="sayHiReplacer" name="sayHi"/>
        </bean>
    </beans>

*  测试代码

@Test
    public void instantiationstrategyreplacedmethod() { 
        ClassPathXmlApplicationContext ac
                = new ClassPathXmlApplicationContext("instantiationstrategytest/instantiationstrategyreplacedmethod.xml");
        ReplacedMethodBean replacedMethodBean = ac.getBean("replacedMethodBean", ReplacedMethodBean.class);
        replacedMethodBean.sayHi();
    }

*  运行

ReplacedMethodBeanSayHiMethodReplacer.reimplement say hi
    
    Process finished with exit code 0

### 4.2：源码分析 ###

该类是SImpleInstantiationStrategy的子类，通过方法`instantiateWithMethodInjection`提供了生成bean的动态子类的操作，源码如下:

org.springframework.beans.factory.support.CglibSubclassingInstantiationStrategy#instantiateWithMethodInjection(org.springframework.beans.factory.support.RootBeanDefinition, java.lang.String, org.springframework.beans.factory.BeanFactory)
    protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) { 
    	return instantiateWithMethodInjection(bd, beanName, owner, null);
    }

继续：

org.springframework.beans.factory.support.CglibSubclassingInstantiationStrategy#instantiateWithMethodInjection(org.springframework.beans.factory.support.RootBeanDefinition, java.lang.String, org.springframework.beans.factory.BeanFactory, java.lang.reflect.Constructor<?>, java.lang.Object...)
    	protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
    			@Nullable Constructor<?> ctor, Object... args) { 
    
    	// <20210426 1755>
    	return new CglibSubclassCreator(bd, owner).instantiate(ctor, args);
    }

`<20210426 1755>`处是通过`CglibSubClassCreator`类来完成代理子类的创建，这是一个私有的内部子类，继续看源码：

org.springframework.beans.factory.support.CglibSubclassingInstantiationStrategy.CglibSubclassCreator#instantiate
    public Object instantiate(@Nullable Constructor<?> ctor, Object... args) { 
    	// <20210426 1809>
    	// 创建增强的动态子类
    	Class<?> subclass = createEnhancedSubclass(this.beanDefinition);
    	Object instance;
    	// 如果是构造函数为空，则使用默认的构造函数创建实例，注意这里创建的实例是
    	// bean的增强子类的
    	if (ctor == null) { 
    		instance = BeanUtils.instantiateClass(subclass);
    	}
    	else { 
    		try { 
    			// 根据参数类型从增强子类的class中获取对应的增强子类构造函数
    			Constructor<?> enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
    			// 通过增强子类构造函数，创建bean的增强子类的实例对象
    			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;
    	// <20210427 1527>
    	// 设置回调对象
    	factory.setCallbacks(new Callback[] { NoOp.INSTANCE,
    			new LookupOverrideMethodInterceptor(this.beanDefinition, this.owner),
    			new ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)});
    	return instance;
    }

`<20210426 1809>`处是创建动态子类，源码如下：

org.springframework.beans.factory.support.CglibSubclassingInstantiationStrategy.CglibSubclassCreator#createEnhancedSubclass
    // 基于CGLIB创建bean class的增强子类
    private Class<?> createEnhancedSubclass(RootBeanDefinition beanDefinition) { 
    	// 创建Enhancer类
    	Enhancer enhancer = new Enhancer();
    	// 设置父类的class的type
    	enhancer.setSuperclass(beanDefinition.getBeanClass());
    	// 设置命令策略
    	enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
    	// 设置生成策略
    	if (this.owner instanceof ConfigurableBeanFactory) { 
    		ClassLoader cl = ((ConfigurableBeanFactory) this.owner).getBeanClassLoader();
    		enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(cl));
    	}
    	// <20210427 1525>
    	// 设置方法重载过滤器，用于获取使用哪种cglib的interceptor来增强子类
    	enhancer.setCallbackFilter(new MethodOverrideCallbackFilter(beanDefinition));
    	// 设置回调的类型
    	enhancer.setCallbackTypes(CALLBACK_TYPES);
    	return enhancer.createClass();
    }

`<20210427 1525>`处的MethodOverrideCallbackFilter实现了`org.springframework.cglib.proxy.CallbackFilter`接口，并实现了其方法`accept`，源码如下：

org.springframework.beans.factory.support.CglibSubclassingInstantiationStrategy.MethodOverrideCallbackFilter#accept
    public int accept(Method method) { 
    		// 从bd中获取方法的MethodOverride
    		MethodOverride methodOverride = getBeanDefinition().getMethodOverrides().getOverride(method);
    		if (logger.isTraceEnabled()) { 
    			logger.trace("MethodOverride for " + method + ": " + methodOverride);
    		}
    		// 如果么有，放行private static final int PASSTHROUGH = 0;
    		// 对应<20210427 1527>处设置数组的NoOp.INSTANCE
    		if (methodOverride == null) { 
    			return PASSTHROUGH;
    		}
    		// 如果是lookup-method，则返回private static final int LOOKUP_OVERRIDE = 1;
    		// 对应<20210427 1527>处设置数组的new LookupOverrideMethodInterceptor(this.beanDefinition, this.owner)
    		else if (methodOverride instanceof LookupOverride) { 
    			return LOOKUP_OVERRIDE;
    		}
    		// 如果是replaced-method，则返回private static final int METHOD_REPLACER = 2;
    		// 对应<20210427 1527>处设置数组的new ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)
    		else if (methodOverride instanceof ReplaceOverride) { 
    			return METHOD_REPLACER;
    		}
    		throw new UnsupportedOperationException("Unexpected MethodOverride subclass: " +
    				methodOverride.getClass().getName());
    	}

可以看出lookup-method对应的是`LookupOverrideMethodInterceptor`，replaced-method对应的是`ReplaceOverrideMethodInterceptor`,接下来我们分别来看下这两个方法拦截器是如何执行我们定义逻辑的。这是CglibSubclassingInstantiationStrategy的2个私有的内部子类，如下：

org.springframework.beans.factory.support.CglibSubclassingInstantiationStrategy.LookupOverrideMethodInterceptor
    org.springframework.beans.factory.support.CglibSubclassingInstantiationStrategy.ReplaceOverrideMethodInterceptor

### 4.3：LookupOverrideMethodInterceptor ###

org.springframework.beans.factory.support.CglibSubclassingInstantiationStrategy.LookupOverrideMethodInterceptor#intercept
    // 这里obj就是我们定义的抽象类的增强子类，method就是我们定义的抽象类中用于返回bean的抽象方法
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy mp) throws Throwable { 
    	// 这里强转是安全的，因为在CallbackFilter接口已经进行了选择了
    	LookupOverride lo = (LookupOverride) getBeanDefinition().getMethodOverrides().getOverride(method);
    	Assert.state(lo != null, "LookupOverride not found");
    	// 获取方法的参数
    	Object[] argsToUse = (args.length > 0 ? args : null);  // if no-arg, don't insist on args at all
    	// 有bean名称
    	if (StringUtils.hasText(lo.getBeanName())) { 
    		// 从容器中获取名称为beanName的bean返回，作为结果
    		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()));
    	}
    }

### 4.4：ReplaceOverrideMethodInterceptor ###

org.springframework.beans.factory.support.CglibSubclassingInstantiationStrategy.ReplaceOverrideMethodInterceptor#intercept
    // obj是我们的bean的增强子类，method是bean中要替换的目标方法
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy mp) throws Throwable { 
    	// 通过方法获取对应的ReplacedOverride
    	ReplaceOverride ro = (ReplaceOverride) getBeanDefinition().getMethodOverrides().getOverride(method);
    	Assert.state(ro != null, "ReplaceOverride not found");
    	// 获取对应的MethodReplacer
    	MethodReplacer mr = this.owner.getBean(ro.getMethodReplacerBeanName(), MethodReplacer.class);
    	// 调用MethodReplacer的reimplement方法获取结果
    	return mr.reimplement(obj, method, args);
    }

[Link 1]: https://blog.csdn.net/wang0907/article/details/115429599
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70]: /images/20221022/c08acea41ea449e4a59336eefa4f84c5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70 1]: /images/20221022/7d45bdb265764a31a0467ced21c5114c.png
[lookup-method]: https://blog.csdn.net/wang0907/article/details/114321253
[replaced-method]: https://blog.csdn.net/wang0907/article/details/114325252