AspectJ y otras plataformas de desarrollo orientadas a ... · Solución: Programación Orientada a...

Programación Orientada a Aspectos

AspectJ y otras plataformas

de desarrollo orientadas a aspectosAbait, Esteban S.

Agenda

� � Motivación

� AspectJ

� Ejemplos en AspectJ

� Otras plataformas AOP

� Recursos y Referencias

Motivación - Modularización

� Concerns que dada su naturaleza crosscutting

son imposibles de modularizar mediante el uso

de la programación orientada a objetos.

� Ejemplos: Logging (típico), persistencia,

sincronización, etc.

Motivación - Consecuencias

� Código difícil de modificar y mantener.

� Ejemplo: modificar el esquema de sincronización

utilizado por eclipse involucró cambiar 2573

métodos e insertar en 1284 métodos una llamada a

lock() así como también una llamada a unlock().

� Código difícil de entender.

On November 10, 2004, Silenio Quarti committed

code changes “76595 (new lock)” to the Eclipse

CVS repository. They xed bug #76595 “Hang in fi

gfk pix-buf new” that reported a deadlock and

required the implementation of a new locking

mechanism for several platforms. The extent of the

modi cation was enormous: He modi ed 2573 fi fi

methods and inserted in 1284methods a call to

lock, as well as a call to unlock. As it turns out,

AOP could have been used to add these.

[Breu y Zimmerman 2006]

Motivación - Ejemplo

� Método extraído de Tomcat 6.x

public void removeChild (Container child) {

synchronized(children) { if (children.get(child.getName()) == null) return; children.remove(child.getName()); } if (started && (child instanceof Lifecycle)) { try { if( child instanceof ContainerBase ) if( ((ContainerBase)child).started ) ((Lifecycle) child).stop(); else ((Lifecycle) child).stop(); } catch (LifecycleException e) { log.error("ContainerBase.removeChild: stop: ", e); } } fireContainerEvent(REMOVE_CHILD_EVENT, child); }

Concerns

�Sincronización�Ciclo de vida�Logging�Notificación

10% del código corresponde al concern original.

Tomado de: org/apache/catalina/core/ContainerBase.java

Apache Tomcat is the servlet container that is used in the reference

implementation for Sun's Java Servlet and JavaServer Pages

technologies. Código fuente disponible en:

http://jakarta.apache.org/tomcat.

Lifecycle es una interfase común para diferentes componentes de Catalina,

la cual provee mecanismos para comenzar (start) y detener (stop) al

componente. Este concern está implementado en más de 40 clases. La

operación start debe ser llamada antes que cualquier método público del

componente, mientras que stop termina el uso del objeto.

Mecanismo de notificación: Las clases que implementan la interfase

Lifecycle deben adoptar el rol de Sujeto (Observable) del patrón

Observer/Observabl.

Más información sobre crosscutting concerns en Tomcat ver [Marin et al.

2007].

Motivación - AOP

� Solución: Programación Orientada a Aspectos.

� Introduce el concepto de aspecto como

mecanismo que permite encapsular e

implementar un crosscutting concern.

� Consecuencia: mejor separación de concerns.

Motivación - Elementos

� Un sistema se descompone en clases y aspectos.

� La relación entre ambos se determina en base a los conceptos de join

points y weaving.

Un join-point indica un posible punto del sistema

donde el código definido por el aspecto puede

insertarse (por ejemplo, al inicio o final de un

método).

Un aspect weaver tiene la responsabilidad de

procesar el lenguaje base y el lenguaje de

aspectos y componerlos con el objetivo de obtener

la implementación del sistema.

El aspect weaver utiliza los join-points para

componer los aspectos con el código base.

Agenda

� Motivación

� � AspectJ




AspectJ - Introducción

� AspectJ es una extensión al lenguaje Java

mediante la cual es posible modularizar un

amplio rango de crosscutting concerns.

� Al ser una extensión de Java provee distintos

