Diferencia entre revisiones de «Programemos en AspectJ»

Contenido eliminado Contenido añadido
Formato
Línea 1:
 
== '''Programemos en AspectJ''' ==
 
Mariano Lorente López
 
Línea 11 ⟶ 8:
 
2 Agosto de 2004
 
 
'''INDICE'''
 
INTRODUCCIÓN.
 
¿QUE ES UN ASPECTO?.
 
¿CÓMO SE APLICA UN ASPECTO?.
 
COMPOSICIÓN DE UN ASPECTO.
 
QUE SE DEBE SABER.
 
ASPECTS.
 
ASPECT.
 
EXTENDS, IMPLEMENTS.
 
PERTARGET, PERTHIS.
 
PERCFLOW, PERCFLOWBELOW.
 
ISSINGLETON.
 
POINTCUT DEFINITIONS.
 
PRIVATE POINTCUT ID() : CALL([MODIFIERSPAT] TYPEPAT [TYPEPAT.].IDPAT(TYPEPAT | .., ...));.
 
POINTCUT ID(TYPE PARAM) : SET([MODIFIERSPAT] [TYPEPAT.] NEW (TYPEPAT | .., ...)) [THROWS THROWSPAT];
.
PUBLIC ABSTRACT POINTCUT ID();.
 
ABSTRACT POINTCUT ID(OBJECT O);.
 
COMODINES Y OPERADORES DEL POINTCUT.
 
*
 
..
 
+
 
!
 
||
 
&&
 
PRIMITIVE POINTCUTS.
 
CALL(METHODPAT).
 
CALL(CONSTRUCTORPAT).
 
EXECUTION(METHODPAT).
 
EXECUTION(CONSTRUCTORPAT).
 
INITIALIZATION(CONSTRUCTORPAT).
 
PREINITIALIZATION(CONSTRUCTORPAT).
 
STATICINITIALIZATION(TYPEPAT).
 
GET(FIELDPAT).
 
SET(FIELDPAT).
 
HANDLER(TYPEPAT).
 
ADVICEEXECUTION().
 
WITHINCODE(CONSTRUCTORPAT).
 
WITHIN(TYPEPAT).
 
JOIN POINT.
 
ADVICE DECLARATIONS.
 
BEFORE(FORMALS).
 
AFTER (FORMALS).
 
AFTER (FORMALS) RETURNING [ (FORMAL) ].
 
AFTER (FORMALS) THROWING [ (FORMAL) ].
 
TYPE AROUND (FORMALS).
 
 
 
----
 
 
Programemos en AspectJ
 
 
''==Introducción''==
 
La programación orientada al aspecto (de ahora en adelante AOP), viene a complementar a la programación orientada a objetos (OOP), dando un nuevo punto de vista para resolver ciertos problemas que se plantean en la programación. A igual que entendemos cual es la función de una propiedad en una clase, un método, o la definición de una clase abstracta, la AOP permite definir aspectos de una aplicación.
 
 
''==¿QueQué es un Aspecto?''==
 
Es un proceso realizado dentro de una clase pero que no es propio de la misma. Una forma más claro de verlo es con un ejemplo.
Línea 124 ⟶ 21:
Si se tiene una clase que representa a un Cliente, y dentro del método grabar se quiere registrar en un log todas las operaciones realizadas.
 
Figura 1.
Figura 1.class Cliente { private String _nombre; Cliente() { } ... public void Grabar() { ... Inicio Log ... Grabar en base de datos ... Fin Log }}
 
class Cliente {
private String _nombre;
Cliente() { }
...
public void Grabar() {
... Inicio Log
... Grabar en base de datos
... Fin Log
}}
 
La persistencia de los datos de un cliente es un aspecto, el introducir una traza dentro de un proceso es un aspecto. Resumiendo, se puede decir que se puede considerar un aspecto de una clase, aquel proceso que no es inherente a la misma y que tiene entidad propia.
 
 
''==¿Cómo se aplica un Aspecto?''==
 
En la programación tradicional OOP, se tiene una clase que en un momento dado necesita de la funcionalidad de otra. Para ello crea un nuevo objeto de dicha clase y utiliza los métodos proporcionados. Tal y como se comenta en el punto anterior, se puede considerar que ciertas funcionalidades no son inherentes a una clase y por ello se definen como aspectos. Ahora mismo puedes pensar, que se puede definir como otra clase para poderla utilizar, pero ahí radica el cambio. No se quiere utilizar funcionalidades definidas en otras clases, sino que se quiere aplicar ciertos aspectos a ciertas clases, y que a partir de ese momento la clase original tenga la funcionalidad nueva que se le ha definido a través de aspectos.
Línea 137 ⟶ 44:
Para ver como se puede hacer esto con aspectos hay que observar la siguiente figura.
 
Figura 2.
Figura 2.public aspect LogAspect { before() : execution(void Cliente.Grabar()) { System.out.println("... Inicio Log"); } after() : execution(void Cliente.Grabar()) { System.out.println("... Fin Log"); }}class Cliente { private String _nombre; Cliente() { } ... public void Grabar() {... Grabar en base de datos }}
public aspect LogAspect {
before() : execution(void Cliente.Grabar()) {
System.out.println("... Inicio Log");
}
after() : execution(void Cliente.Grabar()) {
System.out.println("... Fin Log");
}}class Cliente {
private String _nombre;
Cliente() { } ...
public void Grabar() {
... Grabar en base de datos
}}
 
En la línea que se escribe "public aspect LogAspect" se define el aspecto y en la línea que escribe "before() : execution(void Cliente.Grabar())" se indica donde se quiere aplicar el aspecto. Como se puede ver, si se quiere aprovechar la clase Cliente no se tiene ningún problema a la hora de copiarla, ya que toda la funcionalidad que tiene, es propia de dicha clase. Ahora se tiene el poder de decisión para copiar los aspectos para dicha clase o no.
 
 
''==Composición de un Aspecto''==
 
Un Aspecto se compone de su declaración, la definición de sus puntos de corte(Pointcut) y de sus puntos de ejecución (Advice).
Línea 155 ⟶ 74:
 
 
''Que==Qué se debe saber''==
 
Dentro de un Aspecto puede declarar variables, y métodos.