Inhaltsverzeichnis
1. Spring AOP basierend auf der XML -Konfiguration
2. Verwenden Sie Anmerkungen, um AOP zu konfigurieren
3..
4. Aspektj Benachrichtigungsnotizen
5. Null Konfiguration zum Implementieren von Spring -IOC und AOP
AOP (Aspektorientierte Programmierung) ist eine Technologie, die horizontale Multimodul-Unified Control von Programmfunktionen durch Vorkompilierungsmethoden und dynamische Wirkstoffe während der Laufzeit implementiert. AOP ist eine Ergänzung zu OOP und ein wichtiger Bestandteil des Frühlingsgerüsts. Die verschiedenen Teile der Geschäftslogik können durch Verwendung von AOP isoliert werden, wodurch die Kopplung zwischen den verschiedenen Teilen der Geschäftslogik, die Wiederverwendbarkeit des Programms verbessert und die Effizienz der Entwicklung verbessert wird. AOP kann in statisches Weben und dynamisches Weben unterteilt werden. Dynamisches Weben erfordert nicht das Ändern des Zielmoduls. Spring Framework implementiert AOP, und die Verwendung von Anmerkungen zur Konfiguration von AOP ist bequemer und intuitiver als die Verwendung der XML -Konfiguration.
1. Spring AOP basierend auf der XML -Konfiguration
Bevor Sie die Annotation zur Implementierung der AOP -Funktion erläutern, verwenden Sie zunächst das vorherige Lernen, um die Feder -AOP -Funktion mit XML zu konfigurieren, damit sie zum Vergleich und zum besseren Verständnis dient.
1.1. Erstellen Sie ein neues Maven -Projekt und fügen Sie eine Referenz hinzu.
<project xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.w3.org/2001/xmlschema-Instance g/xsd/maven-4.0.0.xsd "> <modelVersion> 4.0.0 </modelversion> <gruppe> com.zhangguo </gruppen> <artifactID> Spring052 </artifactid> <version> 0.0.1-Snapshot </Version> <Packages> jar </packaging> <name> spring052 </name> <url> http://maven.apache.org </url> <Proporties> <Project.build.SourceCoding> utf-8 </Project.build.build.build.build.build.build.build.build.build.build.build.build.build.build.build.build.build.build.build.build. > </properties> <depeopcies> <abhängigkeit> <GroupID> junit </Groupid> <artifactId> junit </artifactId> <Scope> test </scope> <version>4.10</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.8.9</version> </dependency> <dependency> <groupId>cglib</groupId> <artifactid> cglib </artifactId> <version> 3.2.4 </Version> </abhängig> </abhängig> </project>1.2.
Paket com.zhangguo.spring052.AOP01; .out.println (n1+"-"+n2+"+Ergebnis); result = n1*n2;
1.3.
Paket com.zhangguo.spring052.aop01; import org.aspepy.lang.joInpoint; --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1.4.
<? ingframework.org/schema/p "xmlns: aop =" http://www.springframework.org/schema/aop "xsi: schemalocation =" http://www.spingframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.pringframework.org/schema/aop http://www.sprungramework.org/schema/aop http://www.spraination/schema/aop AOP-4.3.xsd "> <!-Proxy-Objekt-> <bean id =" math "> </bean> <!-Benachrichtigung-> <bean id =" advices "> </bean> <!-AOP-Konfiguration-> <AOP: config Proxy-Target-Class =" True "> <! Expression = "Execution (* com.zhangguo.spring052.aop01.math. Bohnen>
1.5.
Paket com.zhangguo.spring052.aop01; import org.springframework.context.applicationContext; "); Math math = ctx.getbean (" math ", math.class); int n1 = 100, n2 = 5; Math.Add (N1, N2);Auslaufergebnisse:
2. Verwenden Sie Anmerkungen, um AOP zu konfigurieren
2.1. Es entspricht dem Hinzufügen einer Bean der XML-Konfigurationsdatei im vorherigen Beispiel <!-Proxy-Objekt-> <bean id = "math"> </bean>, und der Code der Mathematikklasse lautet wie folgt:
Paket com.zhangguo.spring052.AOP02; // öffentlich int sub (int n1, int n2) {int result = n1-n2; System.out.println (n1+"-"+n2+"+Ergebnis); println (n1+"/"+n2+"="+return Ergebnis;2.2.
Paket com.zhangguo.spring052.aop02; import org.aspespectj.lang.joinpoint; */@Component@Aspektpublic Class Advices {@before ("Execution ( * com.zhangguo.spring052.aop02.math.*(..) ") public void vor (joinpoint jp) {System.out.println (" -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Der obige Code entspricht im Grunde der folgenden Konfiguration
<!-Benachrichtigungen-> <bean id = "advices"> </bean> <!-AOP-Konfiguration-> <AOP: Konfiguration Proxy-Target-Class = "True"> <!-Abschnitt-> <AOP: Aspekt Ref = "Advices"> <! 1 "/> <!-Benachrichtigungsmethode und Punkt verbinden-> <AOP: vor method =" vor "pointcut-ref =" pointcut1 "/> <aoP: After Method =" AFTER " pointcut-ref = "pointcut1"/> </aoP: Aspekt> </aop: config>
2.3.
<? ingframework.org/schema/p "xmlns: aop =" http://www.springframework.org/schema/aop "xmlns: context =" http://www.spingframework.org/schema/context " XSI: Schemalocation = "http://www.springframework.org/schema/beans http://www.pringframework.org/schema/beans/spring-beans.xsd http://www.springframe.org/schem.org/scha. Schema/Kontext/Spring-Context-4.3.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd "> <Context: Komponent-scan-Basis-Package = "com.zhangguo.spring052.aop02"> </context: component-scan> <AOP: Aspektj-autoproxy proxy-target-class = "true"> </aop: Aspektj-autoproxy> </beans>
2.4.
Paket com.zhangguo.spring052.aop02; import org.springframework.context.applicationContext; ); Math.Add (N1, N2);
Auslaufergebnisse:
3..
Die Punkte -Tangentenfunktion kann auf eine genaue quer logische Position positioniert werden. unterschiedliche Targeting.
@Aspectj verwendet den speziellen Ausdruck von Aspektjs, um den Abschnitt zu beschreiben.
Methode Point-Cut-Funktion: Definiert Verbindungspunkte, indem die Zielklassenmethodeninformationen beschrieben werden.
Methode Parameter Point-Cut-Funktion: Definiert Verbindungspunkte, indem die Parameterinformationen der Zielklassenmethode beschrieben werden.
Punktklassen-Punkt-Kut-Funktion: Definiert Verbindungspunkte durch Beschreibung der Informationen zum Zielklassentyp.
Punkt-Schnitt-Funktion der Agentenklasse: Definiert Verbindungspunkte durch Beschreibung der Proxy-Klasseninformationen.
Gemeinsame Aspekte -J -Ausdrucksfunktionen:
Die am häufigsten verwendete Point-Cut-Funktion ist: Ausführung (<Modifikator-Modus>? <<C-Modemodus> <Methodenname-Modus> (<Parametermodus>) <Unnahmodus>?) Point-Cut-Funktion, die die meisten Anforderungen erfüllen kann.
Um die Funktionen jeder Punkt -Tangentenfunktion anzuzeigen, wird nun eine neue Klasse hinzugefügt. Die Klasse lautet wie folgt:
Paket com.zhangguo.spring052.aop03; org.springframework.stereotype.comPonent; @Component ("Strutil") Strudil {public void show () {System.out.println ("Hallo Stutil!");Der Testcode lautet wie folgt:
Paket com.zhangguo.spring052.aop03; import org.springframework.context.applicationContext; ); Math.Add (N1, N2);
3.1.
Paket com.zhangguo.spring052.aop03; import org. */@Component@Aspektpublic Class Advices {@before ("Execution ( * com.zhangguo.spring052.aop03.math.*(..) ") öffentliche void vor (joinpoint jp) {System.out.println (" ---------------------------------------------------- 03 Paket werden in @after ("Ausführung (*com.zhangguo.spring052.aop03.*.*(..))") public void nach (joinpoint jp) { System.out.println ("-------------------------------");Die Betriebsergebnisse sind wie folgt:
Ausführung (<Modifikator -Modus>? <Returnyp -Modus> <Methodenname -Modus> (<Parametermodus>) <Unterwechselmodus>?)
3.2.
// Innerhalb der Punkt-Schnitt-Funktion // Com.zhangguo.spring052.AOP03 Paket Alle Methoden aller Klassen werden in @after ("Innere (com.zhangguo.spring052.aop03 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------3.3
// Diese Punkt-Schnitt-Funktion // implementiert einen Verbindungspunkt des Proxy-Objekts der IMath-Schnittstelle @after ("this (com.zhangguo). ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------3.4
// args point-cut function // erfordert, dass die Methode zwei int-Typ-Referenzen hat, bevor sie in die Querschnittlogik @after verwandt wird ("Args (int, int)) nach dem (Joinpoint JP) {System.out.OUT.println ("------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------— Wenn der Parametertyp nicht der Basisdatentyp ist, ist der Paketame erforderlich.
3.5
Passen Sie zuerst eine Annotation an, die mit der Methode kommentiert werden kann
Paket com.zhangguo.spring052.aop03; importieren java.lang.Annotation Ention(RetentionPolicy.Runtime)@documentedPublic @Interface Myanno {} //@Annotation Point-Cut-Funktion // muss die Methode annotieren Com.zhangguo.spring052.aop03.Myanno in die Querschneidelogik @after ("@Annotation (com.zhangguo.spring052.aop03.myanno). } Paket com.zhangguo.spring052.aop03; org.springframework.stereotype.comPonent; @Component ("Strutil") öffentliche Klasse Strutil {@myanno public void show () {System.out.println ("Hallo Strutil!");Auslaufergebnisse:
Andere Point-Schneidungsfunktionen mit @ sind für Annotation
4. Aspektj Benachrichtigungsnotizen
Es gibt 6 Benachrichtigungsanmerkungen in Aspektj, 5 werden häufig verwendet, und es werden weniger Einführungen verwendet.
Lösen Sie zunächst das Problem der Definition von Punkt -Tangenten -Multiplexen, wie im folgenden Code gezeigt, der Inhalt der Punkt -Tangentenfunktion genau gleich:
Paket com.zhangguo.spring052.aop04; import org. */@Component@Aspektpublic Class Advices {@before ("Execution ( * com.zhangguo.spring052.aop04.math.*(..) ") public void vor (joinpoint jp) {system.out.println (" ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Sie können zuerst eine Tangente definieren und es dann wie folgt multiplexen:
Paket com.zhangguo.spring052.aop04; import org.aspespectj.lang.joinpoint; */@Component@Aspektpublic Class Advices { // 切点 @pointcut ("Ausführung (* com.zhangguo.spring052.aop04.math. )); System.out.println ("-------------------------------");Ändern Sie die Datei advices.java und fügen Sie verschiedene Benachrichtigungstypen wie folgt hinzu:
Paket com.zhangguo.spring052.aop04; import org.aspespectj.lang.joinpoint; ang.annotation.around; import org.aspespec.lang.annotation.around; import org.aspespectj.lang.annotation org.aspespectj.lang.Annotation.pointcut; org.springFramework.stereotype.comPonent; -Notice @before ("pointCut ()") public void vor (joinpoint jp) { System.out.println (JP.GetSignature (). GetName ()); ----------------------------------------------------------------------------------------------------------------------------------------------------- Throwable {System.out.println (pjp.getSignature (). GetName ()); ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- AfterReturning (Joinpoint JP, Objektergebnis) {System.out.println (JP.GetSignature (). GetName ()); ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------— System.out.println (JP.GetSignature (). GetName ()); ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Auslaufergebnisse:
5. Null Konfiguration zum Implementieren von Spring -IOC und AOP
Um null Konfiguration zu erreichen, fügen wir basierend auf dem ursprünglichen Beispiel eine neue benutzerähnliche Klasse hinzu, wie unten gezeigt:
Paket com.zhangguo.spring052.aop05; Benutzer der öffentlichen Klasse {public void show () {System.out.println ("ein Benutzerobjekt");Diese Klasse ist nicht kommentiert und der Container wird nicht automatisch verwaltet. Da es keine XML -Konfigurationsdatei gibt, verwenden Sie eine als Konfigurationsinformationen, und die Datei applicationCfg.java lautet wie folgt:
Paket com.zhangguo.spring052.aop05; org.springframework.context.annotation.bean; IRAULY // Konfigurationsklasse, die zur Darstellung der aktuellen Klasse als Container verwendet wird, ähnlich wie <beans/>@componentscan (Basepackages = "com.zhangguo.spring052.aop05") // Der Scan-Bereich entspricht dem Knoten der XML-Konfiguration <Kontext: Komponenten-scan/>@ANLEGEOSPECTJAUTOPROXY (ProxytargetClass = True) // auto proxy, äquivalent zu <AOP: Aspektj-Autoproxy Proxy-Target-Class = "True" ”true"> Aspekt: Aspekt: Aspekt: Aspekt: "> </AOP: Konfiguration, gleichwertig zu <bean id = getUser/> @bean public user getUser () {return New User ();Jeder Teil dieser Klasse hat im Grunde eine Eins-zu-Eins-Beziehung zur XML-Konfiguration. Der Testcode lautet wie folgt:
Paket com.zhangguo.spring052.aop05; org.springframework.context.ApplicationContext; {// Container initialisieren über die Klasse ApplicationContext ctx = neu AnnotationConfigapplicationContext (ApplicationCFG.ClASS); = ctx.getbean ("getUser", user.class); advices.java ist das gleiche wie oben, ohne Änderungen ist das laufende Ergebnis wie folgt:
Das oben genannte ist der Inhalt dieses Artikels.