PDF de programación - Últimas Tendencias en Desarrollo de Software Empresarial: SOA y Web 2.0

Últimas Tendencias en
Desarrollo de Software
Empresarial: SOA y Web 2.0

Dr. Diego Lz. de Ipiña Gz. de Artaza

http://paginaspersonales.deusto.es/dipina

Araba Enpresa Digitala, Miñano, 4 de Mayo 2006

[email protected]

Contenidos

1.

2.

3.

















Programación orientada a aspectos (AOP):

Concepto
Aplicabilidad de AOP
Herramientas: AspectJ

Web 2.0: una revolución en ciernes

Tecnologías Web 2.0: AJAX, wikis, blogs, sindicación
Aplicaciones Web 2.0: GoogleMaps, Flickr, del.icio.us, Digg
Web Semántica:







Concepto
Tecnologías: RDF, OWL
Aplicaciones

El paradigma SOA

Desarrollo avanzado de aplicaciones empresariales:

Servicios Web Avanzados (WS-*)

Frameworks de última generación:

Web Services Enhancements 3.0, and Windows Communication Foundation
Java EE 5.0: EJB 3.0, JSF y Spring
LAMP y Ruby on Rails









2

1

AOP: Concepto

 OOP modela comportamiento en una jerarquía de

objetos  es vertical

 AOP factoriza conceptos comunes a varias

aplicaciones (cross-cuttingconcerns)  es horizontal
 Ej. Logeo, Seguridad, Transacciones
 Creado por Gregor Kiczales en Xerox PARC

 Objetivos:

 Separar conceptos comunes a aplicaciones
 Evitar solapamiento de funcionalidad

 ¡¡¡No substituye OOP, la complementa!!!

AOP: Concepto

 Un concepto (concern) puede clasificarse en:

 Concepto fundamental de negocio (corebusinessconcern)

 Procesar pagos en un sistema de tarjetas de crédito

 Concepto general (systemconcern)

 Logeo, transacciones, autenticación, seguridad, etc.
 Aparecen en muchas aplicaciones

 OOP hace que se repita funcionalidad de sistema en

muchos módulos:
 Mayor complicación del código
 Diseño e implementación más difícil
 Más difícil la evolución

3

4

2

AOP: Aspecto

 Una implementación de AOP encapsula la

funcionalidad común a varias aplicaciones a través
del concepto de Aspecto (aspect)
 Aspecto = módulo de código que factoriza funcionalidad

común correspondiente a requisitos no funcionales

 Compuesto de:

 Consejos o advices (funcionalidad adicional a añadir) y
 Puntos de unión (join points), lugares dónde se añade esa

funcionalidad extra

 Ejemplo: un aspecto de seguridad puede incluir un consejo
de seguridad que añade instrucciones de comprobación al
comienzo de los métodos a(), b() y c() de una clase

5

AOP: Motivación

 Consideremos una aplicación bancaria:

void transfer(Account fromAccount, Account

toAccount, int amount) {
if (fromAccount.getBalance() < amount) {

throw new InsufficientFundsException();

}
fromAccount.withdraw(amount);
toAccount.deposit(amount);

}

 Normalmente, “corrompemos” código con detalles no

funcionales: autorización, logeo, transacciones, etc.

6

3

AOP: Motivación

