Remplacer default-lazy-init = true pour les définitions de bean Spring

Je suis en conservant une grande Java EE du système. La plupart de la logique métier est converti à partir d'EJB:s dans POJO:s configurés dans plusieurs printemps contexte fichiers de configuration. EJB:s sont principalement utilisés comme des Façades, qui recherche la logique métier beans spring à partir d'un contexte composé de tous les printemps contexte fichiers de configuration mentionné plus tôt. Pour cela, nous utilisons la AbstractStatelessSessionBean fourni avec le framework spring.

Tous ces fichiers de configuration ont la valeur par défaut-lazy-init=true directive, ce qui signifie que la logique métier de haricots ne sont pas créés jusqu'à ce qu'ils sont réellement utilisés par le système. C'est préférable que la plupart du temps depuis la réédition en mode développeur devient plus rapide.

Mais lorsque de grandes fusions, nous rencontrez des problèmes pour trouver toutes les erreurs de configuration, tels que les dépendances manquantes.

Mon idée est d'écrire une certaine forme de test d'intégration, dans le but de trouver ces erreurs. Cela signifie, je pense, que j'ai besoin de trouver un moyen de remplacer le tout par défaut-lazy-init=true déclarations lors de la création du contexte de l'application.

Est-il possible de le faire par programmation, ou peut-être avec un test-c'est le contexte de fichier qui contient tous les réels contexte fichiers?

source d'informationauteur Jon

java spring

14

Disons actuellement, vous avez un seul applicationContext.xml fichier contenant tous les haricots définitions:
```
<beans default-lazy-init="true">

    

</beans>
```
Renommer applicationContext-main.xml ou quelque chose et supprimer default-lazy-init="true" attribut. Maintenant créer deux applicationContext.xml fichiers:
```
<beans default-lazy-init="true">

    <import resource="applicationContext-core.xml"/>

</beans>
```
et:
```
<beans default-lazy-init="false">

    <import resource="applicationContext-core.xml"/>

</beans>
```
Comme vous pouvez le voir, la seule différence est la valeur de default-lazy-init. Au cours du développement de votre équipe peut utiliser l'ancienne version de applicationContext.xml qui comprend tous les haricots avec lazy-init. Sur l'organisation d'environnement de tests et de les transférer à la dernière, de sorte que tous les haricots inclus dans applicationContext-core.xml sont créés avec impatience.
8

Je crois que la meilleure façon est de contrôler paresseux init de haricots est de laisser la valeur par défaut-lazy-init de tous les fichiers de config sauf le premier que Tomasz Nurkiewicz suggère. Je n'ai cependant dans ce cas besoin d'un moyen rapide et sale corrigé pour vérifier tous les haricots définitions. (C'est un peu un processus de modification du paresseux init politique.)

Je suis venu avec un simple BeanFactoryPostProcessor qui semble faire la job:
```
public class NonLazyInitBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        for (String beanName : beanFactory.getBeanDefinitionNames()) {
            beanFactory.getBeanDefinition(beanName).setLazyInit(false);
        }
    }
}
```
Si inclus dans un fichier de contexte, il remplace le paresseux init indicateur est défini par tout inclus contexte fichiers.
```
<beans default-lazy-init="false">
    <bean class="example.NonLazyInitBeanFactoryPostProcessor" />
    <import resource="applicationContext-core.xml"/>
</beans>
```
Si je tente de créer un contexte à partir de ci-dessus xml, les erreurs de configuration précédemment masqués par paresse, l'initialisation ne se montrent immédiatement comme des exceptions.
1

Il y a un "mais" dans ce post-processeur
```
for (String beanName : beanFactory.getBeanDefinitionNames()) {
        beanFactory.getBeanDefinition(beanName).setLazyInit(false);
    }
```
Cette boucle va se répéter seulement sur le haut de la plupart des haricots non compris les e.g interne(local) de haricots definitions ...
0

Vous ne pouvez pas accéder au scanner du contexte - il est complètement privé, mais puisque vous pouvez entrer dans le code source, vous pouvez voir ce qui est nécessaire pour mettre en place votre propre. J'ai utilisé du Printemps propres ReflectionTestUtils pour définir mon propre configuré scanner dans le contexte:
```
    ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(context);
    BeanDefinitionDefaults defaults = new BeanDefinitionDefaults();
    defaults.setLazyInit(true);
    scanner.setBeanDefinitionDefaults(defaults);
    ReflectionTestUtils.setField(context, "scanner", scanner);
    context.scan("com.some.path");
```
Vous pouvez le faire n'importe où vous avez accès au Contexte de l'Application avant que le composant d'analyse.

Vous devez vous connecter pour publier un commentaire.