Spring?aware接口的作用是什么

這篇文章主要講解了“Spring aware接口的作用是什么”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“Spring aware接口的作用是什么”吧！

1. aware接口的作用

通過aware接口可以獲取Spring容器相關信息，但這樣會與Spring容器耦合。

2. 常用aware接口及作用

執行順序從上到下。

3. 使用樣例：ApplicationContextAware 在Bean中獲取上下文

/**
 * 獲取spring注入對象方法
 */
@Component("springUtil")
public final class SpringUtil implements ApplicationContextAware {
    /**
     * 應用上下文
     */
    private static ApplicationContext applicationContext;
    /**
     * public方法可能被調用，導致線程不安全。這樣寫也是為了通過sonar檢測
     * @param applicationContext 通過aware設置上下文
     */
    @Override
    public void setApplicationContext(@NonNull ApplicationContext applicationContext) {
        synchronized (SpringUtil.class) {
            if (null == SpringUtil.applicationContext) {
                SpringUtil.applicationContext = applicationContext;
            }
        }
    }

    /**
     * 獲取注入對象
     *
     * @param name 對象名稱
     * @return 指定注入對象
     */
    public static Object getBean(String name) {
        return getApplicationContext().getBean(name);
    }

    private static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    /**
     * 獲取注入對象
     *
     * @param clazz 對象類型
     * @param <T>   泛型
     * @return 指定注入對象
     */
    public static <T> T getBean(Class<T> clazz) {
        return getApplicationContext().getBean(clazz);
    }

    /**
     * 獲取注入對象
     *
     * @param name  對象名稱
     * @param clazz 對象類型
     * @param <T>   泛型
     * @return 指定注入對象
     */
    public static <T> T getBean(String name, Class<T> clazz) {
        return getApplicationContext().getBean(name, clazz);
    }
}

4. 自定義aware的方式

先定義一個繼承Aware的接口，然后注冊一個實現BeanPostProcessor接口的Bean，在postProcessBeforeInitialization中處理Aware接口的邏輯。

舉一個例子。獲取調用自定義Aware接口方法的時間。

4.1 定義繼承Aware的接口

public interface TimeAware extends Aware {
    void setTriggerTime(Date date);
}

4.2 注冊實現BeanPostProcessor接口的Bean

@Component
public class AwarePostProcessor implements BeanPostProcessor {
    private final ConfigurableApplicationContext applicationContext;
    /**
     * 可寫可不寫，這個構造是為了獲取applicationContext
     */
    public AwarePostProcessor(ConfigurableApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof Aware) {
            if (bean instanceof TimeAware) {
                // 實現自定義Aware接口的邏輯，設置調用的時間
                ((TimeAware)bean).setTriggerTime(new Date());
            }
        }
        return bean;
    }
}

4.3 實現TimeAware接口，并測試

@Import(AwarePostProcessor.class)
public class Test implements TimeAware {
    Date date;
    @Override
    public void setTriggerTime(Date date) {
        this.date = date;
    }

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(Test.class);
        Test bean = context.getBean(Test.class);
        System.out.println(bean.date);
    }
}

結果：

5. 源碼處理方式

• Bean實例化->填充屬性->初始化，在初始化階段將實現aware接口的Bean的方法執行。

1.先執行實現了下面三個aware接口的方法

• BeanNameAware

• BeanClassLoaderAware

• BeanFactoryAware

2.調用初始化方法

3.執行實現剩下aware接口的方法

5.1 初始化階段的源碼邏輯

AbstractAutowireCapableBeanFactory#initializeBean

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			/**
			 * 調用Bean實現的Aware接口的方法，主要包括下面三個接口
			 * BeanNameAware ----> setBeanName()
			 * BeanClassLoaderAware ----> setBeanClassLoader()
			 * BeanFactoryAware  ----> setBeanFactory()
			 */
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			/** 調用Bean對象的postProcessBeforeInitialization方法，此處會執行標注@PostConstruct注解的方法 */
			// 此處會調用ApplicationContextAwareProcessor執行其他的aware方法.
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
			/**
			 * 執行Bean的初始化方法:
			 *
			 * 1.先判斷Bean是否實現了InitializingBean接口，如果實現了InitializingBean接口，則調用Bean對象的afterPropertiesSet方法；
			 * 2.然后判斷Bean是否有指定init-method方法，如果指定了init-method方法，則調用bean對象的init-method指定的方法.
			 */
			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()) {
			/**
			 * 調用Bean對象的postProcessAfterInitialization方法
			 *
			 * 如果需要創建代理，在該步驟中執行postProcessAfterInitialization方法的時候會去創建代理
			 * 調用AbstractAutoProxyCreator類的postProcessAfterInitialization方法，然后調用wrapIfNecessary方法去創建代理.
			 *
			 *
			 * 另外還有一些Aware接口，也會在該步驟中執行，例如：ApplicationContextAwareProcessor后置處理器，對應的setApplicationContext方法會被執行.
			 */
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

5.2 實現前三個aware接口的處理

調用initializeBean =>invokeAwareMethods方法將前三個aware方法調用
AbstractAutowireCapableBeanFactory#invokeAwareMethods

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

5.3 剩余實現aware接口的Bean的處理

調用initializeBean =>applyBeanPostProcessorsBeforeInitialization=>BeanPostProcessor.postProcessBeforeInitialization
進入ApplicationContextAwareProcessor#postProcessBeforeInitialization=>invokeAwareInterfaces

private void invokeAwareInterfaces(Object bean) {
		if (bean instanceof EnvironmentAware) {
			((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
		}
		if (bean instanceof EmbeddedValueResolverAware) {
			((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
		}
		if (bean instanceof ResourceLoaderAware) {
			((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
		}
		if (bean instanceof ApplicationEventPublisherAware) {
			((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
		}
		if (bean instanceof MessageSourceAware) {
			((MessageSourceAware) bean).setMessageSource(this.applicationContext);
		}
		if (bean instanceof ApplicationContextAware) {
			((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
		}
	}

因此可以自定義aware接口，并且注冊一個實現BeanPostProcessor的postProcessBeforeInitialization方法的Bean，處理調用aware方法時的處理邏輯。

感謝各位的閱讀，以上就是“Spring aware接口的作用是什么”的內容了，經過本文的學習后，相信大家對Spring aware接口的作用是什么這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！