前言
不知道大家有没有遇到这样的场景,比如,我自己有一个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方法把对象注入进去
其实整个逻辑并不复杂,大家感兴趣可以自己去看一下