FactoryBean
2020-12-17 本文已影响0人
何德何能者
FactoryBean是spring框架定义的一个接口. 用于自定义bean的整个实例化过程;
说到实例化，默认spring bean只有给beanFactory注册beanDefinition就可以自动完成实例化, 这种方式能满足绝大多数的实例化需求. FactoryBean是为了满足复杂实例化的需求，比如aop生成代理对象, 自定义接口给接口生成代理对象等。
image.png
用法.
AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext();
// 定义beanDefinition
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(UserComponentFactoryBean.class);
// 自动注入
builder.setAutowireMode(2);
annotationConfigApplicationContext.registerBeanDefinition("userComponentFactoryBean", builder.getBeanDefinition());
annotationConfigApplicationContext.refresh();
public class UserComponentFactoryBean implements FactoryBean<UserComponent> {
private UserComponent userComponent;
@Override
public UserComponent getObject() throws Exception {
if (userComponent == null) {
userComponent = new UserComponent();
System.out.println("------------ factoryBean----" + userComponent.hashCode());
}
return userComponent;
}
@Override
public Class<?> getObjectType() {
return UserComponent.class;
}
@Override
public boolean isSingleton() {
return true;
}
}
这里使用注册beanDefinition的方式让beanFactory感知到有FactoryBean，当然也可以用包扫描的方式加@Component。
这里UserComponentFactoryBean的getObject()方法获取对象实例只是示范，并不规范。
注意：如果UserCompontFactoryBean有依赖其他bean，FactoryBean不会自动完成注入。
如果需要获取bean关联的FactoryBean需要在beanName前加上 &
ProxyFactoryBean
spring中使用ProxyFactoryBean创建代理。
ProxyFactoryBean可以配置的属性有.
- proxyTargetClass: 如果要对类进行代理，这个属性设置为true
- optimize: 针对CGLIB优化.
- frozen: 冻结配置。如果为true有俩个作用，一个是不允许CGLIB优化， 另一个是代理创建后不允许手动进行增强的添加修改。默认是false, 所以一般情况下可以进行增强的手动添加修改;
- exposeProxy:是否暴露代理对象。如果是true, 则在增强点/目标对象可以通过AopContext.currentProxy()拿到代理对象;
- proxyInterfaces: string对象数组, 用于指定代理对象实现的接口。如果有值且-proxyTargetClass=false将启用jdk代理.
- interceptoreNames: 数组, 声明增强点集合。可以用* 一次匹配多个增强点;
- singleton: ProxyFactoryBean的getObject方法是否返回单例;
示例
- 定义被代理对象
public class TargetBean {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Object getProxy() {
// 在被代理对象里获取 代理
return AopContext.currentProxy();
}
@Override
public String toString() {
return "TargetBean{" +
"name='" + name + '\'' +
'}';
}
}
- 定义ProxyFactoryBean, 并设置一个增强点
@Configuration
public class FactoryBeanConfig {
@Bean("debugInterceptor")
public DebugInterceptor getInterceptor() {
return new DebugInterceptor();
}
@Bean
public ProxyFactoryBean getProxyFactoryBean() {
ProxyFactoryBean pfb = new ProxyFactoryBean();
pfb.setInterceptorNames("debugInterceptor");
pfb.setTarget(new TargetBean());
// 暴露代理对象
pfb.setExposeProxy(true);
return pfb;
}
}
- 启动
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
applicationContext.scan("com.xie.java.aop.factorybean");
applicationContext.refresh();
TargetBean targetBean = applicationContext.getBean(TargetBean.class);
System.out.println("target bean :" + targetBean);
System.out.println("proxy bean :" + targetBean.getProxy());
// 任何代理对象都可以强制转换成 Advised对象
Advised advised = (Advised) targetBean;
System.out.println("advised :" + advised);
for (Advisor ad : advised.getAdvisors()) {
System.out.println("ad :" + ad );
System.out.println(" count = " + ((DebugInterceptor) ad.getAdvice()).getCount());
// 如果frozen = false, 可动态添加修改增强点
}
以上示例可以看出， ProxyFactoryBean是spring bean对象，目标类TargetBean不能是spring bean, 不然 getBean(TargetBean.class)会报异常。
getBean(TargetBean.class)查找ProxyFactoryBean的流程如下
1、根据类型TargetBean.class 查询spring容器中的所有bean Definition; 如果是FactoryBean则触发getType方法。
代码来自 DefaultListableBeanFactory
private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) {
List<String> result = new ArrayList<String>();
// Check all bean definitions.
for (String beanName : this.beanDefinitionNames) {
// Only consider bean as eligible if the bean name
// is not defined as alias for some other bean.
if (!isAlias(beanName)) {
try {
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// Only check bean definition if it is complete.
if (!mbd.isAbstract() && (allowEagerInit ||
(mbd.hasBeanClass() || !mbd.isLazyInit() || isAllowEagerClassLoading()) &&
!requiresEagerInitForType(mbd.getFactoryBeanName()))) {
// In case of FactoryBean, match object created by FactoryBean.
// 判断bean Definition是否是FactoryBean类型
boolean isFactoryBean = isFactoryBean(beanName, mbd);
BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();
boolean matchFound =
(allowEagerInit || !isFactoryBean ||
(dbd != null && !mbd.isLazyInit()) || containsSingleton(beanName)) &&
(includeNonSingletons ||
(dbd != null ? mbd.isSingleton() : isSingleton(beanName))) &&
isTypeMatch(beanName, type);
if (!matchFound && isFactoryBean) {
// In case of FactoryBean, try to match FactoryBean instance itself next.
beanName = FACTORY_BEAN_PREFIX + beanName;
matchFound = (includeNonSingletons || mbd.isSingleton()) && isTypeMatch(beanName, type);
}
if (matchFound) {
result.add(beanName);
}
}
}
..... 此处省略
// Check manually registered singletons too.
// 检查手动注册的单例
for (String beanName : this.manualSingletonNames) {
try {
// In case of FactoryBean, match object created by FactoryBean.
// 又一个FactoryBean判断
if (isFactoryBean(beanName)) {
if ((includeNonSingletons || isSingleton(beanName)) && isTypeMatch(beanName, type)) {
result.add(beanName);
// Match found for this bean: do not match FactoryBean itself anymore.
continue;
}
// In case of FactoryBean, try to match FactoryBean itself next.
beanName = FACTORY_BEAN_PREFIX + beanName;
}
// Match raw bean instance (might be raw FactoryBean).
if (isTypeMatch(beanName, type)) {
result.add(beanName);
}
}
... 此处省略
}
return StringUtils.toStringArray(result);
}
2、 找到ProxyFactoryBean后, 根据ProxyFactoryBean的 bean name 触发getBean(name, type args)
找到ProxyFactoryBean的实例后 触发getObjectForBeanInstance方法，从bean里获取bean
代码来着 AbstractBeanFactory
/**
* Get the object for the given bean instance, either the bean
* instance itself or its created object in case of a FactoryBean.
* @param beanInstance the shared bean instance
* @param name name that may include factory dereference prefix
* @param beanName the canonical bean name
* @param mbd the merged bean definition
* @return the object to expose for the bean
*/
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {
// Don't let calling code try to dereference the factory if the bean isn't a factory.
if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
// 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) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
Object object = null;
if (mbd == null) {
// 此处 触发从FactoryBean 缓存 获取 对象
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());
// 触发直接从FactoryBean 获取对象
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
3、触发ProxyFactory的 getObject()方法
public Object getObject() throws BeansException {
initializeAdvisorChain();
if (isSingleton()) {
return getSingletonInstance();
}
else {
if (this.targetName == null) {
logger.warn("Using non-singleton proxies with singleton targets is often undesirable. " +
"Enable prototype proxies by setting the 'targetName' property.");
}
return newPrototypeInstance();
}
}
总结ProxyFactoryBean到目标代理对象的流程。
1、spring根据getBean的目标类型查找BeanDefinition
2、如果BeanDefinition是FactoryBean，则触发其getType方法
3、拿到ProxyFactoryBean bean后， 最终触发FactoryBean的getObject方法拿到代理对象.
MyBatise在FactoryBean上的应用
MapperFactoryBean<T>
程序急需要定义Mapper接口，MapperFactoryBean就会为其生成代理对象.
Dubbo在FactoryBean上的应用
ReferenceBean<T>
dubbo会为标识为@Reference的注入使用javassist生成具体的bean.
Spring Context在FactoryBean上的应用
ScopedProxyFactoryBean
给声明了@RefreshScope的类生成代理, 处理配置实时刷新同步的问题
