1. Notizen
Annotation ist ein Mechanismus, der der Annotation ähnelt. Das Hinzufügen von Anmerkungen im Code kann diese Informationen zu einem bestimmten Zeitpunkt später verwenden. Im Gegensatz zu Kommentaren sind Kommentare für uns zu sehen. Die virtuelle Java -Maschine kann nicht kompiliert werden, und die Anmerkungen werden nicht kompiliert, aber wir können die Informationen in den Anmerkungen durch den Reflexionsmechanismus lesen. Annotation verwendet das Schlüsselwort @Interface, erbt Java.lang.Annotition.annotation
1. Anmerkungen in Javase
Lassen Sie mich Ihnen ein Beispiel geben, um zu überprüfen, welche Annotation in Javase ist. Der Schlüssel sind zwei Punkte: die Definition der Annotation und wie die Informationen über der Annotation durch Reflexion erhalten werden.
1. Definieren Sie zuerst zwei Anmerkungen. Einer wird in der Klasse kommentatiert und der andere mit der Methode annotiert.
Klasseninfo
Paket com.itheima10.Annotation; import Java.lang.annotation In der Klasse @Retention (retentionPolicy.runtime) // In Java können Klassendateien und Laufzeitanmerkungen @Documented // im Help -Dokument public @Interface classInfo { /** * generiert werden. Diese Annotation enthält zwei Eigenschaften des Zeichenfolge -Typs * @return * /String name () standard "standard" "; String value () Standard "";}MethodInfo
Paket com.itheima10.Annotation; importieren java.lang.annotation In Methoden @retention (retentionPolicy.runtime) // In Java können Klassendateien und Laufzeitanmerkungen @Documented // in Hilfedokument public @Interface methodInfo { /*** generiert werden. Diese Annotation enthält zwei Eigenschaften des String -Typs* /String name () Default "; String value () Standard "";}2. Schreiben Sie eine Annotationuse -Klasse, um die oben definierte Annotation zu verwenden
Paket com.itheima10.Annotation; @classinfo (name = "xiaopingguo118", value = "niu") öffentliche Klasse Annotationuse {@MethodInfo (name = "java", value = "Spring Framework ist wichtig") public void java () {}}}}}3. Schreiben Sie den Annotationstest der Testklasse und analysieren Sie die Eigenschaften über den beiden Anmerkungen
package com.itheima10.annotation;import java.lang.reflect.Method;import org.junit.Test;public class AnnotationTest { public static void test(){ /** * If parse the annotation of the class, get Class * If parse the annotation of the method, get method first */ Class class1 = Itheima10.class; // Beurteile, ob es in der Klasse eine Classinfo -Annotation gibt, wenn (class1.isannotationPresent (classInfo.class)) {// die Annotation auf der ClassClasssinfo classInfo = (classInfo) class1.getannotation (classInfo.classe) erhalten; System.out.println (classInfo.value ()); System.out.println (classInfo.name ()); } Method [] methoden = class1.getMethods (); Für (Methode Methode: Methoden) {// gibt es eine MethodeInfo -Annotation für die Methode, die durch durchquert wird. System.out.println (methodInfo.name ()); System.out.println (methodInfo.value ()); }}} @Test public void test () {AnnotationTest.test (); }}2. Anmerkungen im Frühjahr
Das Frühlingsgerüst bietet uns Annotationsfunktionen.
Die Verwendung der Annotationsprogrammierung dient hauptsächlich, um XML -Dateien zu ersetzen und die Entwicklung schneller zu gestalten. Die Verwendung von XML -Dateien besteht jedoch darin, das Problem der Änderung des Quellcode des Programms zu lösen. Wenn ich jetzt keine XML -Dateien verwende, würde es nicht gegen das Prinzip des Öffnens und Schließens verstoßen? Es ist wahr. Anmerkungen sind jedoch auch gut, sodass Sie bei Verwendung Anmerkungen nicht so viele XML -Dateien konfigurieren müssen. Das Wichtigste ist, dass sie eine hohe Entwicklungseffizienz haben. .
Wenn keine Anmerkungen verwendet werden, müssen viele <Bean> -Tags in der Konfigurationsdatei -ApplicationContext.xml -Datei des Spring Framework konfiguriert werden, um Klassenobjekte zu deklarieren. Mit Anmerkungen müssen Sie die Konfigurationsdatei nicht hinzufügen, und die entsprechende Beschreibung besteht darin, Anweisungen in der Position "Kommentar" der entsprechenden Klasse hinzuzufügen. Die spezifische Einführung lautet wie folgt:
• 1. Die Kombination von Beziehungen zwischen @Resource -Objekten, die Standardeinstellung besteht darin, sich nach Namen zu montieren. Wenn das zugehörige Objekt nicht basierend auf dem Namen gefunden werden kann, wird die Suche nach Typ fortgesetzt. Wenn kein Namensattribut angegeben ist,
• Wenn die Annotation in einem Feld markiert ist, besteht die Standardeinstellung darin, den Namen des Feldes als Bean -Name zu nehmen, um das Abhängigkeitsobjekt zu finden
• Wenn die Annotation auf der Setter -Methode des Attributs gekennzeichnet ist, wird der Standardattributname als Bean -Name angenommen, um das Abhängigkeitsobjekt zu finden.
• Hinweis: Wenn das Namensattribut nicht angegeben ist und das Abhängigkeitsobjekt nicht standardmäßig gefunden werden kann, fällt die @Resource -Annotation nach Typ zurück. Sobald das Namensattribut angegeben ist, kann es nur mit Namen zusammengestellt werden.
• 2. @Autowired
@Autowired wird standardmäßig nach Typ zusammengestellt. Die Lösung besteht darin, abhängige Objekte nach Typ zusammenzustellen. Standardmäßig müssen abhängige Objekte existieren. Wenn Nullwerte zulässig sind, kann es auf false eingestellt werden.
• 3. @Qualifier
Wenn wir Assembly mit Namen verwenden möchten, können wir sie in Verbindung mit der @Qualifier -Annotation verwenden.
1. Um Anmerkungen zu verwenden, müssen Sie der Konfigurationsdatei den Namespace- und Einschränkungsdateischritt hinzufügen:
Einführung des Kontext -Namespace
<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.5sd ">
2. Fügen Sie den Kontext hinzu: Annotation-Config-Tag zur Konfigurationsdatei
<Kontext: Annotation-Konfiguration> </Kontext: Annotation-Config>
Beispieldemonstration:
Schreiben Sie eine Personklasse mit einem Schülerattribut und einer Methode von Say (). Der Code ist wie folgt
Paket com.itheiman10.spring.di.annotation; import Javax.annotation Typ @qualifier ("student") * */public class Person {@resource (name = "student") privat student; public void sagt () {this.student.say (); }}Schülerklassencode lautet wie folgt
Paket com.itheima10.spring.di.annotation; öffentliche Klasse Student {public void say () {System.out.println ("Student"); }}Konfigurieren Sie die Datei applicationContext.xml
<? xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xsi: scheMalocation = "http://wwww.springframework.org/schema/Beans http://www.springFramework.org/schema/swww.springFramework.org/schema/Stpan- http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd "> <!-Put Person und Student in Spring Contenter-> <Bean id =" person> </ban> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </bean> </ban> </ban> </bean; Context Namespace XMLNS: context = "http://www.springframework.org/schema/context" http://www.springframework.org/schema/context http://www.pringframework.org/schema/context/Spring.-Spring- <!-Der Annotationsparser, der seit Beginn des Starts injiziert wurde-> <Kontext: Annotation-Konfiguration> </Kontext: Annotation-Config> </beans>
Schreiben Sie Testunterrichtsannotationstest
Paket com.itheiman10.spring.di.annotation; import org.junit.test; import org.springframework.context.applicationContext import org.springframework Der Frühlingscontainer ist an* <Kontext: Annotation-Config> </CONTEXT: Annotation-Config>*, der Annotations-Parser für Abhängigkeitsinjektion gestartet. Ob der Wert des Namensattributs der Annotation " * * Wenn es sich um" "handelt, entspricht es mit dem Namen des Attributs, in dem sich die Annotation befindet, und der Wert der ID im Federcontainer. Wenn die Übereinstimmung erfolgreich ist, wird die Zuordnung * Wenn das Spiel nicht erfolgreich ist, wird die Zuordnung gemäß dem Typ durchgeführt. Wenn die Übereinstimmung erfolgreich ist, wird die Zuordnung zugewiesen * Wenn die Übereinstimmung nicht erfolgreich ist, wird die Zuordnung gemeldet. Wenn die Übereinstimmung nicht erfolgreich ist. Vergleichen Sie den Referenztyp XML und Anmerkungen. Die Effizienz ist relativ hoch. Schreiben ist problematischer. Das Schreiben von Annotationen ist relativ einfach und weniger effizient * * */public class AnnotationTest {@test public void testannotation () {applicationContext context = new classPhodexMlApplicationContext ("ApplicationContext.xml"); Person Person = (Person) context.getbean ("Person"); Person.say (); }}Wenn Sie Anmerkungen verwenden, müssen Sie Person und Schüler in der Konfigurationsdatei nicht laden, um das Schreiben der Konfigurationsdatei zu vereinfachen.
3. Scan
In den vorherigen Beispielen haben wir die XML -Bean -Definition verwendet, um Komponenten zu konfigurieren. In einem etwas größeren Projekt gibt es normalerweise Hunderte von Komponenten. Wenn diese Komponenten mit der XML -Bean -Definition konfiguriert werden, erhöht sie offensichtlich die Größe der Konfigurationsdatei, sodass es nicht sehr bequem ist, zu finden und zu warten. Spring2.5 führt einen automatischen Komponenten -Scanmechanismus für uns vor, der Klassen finden kann, die mit @Component, @Service, @Controller und @Repository -Anmerkungen unter dem Klassenpfad kommentiert werden und diese Klassen in den Federcontainer einbeziehen, um sie zu verwalten. Die Funktion ist die gleiche wie die Verwendung von Bean -Knotenkonfigurationskomponenten in einer XML -Datei. Um den automatischen Scanmechanismus zu verwenden, müssen wir die folgenden Konfigurationsinformationen öffnen:
1. Einführen des Kontext -Namespace
Kontext hinzufügen: Komponenten-scan-Tag in der XML-Konfigurationsdatei
Wobei Basispaket das Paket (Unterpackung) ist, das gescannt werden muss.
Beispiel:
Das obige Beispiel ist wie folgt in einem Scan -Modus geschrieben
@ComponentPublic Class Person {@resource (name = "student") Private Student; public void sagt () {this.student.say (); }}@Componentpublic class Student {public void say () {System.out.println ("Student"); }}applicationContext.xml muss nur in einem Satz konfiguriert werden
<!-Komponentenkomponente steckt eine Klasse in einen Federcontainer, und die Klasse wird als Scannen der Komponente unter dem durch Basis-Package angegebenen Paket und Unterpackung bezeichnet-> <context: component-scan base-package = "com.itheima10.spring.scan"> </context: component-scan>
Schreiben Sie Testunterrichtsannotationstest
/*** Prinzip* 1. Spring Container* 2. Spring Container Parsing* <CONTEXT: COMPONENT-SCAN-BASE-PACKAGE = "Com.itheima10.spring.Scan"> </context: component-scan> 3. Scan in den Paketen und Unterpackungen, die durch Base-Package-Package angegeben sind. == äquivalent zu <bean id = "person"> @component ("aa") public class Person {} == äquivalent zu <bean id = "aa"> 5. Folgen Sie den Analysenschritten von @resource: Der gesamte Prozess wird zweimal gescannt, die Effizienz wird niedriger und niedriger, und das Schreiben wird leichter und leichter * * * * * * * * * * * * * * * * * * * * * @öffentliche Klasse. ApplicationContext context = new classPathXmlApplicationContext ("ApplicationContext.xml"); Person Person = (Person) context.getbean ("Person"); Person.say (); }}Wiederauftreibung von Instanzen
Wir werden das letzte Dokumentverwaltungssystem in Artikel51 in Annotation ändern. Die Dokumentschnittstelle bleibt unverändert, mit Lese- und Schreibmethoden. Die Implementierungsklassen sind wie folgt Exceldocument, PDFDocument und WordDocument.
@Component ("exceldocument") public class exceldocument implementiert document {public void read () {System.out.println ("excel read"); } public void write () {system.out.println ("excel write"); }}@Component ("pdfdocument") public class pdfdocument implementiert dokument {public void read () {System.out.println ("pdf read"); } public void write () {System.out.println ("pdf write"); }}@Component ("wordDocument") public class worddocument implementiert document {public void read () {System.out.println ("Word Read"); } public void write () {System.out.println ("Word write"); }}DocumentManager
@Component ("documentManager") öffentliche Klasse documentManager {@resource (name = "exceldocument") privates Dokument; public void read () {this.document.read (); } public void write () {this.document.write (); }}Konfigurationsdatei
<Kontext: component-scan base-package = "com.itheima10.spring.iocdi.document">
</Kontext: Komponenten-scan>
Schreiben Sie einen Testunterrichts -Dokumenttest
public class documentTest {@test public void testDocument () {applicationContext context = new classPathXmlApplicationContext ("applicationContext.xml"); DocumentManager documentManager = (documentManager) context.getbean ("documentManager"); documentManager.read (); documentManager.write (); }} 2. Einführung in andere Annotationsfunktionen
@Service wird verwendet, um Business -Layer -Komponenten und Service -Layer -Anmerkungen zu kommentieren
@Controller wird verwendet, um Kontrollkomponenten (z. B. Aktion in Streben) und die Annotation der Steuerungsschicht zu kommentieren
@Repository wird verwendet, um Datenzugriffskomponenten, d. H. DAO -Komponenten, zu kommentieren. Annotation der Persistenzschicht
@Component bezieht sich auf Komponenten. Wenn Komponenten nicht einfach zu klassifizieren sind, können wir diese Annotation verwenden, um zu kommentieren.
Beispiele reproduzieren MVC -Fall
Wir überprüfen die MVC -Fälle erneut in Artikel51 und fügen die DAO-, Dienst- und Aktionsschichten von PersondaoImpl, Personala und PEVORSERSIVICEIMPL hinzu, um den DAO-, Service- und Aktionsschichten von PersondaoImpl Anmerkungen hinzuzufügen.
@Repository ("persondao") public class persondaoimpl implementiert persondao {@Override public void SavePerson () {System.out.println ("Save Person"); }} @Service ("personSservice") öffentliche Klasse personSserviceImpl implementiert personSservice {@resource (name = "persondao") private persondao persondao; public void setpersondao (persondao persondao) {this.persondao = persondao; } @Override public void SavePerson () {this.Persondao.saveperson (); }} @Controller ("personalaction") public class -personala {@resource (name = "pelonService") private pealtonservice personSservice; public void setpersonService (personSservice personSservice) {this.PersonService = personSservice; } public void SavePerson () {this.PersonService.saveperson (); }}Schreiben Sie Test mvctest
public class mvCtest {@test public void testMvc () {applicationContext context = new classPhodexMlApplicationContext ("applicationContext.xml"); Personalaction personaction = (personaction) context.getbean ("personalaction"); PersonAction.SavePerson (); }}4. Vererbung im Frühling
Der Frühling unterstützt die Vererbung, die in die Erbschafts- und Attributvererbung unterteilt werden kann.
1. Klasse Erbe
Federeigenschaften:
(1) Zusammenfassung: Wenn dies auf wahr eingestellt ist, bedeutet dies, dass die definierte Bohne abstrakt ist, die Spring nicht so einsetzt, dass die Bohne nicht instanziiert wird.
Frage: Muss es eine abstrakte Klasse sein? Könnte es eine abstrakte Klasse sein?
(2) Elternteil: Zeigt die Funktion der Bohnen -ID auf der Bohne an, die der Funktion der Ausdehnung der Java -Klasse entspricht.
Szene: Es gibt drei Bohnen:
<bean id = "bean1" class = "... testbean"> <Eigenschaft name = "sex" value = "männlich"/> </bean> <bean id = "bean2" class = "... testbean"> <Eigenschaft name = "sex" value = "männlich"/> </bean> <bean3 = "Bean3" class = "... testbean"> <
Modifizieren Sie: Definieren Sie Feder übergeordnete Bean
<bean id = "baseBean" class = "... testbean"> <Eigenschaft name = "sex" value = "male"/> </bean>
Subbeans definieren
<bean id = "bean1" parent = "baseBean"/> Erben Sie die Eigenschaften der übergeordneten Bean <bean id = "bean2" parent = "baseBean"/> <bean id = "bean3" parent = "baseBean"> Überschreibe die Eigenschaften der übergeordneten Bean <Stiefs <"sachliche".
Kinderbohnen können die Eigenschaften der übergeordneten Bohnen erben oder die Eigenschaften der übergeordneten Bohne außer Kraft setzen.
2. Attributvererbung
Es gibt die gleichen Attribute zwischen mehreren verschiedenen Bohnen, und die Szene kann extrahiert werden:
<bean id = "bean1" class = "... atestbean"> <Eigenschaft name = "sex" value = "male"/> <Eigenschaft name = "task" ref = "task"/> </bean> <bean id = "bean2" class = "... BTESTBEAN"> <Property name = "sex".
Ändern Sie: (1) öffentliche Attribute extrahieren
<bean id = "basesex" Abstract = "true"> <Eigenschaft name = "sex" value = "männlich"/> </bean>
(2) Bean -Modifikation
<bean id = "bean1" class = "... atestbean" parent = "baseSex"> <Eigenschaft name = "task" ref = "task"/> </bean> <bean id = "bean2" class = "... btestbean" parent = "basex"/>
Hier verfügt die Bean sowohl über Eltern- als auch Klassenattribute, und auf den von übergeordneten Basesex zeigen, dass verschiedene Bohnen denselben Attributwert teilen. Wenn die TransactionProxyFactoryBean den Dienst erklärt, kann die Vererbung des Bean -Attributs die redundante XML -Konfiguration erheblich verringern.
Annotationsbasierte Erbschaft erfordert keine übergeordneten Attribute.
Lassen Sie uns zuletzt ein kleines Zusammenfassungsbild haben
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.