web-dev-qa-db-fra.com

Combien de façons existe-t-il de configurer le framework Spring? Quelles sont les différences entre eux techniquement? (Pas pour ou contre ..)

J'étudie this book (que je recommanderais vivement), et je suis confus quant à la façon dont les auteurs expliquent la manière dont le framework Spring peut être configuré.

Vous pouvez voir quelques exemples de code utilisés dans le livre here . (Ils sont disponibles pour tout le monde ..) Le code auquel je fais référence sera celui du chapitre 2, si vous souhaitez jeter un coup d'œil.

Quoi qu'il en soit, le livre indique qu'il existe 3 façons de configurer le conteneur Spring .

Configuration basée sur XML

Cela nécessitera un fichier XML ressemblant à ceci:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" ...>

    <bean id="accountService" class="com.wiley.beginningspring.ch2.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
    </bean>

    <bean id="accountDao" class="com.wiley.beginningspring.ch2.AccountDaoInMemoryImpl">
    </bean>

</beans>

Et ensuite, pour bootstrap Spring, le code qui sera utilisé sera:

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("/com/wiley/beginningspring/ch2/ch2-beans.xml");

Je n'ai aucune confusion en ce moment.

Configuration basée sur Java

Dans cette méthode de configuration, il y aura une classe pour la configuration comme suit:

@Configuration
public class Ch2BeanConfiguration {

    @Bean
    public AccountService accountService() {
        AccountServiceImpl bean = new AccountServiceImpl();
        bean.setAccountDao(accountDao());
        return bean;
    }

    @Bean
    public AccountDao accountDao() {
        AccountDaoInMemoryImpl bean = new AccountDaoInMemoryImpl();
        return bean;
    }
}

et le code responsable du démarrage de Spring ressemble à ceci:

ApplicationContext applicationContext
            = new AnnotationConfigApplicationContext(Ch2BeanConfiguration.class);

Donc, jusqu'ici, tout est clair pour moi. (Kind of ..) Je voudrais aussi noter que nous avons ici une annotation qui s'appelle @Configuration ...

Configuration basée sur les annotations

La dernière méthode de configuration disponible, expliquée dans le livre, est la configuration basée sur les annotations .

Il existe un fichier XML comme dans la configuration basée sur XML, mais il est beaucoup plus petit:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" ...>
    <context:component-scan base-package="com.wiley.beginningspring.ch2"/>
</beans>

Tous les haricots ont des annotations telles que:

@Component, @Service

etc..

Et toutes les dépendances ont les annotations:

@Autowired

afin que les haricots peuvent être injectés.

La façon dont le framework Spring a démarré avec cette méthode de configuration est la suivante:

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("/ch2-beans.xml");

Voici mes questions:

Pourquoi la configuration (ainsi appelée) basée sur des annotations utilise-t-elle réellement ClassPathXmlApplicationContext mais pas AnnotationConfigApplicationContext ci-dessus? Ce dernier semble beaucoup plus approprié pour être utilisé dans une configuration contenant les mots "Basé sur les annotations", n'est-ce pas?

La configuration basée sur Java expliquée dans le livre semble ressembler à ce qui devrait être appelé Configuration basée sur les annotations .

Et la façon dont la configuration basée sur les annotations est expliquée dans le livre me semble en réalité quelque chose comme: Configuration basée sur XML avec des beans Autowired. Il ne possède même pas l'annotation @Configuration, que possède la "Configuration basée sur Java".

De combien de façons existe-t-il pour configurer la structure Spring?

javaxmlspring
37
Koray Tugay

Pour éviter toute confusion, nous devons comprendre que cette définition de configuration et sont deux choses différentes. Il existe trois façons de définir la configuration, disponible au printemps 4 par défaut:

  • Configuration basée sur XML , lorsque vous décrivez la configuration dans un fichier xml;
  • Configuration basée sur Java , lorsque la configuration est Java, marquée avec des annotations spécifiques;
  • Configuration basée sur Groovy , lorsque la configuration est un fichier avec le code Groovy;

