Comment ApplicationContextAware travaux au Printemps?

Au printemps, si un bean implémente ApplicationContextAware, alors qu'il est en mesure d'accéder à la applicationContext. Par conséquent, il est en mesure d'obtenir d'autres haricots.
par exemple,

public class SpringContextUtil implements ApplicationContextAware {
    private static ApplicationContext applicationContext;     

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

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

Puis SpringContextUtil.getApplicationContext.getBean("name") pouvez obtenir le haricot "nom".

Pour ce faire, nous devons mettre cette SpringContextUtil à l'intérieur de la applications.xml, par exemple

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

Ici le haricot SpringContextUtil ne comprend pas la propriété applicationContext. Je suppose que quand le printemps bean initialiser, cette propriété est définie. Mais comment est-ce fait? Comment fonctionne la méthode setApplicationContext appelée?

C'est juste la façon dont des travaux du printemps. Printemps appels de méthode dans le cadre de l'initialisation du bean. Je ne vois pas le problème.
Le printemps est de la Magie. Embrasser la magie

InformationsquelleAutor Jimmy | 2014-02-04

java spring

84

Quand le printemps instancie des haricots, il recherche un couple d'interfaces comme ApplicationContextAware et InitializingBean. S'ils sont trouvés, les méthodes sont invoquées. E. g. (très simplifié)
```
Class<?> beanClass = beanDefinition.getClass();
Object bean = beanClass.newInstance();
if (bean instanceof ApplicationContextAware) {
    ((ApplicationContextAware) bean).setApplicationContext(ctx);
}
```
Noter que dans la version plus récente, il peut être préférable d'utiliser des annotations, plutôt que la mise en œuvre de printemps des interfaces spécifiques. Maintenant, vous pouvez simplement utiliser:
```
@Inject //or @Autowired
private ApplicationContext ctx;
```
- Merci beaucoup, c'est Ce que je veux! Peut-être que j'ai besoin de lire certains de printemps de code pour comprendre comment les travaux du printemps.
- Il est préférable d'utiliser @Autocâblés pour la plupart des cas, mais il y a d'autres où ça pourrait ne pas fonctionner, par exemple lorsque vous avez un "@Composante" qui est un singleton, mais vous avez besoin d'injecter un bean qui a une portée de session. Comme les dépendances sont autocâblés dans le contexte de l'application de création, vous n'aurez pas vraiment avoir un bean de session injecté, en ayant une référence au contexte de l'application, vous pouvez récupérer la session bean par programme, qui sera de retour le bean de session de l'instance correctement.
- J'attendrais le Printemps injecte généré dynamiquement, un proxy de la classe au lieu d'un classe a de l'application, mais lors de l'accès, il délègue à une session de la portée de l'instance, ou lève une exception il n'y a pas de demande lié à la thread en cours d'exécution
- si un sesson portée bean ne peut pas être obtenu à partir injecté ApplicationContext, alors il ne peut pas être obtenu à partir de ApplicationContextAware instance soit. Parce que ApplicationContextAware instance obtient un bean à partir de la même applicationContext objet comme celui injecté.
InformationsquelleAutor Bozho

Printemps de code source pour expliquer comment ApplicationContextAware travail

lorsque vous utilisez ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

Dans AbstractApplicationContext classe,le refresh() méthode avez le code suivant:

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

entrer dans cette méthode,beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)); va ajouter ApplicationContextAwareProcessor à 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));
...........

Quand le printemps initialiser haricot AbstractAutowireCapableBeanFactory,
dans la méthode initializeBean,appel applyBeanPostProcessorsBeforeInitialization pour mettre en œuvre la fève de post-traitement. le processus d'injecter de l'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;
    }

quand BeanPostProcessor mettre en œuvre Objectto exécuter le postProcessBeforeInitialization méthode,par exemple ApplicationContextAwareProcessor qui a ajouté de l'avant.

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);
            }
        }
    }

InformationsquelleAutor Edward

-1

ApplicationContextAware Interface ,l'actuel contexte de l'application, à travers lequel vous pouvez appeler le printemps conteneur de services. Nous pouvons obtenir en cours applicationContext instance injecté par la méthode ci-dessous dans la classe
```
public void setApplicationContext(ApplicationContext context) throws BeansException.
```
- Avertissement: Le lien mène à un anti-spam de type page web (dans le temps?)
InformationsquelleAutor techiesantosh

Vous devez vous connecter pour publier un commentaire.