streamalism.org

1. Introduktion

I denne artikel implementerer vi en tilpasset AOP-kommentar ved hjælp af AOP-supporten i foråret.

For det første giver vi et overblik på højt niveau af AOP og forklarer, hvad det er og dets fordele. Herefter implementerer vi vores kommentar trin for trin og gradvis opbygger en mere dybtgående forståelse af AOP-koncepter, mens vi går.

Resultatet bliver en bedre forståelse af AOP og evnen til at oprette vores brugerdefinerede forårskommentarer i fremtiden.

2. Hvad er en AOP-kommentar?

For hurtigt at opsummere står AOP for aspektorienteret programmering. I det væsentlige det er en måde at føje adfærd til eksisterende kode uden at ændre denne kode.

For en detaljeret introduktion til AOP, er der artikler om AOP-punktgenveje og rådgivning. Denne artikel antager, at vi allerede har en grundlæggende viden.

Den type AOP, som vi vil implementere i denne artikel, er annoteringsdrevet. Vi er måske allerede bekendt med dette, hvis vi har brugt foråret @Transaktionel kommentar:

@Transactional public void orderGoods (Order order) {// En række databaseopkald, der skal udføres i en transaktion}

Nøglen her er ikke-invasivitet. Ved at bruge annoteringsmetadata forurenes vores kerneforretningslogik ikke med vores transaktionskode. Dette gør det lettere at ræsonnere om, refaktorere og teste isoleret.

Nogle gange kan folk, der udvikler forårsprogrammer, se dette som ‘Spring Magic 'uden at tænke meget detaljeret over, hvordan det fungerer. I virkeligheden er det, der sker, ikke særlig kompliceret. Når vi har gennemført trinene i denne artikel, vil vi dog være i stand til at oprette vores egen brugerdefinerede kommentar for at forstå og udnytte AOP.

3. Maven-afhængighed

Lad os først tilføje vores Maven-afhængigheder.

I dette eksempel bruger vi Spring Boot, da dens konvention over konfigurationsmetode giver os mulighed for at komme i gang så hurtigt som muligt:

 org.springframework.boot spring-boot-starter-parent 2.2.2.RELEASE org.springframework.boot spring-boot-starter-aop 

Bemærk, at vi har inkluderet AOP-starter, som trækker i bibliotekerne, vi har brug for for at begynde at implementere aspekter.

4. Oprettelse af vores brugerdefinerede kommentar

Annotationen, vi skal oprette, er en, der bruges til at logge den tid, det tager en metode at udføre. Lad os oprette vores kommentar:

@Target (ElementType.METHOD) @Retention (RetentionPolicy.RUNTIME) offentlig @interface LogExecutionTime {} 

Selvom det er en relativt enkel implementering, er det værd at bemærke, hvad de to metanoteringer bruges til.

Det @Mål kommentar fortæller os, hvor vores kommentar finder anvendelse. Her bruger vi ElementType.Method, hvilket betyder, at det kun fungerer på metoder. Hvis vi forsøgte at bruge kommentaren et andet sted, ville vores kode ikke kompilere. Denne adfærd giver mening, da vores kommentar vil blive brugt til udførelsestid for loggningsmetode.

Og @Tilbageholdelse angiver bare, om kommentaren vil være tilgængelig for JVM ved kørsel eller ej. Som standard er det ikke, så Spring AOP ville ikke være i stand til at se kommentaren. Det er derfor, det er blevet omkonfigureret.

5. Oprettelse af vores aspekt

Nu har vi vores kommentar, lad os oprette vores aspekt. Dette er bare det modul, der vil indkapsle vores tværgående bekymring, hvilket er vores sag, er logning af metodeudførelsestid. Alt, hvad det er, er en klasse, kommenteret med @Aspect:

@Aspect @Component public class EksempelAspect {}

Vi har også inkluderet @Komponent anmærkning, da vores klasse også skal være en forårskønt for at blive opdaget. I det væsentlige er dette den klasse, hvor vi implementerer den logik, som vi ønsker, at vores brugerdefinerede kommentar skal injiceres.

6. Oprettelse af vores genvej og rådgivning

Lad os nu oprette vores genvej og rådgivning. Dette vil være en kommenteret metode, der lever i vores aspekt:

@Around ("@ annotation (LogExecutionTime)") public Object logExecutionTime (ProceedingJoinPoint joinPoint) throw Throwable {return joinPoint.proceed (); }

Teknisk set ændrer dette ikke adfærd for noget endnu, men der foregår stadig en hel del, der skal analyseres.

For det første har vi kommenteret vores metode med @Rundt om. Dette er vores råd, og omkring rådgivning betyder, at vi tilføjer ekstra kode både før og efter metodeudførelse. Der er andre typer rådgivning, såsom Før og efter men de vil blive udeladt af anvendelsesområdet for denne artikel.

Dernæst vores @Rundt om annotation har et punkt-cut-argument. Vores genvej siger bare, 'Anvend dette råd enhver metode, der er kommenteret @LogExecutionTime. ' Der er mange andre typer af genveje, men de vil igen blive udeladt, hvis omfanget er.

Metoden logExecutionTime () i sig selv er vores råd. Der er et enkelt argument, FortsætterJoinPoint. I vores tilfælde vil dette være en eksekveringsmetode, som er blevet kommenteret med @LogExecutionTime.

Endelig når vores annoterede metode ender med at blive kaldt, hvad der vil ske er, at vores råd kaldes først. Så er det op til vores råd at beslutte, hvad de skal gøre næste gang. I vores tilfælde gør vores råd intet andet end at ringe Fortsæt(), som bare kalder den oprindelige kommenterede metode.

7. Logning af vores udførelsestid

Nu har vi vores skelet på plads, alt hvad vi skal gøre er at tilføje lidt ekstra logik til vores råd. Dette er, hvad der logger udførelsestiden ud over at kalde den oprindelige metode. Lad os tilføje denne ekstra adfærd til vores råd:

@Around ("@ annotation (LogExecutionTime)") public Object logExecutionTime (ProceedingJoinPoint joinPoint) throw Throwable {long start = System.currentTimeMillis (); Objekt fortsæt = joinPoint.proceed (); lang udførelsestid = System.currentTimeMillis () - start; System.out.println (joinPoint.getSignature () + "udført i" + udførelsestid + "ms"); tilbage fortsæt; }

Igen har vi ikke gjort noget, der er særlig kompliceret her. Vi har lige registreret det aktuelle tidspunkt, udført metoden og derefter udskrevet den tid, det tog til konsollen. Vi logger også metodesignaturen, som leveres til brug af joinpoint eksempel. Vi ville også være i stand til at få adgang til andre informationstykker, hvis vi ønskede det, såsom metodeargumenter.

Lad os nu prøve at kommentere en metode med @LogExecutionTime, og derefter udføre det for at se, hvad der sker. Bemærk, at dette skal være en Spring Bean for at fungere korrekt:

@LogExecutionTime public void serve () kaster InterruptedException {Thread.sleep (2000); }

Efter udførelse skal vi se følgende logget på konsollen:

ugyldig org.baeldung.Service.serve () udført i 2030ms

8. Konklusion

I denne artikel har vi brugt Spring Boot AOP til at oprette vores brugerdefinerede annotering, som vi kan anvende på Spring beans for at injicere ekstra adfærd til dem ved kørsel.

Kildekoden til vores applikation er tilgængelig på over på GitHub; dette er et Maven-projekt, som skal kunne køre som det er.