1. Vorwort
In früheren Projekten achtete ich selten auf die spezifische Umsetzung und Theorie der Frühlings -AOP. Ich habe gerade kurz verstanden, was AOP ist und wie man es benutzt. Ich habe einen Blog -Beitrag gesehen, der gut geschrieben wurde, also kam ich, um ihn zu lernen.
AOP
AOP (Aspektorientierte Programmierung), dh eine Aspekt-orientierte Programmierung, kann als Ergänzung und Verbesserung der OOP (objektorientierte Programmierung) bezeichnet werden. OOP führt Konzepte wie Kapselung, Vererbung und Polymorphismus ein, um eine Objekthierarchie zu etablieren, mit der eine Sammlung von öffentlichem Verhalten simuliert wird. OOP ermöglicht es den Entwicklern jedoch, vertikale Beziehungen zu definieren, eignet sich jedoch nicht zur Definition horizontaler Beziehungen wie Protokollierungsfunktionen. Der Protokollcode ist in allen Objektebenen häufig horizontal verstreut und hat nichts mit den Kernfunktionen des entsprechenden Objekts zu tun. Diese Art von nicht verwandtem Code, der überall verstreut ist, heißt Cross -Schneiden. Im OOP -Design verursacht es eine große Menge an Code -Duplikation, die der Wiederverwendung jedes Moduls nicht förderlich ist.
Im Gegenteil die AOP -Technologie verwendet eine Technik, die als "Kreuzbrechung" bezeichnet wird, um das Innere eines eingekapselten Objekts zu analysieren und jene gemeinsamen Verhaltensweisen zu verkapulieren, die mehrere Klassen in ein wiederverwendbares Modul beeinflussen und es "Aspekt" nennen, das die Facette ist. Der sogenannte "Abschnitt" wird lediglich durch Logik oder Verantwortlichkeiten eingekapselt, die nicht mit dem Unternehmen zusammenhängen, sondern vom Geschäftsmodul gemeinsam genannt werden, was für die Reduzierung des Duplikatcode des Systems, die Verringerung der Kopplung zwischen Modulen und zur künftigen Betriebsfähigkeit und Wartbarkeit geeignet ist.
Mit der "Crosscutting" -Technologie unterteilt AOP das Softwaresystem in zwei Teile: Kernprobleme und Cross-Schnell-Sorge. Der Hauptprozess der Geschäftsverarbeitung ist der zentrale Schwerpunkt und der Teil, der wenig damit zu tun hat, ist der Querschnittsfokus. Ein Merkmal von Übergreifungsbedenken ist, dass sie häufig in mehreren Kernproblemen auftreten und an verschiedenen Orten im Grunde ähnlich sind, wie z. B. Authentifizierung, Protokolle und Dinge. Die Rolle von AOP besteht darin, verschiedene Bedenken im System zu trennen und die Kernprobleme durch Übergreifungsbedenken zu trennen.
AOP -Kernkonzept
1. Cross-Cut-Aufmerksamkeitspunkte
Welche Methoden, die Sie abfangen müssen und wie Sie nach Abfangen damit umgehen können? Diese Bedenken werden als interkürzende Bedenken bezeichnet
2. Abschnitt (Aspekt)
Klassen sind Abstraktionen der Merkmale von Objekten, und Abschnitte sind Abstraktionen von Überschneidungsbedenken
3. Joinpoint
Der abgefangene Punkt, da die Feder nur die Verbindungspunkte vom Typ Methoden unterstützt, so bezieht sich der Verbindungspunkt in der Feder auf die abgefangene Methode. Tatsächlich kann der Verbindungspunkt auch ein Feld oder ein Konstruktor sein.
4. Pointcut
Definition der Abfangen von Verbindungspunkten
5. Benachrichtigung (Rat)
Die sogenannte Benachrichtigung bezieht sich auf den Code, der nach Abschluss des Verbindungspunkts ausgeführt wird. Benachrichtigungen sind in fünf Kategorien unterteilt: voreingestellte, nacheingestellte, Ausnahme, endgültige und umgebende Benachrichtigungen.
6. Zielobjekt
Das Zielobjekt des Proxy
7. Gewebe
Der Prozess der Anwendung eines Schlitzes auf ein Zielobjekt und die Erstellung von Proxy -Objekten verursacht
8. Einführung
Ohne den Code zu ändern, kann die Einführung während der Laufzeitzeit einige Methoden oder Felder zur Klasse hinzufügen
Frühlingsunterstützung für AOP
Der AOP -Agent im Frühjahr ist für die Erzeugung und Verwaltung des IOC -Containers von Spring verantwortlich, und seine Abhängigkeiten werden auch vom IOC -Container verwaltet. Daher kann der AOP -Proxy direkt auf andere Bean -Instanzen im Container abzielen, und diese Beziehung kann durch Abhängigkeitsinjektion des IOC -Behälters bereitgestellt werden. Die Regeln für die Erstellung eines Proxy im Frühjahr sind:
1. Standardmäßig wird Java Dynamic Proxy zum Erstellen von AOP -Proxy verwendet, sodass Sie Proxy für jede Schnittstelleninstanz erstellen können.
2. Wenn die Klasse, die einen Proxy benötigt, keine Proxy -Schnittstelle ist, wechselt Spring in die Verwendung von CGGLIB -Proxy und kann auch CGGLIB zur Verwendung erzwingen.
AOP -Programmierung ist eigentlich eine sehr einfache Sache. Wenn Sie sich die AOP -Programmierung ansehen, müssen Programmierer nur an drei Teilen teilnehmen:
1. Definieren Sie gewöhnliche Geschäftskomponenten
2. Definieren Sie den Einstiegspunkt, ein Einstiegspunkt kann mehrere Geschäftskomponenten überschreiten
3. Definieren Sie die erweiterte Verarbeitung. Eine verbesserte Verarbeitung ist die Verarbeitungsaktion, die im AOP -Framework in gewöhnliche Geschäftskomponenten eingeweicht wird.
Daher ist der Schlüssel zur AOP -Programmierung darin, den Einstiegspunkt zu definieren und die Verbesserungsverarbeitung zu definieren. Sobald die entsprechende Einstiegspunkt- und Verbesserungsverarbeitung definiert ist, generiert das AOP -Framework automatisch einen AOP -Proxy, dh die Methode von Proxy -Objekt = Verbesserungsverarbeitung + Methode des Proxy -Objekts.
Hier ist eine Feder AOP .xml -Dateivorlage namens AOP.xml, und der nachfolgende Inhalt wird auf AOP.xml erweitert:
<? xmlns: aop = "http://www.springframework.org/schema/aop" xmlns: tx = "http://www.spingframework.org/schema/tx" xsi: schemalocation = "http://wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww.Stx http://www.springframework.org/schema/beans/spring-beans-2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.2.xsd "> </beans>
Einfache Implementierung von AOP basierend auf dem Frühling
Beachten Sie, dass ich vor dem Erläutern den Code erläutern kann, dass es nicht ausreicht, das von Spring dem Entwickler bereitgestellte JAR -Paket zu verwenden. Bitte laden Sie zwei JAR -Pakete online herunter:
1. Aopalliance.Jar
2. Aspektjweaver.jar
Lassen Sie uns die XML -Implementierungsmethode von Spring AOP erklären und zuerst eine Schnittstelle definieren:
public interface helloWorld {void Printhelloworld (); void doprint ();} Definieren Sie zwei Schnittstellen -Implementierungsklassen:
public class helloWorldimpl1 implementiert helloWorld {public void Printhelloworld () {System.out.println ("Geben Sie HelloWorldimpl1.prinThelloworld ()"); } public void doprint () {System.out.println ("HelloWorldimpl1.doprint ()"); zurückkehren ; }} public class helloWorldimpl2 implementiert helloWorld {public void Printhelloworld () {System.out.println ("Geben Sie HelloWorldimpl2.prinThelloworld ()"); } public void doprint () {System.out.println ("HelloWorldimpl2.doprint ()"); zurückkehren ; }} Cross-Cutting Focus, hier ist die Druckzeit:
public class timeHandler {public void printTime () {System.out.println ("currentime =" + system.currentTimemillis ()); }} Mit diesen drei Klassen können Sie eine einfache Frühlings -AOP implementieren. Schauen Sie sich die Konfiguration von AOP.xml an:
<? xmlns: aop = "http://www.springframework.org/schema/aop" xmlns: tx = "http://www.spingframework.org/schema/tx" xsi: schemalocation = "http://wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww.Stx http://www.springframework.org/schema/beans/spring-beans-2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd"> <bean id="helloWorldImpl1" /> <bean id="helloWorldImpl2" /> <bean id="timeHandler" /> <aop:config> <aop:aspect id="time" ref="timeHandler"> <aop:pointcut id = "addAllMethod" Expression = "Execution (* com.xrq.aop.Helloworld.
Schreiben Sie eine Hauptfunktion, um sie aufzurufen:
public static void main (string [] args) {applicationContext ctx = new classPathXmlApplicationContext ("aop.xml"); HelloWorld hw1 = (helloWorld) ctx.getbean ("helloWorldimpl1"); HelloWorld hw2 = (helloWorld) ctx.getbean ("helloWorldimpl2"); hw1.printhelloworld (); System.out.println (); hw1.doprint (); System.out.println (); System.out.println (); hw2.PrinThelloworld (); System.out.println (); hw2.doprint ();} Das laufende Ergebnis ist:
Currentime = 1446129611993enter HelloWorldimPl1.PrinThelloworld () Currentime = 1446129611993CurrentTime = 1446129611994enter HelloWorldimpl1.Doprint () CurrentTime = 144612961199494Crentime HelloWorldimpl2.PrinThelloworld () Currentime = 1446129611994CurrentTime = 1446129611994enter Helloworldimpl2.doprint () currentime = 1446129611994
Ich habe gesehen, dass alle Methoden der beiden Implementierungsklassen der HelloWorld -Schnittstelle zum Proxy hinzugefügt wurden, und der Proxy -Inhalt ist die Druckzeit.
Zusätzliche Details zur Feder-basierte AOP-Nutzung
1. Fügen Sie ein Querschnittsanliegen hinzu und drucken Sie das Protokoll aus. Die Java -Klasse lautet:
public class logHandler {public void logbefore () {System.out.println ("log vor der Methode"); } public void logAfter () {System.out.println ("Log After Method"); }}<? xmlns: aop = "http://www.springframework.org/schema/aop" xmlns: tx = "http://www.spingframework.org/schema/tx" xsi: schemalocation = "http://wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww.Stx http://www.springframework.org/schema/beans/spring-beans-2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd "> <bean id =" helloWorldimpl1 "/> <bean id =" helloWorldimpl2 "/> <bean id =" timehandler "/> <bean id =" loghandler "/<aop: config"/> <bean id = "loghandler"/<aop: konfigurieren " ref = "timeHandler" order = "1"> <aoP: pointcut id = "addtime" expression = "Execution (* com.xrq.aop.Helloworld. id = "log" ref = "logHandler" order = "2"> <aoP: pointcut id = "printlog" expression = "Ausführung (* com.xrq.aop.helloworld. </AOP: Aspekt> </aop: config> </beans>
Die Testklasse bleibt unverändert und das Druckergebnis ist:
Currentime = 1446130273734log vor methodenter helloWorldimpl1.prinThelloworld () log After MethodCurrentTime = 1446130273735CurrentTime = 14461302737366log vor methodenter HelloworDimpl1.doprint () Log Aftertime 1446130273736log vor methodenter helloWorldimpl2.PrinThelloworld () log After MethodCurrentTime = 1446130273736CurrentTime = 1446130273737log vor Methodeenter Helloworldimpl2
Es gibt zwei Möglichkeiten, den LogHandler vor dem TimeHandler zu verwenden:
(1) Es gibt ein Auftragsattribut in Aspekt, und die Anzahl des Orderattributs ist die Reihenfolge der Überschreitung der Fokuspunkte
(2) Definieren Sie den LogHandler vor dem TimeHandler. Spring verwendet standardmäßig die Definitionsreihenfolge des Aspekts als Webenreihenfolge.
2. Ich möchte nur einige Methoden in die Schnittstelle weben
Ändern Sie einfach den Pointcut -Ausdruck:
<? xmlns: aop = "http://www.springframework.org/schema/aop" xmlns: tx = "http://www.spingframework.org/schema/tx" xsi: schemalocation = "http://wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww.Stx http://www.springframework.org/schema/beans/spring-beans-2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd "> <bean id =" helloWorldimpl1 "/> <bean id =" helloWorldimpl2 "/> <bean id =" timehandler "/> <bean id =" loghandler "/<aop: config"/> <bean id = "loghandler"/<aop: konfigurieren " ref = "timeHandler" order = "1"> <aop: pointcut id = "addtime" expression = "Execution (* com.xrq.aop.Helloworld.print* (..)") /> <aop: vor methode = "drucktime" pointcut-ref = "addtime" /> <AOP: After Method = "printime" pointtime "pointcut-" -Ap: "pointtime" pointcut-". id="log" ref="logHandler" order="2"> <aop:pointcut id="printLog" expression="execution(* com.xrq.aop.HelloWorld.do*(..))" /> <aop:before method="LogBefore" pointcut-ref="printLog" /> <aop:after method="LogAfter" pointcut-ref="printLog" /> </AOP: Aspekt> </aop: config> </beans>
Es bedeutet, dass TimeHandler nur Methoden webt, die am Anfang des HelloWorld -Schnittstellendrucks beginnen. LogHandler webt nur Methoden, die zu Beginn der HelloWorld -Schnittstelle beginnen
3. Erzwingen Sie CGlib, Proxy zu erzeugen
Wie bereits erwähnt, verwendet Spring Dynamic Proxy oder CGGLIB, um Proxy zu erzeugen. Höhere Versionen von Spring wählen automatisch, ob dynamische Proxy oder CGLIB verwendet werden sollen, um Proxy -Inhalte zu generieren. Natürlich können wir CGGLIB auch dazu zwingen, Proxy zu generieren, dh ein "Proxy-Target-Klasse" -attribut in <AOP: config>. Wenn dieser Attributwert auf true festgelegt wird, funktioniert der klassenbasierte Proxy. Wenn die Proxy-Target-Klasse auf False eingestellt ist oder dieses Attribut weggelassen wird, funktioniert der interface-basierte Proxy.
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.