void transfer(Account fromAccount, Account toAccount, int amount) {

getCurrentUser().().().().canPerform(OP_TRANSFER
if (!getCurrentUser
canPerform(OP_TRANSFER))))) {
canPerform(OP_TRANSFER
getCurrentUser
getCurrentUser
canPerform(OP_TRANSFER

throw new SecurityException();

}
if (amount < 0) {

throw new NegativeTransferException();

}
if (fromAccount.getBalance() < amount) {

throw new InsufficientFundsException();

}
Transaction
Transaction txtxtxtx = = = = database.newTransaction
database.newTransaction();();();();
database.newTransaction
Transaction
Transaction
database.newTransaction
try {

fromAccount.withdraw(amount);
toAcount.deposit(amount);
tx.commit
tx.commit();();();();
tx.commit
tx.commit
fromAccount, , , , toAccount
systemLog.logOperation(OP_TRANSFER, , , , fromAccount
systemLog.logOperation(OP_TRANSFER
toAccount, , , ,
toAccount
fromAccount
systemLog.logOperation(OP_TRANSFER
systemLog.logOperation(OP_TRANSFER
fromAccount
toAccount

amount
amount););););
amount
amount

}
catch(Exception e) {

tx.rollback
tx.rollback();();();();
tx.rollback
tx.rollback

}

}

AOP: Motivación

 El código anterior mezcla:

 Business logic concerns y
 Cross-cutting concerns

 Consecuencias:

 Dificultad para cambiar implementación de cross-

cutting concerns
 Los conceptos comunes están desperdigados por el

código  ¡¡¡FALTA DE MODULARIZACIÓN!!!
 AOP pretende resolver esta situación

7

8

4

AOP: Motivación

9

JPM: Entrelazando AOP y OOP

 El Joint Point Model (JPM) define cómo un

aspecto interactúa con un programa,
mediante:
 Puntos de unión (Joinpoints)  dónde puede

aplicarse el aspecto

 Puntos de corte (Pointcuts)  cuándo, conjunto

de joinpoints, consultas sobre ellos

 Consejos (advices)  cómo, funcionalidad a

añadir en los joinpoints

10

5

Weaving: “Tejiendo
programas”

 ¿Cómo inyectar consejos en puntos de

unión de un programa?
 Mediante un preprocesador  complica

desarrollo

 Un postprocesador binario  complica

desarrollo

 Un compilador específico a AOP  AspectJ
 Durante la carga de clases  lento
 En tiempo de ejecución  lento

Weaving: “Tejiendo
programas”

11

12

6

Un lenguaje AOP: AspectJ

 Permite la definición de aspectos en un programa Java:

 Declaraciones entre-tipos: añade métodos, campos o interfaces

a clases

aspect VisitAspect {

Point.acceptVisitor(Visitor v) {

v.visit(this);

}

}

 Pointcuts: permite a un programa especificar un conjunto de

puntos de unión

pointcut set() : execution(* *.set*(..) ) &&

this(Point);

 Advice: permiten a un programador especificar las acciones a

ejecutar cuando un pointcut se evalua a true

after () : set() {
Display.update();

}

13

Instalación AspectJ







Descargarlo de: http://www.eclipse.org/aspectj/
Instalar: java -jar aspectj-DEVELOPMENT-
20060426104617.jar
Configuración:





Añadir C:\Archivos de
programa\Java\aspectj1.5\lib\aspectjrt.jar
a tu CLASSPATH.



Contiene las clases requeridas por cualquier programa que
utiliza el compilador ajc.

Modificar tu PATH para incluir C:\Archivos de
programa\Java\aspectj1.5\bin.



Ajc y AjcBrowser

14

7

Instalación AspectJ

Ejemplo AspectJ



Añadir capacidad de logeo con aspectos a una clase:

public class ClassExample
ClassExample {
ClassExample
ClassExample

public static void method1
method1() {
method1
method1

System.out.println("¡Hola ESIDE!");

}

public static void method2
method2() {
method2
method2

System.out.println("¡Hola revista ESIDE!");

}

public static void saySomething(String
saySomething(String x)x)x)x) {
saySomething(String
saySomething(String

System.out.println(x);

}

main(String[] [] [] [] args
void main(String
public static void
args)))) {
args
main(String
voidvoid
main(String
args

method1();
method2();
saySomething("¡Aprende AOP!");

}

}

15

16

8

Ejemplo AOP

// AspectExample.aj
AspectExample {
aspect AspectExample
public aspect
AspectExample
aspect
aspect
AspectExample
ClassExample.*())
call(public* * * * ClassExample
methodCall():
public pointcut
pointcut methodCall
(): call(public
.*());
.*())
ClassExample
call(public
pointcut
pointcut
methodCall
methodCall
(): ():
call(public
ClassExample
.*())
public pointcut
a): call(public
methodCallArg(String a):
pointcut methodCallArg(String
call(public* * * *
call(public
a): a):
methodCallArg(String
pointcut
methodCallArg(String
pointcut
call(public
)) && args(a
String)) &&
ClassExample.*(.*(.*(.*(String
ClassExample
args(a))));
args(a
)) &&
String
ClassExample
ClassExample
String
)) &&
args(a

a): methodCallArg(a
before(String a):
before(String
methodCallArg(a)))) {
methodCallArg(a
a): a):
before(String
before(String
methodCallArg(a

System.out.print("\n -- ClassExample.");
System.out.println(thisJoinPointStaticPart.getSignature().getName()

+ "(" + a + ") empezando--");
}

a): methodCallArg(a
after(String a):
after(String
methodCallArg(a)))) {
methodCallArg(a
a): a):
after(String
after(String
methodCallArg(a

System.out.print("\n -- ClassExample.");
System.out.println(thisJoinPointStaticPart.getSignature().getName()

+ "(" + a + ") ejecutado--");
}

(): methodCall
before():
before
methodCall()()()() {
(): ():
methodCall
before
before
methodCall
System.out.println("\n -- ClassExample." +

thisJoinPointStaticPart.getSignature().getName() + " empezando --");
}

(): methodCall
after():
after
methodCall()()()() {
methodCall
(): ():
after
after
methodCall

System.out.println(" -- ClassExample." +

thisJoinPointStaticPart.getSignature().getName() + " ejecutado--\n");
}

17

}

Ejemplo AOP



1.

2.

3.











El anterior código hace lo siguiente:

Define un nuevo aspecto con el nombre AspectExample
AspectExample
AspectExample
AspectExample
Define dos puntos de unión para:

Métodos públicos de ClassExample sin argumentos
(methodCall
methodCall) y
methodCall
methodCall
Métodos que aceptan como argumento un String
(methodCallArg
methodCallArg).
methodCallArg
methodCallArg

Define cuatro consejos (fragmento de código) a ejecutar:

Antes de la invocación de los métodos públicos de ClassExample
con un argumento de tipo String.
Después de que se ejecuten los métodos que tienen un String
como parámetro.
Antes y después de que se invoquen los métodos de
ClassExample sin argumentos.



La siguiente línea de código devuelve el nombre del método a
invocar:
thisJointPointStaticPart.getSignature().getName()

18

9

Ejemplo AOP

 Para compilar este código y luego ejecutarlo escribe:

ajc AspectExample.aj ClassExample
java ClassExample

 El resultado será:

-- ClassExample.method1 empezando --
¡Bienvenidos a Araba Enpresa Digitala!

-- ClassExample.method1 ejecutado--
-- ClassExample.method2 empezando --

¡Bienvenidos a Últimas Tendencias en Desarrollo de

Software Empresarial: SOA y Web 2.0!

-- ClassExample.method2 ejecutado--
-- ClassExample.saySomething(¡Aprende AOP!) empezando--

¡Aprende AOP!

-- ClassExample.saySomething(¡Aprende AOP!) ejecutado—

 Sin tener que cambiar una sola línea de ClassExample hemos sido

capaces de añadir capacidad de logeo y testear esa clase

19

20

Ejemplos Pointcuts



Se pueden usar los operadores relacionales &&, || o ! para combinarlos:

call(void MyClass.myMethod(..))

Call to myM