Inleiding tot Spring AOP

1. Inleiding

In deze tutorial introduceren we AOP (Aspect Oriented Programming) met Spring en beginnen we te begrijpen hoe we deze krachtige tool in praktische scenario's kunnen gaan gebruiken.

Het is ook mogelijk om de annotaties van AspectJ te gebruiken bij het ontwikkelen met Spring AOP, maar in dit artikel concentreren we ons op de kernconfiguratie van Spring AOP XML.

2. Overzicht

AOP is een programmeerparadigma dat tot doel heeft de modulariteit te vergroten door de scheiding van transversale problemen mogelijk te maken. Het doet dit door extra gedrag toe te voegen aan bestaande code zonder de code zelf te wijzigen.

In plaats daarvan kunnen we deze nieuwe code en deze nieuwe gedragingen afzonderlijk declareren.

Het AOP-raamwerk van Spring helpt ons deze transversale zorgen te implementeren.

3. Maven afhankelijkheden

Laten we beginnen met het toevoegen van Spring's AOP-bibliotheekafhankelijkheid in het pom.xml:

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

De laatste versie van de afhankelijkheid kan hier worden gecontroleerd.

4. AOP-concepten en terminologie

Laten we kort de concepten en terminologie bespreken die specifiek zijn voor AOP:

4.1. Bedrijfsobject

Een bedrijfsobject is een normale klasse met een normale bedrijfslogica. Laten we eens kijken naar een eenvoudig voorbeeld van een bedrijfsobject waarbij we gewoon twee getallen optellen:

openbare klasse SampleAdder {public int add (int a, int b) {return a + b; }} 

Merk op dat deze klasse een normale klasse is met bedrijfslogica en zonder enige Spring-gerelateerde annotaties.

4.2. Aspect

Een aspect is een modularisering van een zorg die meerdere klassen beslaat. Unified logging kan een voorbeeld zijn van een dergelijke transversale zorg.

Laten we eens kijken hoe we een eenvoudig aspect definiëren:

openbare klasse AdderAfterReturnAspect {privé Logger-logger = LoggerFactory.getLogger (this.getClass ()); public void afterReturn (Object returnValue) gooit Throwable {logger.info ("value return was {}", returnValue); }} 

In het bovenstaande voorbeeld hebben we zojuist een eenvoudige Java-klasse gedefinieerd met een methode genaamd afterReturn daar is één type argument voor nodig Voorwerp en het logt gewoon die waarde in. Merk op dat zelfs onze AdderAfterReturnAspect is een standaardklasse, zonder enige lente-annotaties.

In de volgende secties zullen we zien hoe we dit aspect kunnen koppelen aan ons bedrijfsobject.

4.3. Joinpoint

EEN Joinpoint is een punt tijdens het uitvoeren van een programma, zoals het uitvoeren van een methode of het afhandelen van een uitzondering.

In het voorjaar van AOP, een JoinPoint vertegenwoordigt altijd de uitvoering van een methode.

4.4. Pointcut

Een Pointcut is een predikaat dat helpt bij het matchen van een Advies toe te passen door een Aspect op een bepaald JoinPoint.

Het advies wordt vaak geassocieerd met een Pointcut expressie en draait op elk Joinpoint geëvenaard door de Pointcut.

4.5. Advies

Een advies is een actie die wordt ondernomen door een aspect bij een bepaald aspect Joinpoint. Er zijn verschillende soorten advies "Rond", "voor" en "na" advies.

In het voorjaar heeft een Advies is gemodelleerd als een interceptor, waarbij een keten van interceptors rond de Joinpoint.

4.6. Bedrijfsobject en -aspect bedraden

Laten we eens kijken hoe we een zakelijk object kunnen koppelen aan een aspect met een advies na retournering.

Hieronder staat het configuratie-fragment dat we in een standaard Spring-configuratie in het “” label:

Zoals te zien is, hebben we een eenvoudige boon gedefinieerd, genaamd simpleAdder die een exemplaar van een Business Object vertegenwoordigt. Daarnaast maken we een instantie van een aangeroepen Aspect AdderAfterReturnAspect.

XML is hier natuurlijk niet onze enige optie; zoals eerder vermeld, worden AspectJ-annotaties ook volledig ondersteund.

4.7. Configuratie in een oogopslag

Label aop: config wordt gebruikt voor het definiëren van AOP-gerelateerde configuratie. Binnen de config tag definiëren we de klasse die een aspect vertegenwoordigt. We hebben het een referentie gegeven van "DoAfterReturningAspect" aspectboon die we hebben gemaakt.

Vervolgens definiëren we een Pointcut met de pointcut label. Pointcut gebruikt in het bovenstaande voorbeeld is uitvoering (* org.baeldung.logger.SampleAdder +. * (..)) wat betekent dat je een advies toepast op elke methode binnenin SampleAdder klasse die een willekeurig aantal argumenten accepteert en elk waardetype retourneert.

Vervolgens bepalen we welk advies we willen toepassen. In het bovenstaande voorbeeld gaan we advies na terugkeer toepassen dat is gedefinieerd in ons aspect AdderAfterReturnAspect door de methode met de naam uit te voeren afterReturn gedefinieerd met behulp van attribuutmethode.

Dit advies binnen Aspect neemt één parameter van het type aan Voorwerp. De parameter geeft ons de mogelijkheid om een ​​actie uit te voeren vóór en / of na de aanroep van de doelmethode. In dit geval loggen we alleen de retourwaarde van de methode.

Spring AOP ondersteunt meerdere adviezen met behulp van op annotatie gebaseerde configuratie - deze en meer voorbeelden zijn hier en hier te vinden.

5. Conclusie

In deze tutorial hebben we concepten geïllustreerd die worden gebruikt in AOP en een voorbeeld van het gebruik van de AOP-module van Spring. Als u meer wilt weten over AOP, zijn hier enkele bronnen:

  • Een inleiding tot AspectJ
  • Een aangepaste Spring AOP-annotatie implementeren
  • Een inleiding tot Pointcut-uitdrukkingen in het voorjaar
  • Vergelijking van Spring AOP en AspectJ
  • Een inleiding tot adviestypes in het voorjaar

De implementatie van deze voorbeelden is te vinden in het GitHub-project - dit is een op Maven gebaseerd project, dus het zou gemakkelijk moeten kunnen worden geïmporteerd en uitgevoerd zoals het is.