niveles de compatibilidad entre los lenguajes.

AspectJ - Compatibilidad

� Compatibilidad con Java:� Upward compatibility: todo programa legal en Java es legal en AspectJ.

� Platform compatibility: todo programa legal en AspectJ puede correr

sobre una maquina virtual de Java.

� Tool compatibility: es posible extender herramientas existentes para

soportar AspectJ de manera natural (plugins para Eclipse o Netbeans).

� Programmer compatibility: La programación en AspectJ surge

naturalmente como extensión de Java.

� Ventaja: Rápida adopción por parte de la

comunidad.

AspectJ - Weaving

� Weaving en AspectJ

� Weaving en tiempo de compilación (estático)

� Entrada: código java y aspectj.

� Salida: bytecode ejecutable en cualquier JVM.

� Futuro: weaving en tiempo de ejecución (dinámico),

al momento de cargar las clases en la VM.

Weaving is the process of composing the system from individual core

modules by following the weaving rules. In essence, the weaving rules

determine the final form of the system. The weaving rules are defined in

aspects that are separate entities from the individual core modules. This

separation makes it possible to change the woven system simply by

providing alternative weaving rules in the aspects.

AspectJ – Ejemplo (I)

Display

*

2Point

getX()getY()setX(int)setY(int)moveBy(int, int)

Line

getP1()getP2()setP1(Point)setP2(Point)moveBy(int, int)

Figure

makePoint(..)makeLine(..)

FigureElement

moveBy(int, int)

Operaciones para mover elementos

¿Cómo actualizar el Displaycada vez que un elemento gráfico modifica su estado?

Las características del lenguaje serán presentadas usando

este simple ejemplo.

A Figure consists of a number of FigureElements, which

can be either Points or Lines. The Figure class provides

factory services. There is also a Display.

Para este ejemplo podríamos observar que el crosscutting

concern de actualización de la pantalla atraviesa aquellas

clases de tipo FigureElement en aquellos métodos que

modifican el estado de las mismas (setters y getters).

AspectJ – Ejemplo (II)

class Line {

void setP1(Point p1) {

this.p1 = p1;

Display.update(this);

}


this.p2 = p2;


}}

class Point {

void setX(int x) {

this.x = x;


}

void setY(int y) {

this.y = y;


}}

� No hay localidad para el

concern “actualización del

Display”

� La evolución es costosa,

los cambios se propagan

por todas las clases.

AspectJ – Ejemplo (III)

- � Uso patrón

observer/observable.

� Mejor evolución:

� agregar nuevas vistas

no repercute en

cambios.

� Aún existe tangling.

class Line extends Observable {� void setP1(Point p1) {

this.p1 = p1;

super.setChanged();

super.notifyObservers();

}


this.p2 = p2;

super.setChanged();


}}

class Point extends Observable {

void setX(int x) {

this.x = x;

super.setChanged();


}

...}

AspectJ – Constructores

� AspectJ añade a Java

� un nuevo concepto: join-point.

� un conjunto de constructores:

� pointcuts.

� advices.

� inter-type declarations.

� aspects.

Pointcuts and advice afectan el flujo dinámico del

programa, mientras que las inter-type declarations

modifican de forma estática la jerarquía de clases

del programa.

Aspects agrupan los constructores anteriores.

AspectJ – Join points

� Join points: son puntos bien definidos en el flujo

de un programa.

� AspectJ expone sólo un subconjunto de join

points posibles.

void setX(int x) { this.x = x; }

Ejemplo: Del código anterior podemos identificar dos join points bien definidos:

- la ejecución del método setX. - el acceso al campo x.

Cuando un método o constructor son corridos,

existen dos tiempos asociados a ellos: cuando son

llamados, y cuando son ejecutados. Por lo tanto son

dos join points diferentes.

Ejemplos de join points son: llamadas a métodos,

ejecución de métodos, instanciación de un objeto,

