Programación orientada a aspectos

05/11/2013

La programación orientada a aspectos (AOP) es un patrón de diseño de aplicaciones implementado por Spring para aplicaciones Java.

›En el desarrollo de cualquier aplicación, existen las denominadas “ preocupaciones transversales (crosscutting concerns) que son actividades comunes para la mayoría de las aplicaciones: inicio sesión, seguridad, transacciones…

En este ejemplo vemos que hay 2 clases (comprar y vender) que tienen que realizar unas actividades comunes: login, abrir transacciones, persistencia, cerrar y el código de negocio realmente de dichas clases es el módulo de Comprar y Vender.

Clases que necesitan utilizar "preocupaciones transversales"

Clases que necesitan utilizar “preocupaciones transversales”

›
Las “preocupaciones transversales ” son actividades que se comparten en la aplicación y que son delegados en un módulo/componente específico. Ejm: Seguridad de la aplicación, Transacciones, Persistencia a datos…
Podríamos ver las preocupaciones transversales como módulos que se ejecutan en algún momento de la ejecución de una clase. Este dibujo es bastante representativo:
La preocupaciones transversales serían el Logging, Cacheo y Validación

La preocupaciones transversales serían el Logging, Cacheo y Validación

›
›El cambio de una “preocupación” implica que puede que haya que modificar y verificar muchas clases, lo que complica el código enormemente.
›La programación orientada a Aspectos (AOP) intenta resolver el problema de las preocupaciones transversales. ›Para ello intercepta la ejecución de los métodos de los Beans de la aplicación (POJOs) y dependiendo de sus parámetros, ejecutará o no la “preocupación transversal”. ›La intercepción de la ejecución va a depender de un fichero de configuración xml, con lo que permite “extraer” toda la lógica de componentes de la lógica de negocio sin afectar dicho código.
›Para realizar dicha intercepción, Spring añade una clase proxy que delega la funcionalidad de las preocupaciones transversales. ›La clase sobre la que queremos aplicar una preocupación transversal, está encapsulada en una clase proxy que se ejecuta en tiempo de ejecución de Spring y que capturará la ejecución de la preocupación transversal sin afectar el código de la clase de negocio.
Clase proxy que permite gestionar las preocupaciones transversales

Clase proxy que permite gestionar las preocupaciones transversales

Spring crea automáticamente clases proxy que “encapsulan” al bean de negocio y que puedan gestionar correctamente la preocupación transversal sin afectar al código fuente del bean.
›Un pointcut (punto de ruptura) es un punto de ejecución de la aplicación donde se ejecuta el código adicional del componente Advise (Consejo). La combinación de un punto de corte y un consejo es lo que se denomina un Aspect (Aspecto). ›Al declarar el punto de corte, puede definirse cuándo queremos que se ejecute el Consejo (Advise) y puede ser antes (before), después (after), justo cuando se devuelve el fin de ejecución del método (after-returning) o si ha habido alguna excepción (after-throwing).
Veamos un ejemplo práctico de todo esto:
Imaginemos que estamos desarrollando una aplicación para gestionar espectáculos. Tenemos una interfaz denominada Participante que gestiona un método actuar.

package com.ejemplospring.beans;

public interface Participante {
     void actuar();
}

Tenemos una clase denominada Malabarista que implementa el método actuar de la interfaz Participante.

package com.ejemplospring.beans;

public class Malabarista implements Participante {

    private int bolas=3;

     public Malabarista(){}

     public Malabarista (int beanbolas){
        this.bolas = beanbolas;
     }

     public void actuar(){
          System.out.println(“Malabarista actuando con ” + bolas + ” bolas”);
     }

}

Ahora como en todo espectáculo, cada vez que aparecen los participantes para realizar una función realizan unas acciones:
– Antes de empezar la función: buscar asiento y apagar el móvil
– Cuando acaba la función: aplaudir
– Si la función no nos gusta: protestar
Como vemos estas acciones son “preocupaciones transversales” porque ocurren para cualquier participante. En la programación orientada a aspectos se declaran en un xml que depende de un POJO. El POJO sería este:

package com.ejemplospring.beans;

public class Publico {

     public void buscar_asiento(){
       System.out.println(“El público está buscando su asiento”);
     }

     public void apagar_moviles(){
        System.out.println(“El público está apagando el móvil”);
     }

     public void aplaudir(){
        System.out.println(“El público está aplaudiendo”);
     }

     public void protestar(){
        System.out.println(“Fuera!!! El publico está protestando”);
     }

}

La declaración de los beans tanto del público (preocupaciones transversales) como de la propia lógica de negocio se hacen en un fichero xml junto con el point-cut. El punto de corte indica qué método del bean de negocio (en este caso el método actuar de la clase Participante), se deben ejecutar los métodos del Bean del público (las preocupaciones transversales), osea apagar el móvil y buscar asiento antes de ejecutar el método actuar y aplaudir justo al finalizar dicho método.

<?xml version=”1.0″ encoding=”UTF-8″?>

<beans xmlns=”http://www.springframework.org/schema/beans&#8221;
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance&#8221;
xmlns:aop=”http://www.springframework.org/schema/aop&#8221;
xsi:schemaLocation=”http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd”&gt;

<bean id=”jose” class=”com.ejemplospring.beans.Malabarista” />
<bean id=”publico” class=”com.ejemplospring.beans.Publico” />

<aop:config>

   <aop:aspect ref=”publico”>
   <aop:pointcut id=”colaborador”  expression=”execution(* com.ejemplospring.beans.Participante.actuar(..))” />
   <aop:before pointcut-ref=”colaborador”method=”buscar_asiento” />
   <aop:before pointcut-ref=”colaborador” method=”apagar_moviles” />
   <aop:after-returning pointcut-ref=”colaborador” method=”aplaudir” />
</aop:aspect>

</aop:config>

</beans>
La clase main que genera el programa sería esta:

package com.ejemplospring;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.ejemplospring.beans.Participante;

public class Aspectos {

   public static void main(String[] args) {
      ApplicationContext ctx = new ClassPathXmlApplicationContext(“com/ejemplospring/beans.xml”);
      Participante participante = (Participante)ctx.getBean(“jose”);
      participante.actuar();
   }
}

y esta es la salida de la aplicación:

Los métodos se ejecutan sin afectar al código

Los métodos se ejecutan sin afectar al código

Como vemos al finalizar la aplicación, hemos podido ejecutar los distintos métodos “transversales” en distintos momentos durante la ejecución del método actuar del participante sin tener que modificar ninguna línea de código del bean de negocio. Toda la configuración transversal está en un fichero xml sin afectar al código de la aplicación.

En esta url, tenéis la información oficial sobre la programación orientada a aspectos de Spring:

Una respuesta to “Programación orientada a aspectos”


Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

A %d blogueros les gusta esto: