Follow Us on Twitter

Aspect Oriented Programming

September 2004 - Oracle heeft deze maand een beta versie uitgebrachtvan de JDeveloper plugin voor Aspect Oriented Programming met AspectJ. Oraclesluit hiermee aan op deze veelbelovende nieuwe ontwikkelmethodiek. AspectOriented Programming helpt bij het scheiden van functionele onderdelen van eenapplicatie die op veel verschillende plaatsen van toepassing zijn(‘crosscutting concerns’). Dit is met object georiënteerd programmeren vaakmoeilijk te realiseren omdat deze algemene onderdelen in de code zijn verweven met de rest van de functionaliteit van de applicatie.

Aspect Oriented Programming

Het doel van Aspect Oriented Programming (AOP) is het scheiden van 'concerns'. Een concern is een onderdeel van een programma waarmee rekening moet worden gehouden tijdens het ontwerp. Een functioneel concern is bijvoorbeeld de business logic terwijl een technisch concern bijvoorbeeld het loggen van de program flow is. Als de programmacode voor deze concerns door elkaar gaat lopen spreekt men van een 'crosscut'.

In AOP kunnen deze verschillende concerns worden gecombineerd tot zogeheten Aspecten. Dit zijn herbruikbare implementaties van een bepaald concern. Bij het compileren van een programma wordt een aspect samengevoegd met de overige code tot een nieuwe executable. Dit proces heet Aspect Weaving (zie figuur 1). 

Een programmeur kan zich zo concentreren op het programmeren van de business logica, terwijl de logging concerns gegarandeerd zijn

 
Figuur 1. Het combineren van een aspect met bestaande code tot een nieuwe executable.

De AOP methodiek is geïmplementeerd in verschillende AOP talen. Eén van deze talen is AspectJ. Het is een Java extensie die oorspronkelijk is ontwikkeld door Xerox en nu is ondergebracht bij het Eclipse platform. Naast AspectJ zijn er nog andere talen ontwikkeld zoals Jboss_AOP en AspectWerkz. Er zijn plannen om deze laatste ook als JDeveloper plugin beschikbaar te stellen.

AspectJ

AspectJ is een taal waarmee aspect georiënteerd kan worden ontwikkeld. De taal bevat verschillende (programmeer) constructies waarmee aspecten kunnen worden gebouwd.

Constructies

De basis taalconstructies in AspectJ zijn:

  • Join Point;
    Een Join Point is een gedefinieerd punt in de code zoals een method call,  een method executie, initialisatie van objecten, field get en set methoden etc.
  • PointCut;
    Een Pointcut is een subset van de beschikbare Join Points, gebaseerd op opgegeven criteria.
  • Advice;
    Een Advice beschrijft welke actie er ondernomen moet worden bij het bereiken van een Join Point uit de Pointcut set. Daarnaast wordt gedefinieerd op welk moment dat moet gebeuren, voor, na of rondom het Join Point.
  • Introduction;
    Een Introduction is het toevoegen van een aspect aan al bestaande code tijdens het compileren.
  • Aspect;
    Een Aspect is de definitie van pointcuts en advices die geïntroduceerd moeten worden in de code.

Implementatie

In de implementatie van AspectJ wordt een aspect gedefinieerd als een klasse van het type aspect. Hierin worden de pointcuts beschreven en de advices geformuleerd.

Om deze aspecten te 'weaven' met de code moet de code worden gecompileerd met de AspectJ compiler (ajc). Het resultaat bevat de oorspronkelijke code waarin het aspect is geïntegreerd.

In het voorbeeld van het concern business logica met het concern program flow logging is na het compileren aan het begin en het eind van elke methode een log-statement in de code toegevoegd.

De uiteindelijke executable bevat AspectJ specifieke code. AspectJ biedt daarom ook een module voor het debuggen van de gecompileerde code.

Voorbeeld

Alle methoden in de code behalve de methoden van de logger zelf worden aan het begin en einde van een logging statement voorzien. De variabele ‘thisJoinPoint’ is een speciaal reflectief object dat de runtime context weergeeft van het Join Point.

public aspect Logflow {
    pointcut alleMethoden(): execution(public * *..*(..));
    pointcut loggingMethoden(): execution(* my.Logger.*(..));
    pointcut alleTeLoggenCalls(): alleMethoden()&& (!loggingMethoden());
    before():  alleTeLoggenCalls() {
      my.Logger.begin(thisJoinPont.getSignature().toString());
    }
    after():  alleTeLoggenCalls() {
      my.Logger.eind(thisJoinPont.getSignature().toString());
    }
} 

Conclusie

AOP biedt interessante mogelijkheden om verschillende design concerns van elkaar te scheiden. Hiermee wordt een oplossing geboden voor het probleem dat een kleine wijziging in een bepaald concern een grote hoeveelheid aanpassingen door de hele code nodig maakt. De verschillende concerns kunnen apart ontworpen en geïmplementeerd worden met behulp van aspecten, wat het scheiden van design en verantwoordelijkheden vereenvoudigt en de kans op fouten verkleint.

De implementatie introduceert echter wel weer een extra compiler slag, waarbij de uiteindelijk opgeleverde code minder toegankelijk en moeilijker te debuggen is.

AOP wordt steeds breder ondesteund en toegepast. Gezien de mogelijkheden die het biedt is het zeker een technologie om bij design overwegingen in gedachten te houden. De nieuwe JDeveloperAOP plugin kan daarbij behulpzaam zijn.

Relevante Links

Waardering:
 

Reacties

Nieuwe reactie inzenden

De inhoud van dit veld is privé en zal niet openbaar worden gemaakt.

Meer informatie over formaatmogelijkheden

CAPTCHA
Deze vraag is om te testen of u een persoon bent en om spam te voorkomen
Image CAPTCHA
Enter the characters shown in the image.