Fichier de configuration
Dans les exemples précédents, nous avons utilisé la définition du bean XML pour configurer les composants. Dans un projet légèrement plus grand, il y a généralement des centaines de composants. Si ces composants sont configurés à l'aide de définitions de bean XML, cela augmentera évidemment la taille du fichier de configuration, ce qui ne le rend pas très pratique pour trouver et entretenir.
Spring 2.5 introduit un mécanisme de balayage de composant automatique pour nous. Il peut trouver des classes annotées avec @Component, @Service, @Controller et @Repository Annotations sous le ClassPath, et incorporer ces classes dans le conteneur de printemps pour gérer.
Sa fonction est la même que l'utilisation des composants de configuration du nœud bean dans les fichiers XML. Pour utiliser le mécanisme de balayage automatique, nous devons ouvrir les informations de configuration suivantes:
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd "> <contextes: composant-scan Base-Package =" CN.itcast "/> </Ebands>
La configuration <context:component-scan base-package="cn.itcast" /> enregistre implicitement plusieurs processeurs qui analysent les annotations, y compris le <contexte: annotation- <context:component-scan base-package="cn.itcast" /> <context:annotation-config/> configuration. De plus, le package de base est un package (sous-package) qui doit être analysé.
annotation
@Service est utilisé pour annoter les composants de la couche commerciale, @Controller est utilisé pour annoter les composants de la couche de contrôle (tels que l'action dans Struts2), et @Repository est utilisé pour annoter le composant d'accès aux données, c'est-à-dire le composant DAO. @Component fait référence aux composants. Lorsque les composants ne sont pas faciles à classer, nous pouvons utiliser cette annotation pour annoter.
Cet article est basé sur le cas de @Autowire Annotation and Automatic Assembly.
Nous modifions d'abord le fichier de configuration de Spring en:
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd "> <contextes: composant-scan Base-Package =" CN.itcast "/> </Ebands>
Un exemple
Ensuite, utilisez @Service Annotation pour annoter la classe PersonServiceBean, comme suit:
@ServicePublic Class PersonServiceBean implémente PersonService {Private Persondao Persondao; public void setpersondao (persondao persondao) {this.persondao = persondao; } @Override public void Save () {persondao.add (); }}Annotez la classe Persondaobean à l'aide de l'annotation @Repository, comme suit:
@RepositoryPublic class PersondaObean implémente Persondao {@Override public void add () {System.out.println ("Exécuter la méthode add () en persondaobean"); }}Enfin, nous modifions le code de la classe Springtest à:
public class SpringTest {@Test public void instancespancesPring () {abstractApplicationContext ctx = new ClassPathXmlApplicationContext ("beans.xml"); PersonService PersonService = (PersonService) ctx.getBean ("PersonServiceBean"); Persondao Persondao = (Persondao) ctx.getBean ("Persondaobean"); System.out.println (PersonService); System.out.println (Persondao); ctx.close (); }}Testez la méthode InstancesPring () et vous pouvez voir que la console Eclipse imprime:
Si nous voulons utiliser le nom spécifié pour l'obtenir, nous pouvons modifier le code de la classe PersonServiceBean pour:
@Service ("PersonService") classe publique PersonServiceBean implémente PersonService {Private Persondao Persondao; public void setpersondao (persondao persondao) {this.persondao = persondao; } @Override public void Save () {persondao.add (); }}De cette façon, le code de la classe Springtest doit être changé en:
public class SpringTest {@Test public void instancespancesPring () {abstractApplicationContext ctx = new ClassPathXmlApplicationContext ("beans.xml"); PersonService PersonService = (PersonService) ctx.getBean ("PersonService"); System.out.println (PersonService); ctx.close (); }}Testez la méthode InstancesPring () et vous pouvez voir que la console Eclipse imprime:
Nous avons déjà appris la portée des haricots gérés par le printemps, et nous pouvons savoir que la portée des deux haricots gérés par le ressort ci-dessus est Singleton par défaut. Bien sûr, nous pouvons également modifier la portée des haricots gérés par le printemps, tels que la modification du code de la classe PonderServiceBean pour:
@Service ("PersonService") @Scope ("Prototype") Classe publique PersonServiceBean implémente PersonService {Private Persondao Persondao; public void setpersondao (persondao persondao) {this.persondao = persondao; } @Override public void Save () {persondao.add (); }}Cela signifie que la portée du PersonServiceBean géré par le printemps est devenue un prototype. À l'heure actuelle, nous modifions le code de la classe Springtest à:
public class SpringTest {@Test public void instancespancesPring () {abstractApplicationContext ctx = new ClassPathXmlApplicationContext ("beans.xml"); PersonService PersonService1 = (PersonService) ctx.getBean ("PersonService"); PersonService PersonService2 = (PersonService) ctx.getBean ("PersonService"); System.out.println (PersonService1 == PersonService2); ctx.close (); }}Testez la méthode InstancesPring () et vous pouvez voir que la console Eclipse imprime:
La portée du prototype signifie que chaque fois que vous obtenez un haricot d'un conteneur à ressort, c'est un nouvel objet.
Si les composants sont inclus dans le conteneur à ressort en scannant automatiquement sous le chemin de ClassPath, comment spécifier la méthode d'initialisation et la méthode de destruction du bean? Pour le moment, nous devons utiliser deux annotations: @postConstruct et @Predestroy. Pour l'expérimentation, nous avons modifié le code de la classe PersonServiceBean pour:
@Service ("PersonService") classe publique PersonServiceBean implémente PersonService {Private Persondao Persondao; @PostConstruct public void init () {System.out.println ("Initialize Resource"); } @Predestroy public void destrust () {System.out.println ("Détroyer, Close Resource"); } public void setpersondao (persondao persondao) {this.persondao = persondao; } @Override public void Save () {persondao.add (); }}Ensuite, nous devons modifier le code de la classe Springtest à:
public class SpringTest {@Test public void instancespancesPring () {abstractApplicationContext ctx = new ClassPathXmlApplicationContext ("beans.xml"); PersonService PersonService = (PersonService) ctx.getBean ("PersonService"); ctx.close (); }}De cette façon, testez la méthode InstancesPring () et la console Eclipse imprimera:
Pour afficher le code source, cliquez pour permettre à Spring de numériser et de gérer automatiquement les beans à télécharger.
Résumer
Ce qui précède est le package de scan à ressort automatique introduit par l'éditeur. J'espère que ce sera utile à tout le monde. Si vous avez des questions, veuillez me laisser un message et l'éditeur répondra à tout le monde à temps. Merci beaucoup pour votre soutien au site Web Wulin.com!