Inleiding tot Pointcut-uitdrukkingen in het voorjaar

1. Overzicht

In deze tutorial zullen we de Spring AOP pointcut-expressietaal bespreken.

We zullen eerst enkele terminologie introduceren die wordt gebruikt bij aspectgeoriënteerd programmeren. EEN sluit je aan bij punt is een stap in de programma-uitvoering, zoals het uitvoeren van een methode of het afhandelen van een uitzondering. In Spring AOP vertegenwoordigt een join-punt altijd de uitvoering van een methode. EEN pointcut is een predikaat dat overeenkomt met de join-punten en een pointcut expressie taal is een manier om pointcuts programmatisch te beschrijven.

2. Gebruik

Een pointcut-uitdrukking kan verschijnen als een waarde van de @Pointcut annotatie:

@Pointcut ("within (@ org.springframework.stereotype.Repository *)") openbare ongeldige repositoryClassMethods () {}

De methode-declaratie wordt de pointcut handtekening. Het biedt een naam die kan worden gebruikt door adviesannotaties om naar die pointcut te verwijzen.

@Around ("repositoryClassMethods ()") public Object measureMethodExecutionTime (ProceedingsJoinPoint pjp) gooit Throwable {...}

Een pointcut-uitdrukking kan ook verschijnen als de waarde van de uitdrukking eigendom van een aop: pointcut label:

3. Pointcut-aanduidingen

Een pointcut-uitdrukking begint met een pointcut-aanduiding (PCD), wat een trefwoord is dat Spring AOP vertelt wat er overeen moet komen. Er zijn verschillende pointcut-aanduidingen, zoals de uitvoering van een methode, een type, methode-argumenten of annotaties.

3.1 executie

De primaire Spring PCD is executie, die overeenkomt met de methode-uitvoering-join-punten.

@Pointcut ("executie (public String com.baeldung.pointcutadvice.dao.Foobao.findById (Long))")

Dit voorbeeld van een pointcut komt exact overeen met de uitvoering van findById methode van de Foobao klasse. Dit werkt, maar het is niet erg flexibel. Stel dat we alle methoden van de Foobao class, die verschillende handtekeningen, retourtypen en argumenten kan hebben. Om dit te bereiken kunnen we jokertekens gebruiken:

@Pointcut ("uitvoering (* com.baeldung.pointcutadvice.dao.Foobao. * (..))")

Hier komt het eerste jokerteken overeen met elke geretourneerde waarde, het tweede komt overeen met de naam van een methode en de (..) patroon komt overeen met een willekeurig aantal parameters (nul of meer).

3.2 binnen

Een andere manier om hetzelfde resultaat te bereiken als in de vorige sectie, is door de binnen PCD, die het matchen beperkt om punten van bepaalde typen samen te voegen.

@Pointcut ("binnen (com.baeldung.pointcutadvice.dao.Foobao)")

We kunnen ook elk type binnen de com.baeldung pakket of een subpakket.

@Pointcut ("binnen (com.baeldung .. *)")

3.3 dit en doelwit

dit beperkt de matching tot join-punten waarbij de bean-referentie een instantie van het opgegeven type is, while doelwit beperkt het matchen tot join-punten waar het doelobject een instantie van het opgegeven type is. De eerste werkt wanneer Spring AOP een op CGLIB gebaseerde proxy maakt, en de laatste wordt gebruikt wanneer een op JDK gebaseerde proxy wordt gemaakt. Stel dat de doelklasse een interface implementeert:

public class Foobao implementeert Bar Dao {...}

In dit geval gebruikt Spring AOP de op JDK gebaseerde proxy en moet u de doelwit PCD omdat het proxy-object een exemplaar is van Proxy class en implementeer het Barão koppel:

@Pointcut ("target (com.baeldung.pointcutadvice.dao.Barbao)")

Aan de andere kant als Foobao implementeert geen interface of proxyTargetClass eigenschap is ingesteld op true, dan is het proxy-object een subklasse van Foobao en de dit PCD kan worden gebruikt:

@Pointcut ("this (com.baeldung.pointcutadvice.dao.Foobao)")

3.4 args

Deze PCD wordt gebruikt voor het matchen van bepaalde methode-argumenten:

@Pointcut ("executie (* * .. find * (Long))")

Deze pointcut komt overeen met elke methode die begint met find en heeft slechts één parameter van het type Lang. Als we een methode willen matchen met een willekeurig aantal parameters maar met de eerste parameter van het type Lang, zouden we de volgende uitdrukking kunnen gebruiken:

@Pointcut ("executie (* * .. find * (Long, ..))")

3.5 @doelwit

De @doelwit PCD (niet te verwarren met de doelwit PCD hierboven beschreven) beperkt matching tot join-punten waar de klasse van het uitvoerende object een annotatie van het opgegeven type heeft:

@Pointcut ("@ target (org.springframework.stereotype.Repository)")

3.6 @args

Deze PCD beperkt het matchen tot join-punten waar het runtime-type van de daadwerkelijke doorgegeven argumenten annotaties van het / de gegeven type (n) hebben. Stel dat we alle methoden willen traceren die bonen accepteren die zijn geannoteerd met @Entiteit annotatie:

@Pointcut ("@ args (com.baeldung.pointcutadvice.annotations.Entity)") openbare ongeldige methodenAcceptingEntities () {}

Om toegang te krijgen tot het argument moeten we een JoinPoint argument bij het advies:

@Before ("methodesAcceptingEntities ()") public void logMethodAcceptionEntityAnnotatedBean (JoinPoint jp) {logger.info ("Beans accepteren met @Entity annotatie:" + jp.getArgs () [0]); }

3.7 @binnen

Deze PCD beperkt het matchen om punten samen te voegen binnen typen die de gegeven annotatie hebben:

@Pointcut ("@ binnen (org.springframework.stereotype.Repository)")

Wat gelijk staat aan:

@Pointcut ("binnen (@ org.springframework.stereotype.Repository *)")

3.8 @annotatie

Deze PCD beperkt het matchen tot join-punten waar het onderwerp van het join-punt de gegeven annotatie heeft. We kunnen bijvoorbeeld een @Loggable annotatie:

@Pointcut ("@ annotation (com.baeldung.pointcutadvice.annotations.Loggable)") public void loggableMethods () {}

Vervolgens kunnen we de uitvoering van de methoden die door die annotatie zijn gemarkeerd, loggen:

@Before ("loggableMethods ()") openbare ongeldige logMethod (JoinPoint jp) {String methodName = jp.getSignature (). GetName (); logger.info ("Uitvoeringsmethode:" + methodNaam); }

4. Combineren van Pointcut-uitdrukkingen

Pointcut-uitdrukkingen kunnen worden gecombineerd met &&, || en ! operators:

@Pointcut ("@ target (org.springframework.stereotype.Repository)") public void repositoryMethods () {} @Pointcut ("execution (* * .. create * (Long, ..))") public void firstLongParamMethods () {} @Pointcut ("repositoryMethods () && firstLongParamMethods ()") openbare void entityCreationMethods () {}

5. Conclusie

In deze korte inleiding tot Spring AOP en pointcuts hebben we enkele voorbeelden geïllustreerd van het gebruik van pointcut-uitdrukkingen.

De volledige reeks voorbeelden is te vinden op GitHub.