Et il y a deux façons d'ajouter une définition de bean dans l'application:

  • configuration à l'intérieur de définition du bean, lorsque vous ajoutez manuellement des beans par déclaration directement dans la configuration.

    Dans ce cas, la définition sera basée sur le type de configuration. Pour xml-config, il s'agira de la balise <bean/>, Pour la méthode de configuration basée sur Java avec l'annotation @Bean Et la construction beans {...} Pour Groovy.

  • basée sur une annotation définition du bean, lorsque vous marquez des classes de bean avec des annotations spécifiques (comme @Component, @Service, @Controller Etc). Ce type de configuration utilise balayage de chemin de classe .

    Dans ce cas, vous devez spécifier une directive pour l'analyse de classpath. Pour xml-config, ce sera <context:component-scan base-package="..."/>, Pour Java-config - une annotation @ComponentScan, Pour Groovy ctx.'component-scan'(...) invocation.

Comme vous le voyez, vous pouvez utiliser des configurations et des définitions de bean de différentes combinaisons.

Notez que si vous utilisez une configuration basée sur xml, vous pouvez choisir une approche pour piloter l'injection de dépendance: manuellement en XML, ou en utilisant des annotations (@Autowire, @Required Etc.). En cas de retard, vous devez définir <context:annotation-config/>. Mais ne confondez pas la définition de haricot et le contrôle d'injection de dépendance.

Maintenant basé sur ce point de vue, essayons de répondre à vos questions:

Pourquoi la configuration (dite appelée) basée sur les annotations utilise-t-elle réellement ClassPathXmlApplicationContext mais pas AnnotationConfigApplicationContext ci-dessus?

L'auteur du livre a mélangé les concepts. En réalité, il s’agit d’une configuration basée sur XML avec une définition de bean basée sur des annotations.

La configuration basée sur Java expliquée dans le livre) ressemble à ce qui devrait être appelé Configuration basée sur les annotations.?

Vous avez raison - Java utilise activement les annotations et peut être appelée fonction Annotation. Mais annotation fait partie de Java. En outre, il s'agit d'un terme traditionnel, spécifié dans la documentation .

De combien de façons existe-t-il pour configurer la structure Spring?

Donc, par défaut, nous avons trois façons de décrire la configuration et deux façons de définir des beans. Cela fait six façons de configurer la structure Spring (par défaut). Mais, bien sûr, tous ces moyens peuvent être utilisés en combinaison les uns avec les autres.

43
Ken Bekov

Le moyen le plus simple de comprendre cela consiste à examiner la longue histoire du cadre de développement.

  • Configuration basée sur XML - c'était là depuis le début - version 1 - voir javadoc pour ClassPathXmlApplicationContext . C'était vers mars 2004, à l'époque de J2EE 1.4, avec une configuration XML énorme et Spring une grande simplification (XML également, mais plus simple). Cela utilise XML pour tout, y compris la spécification du câblage automatique, ou les dépendances qui vont directement où (exemple: ref = "accoundDao").

  • Configuration basée sur les annotations - dans Spring 2.5 - ceci était une réaction à Java EE 5, de nouvelles annotations comme @ Autowired ont été introduites, il y avait encore une configuration de contexte en XML fichiers - en général, vous définissiez quels paquets devaient être analysés et le reste était fait automatiquement en fonction des annotations - d'où le nom.

  • La configuration basée sur Java fournie avec Spring 3 a été améliorée dans les versions ultérieures. C'est à ce moment que AnnotationConfigApplicationContext et une annotation de configuration ont été introduits - vous pouvez potentiellement supprimer XML entièrement -> Java. Bien que cela ne soit devenu pratique qu'avec la version 4+, d'un grand nombre de balises xml helper pour aop, jdbc etc.

A côté de ces 3 (2 en fait, 1 et 2 utilisant la même classe ApplicationContext), il existe d'autres moyens de créer un contexte:

9
frant.hartm

Au début, je tiens à remercier Ken Bekov pour sa réponse plus ingénieuse. J'ai essayé d'improviser sa réponse afin que tout le monde puisse en apprendre davantage sur ce sujet.

Définition de la configuration:

Spring 4 contient 3 façons de définir sa configuration. Elles sont

enter image description here

