1. Notes
L'annotation est un mécanisme similaire à l'annotation. L'ajout d'annotations dans le code peut utiliser ces informations à un moment donné plus tard. Contrairement aux commentaires, les commentaires sont pour nous de voir. La machine virtuelle Java ne peut pas se compiler et les annotations ne sont pas compilées, mais nous pouvons lire les informations dans les annotations via le mécanisme de réflexion. Annotation utilise le mot-clé @interface, hérite java.lang.annotition.annotation
1. Annotations en javase
Permettez-moi de vous donner un exemple pour passer en revue ce qu'est l'annotation dans Javase. La clé est deux points: la définition de l'annotation et comment obtenir les informations au-dessus de l'annotation par réflexion.
1. Définissez d'abord deux annotations. L'un est une classe annotée sur la classe, et l'autre est annoté MethodInfo sur la méthode.
Classinfo
package com.itheima10.annotation; import java.lang.annotation.documented; import java.lang.annotation.elementType; import java.lang.annotation.retention; import java.lang.annotation.retentionpolicy; Importer java.lang.annotation.target; @target (elementtype.type.type) //notation. être utilisé sur la classe @retention (retentionPolicy.runtime) // Dans Java, les fichiers de classe et les annotations d'exécution @Documented // peuvent être générés dans le document d'aide public @Interface classinfo {/ ** * Cette annotation a deux propriétés de type de chaîne * @return * / string name () Default "; String Value () par défaut "";}Méthodinfo
package com.itheima10.annotation; import java.lang.annotation.documented; import java.lang.annotation.elementType; import java.lang.annotation.retention; import java.lang.annotation.retentionpolicy; Importer java.lang.annotation.target; @target (elementtype.Method) //notation.target; @target (elementtype. être utilisé sur Methods @retention (retentionPolicy.runtime) // Dans Java, les fichiers de classe et les annotations d'exécution @Documented // peuvent être générés dans l'aide à un document public @interface methodinfo {/ ** * Cette annotation a deux propriétés de type de chaîne * / string name () par défaut ""; String Value () par défaut "";}2. Écrivez une classe AnnotationUse pour utiliser l'annotation définie ci-dessus
Package com.itheima10.annotation; @classInfo (name = "xiaopingGuo118", value = "niu") Classe publique AnnotationUse {@MethodInfo (name = "Java", Value = "Spring Framework est important") public Void Java () {}}3. Écrivez l'annotation de la classe de test et analysez les propriétés au-dessus des deux annotations
package com.itheima10.annotation; import java.lang.reflect.method; import org.junit.test; public class annotationtest {public static void test () {/ ** * si analyse l'annotation de la classe, obtenez la classe * Si l'annotation de la méthode, obtenez la méthode d'abord * / class1 = itHeaMa10.class; // jugez s'il y a une annotation classinfo sur la classe if (class1.isannotationPresent (classinfo.class)) {// Obtenez l'annotation sur la classe ClassClassInfo ClassInfo = (classInfo) class1.getAnTannotation (classinfo.class); System.out.println (classinfo.value ()); System.out.println (classInfo.Name ()); } Méthode [] méthodes = class1.getMethods (); pour (méthode Méthode: méthodes) {// y a-t-il une annotation de méthode sur la méthode étant traversée if (method.isannotationPresent (méthodeInfo.class)) {MethodInfo methodinfo = method.getannotation (méthodinfo.class); System.out.println (méthodyInfo.Name ()); System.out.println (méthodyInfo.Value ()); }}} @Test public void test () {annotationTest.Test (); }}2. Annotations au printemps
Le framework Spring nous fournit des fonctions d'annotation.
L'utilisation de la programmation d'annotation est principalement pour remplacer les fichiers XML et accélérer le développement. Cependant, l'utilisation de fichiers XML est de résoudre le problème de la modification du code source du programme. Maintenant que je n'utilise pas de fichiers XML, cela ne violerait-il pas le principe de l'ouverture et de la fermeture? C’est vrai. Cependant, les annotations sont également bonnes, vous n'avez donc pas besoin de configurer autant de fichiers XML lorsque vous utilisez des annotations. La chose la plus importante est qu'ils ont une efficacité de développement élevée. .
Lorsqu'aucune annotation n'est utilisée, de nombreuses balises <anan> doivent être configurées dans le fichier de configuration ApplicationContext.xml du Framework Spring pour déclarer les objets de classe. En utilisant des annotations, vous n'avez pas besoin d'ajouter des extraits de balises dans le fichier de configuration, et la description correspondante consiste à ajouter des instructions dans la position "commentaire" de la classe correspondante. L'introduction spécifique est la suivante:
• 1. La combinaison de relations entre les objets @Resource , la valeur par défaut est de s'assembler par son nom. Si l'objet associé ne peut être trouvé sur la base du nom, la recherche par type se poursuivra. Si aucun attribut de nom n'est spécifié,
• Lorsque l'annotation est marquée sur un champ, la valeur par défaut est de prendre le nom du champ comme nom de bean pour trouver l'objet de dépendance
• Lorsque l'annotation est marquée sur la méthode du secteur de l'attribut, le nom d'attribut par défaut est pris en tant que nom de bean pour trouver l'objet de dépendance.
• Remarque: si l'attribut de nom n'est pas spécifié et que l'objet de dépendance ne peut pas être trouvé par défaut, l'annotation @Resource retombe à l'assemblage par type. Mais une fois l'attribut de nom spécifié, il ne peut être assemblé que par nom.
• 2. @Autowired
@Autowired est assemblé par type par défaut, @Resource est assemblé par nom par défaut, et ce n'est que lorsqu'un bean correspondant au nom ne peut être trouvé par type. La solution consiste à assembler des objets dépendants par type. Par défaut, il nécessite des objets dépendants d'exister. Si les valeurs NULL sont autorisées, elle peut être définie sur False.
• 3. @Qualificatif
Si nous voulons utiliser l'assemblage par nom, nous pouvons l'utiliser en conjonction avec l'annotation @qualifier.
1. Pour utiliser des annotations, vous devez ajouter des étapes d'espace de noms et de fichier de contraintes dans le fichier de configuration:
Présentation de l'espace de noms de contexte
<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"
...
http://www.springframework.org/schema/context/spring-context-2.5.xsd ">
2. Ajouter un contexte: balise annotation-config dans le fichier de configuration
<Context: Annotation-Config> </ Context: Annotation-Config>
Exemple de démonstration:
Écrivez une classe de personne avec un attribut étudiant et une méthode Say (). Le code est le suivant
Package com.itheima10.spring.di.annotation; import javax.annotation.resource; import org.springframework.beans.factory.annotation.autowired; import org.springframework.beans.factory.annotation.qualifier; / ** * @ autowired // match by type * * @ autowifier // par le paro type @ qualificatif ("étudiant") * * / classe publique Personne {@Resource (name = "Student") étudiant privé; public void sait () {this.student.say (); }}Le code de classe étudiante est le suivant
package com.itheima10.spring.di.annotation; classe publique étudiant {public void say () {System.out.println ("étudiant"); }}Configurer le fichier applicationContext.xml
<? xml version = "1.0" Encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: context = "http://www.springframework.org/schema/context" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xsi: scheMalation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.xsd "> <! Spring Container -> <bean id = "Person"> </anEn> <bean id = "Student"> </ Bean> <! - Introduire un espace de nom de contexte xmlns: context = "http://www.springframework.org/schema/context" http://www.springframework.org/schema/Con http://www.springframework.org/schema/context/spring-context-2.5.xsd "-> <! - L'annotation analyseur qui a été injecté depuis son démarrage -> <contextes: annotation-config> </ contexte: annotation-config> </fEARS>
Écrire la classe de test annotationtest
package com.itheima10.spring.di.annotation; import org.junit.test; import org.springframework.context.applicationContext; import org.springframework.context.support.classpathxmlapplicationcontext; / ** * principe: * 1. Démarrer le conteneur Spring * 2. Instantif Le conteneur est analysé à * <Context: Annotation-Config> </ Context: Annotation-Config> *, l'annotation l'analyseur pour l'injection de dépendance sera lancée * 4. Le conteneur de printemps consultera dans la portée des beans inclus dans la direction du printemps pour voir quelles propriétés de ces classes sont ajoutées avec @Resource Annotation * 5. L'attribut de l'annotation est "" * Si c'est "", il correspondra au nom de l'attribut où se trouve l'annotation et la valeur de l'ID dans le conteneur à ressort. Si le match réussit, l'affectation * Si le match est échoué, l'affectation sera effectuée en fonction du type. Si le match est réussi, l'affectation sera attribuée * Si le match est infructueux, l'affectation sera signalée * Si le match est échoué, l'affectation sera signalée directement * Si le match n'est pas réussi Comparez le type de référence XML et les annotations. L'efficacité est relativement élevée. L'écriture est plus gênante. L'écriture d'annotations est relativement simple et moins efficace * * / public class annotationTest {@Test public void Testannotation () {applicationContext context = new ClassPathXmlApplicationContext ("applicationContext.xml"); Personne personne = (personne) context.getBean ("personne"); personne.say (); }}Si vous utilisez des annotations, vous n'avez pas besoin de charger la personne et l'élève dans le fichier de configuration, ce qui peut simplifier l'écriture du fichier de configuration.
3. Scanal
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 la définition de bean XML, il augmentera évidemment la taille du fichier de configuration, ce qui ne le rend pas très pratique pour trouver et entretenir. Spring2.5 introduit un mécanisme de balayage de composants automatique pour nous, qui peut trouver des classes annotées avec @Component, @Service, @Controller et @Repository Annotations sous le ClassPath et incorporer ces classes dans le conteneur de Spring pour gérer. Sa fonction est la même que l'utilisation des composants de configuration du nœud bean dans un fichier XML. Pour utiliser le mécanisme de balayage automatique, nous devons ouvrir les informations de configuration suivantes:
1. Introduire un espace de noms de contexte
Ajouter un contexte: balise de balayage composant dans le fichier de configuration XML
Où le pack de base est le package (sous-package) qui doit être analysé.
Exemple:
L'exemple ci-dessus est écrit en mode scan comme suit
@ComponentPublic class Person {@Resource (name = "Student") Étudiant privé; public void sait () {this.student.say (); }} @ ComponentPublic classe étudiant {public void say () {System.out.println ("Student"); }}applicationContext.xml ne doit être configuré que dans une phrase
<! - Composant du composant met une classe dans un conteneur à ressort, et la classe est appelée balayage du composant sous le package et le sous-package spécifié par Base-Package -> <context: Component-Scan Base-Package = "com.itheima10.spring.can"> </ Context: Component-Scan>
Écrire la classe de test annotationtest
/ ** * Principe * 1. Démarrer le conteneur de printemps * 2. Spring Container Analyse * <Context: Component-Scan Base-Package = "Com.itheima10.spring.scan"> </ context: Component-Scan> 3. Scan dans les packages et sous-packages spécifiés par Base-Pack pour voir les classes contiennent @component Annotation 4. Si il y a cette annotation @component Person} Annotation 4. ==Equivalent to <bean id="person"> @Component("aa") public class Person { } ==Equivalent to <bean id="aa"> 5. Follow the analysis steps of @Resource: The entire process is scanned twice, the efficiency is getting lower and lower, and the writing is getting easier and easier* * */public class AnnotationTest { @Test public void testAnnotation(){ ApplicationContext context = new ClassPathxMlApplicationContext ("ApplicationContext.xml"); Personne personne = (personne) context.getBean ("personne"); personne.say (); }}Réapparition des instances
Nous modifierons le dernier système de gestion de documents dans les éléments 51 en annotation. L'interface de document reste inchangée, avec des méthodes de lecture et d'écriture. Les classes d'implémentation sont les suivantes ExcelDocument, PDFDocument et WordDocument.
@Component ("ExcelDocument") classe publique ExcelDocument implémente le document {public void read () {System.out.println ("Excel Read"); } public void write () {System.out.println ("Excel Write"); }} @ Composant ("pdfDocument") classe publique pdfDocument implémente le document {public void read () {System.out.println ("pdf read"); } public void write () {System.out.println ("pdf écriture"); }} @ Composant ("WordDocument") classe publique WordDocument implémente le document {public void read () {System.out.println ("word read"); } public void write () {System.out.println ("Word Write"); }}Documentaire
@Component ("DocumentManager") classe publique DocumentManager {@Resource (name = "ExcelDocument") document de document privé; public void read () {this.document.read (); } public void write () {this.document.write (); }}Fichier de configuration
<Context: Component-Scan Base-Package = "com.itheima10.spring.iocdi.document">
</ Context: Component-Scan>
Écrivez un document de classe de test
public class documentTest {@Test public void testDocument () {applicationContext context = new ClassPathxmlApplicationContext ("ApplicationContext.xml"); DocumentManager DocumentManager = (documentManager) context.getBean ("DocumentManager"); DocumentManager.read (); documentManager.Write (); }} 2. Introduction aux autres fonctions d'annotation
@Service est utilisé pour annoter les composants de la couche commerciale et les annotations de couche de service
@Controller est utilisé pour annoter les composants de la couche de contrôle (comme l'action dans les entretoises) et l'annotation de la couche de contrôle
@Repository est utilisé pour annoter les composants d'accès aux données, c'est-à-dire les composants DAO. Annotation de la couche de persistance
@Component fait référence aux composants. Lorsque les composants ne sont pas faciles à classer, nous pouvons utiliser cette annotation pour annoter.
Exemples reproduire le boîtier MVC
Nous examinons à nouveau les cas MVC dans l'article51, ajoutant respectivement le DAO, le service et l'action de Persondaoimpl, Personaction et PersonServiceImpl pour ajouter des annotations au DAO, au service et aux couches d'action de Persondaoimpl.
@Repository ("Persondao") classe publique PersondaOIMPL implémente Persondao {@Override public void SavePerson () {System.out.println ("Save Person"); }} @ Service ("PersonService") classe publique PersonServiceImpl implémente PersonService {@Resource (name = "Persondao") Private Persondao Persondao; public void setpersondao (persondao persondao) {this.persondao = persondao; } @Override public void SavePerson () {this.persondao.saveperson (); }} @ Contrôleur ("Personaction") Public Class Personaction {@Resource (name = "PersonService") Private PersonService PersonService; public void setPerSonService (PersonService PersonService) {this.sonService = PersonService; } public void SavePerson () {this.personService.saveSerson (); }}Écrire un test mvCTest
classe publique mvCTest {@Test public void testmvc () {applicationContext context = new ClassPathXmlApplicationContext ("ApplicationContext.xml"); Personaction personaction = (personaction) context.getBean ("personaction"); personaction.saveperson (); }}4. Héritage au printemps
Le printemps prend en charge l'héritage, qui peut être divisé en héritage de classe et en héritage d'attribut.
1. Héritage de classe
Propriétés du printemps:
(1) Résumé: S'il est réglé sur true, cela signifie que le haricot défini est abstrait, dites à Spring de ne pas instancier le haricot;
Question: doit-ce être une classe abstraite? Serait-ce une classe abstraite?
(2) Parent: indique la fonction de l'ID du bean sur le bean, ce qui équivaut à la fonction des étendues sur la classe Java;
Scène: Il y a trois haricots:
<bean id = "bean1" class = "… testbean"> <propriété name = "sexe" value = "mâle" /> </ bean> <bean id = "bean2" class = "… testbean"> <propriété name = "sexe" value = "masculin" /> </ean> <bean id = "bean3" class = "… testBean"> <propriété name = "sex" value = "féminin" /> </ bean>
Modifier: définir le haricot parent de printemps
<bean id = "basebean" class = "… testbean"> <propriété name = "sexe" value = "mâle" /> </ank>
Définir les sous-trois ans
<bean id = "bean1" parent = "BaseBean" /> Hériter les propriétés du parent bean <bean id = "bean2" parent = "Basebean" /> <bean id = "bean3" parent = "Basebean"> écraser les propriétés du parent bean <propriété name = "sexe" value = "féminin" /> </ bean>
Les haricots enfants peuvent hériter des propriétés du haricot parent ou remplacer les propriétés du haricot parent.
2. Attribut héritage
Il y a les mêmes attributs entre plusieurs haricots différents, et la scène peut être extraite:
<bean id = "bean1" class = "… AtestBean"> <propriété name = "sex" value = "mâle" /> <propriété name = "task" ref = "task" /> </ bean> <bean id = "bean2" class = "… btestbean"> <propriété name = "sexe" value = "male" /> </ean>
Modifier: (1) Extraire les attributs publics
<bean id = "bassex" abstract = "true"> <propriété name = "sexe" value = "mâle" /> </bant>
(2) Modification des haricots
<bean id = "bean1" class = "… AtestBean" Parent = "Basesex"> <propriété name = "task" ref = "task" /> </Ean> <bean id = "bean2" class = "… bTestbean" parent = "bassex" />
Ici, le haricot a à la fois des attributs parent et de classe, et le Basesex pointé par le parent est de permettre à différents grains de partager la même valeur d'attribut; Lorsque la transactionProxyfactoryBean déclare le service, l'héritage de l'attribut Bean peut réduire considérablement la configuration XML redondante.
L'héritage basé sur l'annotation ne nécessite pas d'attributs parents.
Ayons une petite image de résumé en dernier
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.