spring中的Aware接口的作用以及代码剖析

前言

      不知道大家有没有遇到这样的场景，比如，我自己有一个PersonService,  实现类是PersonServiceImpl，我想在PersonServiceImpl中使用applicationContext，怎么去做呢？如果使用xml的话，我们当然可以使用构造函数方式注入，要么用setter方式注入，也使用@Resouce或者@Autowired(在springboot中可以)， 在spring mvc中自己可以尝试一下(之前好像用过是不行的)。或者我想在PersonServiceImpl中获取PersonServiceImpl对应的在spring容器中的beanName，该如何做？总不能手动指定吧，也可以，那么有没有更好的方法呢？请看如下内容

正文

      在spring中有一个Aware接口，源码如下：

public interface Aware {

}

接口里面没有任何方法，Aware百度翻译：感知，有意识的。简单来说，他就是一个标识，实现此接口的类会用有某种功能，spring容器会去告知这个类拥有什么功能

现看先Aware接口都有哪些子类

简单说明几个：

ApplicationContextAware接口:  此接口中有一个setApplicationContext的方法，实现此方法便可以获取到applicationContext对象

BeanFactoryAware接口: 此接口中有一个setBeanFactory的方法，实现此方法便可以获取到BeanFactory对象

.....

其实就是spring使用了自动set方法注入，而不用我们自己去xml里面配置了

下面代码演示一波，以BeanNameAware作为示例

代码如下：

/**
 * @description 实现了BeanNameAware接口
 * @author: lierl
 * @date 2019-09-17 11:22
 * @version: 1.0
 **/
@Component
public class PersonOne implements BeanNameAware {
    private String name;
    @Override
    public void setBeanName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "PersonOne{" +
                "name='" + name + '\'' +
                '}';
    }
}

/**
 * @description 单独一个bean
 * @author: lierl
 * @date 2019-09-17 11:22
 * @version: 1.0
 **/
@Component
public class PersonTwo {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "PersonOne{" +
                "name='" + name + '\'' +
                '}';
    }
}

两个类的唯一区别就是PersonOne实现了BeanNameAware接口，而PersonTwo没有，此时我们获取对应的bean，然后并打印对象接的结果是什么呢？

Object personOne = context.getBean("personOne");
System.out.println("personOne: " + personOne);
Object personTwo = context.getBean("personTwo");
System.out.println("personTwo: " + personTwo);

执行结果

personOne: PersonOne{name='personOne'}
personTwo: PersonTwo{name='null'}

总结：

     Aware有很多子接口，这些接口拥有一种感知能力，把你想要的对象注入到你的类中，大家可以自己去使用一下ApplicationContextAware和其他接口

源码分析(基于springboot)：

在创建bean的过程中进行调用了Aware中的子接口方法，从doCreateBean入口

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {

		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		final 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 {
					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.isDebugEnabled()) {
				logger.debug("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
			populateBean(beanName, mbd, instanceWrapper);
			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) {
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				}
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
					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 " +
								"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
					}
				}
			}
		}

		// Register bean as disposable.
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

初始bean的方法中 initializeBean(beanName, exposedObject, mbd);

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
		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 {
			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()) {
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

然后调用invokeAwareMethods(beanName, bean) 此处就是核心点

private void invokeAwareMethods(final String beanName, final 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);
			}
		}
	}

先判断当前实例化的bean是否实现了Aware接口，然后判断实现了哪个子接口，在调用对应的set方法把对象注入进去

其实整个逻辑并不复杂，大家感兴趣可以自己去看一下