ejecución de constructores, referencias a campos y

manejo de excepciones.

Los joinpoints no son posiciones en el código fuente

sino en la ejecución del programa. Son eventos que

ocurren durante la ejecución del programa.

AspectJ – Pointcuts (I)

� Estructura declarativa. Son constructores que

agrupan join points y datos del contexto de

ejecución de dichos puntos.

call(void Point.setX(int))

call (void Point.setX(int)) ||

call (void Point.setY(int))

Elige join points que son llamadas a unmétodo setX con parámetro int, tipo deretorno void de la clase Point.

Es posible componer diferentespointcuts (uso &&, || y !).

AspectJ – Pointcuts (II)

� Los pointcuts pueden tener nombres

� Ejemplo:

� Name-based pointcuts: enumeración explícita

de un conjunto de signaturas de métodos.

pointcut move():

call(void FigureElement.moveBy(int,int)) ||

call(void Point.setX(int)) ||

call(void Point.setY(int)) ||

call(void Line.setP1(Point)) ||

call(void Line.setP2(Point));

Buenas prácticas a la hora de escribir un pointcut:

“Before we introduce the designators, a few words about good practice in writing

pointcuts. Although anonymous pointcut definitions can be used, in all but the

simplest cases using a well-named pointcut is preferred because it greatly aids

program understanding. Try to keep individual pointcut definitions relatively simple,

and build up more complex expressions from smaller, named, constituent parts. A

pointcut definition would normally contain at most one type of kind designator (for

example, a set of calls, or a set of method executions, but not a mixture of bothand

definitely not if they are combined with &&) and optionally some context and scoping

designators...” [Colyer et al. 2004].

AspectJ – Pointcuts (III)

� Property-based pointcuts: son especificado en

base a las propiedades de los métodos en vez

de su nombre exacto.

� Ejemplo:

� Al invocar (call) cualquier método de la clase (FigureElement)

� o de una subclase (+)

� cuyo nombre comience con set (set*)

� que tenga void como retorno y cualquier cantidad de parámetros (...)

call ( void FigureElement+.set*(�) )

Cómo escribir un buen pointcut [Colyer et al. 2004]

Four steps are involved in writing a good pointcut. First, come up with a meaningful name that describes the

characteristic of the join points you want to match, ideally in a way that serves to make your program self-

documenting. For example, secureOperation: pointcut secureOperation();

Join point names tend to be singular (secureOperation rather than secureOperations), and fit into the

sentence "is this a <pointcut_name> join point?" The second step is to decide what kind of join points you

want to match, and add the appropriate kind designator to the pointcut definition (call, execution, handler,

get, set, adviceexecution, or one of the initialization designators). It is rare to combine kind designators of

more than one type in a pointcut; if you do, be sure to combine them using || rather than &&. An example

might be get(* x) || set(* x) to match all references to a field named x. If you are matching call or execution

join points, do not specify a declaring type in the signature pattern unless you are sure that you want static

typing matches.

pointcut secureOperation() : execution(public *(..));

The third step is to decide in which context the pointcut should match (using target, this, or args). If the

pointcut should match in any context, you can omit this stage. If the users of the pointcut need access to the

contextual values at a matched join point, add these to the pointcut parameter list and bind the values in the

context designators.

pointcut secureOperation(ISecured secured) :

execution(public *(..)) &&

this(secured);

Finally, decide on the scope in which the pointcut should match (within a certain component, for example, or

a given control flow).

pointcut secureOperation(ISecured secured) :

execution(public *(..)) &&

target(secured) &&

within(com.xyz.someapp..*);

Try to keep individual pointcut definitions small and simple, and build more complex pointcuts by combining

named, simpler pointcuts.

AspectJ – Advices (I)

� Un Advice define el código que se debe

ejecutar cuando un join point que cumple con

un pointcut es alcanzado en el flujo de

ejecución de un programa.

� Ejemplo: after(): move() {Display. update();

}

