Quelle est la meilleure pratique pour la manipulation de plusieurs profils de Printemps avec java config?

Sur un projet que je suis en train de travailler sur nous avons besoin de plusieurs profils, c'est à dire "par défaut" et "test". Pour résoudre ce problème, nous avons mis en œuvre un contexte principal de la classe, ApplicationContext.java avec 2 public static classes internes: l'une d'entre elles définit le profil par défaut, l'autre définit le profil de test. Notre web.xml est fixé pour cible ApplicationContext.java.

Code comme suit:

@Configuration
//import common beans
public class ApplicationContext {

  @Configuration  
  @Profile("default")
  public static class DefaultContext {
    //default beans
  }  

  @Configuration
  @Profile("test")
  public static class TestContext {
    //test beans
  }

}

Mon problème c'est que le contexte principal de la classe, ApplicationContext.java est dans l'environnement de production (c'est à dire src/main/java) avec des références à des fichiers dans l'environnement de test. Si il ya une meilleure façon de définir ces profils, sans l'introduction de cette dépendance de la production de code pour tester le code, ce serait bien sûr préférable.

Nous avons testé ces cas avec une jetée exemple dans une classe de test, a commencé à partir d'une méthode principale. Cette instance est exécuté avec la commande suivante:

System.setProperty("spring.profiles.active", "test");

OriginalL'auteur Jarle Svendsrud | 2013-04-09

java spring

Si tous les haricots sont communs entre vos profils (qui est, à la fois DefaultContext et TestContext contient les mêmes bean définitions), de définir une interface pour les dépendances, l'e.g:

public interface SystemConfiguration {

    public DataSource getDataSource();
    public SomeService getService();

}

Puis de mettre en œuvre chaque profil avec cette interface:

@Profile("production")
@Configuration
public class ProductionConfiguration implements SystemConfiguration {
    public DataSource getDataSource() {
         //create and return production datasource
    }

    public SomeService getService() {
        //Create and return production service
    }
}

Et puis faire de même pour le test.

@Profile("test")
@Configuration
public class TestConfiguration implements SystemConfiguration {
    public DataSource getDataSource() {
         //create and return dummy datasource
    }

    public SomeService getService() {
        //Create and return dummy service
    }
}

Ensuite, vous pouvez injecter dans votre configuration principal:

@Configuration
public class ApplicationContext {
    @Autowired
    private SystemConfiguration systemConfiguration;

}

Compte tenu de la complexité de notre application, ce n'était pas pratique à mettre en œuvre. La solution présentée est en effet très élégant. Un problème que nous avons eu avec cette solution est que l'un des principaux haricots a été défini dans un sous-module, avec aucune dépendance pour le module principal (où ApplicationContext est défini).

OriginalL'auteur NilsH

1

La solution que nous avons fini avec utilise du Printemps @ComponentScan annotation. Les différents contextes d'application sont définies dans plusieurs modules maven. Cependant, par le partage d'un même paquet de nommage (c'est à dire com.de l'entreprise.application.contexte), cette annotation trouve les contextes à travers à la fois de test et de production des répertoires.

Le code résultant:
```
@ComponentScan("com.company.application.context")
@Configuration
public class ApplicationContext { }
```
Tous les contextes de production et de test, les contextes sont trouvés automatiquement, en supposant que les dépendances maven et le paquet de nommage est correct. Le contexte de production ressemble à ceci:
```
@Configuration
@Profile("default")
//Import contexts from other modules
public class ProductionContext { }
```
De même pour le test de contexte. L'exécution de Jetée d'une méthode principale avec la ligne suivante correctement en charge le test de contexte et ignore la valeur "par défaut" des haricots:
```
System.setProperty("spring.active.profiles", "test");
```
Cette solution évite toute référence directe à partir de la production de code de test, bien que les dépendances maven sont nécessaires.

OriginalL'auteur Jarle Svendsrud
0

Utiliser les fonctionnalités de Maven pour principal séparé et l'application de test de contextes.

Par exemple, si votre application principale contexte de vie dans

src/main/webapp/WEB-INF/myapp-config.xml

vous pouvez mettre un test de contexte de l'application dans

src/test/webapp/WEB-INF/myapp-config.xml

Le truc, c'est que nous voulons commencer Jetée d'une java de la méthode main, pas de cmd avec une commande maven
De Plus, la principale différence est que des profils Maven générer une version différente pour chaque profil. Ainsi, la construction pour le développement local est différente de la libération de l'environnement. À mon avis, c'est une mauvaise approche, la construction doit être identique à garantir la compatibilité

OriginalL'auteur Qwerky

Vous devez vous connecter pour publier un commentaire.