Acest subiect nu este ușor și este rar folosit direct, dar multe cadre și tehnologii îl folosesc sub capotă. Și, desigur, uneori, în timpul interviurilor, vi se poate cere să descrieți în termeni generali ce fel de fiară este aceasta și unde poate fi aplicată. Deci, să aruncăm o privire la conceptele de bază și la câteva exemple simple de AOP în Java . Acum, AOP înseamnă programare orientată pe aspecte, care este o paradigmă menită să crească modularitatea diferitelor părți ale unei aplicații prin separarea preocupărilor transversale. Pentru a realiza acest lucru, se adaugă un comportament suplimentar codului existent fără a face modificări codului original. Cu alte cuvinte, ne putem gândi la asta ca agățarea de funcționalități suplimentare peste metode și clase, fără a modifica codul modificat. De ce este necesar acest lucru? Mai devreme sau mai târziu, ajungem la concluzia că abordarea tipică orientată pe obiecte nu poate rezolva întotdeauna în mod eficient anumite probleme. Și când sosește acel moment, AOP vine în ajutor și ne oferă instrumente suplimentare pentru construirea de aplicații. Iar instrumentele suplimentare înseamnă o flexibilitate sporită în dezvoltarea de software, ceea ce înseamnă mai multe opțiuni pentru rezolvarea unei anumite probleme.
Aplicarea AOP
Programarea orientată pe aspecte este concepută pentru a îndeplini sarcini transversale, care poate fi orice cod care poate fi repetat de mai multe ori prin metode diferite, care nu poate fi structurat complet într-un modul separat. În consecință, AOP ne permite să păstrăm acest lucru în afara codului principal și să îl declarăm vertical. Un exemplu este utilizarea unei politici de securitate într-o aplicație. De obicei, securitatea rulează prin multe elemente ale unei aplicații. În plus, politica de securitate a aplicației ar trebui să fie aplicată în mod egal tuturor părților existente și noi ale aplicației. În același timp, o politică de securitate în uz poate evolua ea însăși. Acesta este locul perfect pentru a utiliza AOP . De asemenea, un alt exemplu este înregistrarea în jurnal. Există mai multe avantaje în utilizarea abordării AOP pentru înregistrare, mai degrabă decât adăugarea manuală a funcțiilor de înregistrare:-
Codul pentru înregistrare este ușor de adăugat și de eliminat: tot ce trebuie să faceți este să adăugați sau să eliminați câteva configurații cu un anumit aspect.
-
Tot codul sursă pentru înregistrare este păstrat într-un singur loc, astfel încât nu este nevoie să vânați manual toate locurile în care este utilizat.
-
Codul de înregistrare poate fi adăugat oriunde, fie în metode și clase care au fost deja scrise, fie în funcționalități noi. Acest lucru reduce numărul de erori de codare.
De asemenea, atunci când eliminați un aspect dintr-o configurație de design, puteți fi sigur că tot codul de urmărire a dispărut și că nimic nu a fost ratat.
- Aspectele sunt coduri separate care pot fi îmbunătățite și utilizate din nou și din nou.
AOP este, de asemenea, utilizat pentru gestionarea excepțiilor, stocarea în cache și extragerea anumitor funcționalități pentru a-l face reutilizabil.
Principiile de bază ale AOP
Pentru a merge mai departe în acest subiect, să cunoaștem mai întâi conceptele principale ale AOP. Sfat — Logică suplimentară sau cod apelat dintr-un punct de conectare. Sfatul poate fi efectuat înainte, după sau în loc de un punct de unire (mai multe despre ele mai jos). Tipuri posibile de sfaturi :
-
Înainte — acest tip de consiliere este lansat înainte ca metodele țintă, adică punctele de unire, să fie executate. Când folosim aspecte ca clase, folosim adnotarea @Before pentru a marca sfatul ca fiind înainte. Când utilizați aspecte ca fișiere .aj , aceasta va fi metoda before() .
- După — sfatul care este executat după executarea metodelor (punctele de unire) este complet, atât în execuția normală, cât și atunci când se aruncă o excepție.
Când folosim aspecte ca clase, putem folosi adnotarea @After pentru a indica că acesta este un sfat care vine după.
Când utilizați aspecte ca fișiere .aj , aceasta este metoda after() .
-
După revenire — acest sfat este efectuat numai când metoda țintă se termină normal, fără erori.
Când aspectele sunt reprezentate ca clase, putem folosi adnotarea @AfterReturning pentru a marca sfatul ca fiind executat după finalizarea cu succes.
Când utilizați aspecte ca fișiere .aj , aceasta va fi metoda de returnare after() (Object obj) .
-
După aruncare — acest sfat este destinat cazurilor în care o metodă, adică un punct de unire, aruncă o excepție. Putem folosi acest sfat pentru a gestiona anumite tipuri de execuție eșuată (de exemplu, pentru a derula înapoi o întreagă tranzacție sau pentru a înregistra cu nivelul de urmărire necesar).
Pentru aspectele de clasă, adnotarea @AfterThrowing este folosită pentru a indica faptul că acest sfat este folosit după aruncarea unei excepții.
Când utilizați aspecte ca fișiere .aj , aceasta va fi metoda de aruncare after() (Excepția e) .
-
În jur - poate unul dintre cele mai importante tipuri de sfaturi. Acesta înconjoară o metodă, adică un punct de îmbinare pe care îl putem folosi, de exemplu, pentru a alege dacă să executăm sau nu o anumită metodă a punctului de unire.
Puteți scrie un cod de sfat care rulează înainte și după executarea metodei punctului de unire.
Sfatul around este responsabil pentru apelarea metodei punctului de unire și a valorilor returnate dacă metoda returnează ceva. Cu alte cuvinte, în acest sfat, puteți să simulați pur și simplu funcționarea unei metode țintă fără a o apela și să returnați ceea ce doriți ca rezultat returnat.
Având în vedere aspectele ca clase, folosim adnotarea @Around pentru a crea sfaturi care înglobează un punct de îmbinare. Când utilizați aspecte sub formă de fișiere .aj , această metodă va fi metoda around() .
-
Tesare în timp de compilare — dacă aveți codul sursă al aspectului și codul în care utilizați aspectul, atunci puteți compila codul sursă și aspectul direct folosind compilatorul AspectJ;
-
Țesătură post-compilare (împletire binară) — dacă nu puteți sau nu doriți să utilizați transformări de cod sursă pentru a țese aspecte în cod, puteți lua clase sau fișiere jar compilate anterior și puteți injecta aspecte în ele;
-
Încărcare în timp de țesere — aceasta este doar țesere binară care este întârziată până când încărcătorul de clasă încarcă fișierul de clasă și definește clasa pentru JVM.
Unul sau mai multe încărcătoare din clasa de țesut sunt necesare pentru a sprijini acest lucru. Acestea sunt fie furnizate în mod explicit de runtime, fie activate de un „agent de țesut”.
Exemple în Java
În continuare, pentru o mai bună înțelegere a AOP , ne vom uita la mici exemple în stil „Hello World”. În dreptul liliacului, voi reține că exemplele noastre vor folosi țeserea în timp de compilare . Mai întâi, trebuie să adăugăm următoarea dependență în fișierul nostru pom.xml :
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.9.5</version>
</dependency>
<build>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>aspectj-maven-plugin</artifactId>
<version>1.7</version>
<configuration>
<complianceLevel>1.8</complianceLevel>
<source>1.8</source>
<target>1.8</target>
<showWeaveInfo>true</showWeaveInfo>
<<verbose>true<verbose>
<Xlint>ignore</Xlint>
<encoding>UTF-8</encoding>
</configuration>
<executions>
<execution>
<goals>
<goal>compile</goal>
<goal>test-compile</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
Exemplul nr. 1
Să creăm o clasă principală . În el, vom avea un punct de intrare și o metodă care imprimă un nume transmis pe consolă:
public class Main {
public static void main(String[] args) {
printName("Tanner");
printName("Victor");
printName("Sasha");
}
public static void printName(String name) {
System.out.println(name);
}
}
public aspect GreetingAspect {
pointcut greeting() : execution(* Main.printName(..));
before() : greeting() {
System.out.print("Hi, ");
}
}
@Aspect
public class GreetingAspect{
@Pointcut("execution(* Main.printName(String))")
public void greeting() {
}
@Before("greeting()")
public void beforeAdvice() {
System.out.print("Hi, ");
}
}
- @Aspect indică faptul că această clasă este un aspect;
- @Pointcut("execution(* Main.printName(String))") este punctul de tăiere care este declanșat pentru toate apelurile către Main.printName cu un argument de intrare al cărui tip este String ;
- @Before(„greeting()”) este un sfat care se aplică înainte de a apela codul specificat în punctul de tăiere greeting() .
Exemplul nr. 2
Să presupunem că avem o metodă care efectuează unele operații pentru clienți și numim această metodă din main :
public class Main {
public static void main(String[] args) {
performSomeOperation("Tanner");
}
public static void performSomeOperation(String clientName) {
System.out.println("Performing some operations for Client " + clientName);
}
}
@Aspect
public class TransactionAspect{
@Pointcut("execution(* Main.performSomeOperation(String))")
public void executeOperation() {
}
@Around(value = "executeOperation()")
public void beforeAdvice(ProceedingJoinPoint joinPoint) {
System.out.println("Opening a transaction...");
try {
joinPoint.proceed();
System.out.println("Closing a transaction...");
}
catch (Throwable throwable) {
System.out.println("The operation failed. Rolling back the transaction...");
}
}
}
public static void performSomeOperation(String clientName) throws Exception {
System.out.println("Performing some operations for Client " + clientName);
throw new Exception();
}
Exemplul nr. 3
În exemplul următor, să facem ceva de genul logării la consolă. Mai întâi, aruncați o privire la Main , unde am adăugat o pseudo-logică de afaceri:
public class Main {
private String value;
public static void main(String[] args) throws Exception {
Main main = new Main();
main.setValue("<some value>");
String valueForCheck = main.getValue();
main.checkValue(valueForCheck);
}
public void setValue(String value) {
this.value = value;
}
public String getValue() {
return this.value;
}
public void checkValue(String value) throws Exception {
if (value.length() > 10) {
throw new Exception();
}
}
}
@Aspect
public class LogAspect {
@Pointcut("execution(* *(..))")
public void methodExecuting() {
}
@AfterReturning(value = "methodExecuting()", returning = "returningValue")
public void recordSuccessfulExecution(JoinPoint joinPoint, Object returningValue) {
if (returningValue != null) {
System.out.printf("Successful execution: method — %s method, class — %s class, return value — %s\n",
joinPoint.getSignature().getName(),
joinPoint.getSourceLocation().getWithinType().getName(),
returningValue);
}
else {
System.out.printf("Successful execution: method — %s, class — %s\n",
joinPoint.getSignature().getName(),
joinPoint.getSourceLocation().getWithinType().getName());
}
}
@AfterThrowing(value = "methodExecuting()", throwing = "exception")
public void recordFailedExecution(JoinPoint joinPoint, Exception exception) {
System.out.printf("Exception thrown: method — %s, class — %s, exception — %s\n",
joinPoint.getSignature().getName(),
joinPoint.getSourceLocation().getWithinType().getName(),
exception);
}
}
- Când metoda are o valoare returnată — dacă (returningValue! = Null) {
- Când nu există o valoare returnată — else {
Puteți citi despre excepții și gestionarea excepțiilor în aceste articole: Excepții în Java și Excepții: captura și manipulare . Asta e tot pentru mine azi. Astăzi ne-am familiarizat cu AOP și ați putut vedea că această fiară nu este atât de înfricoșătoare pe cât cred unii oameni. La revedere, tuturor!
GO TO FULL VERSION