TiempoCódigo crosscutting

Pointcut asociado al advice

Pointcuts and advice together form the dynamic

crosscutting rules. While the pointcuts identify the

required join points, the advice completes the

picture by providing the actions that will occur at the

join points. [Laadad – AspectJ in Action].

Mediante los pointcuts especificamos las reglas de

weaving y con los advices asociamos el

comportamiento crosscutting al código base.

AspectJ – Advices (II)

� Un advice puede ejecutarse antes (before),

después (after) o en vez (around) de un join

point.

before(): move() {System.out.println(�A punto de moverse�);

}after(): move() {

System.out.println(�Se movió�);}

void around(): move() {System.out.println(�A punto de moverse�);proceed();System.out.println(�Se movió�);

}

Before Advice: es el más simple de los tres.

Around Advice

� Around Advice: es especial ya que tiene la habilidad de ejecutar en lugar del

point join, continuar la ejecución original , o causar la ejecución con un contexto

alterado.

� proceed(): Ejecuta la operación del punto de unión detectado

� El advice puede retornar un valor, como si fuera un método y por lo tanto debe

declarar un tipo de retorno.

After Advice

There are three basic forms of after advice: after returning advice, which executes after

the successful return from a matched join point; after throwing advice, which executes

after returning from a matched join point via an exception condition; and after finally

advice (also known as just "after" advice), which executes whether returning from a

matched join point by either normal or exceptional return.

AspectJ – Advices (III)

� Exponer el contexto de ejecución de los join

points. Los valores expuestos por un pointcut

pueden ser usados en el cuerpo de los advices.

� Ejemplo:

void around(Point p, int x) : target(p) && args(x) && call(void setX(int)) {

System.out.println(�El punto � + p + �se movió a x: � + x);}

Advice can take zero or more parameters, specified in the advice declaration. Because

advice is invoked implicitly, there is no way for the programmer to pass parameter values

on a call to the advice. Where do the values for advice parameters come from then?

Recall that a pointcut declaration is a statement that the pointcut will provide contextual

values of the type specified in the pointcut declaration, these provided values from the

pointcut expression associated with a piece of advice are matched to the required values

from the advice specification. The matching happens by name. Each parameter in an

advice specification is given an identifier (a name)and every parameter name must

appear somewhere in the pointcut expression associated with the advice. Failure to

"bind" every parameter in this way results in the compile time error "formal unbound in

pointcut,"

AspectJ – Aspects (I)

� Aspect: empaqueta pointcuts, advices e inter-

type declarations en una unidad modular.

� Es similar a una clase, puede contener

métodos, variables de instancia, etc.

public aspect DisplayUpdate {

pointcut move(FigureElement e) :this(e) &&(call(void moveBy(int, int)) || call(void set*(..)));

after(FigureElement e) : move(e) {Display.update(e);

}}

Primera soluciónal ejemplo.

AspectJ – Aspects (II)

� Similitudes respecto a clases:

� Pueden incluir campos y métodos.

� Poseen especificaciones de acceso (public, private,...).

� Pueden ser abstractos (permitir mayor reuso).

� Un aspecto abstracto puede definir un pointcut o un advice como

abstracto.

� Pueden extender clases, otros aspectos e implementar

interfaces.

AspectJ – Aspects (III)

� Pero un aspecto no es una clase, estas son sus

diferencias:

� No pueden ser instanciados. La VM se encarga de ello,

sólo existe una única instancia.

� Un aspecto no puede heredar de otro aspecto concreto.

� Pueden ser marcados como privilegiados. Lo que implica

que estos podrían acceder a los miembros privados de

las clases.

AspectJ – Inter-type declarations (I)

� Permiten modificar la estructura estática de un

programa.

private Vector<Display> Point.observers = new Vector<Display>();

Introduce un nuevo campo 'observers' a la clase Point. El mismo sólo es visible dentro del aspecto en el cual fue declarado.