Avantages de l'annotation:

  1. Tous les information is in a single file (Pas besoin d'ouvrir deux fichiers pour configurer un comportement donné)

  2. Lorsque la classe change, no need to modify the xml file

  3. Les annoations sont souvent plus intuitives et robustes lors de la re-factorisation du code d'application. En outre, ils bénéficient d'un meilleur IDE comme le fournit gue. Mais ils mélangent le code d'application avec des préoccupations relatives aux ID. Une application devient dépendante d'un framework. La séparation claire est presque impossible. Annotations are also limited when describing different injection behaviour at the same place (constructor, field) dependent on other circumstances (e.g. robot legs problem). De plus, ils ne permettent pas de traiter les classes externes (code de bibliothèque) comme votre propre source, elles sont donc considérées comme plus rapides que XML.

Avantages du fichier XML:

  1. Séparation nette entre le POJO et son comportement

  2. Lorsque vous ne savez pas quel POJO est responsable du comportement, il est plus facile de le trouver (recherche dans un sous-ensemble de fichiers plutôt que dans tout le code source)

  3. XML a le seul avantage d'un style déclaratif défini clairement séparé du code d'application lui-même. Cela reste indépendant des préoccupations de DI. Les inconvénients sont le comportement verbosity, poor re-factoringrobustness et a general runtime failure. Il existe simplement un support d’outil (XML) général avec peu d’avantages par rapport au support IDE pour Java, par exemple. Toutefois, ce XML s'accompagne d’une surcharge de performances, il s’agit donc généralement de slower than code solutions.

XML et lien basé sur l'annotation:

  1. http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/#beans-annotation-config
  2. Annotations vs XML, avantages et inconvénients
  3. injection de dépendance Java: XML ou annotations
  4. Configuration de DI vs XML basée sur des annotations Spring?
  5. configuration XML versus configuration basée sur l'annotation

Lien basé sur Groovy:

  1. https://objectpartners.com/2016/01/12/using-groovy-based-spring-configuration/
  2. http://blog.andresteingress.com/2014/02/14/grails-Java-based-spring-config/

Définition du haricot:

Il y a 2 façons de haricot Définition: enter image description here

Classpath d'analyse:

Pour xml-config ce sera <context:component-scan base-package="..."/>, pour Java-config - @ComponentScan Annotation , pour Groovy ctx.'component-scan'(...) invocation.

Injection de dépendance:

Dans la configuration basée sur XML, dependency injection Peut être effectué manuellement dans xml ou en utilisant annotations (@Autowire, @Required, etc.). Dans ce cas, il est nécessaire de définir <context:annotation-config/>

Question et réponse:

Q1: Pourquoi la configuration (dite) annotée utilise-t-elle réellement ClassPathXmlApplicationContext mais pas AnnotationConfigApplicationContext ci-dessus?

Ans: Il s'agit d'une configuration basée sur XML avec une définition de bean basée sur des annotations.

Contexte d'application:

  1. http://docs.spring.io/spring/docs/4.2.0.RELEASE/javadoc-api/org/springframework/context/ApplicationContext.html

AnnotationConfigApplicationContext:

1 . AnnotationConfigApplicationContext et contexte parent

ClassPathXmlApplicationContext:

  1. http://www.tutorialspoint.com/spring/spring_applicationcontext_container.htm
  2. http://www.mkyong.com/spring3/spring-3-hello-world-example/

Q2: La configuration basée sur Java expliquée dans le livre) semble ressembler à ce qui devrait être appelé Configuration basée sur les annotations .?

Ans: Vous avez raison sur ce cas. Java utilise des annotations et est appelée configuration basée sur les annotations. Toutefois, les annotations ne représentent qu'une partie de Java, rien d'autre.

Mais nous avons besoin de comprendre comment cette hiérarchie passe du xml aux annotations et enfin au groovy?

