¿Cómo funciona ApplicationContextAware en Spring?

En primavera, si un frijol se implementa ApplicationContextAware, entonces puede acceder al archivo applicationContext. Por lo tanto, puede obtener otros granos. p.ej

public class SpringContextUtil implements ApplicationContextAware {
    private static ApplicationContext applicationContext;     

    public void setApplicationContext(ApplicationContext context) throws BeansException {
      applicationContext = context;
    }

    public static ApplicationContext getApplicationContext() {
      return applicationContext;
    }
}

Entonces SpringContextUtil.getApplicationContext.getBean("name")puede obtener el "nombre" del bean.

Para hacer esto, debemos poner esto SpringContextUtildentro de applications.xml, por ejemplo

<bean class="com.util.SpringContextUtil" />

Aquí el frijol SpringContextUtilno incluye la propiedad applicationContext. Supongo que cuando se inicializa el frijol de primavera, se establece esta propiedad. Pero, ¿cómo se hace esto? ¿Cómo setApplicationContextse llama al método ?

Cuando spring instancia beans, busca un par de interfaces como ApplicationContextAwarey InitializingBean. Si se encuentran, se invocan los métodos. Ej. (Muy simplificado)

Class<?> beanClass = beanDefinition.getClass();
Object bean = beanClass.newInstance();
if (bean instanceof ApplicationContextAware) {
    ((ApplicationContextAware) bean).setApplicationContext(ctx);
}

Tenga en cuenta que en la versión más reciente puede ser mejor usar anotaciones, en lugar de implementar interfaces específicas de Spring. Ahora puedes simplemente usar:

@Inject // or @Autowired
private ApplicationContext ctx;

Spring código fuente para explicar cómo funciona ApplicationContextAware
cuando usa ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
En AbstractApplicationContextclase, el refresh()método tiene el siguiente código:

// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);

ingrese este método, beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));agregará ApplicationContextAwareProcessor a AbstractrBeanFactory.

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // Tell the internal bean factory to use the context's class loader etc.
        beanFactory.setBeanClassLoader(getClassLoader());
        beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
        beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
        // Configure the bean factory with context callbacks.
        beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
...........

Cuando spring initialize bean in AbstractAutowireCapableBeanFactory, en el método initializeBean, llame applyBeanPostProcessorsBeforeInitializationpara implementar el proceso de post de bean. el proceso incluye inyectar el applicationContext.

@Override
    public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
            throws BeansException {
        Object result = existingBean;
        for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
            result = beanProcessor.postProcessBeforeInitialization(result, beanName);
            if (result == null) {
                return result;
            }
        }
        return result;
    }

cuando BeanPostProcessor implemente Object para ejecutar el método postProcessBeforeInitialization, por ejemplo, ApplicationContextAwareProcessorel agregado antes.

private void invokeAwareInterfaces(Object bean) {
        if (bean instanceof Aware) {
            if (bean instanceof EnvironmentAware) {
                ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
            }
            if (bean instanceof EmbeddedValueResolverAware) {
                ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(
                        new EmbeddedValueResolver(this.applicationContext.getBeanFactory()));
            }
            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);
            }
        }
    }

Interfaz para ser implementada por cualquier objeto que desee ser notificado del ApplicationContext en el que se ejecuta.

arriba está extraído del sitio web de Spring doc https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/ApplicationContextAware.html .

Por lo tanto, parece que se invoca cuando se inicia el contenedor Spring, si desea hacer algo en ese momento.

Solo tiene un método para establecer el contexto, por lo que obtendrá el contexto y hará algo para algo ahora ya en el contexto, creo.

ApplicationContextAware Interface, el contexto actual de la aplicación, a través del cual puede invocar los servicios de contenedor de primavera. Podemos obtener la instancia de applicationContext actual inyectada por el método siguiente en la clase

public void setApplicationContext(ApplicationContext context) throws BeansException.