public Point.new(int x, int y) { this.setX(x); this.setY(y); }

Declara públicamente un nuevo constructor de dos argumentospara la clase Point.

AspectJ – Inter-type declarations (II)

declare parents : Point implements Comparable;

Declara que la clase Point implementa la interfase Comparable.

public int Point.compareTo(Object cmp) { ... }

Declara que cada Point posee un método compareTo. De existir otro método con el mismo nombre declarado dentro de la clase existirá un conflicto en tiempo de compilación.

� Más ejemplos:

AspectJ – Solución al ejemplo

� Segunda solución al ejemplo “display update”.

public aspect ObserverInstance {private Vector<Display> Point.observers = new Vector<Display>();

public static void addObserver(Point p, Display d) { p.observers.add(d); }public static void removeObserver(Point p, Display d) { ... }

pointcut changes(Point p) : target(p) && ( call (void Point.set*(int)) ||

call (void Point.moveBy(int, int)) );

after(Point p) : changes(p) {for (Display d : p.observers) {

updateObserver(p, d);}

}static void updateObserver(Point p, Display d) {

d.update(p);}

}

Solución al ejemplo

� Ventajas:

� Todo el código correspondiente al patrón se

encuentra en el aspecto.

� El código de la clase Point corresponde sólo a su

funcionalidad básica.

� Consecuencia: mejor separación de concerns y

evolución.

Agenda

� Motivación

� AspectJ

� � Ejemplos en AspectJ



Ejemplos – Tracing (I)

� Ejemplo clásico de AOP.

� Este aspecto imprime las llamadas a los métodos invocados

por un programa durante su ejecución.

public aspect Tracing {

pointcut thePublicMethods(Object t) : target(t) && execution(* org.aspectj..*(..)) && !within(Tracing); before(Object t) : thePublicMethods(t) { System.out.println("Entrando: " + thisJoinPoint.getSignature()); }}

Ejemplos – Tracing (II)

� La salida es

Entrando: void org.aspectj.Point.setX(int)Entrando: void org.aspectj.Point.setY(int)Entrando: void org.aspectj.Line.moveBy(int, int)Entrando: void org.aspectj.Point.moveBy(int, int)Entrando: int org.aspectj.Point.getX()Entrando: void org.aspectj.Point.setX(int)Entrando: int org.aspectj.Point.getY()Entrando: void org.aspectj.Point.setY(int)Entrando: void org.aspectj.Point.moveBy(int, int)Entrando: int org.aspectj.Point.getX()Entrando: void org.aspectj.Point.setX(int)Entrando: int org.aspectj.Point.getY()Entrando: void org.aspectj.Point.setY(int)Entrando: void org.aspectj.Point.setY(int)

Ejemplos – Pre/Pos Condiciones (I)

� Establecer pre/pos condiciones sobre parámetros de

entrada/salida.public aspect PointBoundsChecking {

pointcut setX(int x) :((call(void Point.moveBy(int,int)) && args(x, *))|| (call(void Point.setX(int)) && args(x)));

pointcut setY(int y) :((call(void Point.moveBy(int,int)) && args(*, y))|| (call(void Point.setY(int)) && args(y)));

before(int x) : setX(x) {if (x < MIN_X || x > MAX_X)

throw new IllegalArgumentException("x está fuera de rango.");}

before(int y) : setY(y) {if (y < MIN_Y || y > MAX_Y)

throw new IllegalArgumentException("y está fuera de rango.");}

}

Ejemplos – Pre/Pos Condiciones (II)

� Para un setY(900) la salida es:

Ejemplos – Detectar salida estándar

� Detectar utilización de la salida estándar.

public aspect SystemOutMonitor {

pointcut syserrAccess() : get(* System.err);

pointcut sysoutAccess() : get(* System.out);

declare warning : syserrAccess() || sysoutAccess() : "Please don't write messages to System out or err.";

}

Ejemplos – Más...