Une alternative aux configurations XML est fournie par la configuration basée sur les annotations qui s'appuie sur les métadonnées de bytecode pour le câblage des composants au lieu des déclarations entre crochets angulaires. Au lieu d'utiliser XML pour décrire un câblage de bean, le développeur déplace la configuration dans la classe de composant elle-même en utilisant des annotations sur la déclaration de classe, de méthode ou de champ appropriée. Comme mentionné dans la section intitulée "Exemple: Le RequiredAnnotationBeanPostProcessor" , l'utilisation d'un BeanPostProcessor en conjonction avec des annotations est un moyen courant d'étendre le conteneur Spring IoC. Par exemple, Spring 2.0 a introduit la possibilité d'appliquer les propriétés requises avec l'annotation @Required.

Spring 2.5 permettait de suivre cette même approche générale pour piloter l’injection de dépendance de Spring. L'annotation @Autowired Fournit essentiellement les mêmes fonctionnalités que celles décrites dans Section 6.4.5, "Collaboration automatique de collaborateurs" mais avec un contrôle plus fin et une applicabilité plus large.

Spring 2.5 a également ajouté la prise en charge des annotations JSR-250 telles que @PostConstruct Et @PreDestroy.

Spring 3.0 a ajouté la prise en charge des annotations JSR-330 (injection de dépendance pour Java) contenues dans le package javax.inject, telles que @Inject Et @Named. Des détails sur ces annotations peuvent être trouvés dans le section pertinente.

Q3: Combien de façons existe-t-il de configurer le framework Spring?

Ans:

Theoretically, 3 façons de décrire la configuration et 2 façons de définir des beans. Il tourne 3 * 2 = 6 façons de configurer le framework Spring (par défaut). Tous ces moyens peuvent être utilisés en combinaison les uns avec les autres.

But Actually, Dans un seul mot, nous pouvons configurer le framework spring en utilisant XML ou annotations.

5
SkyWalker

Pas exactement. Il n'y a que deux façons de configurer le framework Spring. Les deux outils de configuration de base du framework Spring sont les suivants:

  • Fichiers XML (en dehors des Java)
  • Annotations basées sur Java (5 +) (à l'intérieur des Java))

Les deux peuvent être utilisés pour:

  • configurer un contexte d'application (ce qui signifie ajouter des beans) - les constructeurs de contextes d'application concrets acceptent les fichiers xml, les packages à analyser ou les classes directement nommées à charger
  • amorcez un contexte d'application dans le cas d'une application Web - en utilisant web.xml vs en utilisant une classe implémentant WebApplicationInitializer

Et pour couronner le tout:

  • vous pouvez numériser des annotations à partir d'un fichier de configuration XML en utilisant <context:component-scan/>
  • vous pouvez charger un fichier XML à partir d'un bean de configuration annoté en utilisant @import

La deuxième manière appelée Java Based Configuration dans votre livre est une annotation particulière @Configuration. Une classe annotée avec elle sera normalement un bean dans le contexte de l'application, mais elle peut également déclarer d'autres beans avec le @Bean annotation sur une méthode. C'est la raison pour laquelle ces classes sont généralement chargées directement au lieu d'être analysées.

La troisième méthode appelée Configuration basée sur les annotations, consiste simplement en un mélange des deux modes, dans lequel vous utilisez la configuration xml à un niveau supérieur et n'analysez que des packages pour des beans supplémentaires.

TL/DR: il n’existe que 2 façons de configurer un contexte d’application dans le framework Spring:

  • fichiers de configuration xml
  • Annotations Java

et ils peuvent être mélangés

mais chaque haricot peut être déclaré de 3 manières:

  • à partir d'un fichier xml
  • avec un @Bean annotation à l'intérieur d'un @Configuration haricot annoté
  • directement avec un @Component _ (ou l’une des annotations spécialisées @Controller, @Service, etc.)

Maintenant, pour vos questions précises:

Pourquoi la configuration (dite appelée) basée sur les annotations utilise-t-elle réellement ClassPathXmlApplicationContext mais pas AnnotationConfigApplicationContext ci-dessus?

Parce que le contexte d'application est d'abord initialisé, il s'agit d'un fichier de configuration XML. L'analyse du paquet se produit plus tard avec l'aide de <context:scan ...> Mots clés. Vous utilisez un AnnotationConfigApplicationContext si vous l'initialisez directement à partir de classes de configuration ou via l'analyse de packages.

La configuration basée sur Java expliquée dans le livre) ressemble à ce qui devrait être appelé Configuration basée sur les annotations.?