� Implementación de los patrones de diseño en

AspectJ [Hannemann and Kiczales 2002].

� Pooling de recursos, transaction management,

reglas de negocio, etc. [Laadad 2003].

� Patrones, persistencia, unit-testing, políticas de

seguridad, etc. [Miles 2005].

Agenda

� Motivación

� AspectJ


� � Otras plataformas AOP


Plataformas AOP - AspectWerkz

� No utiliza precompilador.

� Define los pointcuts mediante anotaciones de

Java o archivos XML.

� Soporta weaving tanto en tiempo de

compilación como en tiempo de ejecución.

� Se unió a AspectJ a partir de la versión 1.5.

Plataformas AOP – Spring (I)

� Spring es un framework open source para el

desarrollo de aplicaciones Java.

� Dispone de un módulo AOP para dar soporte a

aspectos.

� Ofrece integración con AspectJ.

Plataformas AOP – Spring (II)

� Spring no provee una completa implementación

de AOP.

� El objetivo es facilitar la implementación de

algunos crosscutting concerns comunes a las

aplicaciones empresariales.

Plataformas AOP – Spring (III)

� Sólo admite join points de llamadas a métodos.

� Los pointcuts son especificados mediante

anotaciones u archivos XML.

� Tres tipos de advices: before, after y around.

Plataformas AOP – JBoss AOP (I)

� Framework desarrollado puramente en Java.

� Puede ser utilizado en cualquier ambiente de

desarrollo o integrado al servidor de

aplicaciones JBoss.

� Existe un plug-in para eclipse.

Plataformas AOP – JBoss AOP (II)

� Los advices se implementan mediante

“interceptors”

� Un interceptor puede interceptar invocaciones a

métodos o constructores, accesos a campos, etc.

� Para implementar un inteceptor utilizamos la

interfase org.jboss.aop.Interceptor.

� Pointcuts se especifican mediante XML u

anotaciones.

Plataformas AOP – Otras

� Otros frameworks:

� Nanning

� Sólo soporta pointcuts en llamadas a métodos.

� Todos los objetos necesitan implementar una interfaz.

� JAC

� La filosofía de JAC es dejar los componentes funcionales

de negocio libres de extensiones impuestas por los

application servers (realizado a través del container

JAC).

Agenda

� Motivación

� AspectJ



� � Recursos y Referencias

Referencias

� [Breu y Zimmermann 2006] “Mining Aspects from Version History”.

� [Colyer et al. 2004] Colyer A., Clement A., Harley G., Webster M. “Eclipse AspectJ:

Aspect-Oriented Programming with AspectJ and the Eclipse AspectJ Developments

Tools”. Addison-Wesley. December 14 2004. ISBN: 0-321-24587-3.

� [Hannemann and Kiczales 2002] Hannemann, J. and Kiczales, G. (2002) “Design

pattern implementation in Java and AspectJ”. In: Proceedings of the 17th ACM

conference on Object-oriented programming, systems, languages, and applications,

pages 161–173. ACM Press.

� [Laadad 2003] Ramnivas Laadad. “AspectJ in Action”. ©2003 by Manning

Publications Co. All rights reserved.

� [Marin et al. 2007] Marin, M., van Deursen, A. and Moonen, L. (2007) “Identifying

Crosscutting Concerns Using Fan-in Analysis”. ACM Transactions on Software

Engineering and Methodology (TOSEM), 17(1).

Referencias & Recursos

� [Miles 2005] Russ Miles. “AspectJ Cookboock”. O'Reilly Media.

� Recursos en Internet:

� http://eclipse.org/aspectj - Página oficial de AspectJ

� IBM AOP@Work – Artículos sobre AspectJ.

AspectJ y otras plataformas de desarrollo orientadas a ... · Solución: Programación Orientada a...

Documents

Transcript of AspectJ y otras plataformas de desarrollo orientadas a ... · Solución: Programación Orientada a...