Ils l’appellent basé sur Java car il n’a pas besoin de xml, la configuration utilise uniquement Java.

3
Serge Ballesta

Je n'ai pas regardé le livre, mais vos hypothèses sont en fait correctes.

Pour démarrer une application Spring et faire en sorte que tous les beans soient instanciés par la structure à l'aide de beans configurés XML, vous devez utiliser un ClassPathXmlApplicationContext.

Il y a 2 façons de configurer les beans au printemps:

1) Beans XML 2) Approche d'annotation

Fondamentalement, les beans XML ont été utilisés dans Spring 2.5-3 et l’approche Annotations est davantage utilisée dans Spring 4.

@Bean // is a way to create a bean. It is the equalivant of the beans tag in XML.

@Configuration // is a way to tell the Spring container that this class is a list of configuration beans

Spring a 2 conteneurs de printemps:

1) BeanFactory 2) ApplicationContext

Un BeanFactory est le conteneur le plus simple et n'accepte qu'un fichier de configuration. Un ApplicationContext est le conteneur Spring le plus avancé et est utilisé dans les applications d'entreprise car il accepte un tableau de fichiers de configuration, a une intégration JNDI, une intégration EJB et prend en charge l'internationalisation des messages.

J'espère que ça aide.

1
Rajiv Jain

Permettez-moi d'abord d'afficher un code différent en premier:

  1. XML: vous devez enregistrer votre bean printemps dans un fichier de contexte xml en utilisant <bean/>

  2. Configuration Java: vous devez utiliser @Configuration et @Bean pour enregistrer votre haricot de printemps en contexte.

  3. Annotation: en utilisant @Component et ses amis est en fait commun pourrait être utilisé avec 2 autres en utilisant:

    1. en xml en utilisant <context:component-scan/>
    2. dans Java config en utilisant @ComponentScan

Pourquoi utilisé ClassPathXmlApplicationContextparce qu'il a utilisé xml pour configurer l'analyse des composants, mais s'il a utilisé @ComponentScan utilisera alors AnnotationConfigApplicationContext

Donc pour moi, je le considère comme deux manières d’initialiser le contexte printanier xml ou Java) configuration et annotation est une option qui pourrait être utilisée par l’un d’eux ou ne pas être utilisée du tout.

1
Bassem Reda Zohdy

Les trois façons de configurer le framework Spring ne sont pas du tout supposées s’exclure mutuellement. En fait, je suppose qu'en moyenne, vous en trouverez au moins deux utilisés ensemble.

La configuration basée sur les annotations est la moins susceptible d'être utilisée de manière autonome, simplement parce qu'elle repose sur des métadonnées dispersées de manière inhérente dans le code source.

Le AnnotationConfigApplicationContextpeut être utilisé pour déclencher un pur contexte basé sur une annotation, mais vous devrez passer toutes vos classes annoté comme @Component ou dérivés, plutôt que de passer par un seul (ou deux) @Configuration- classe (s) annotée - ce qui n’est généralement pas pratique.

Bien que ceci soit à peu près identique à la liste statique des beans en XML ou à la configuration de Java), le fait que vous ayez à le faire dans le code lorsque vous construisez le contexte de l'application le rend moins utile. , car vous ne pouvez pas bénéficier des différentes méthodes intelligentes pour déclencher automatiquement un contexte d'application (dans des contextes Web, etc.).

C’est pourquoi vous voudrez probablement pouvoir assembler les métadonnées du graphe d’objets en une seule fois, et ne peut être obtenu qu’avec une configuration XML ou Java, qui reposent sur des fonctions "centralisées". "métadonnées décrivant le graphe objet entier.

Pour les approches XML et Java, ces "métadonnées centralisées" (<beans> ou @Configuration) peut être défini statiquement (avec <bean> ou @Bean définitions) ou dynamiquement (en utilisant <component-scan> ou @ComponentScan). Il est donc raisonnable de dire que ces deux approches ne sont que des formats différents avec à peu près les mêmes capacités qui peuvent toutes les deux tirer parti de la configuration basée sur des annotations pour la collecte des métadonnées "décentralisées".

1
Costi Ciudatu