Primavera: ejemplo de AOP (Spring1.2 AOP de estilo antiguo)

Posted on by Rudeus Greyrat

Spring AOP permite agregar un comportamiento adicional al código existente sin su modificación. Spring 1.2 Old Style AOP es compatible con Spring 3, pero hay algunas cosas, como los objetos de dominio de asesoramiento, que no se pueden hacer fácilmente con Spring AOP. El AspectJ es la mejor opción disponible en ese caso. Por lo tanto, se recomienda usar Spring AOP con AspectJ.

El módulo más importante de la Programación Orientada a Aspectos es el asesoramiento. El consejo es una acción realizada por un aspecto en un punto de unión particular. Hay 4 tipos de consejos en Spring 1.2 Old Style AOP:

  1. Antes del consejo: se ejecuta antes de la llamada al método real.
  2. After Advice: se ejecuta después de la llamada al método real.
  3. Around Advice: se ejecuta antes y después de la llamada al método real.
  4. Lanza un consejo: se ejecuta si el método real lanza una excepción.

La arquitectura de Spring AOP Advice es la siguiente:

Arquitectura de primavera AOP

A. Método Antes del Consejo

Se muestra el paso a paso que es el siguiente:

Paso 1: crear una clase de lógica empresarial

En este paso, crearemos una clase que contendrá la lógica comercial real. Para esto, crearemos una nueva clase y la llamaremos Geeks. Y agregue la siguiente línea de códigos.

// Class 
public class Geeks {
    
    // for actual business logic class we will 
    // define a public method to print some random text
    public void message() {
        System.out.println("Welcome to GeeksforGeeks!!");
    }
}

Paso 2: Creando la clase Advisor

En este paso, crearemos una clase Advisor y la nombraremos BeforeAdvisor, y recuerde que esta clase implementará la interfaz MethodBeforeAdvice .

Ejemplo:

Java

// Java Program to Illustrate BeforeAdvisor Class
 
// Importing required classes
import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;
 
// Class
public class BeforeAdvisor implements MethodBeforeAdvice {
 
    // Method
    // Executes before actual business logic call
    public void before(Method arg0, Object[] arg1,
                       Object arg2) throws Throwable
    {
 
        // Print statement
        System.out.println(
            "This is called before the actual call..");
    }
}

Antes de continuar, necesitamos saber acerca de ProxyFactoryBean . Es una clase proporcionada por el framework Spring. La clase ProxyFactoryBean contiene 2 campos target e interceptorName. Para nuestro ejemplo, la instancia de la clase Geeks se considerará como objetivo y la instancia de la clase asesor como un interceptor.

Paso 3: Cree un archivo application-context.xml

En este paso, crearemos beans en el archivo de contexto para nuestra clase Geeks, Advisor y ProxyFactoryBean.

Nota: debe proporcionar su ruta de clase y la definición del paquete al crear beans.

Archivo: application-context.xml

XML

<?xml version="1.0" encoding="UTF-8"?>
<beans 
    xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:p="http://www.springframework.org/schema/p" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> 
   
    <bean id="geeksObj" class="com.geeksforgeeks.Geeks"></bean> 
    <bean id="beforeAdvisorObj" class="com.geeksforgeeks.BeforeAdvisor"></bean> 
       
    <bean id="proxyObj" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" ref="geeksObj"></property> 
        <property name="interceptorNames"> 
            <list> 
            <value>beforeAdvisorObj</value> 
            </list> 
        </property> 
    </bean> 
   
</beans>

Paso 4: Agregar dependencias

Aquí, agregaremos las dependencias requeridas en nuestro archivo pom.xml .

Archivo: pom.xml

XML

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.geeksforgeeks</groupId>
  <artifactId>SpringAOP</artifactId>
  <version>0.0.1-SNAPSHOT</version>
   
<dependencies>
 
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.1.3.RELEASE</version>
    </dependency>
     
    <!-- <a href="https://mvnrepository.com/artifact/aspectj/aspectjrt">https://mvnrepository.com/artifact/aspectj/aspectjrt</a> -->
    <dependency>
    <groupId>aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.5.4</version>
    </dependency>
     
    <!-- <a href="https://mvnrepository.com/artifact/org.aspectj/aspectjweaver">https://mvnrepository.com/artifact/org.aspectj/aspectjweaver</a> -->
    <dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.2</version>
    </dependency>
     
    <!-- <a href="https://mvnrepository.com/artifact/org.aspectj/aspectjtools">https://mvnrepository.com/artifact/org.aspectj/aspectjtools</a> -->
    <dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjtools</artifactId>
    <version>1.9.2</version>
    </dependency>
     
    <!-- <a href="https://mvnrepository.com/artifact/org.ow2.asm/asm">https://mvnrepository.com/artifact/org.ow2.asm/asm</a> -->
    <dependency>
    <groupId>org.ow2.asm</groupId>
    <artifactId>asm</artifactId>
    <version>7.0</version>
    </dependency>
     
    <!-- <a href="https://mvnrepository.com/artifact/org.springframework/spring-aspects">https://mvnrepository.com/artifact/org.springframework/spring-aspects</a> -->
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.1.3.RELEASE</version>
    </dependency>
 
  </dependencies>
</project>

Paso 5: Crear aplicación/archivo principal

En este paso, crearemos una clase Test.java e inicializaremos el método beans and calls message() de la clase Geeks.java.

Archivo: Test.java (Archivo principal/Archivo de aplicación) 

Java

// Java Program to Illustrate Application Class
 
// Importing required classes
import java.util.ResourceBundle;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
 
// Main class
public class Test {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Reading the application-context file using
        // class path of spring context xml file
        Resource context = new ClassPathResource(
            "application-context.xml");
       
        BeanFactory beanFactory
            = new XmlBeanFactory(context);
 
        // Initializing geeks bean using bean factory
        Geeks geeks
            = beanFactory.getBean("proxyObj", Geeks.class);
 
        // Calling the message() method
        // inside main() method
        geeks.message();
    }
}

Paso 6: Agregar salida a través del archivo de aplicación en ejecución.

En este paso, ejecutaremos nuestra aplicación y obtendremos el resultado.

Figura 2 – Salida

B. Consejos para después de la devolución

Implementación: 

Paso 1: crear una clase de lógica empresarial

Usaremos la misma clase Geeks.java para la lógica comercial real.

Paso 2: crear la clase AfterAdvisor

En este paso, crearemos una clase y la llamaremos AfterAdvisor.java e implementaremos la interfaz AfterReturningAdvice e implementaremos su método afterReturning() .

// Java Program to Illustrate AfterAdvisor Class 

// Importing required classes 
import java.lang.reflect.Method;
import org.springframework.aop.AfterReturningAdvice;

// Class 
public class AfterAdvisor
implements AfterReturningAdvice 
{
    // Method  
    // Executes after the actual business logic call
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) 
    throws Throwable 
    {    
        System.out.println("This is called after returning advice..");    
    }
}

Paso 3: cambiar el archivo application-context.xml

Aquí actualizaremos nuestro archivo application-contex.xml de acuerdo con la clase AfterAdvisor y la interfaz AfterReturningAdvice .

Ejemplo

XML

<?xml version="1.0" encoding="UTF-8"?>
<beans 
    xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:p="http://www.springframework.org/schema/p" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> 
   
    <bean id="geeksObj" class="com.geeksforgeeks.Geeks"></bean> 
    <bean id="afterAdvisorObj" class="com.geeksforgeeks.AfterAdvisor"></bean> 
       
    <bean id="proxyObj" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" ref="geeksObj"></property> 
        <property name="interceptorNames"> 
            <list> 
            <value>afterAdvisorObj</value> 
            </list> 
        </property> 
    </bean> 
   
</beans>

Paso 4: Salida

En este paso, ejecutaremos nuestra aplicación.

Figura 3 – Salida

C. Consejos de lanzamientos

Procedimiento: es como la implementación a continuación paso a paso como se muestra a continuación de la siguiente manera: 

Paso 1: crear una clase de lógica empresarial

Aquí actualizaremos nuestra clase de lógica empresarial Geeks.java. A continuación se muestra el código para la clase Geeks.java.

// Class
public class Geeks {

    // For actual business logic class we will
    // define a public method to print some random text
    public void message(String str) {

        // Checking if string is equal or not
        if (str.equals("geeksforgeeks.org"))

            // Print statement as string is equal
            System.out.println("Welcome to GeeksforGeeks!!");
        else

            // Do throw exception
            throw new IllegalArgumentException("Invalid String");
    }
}

Paso 2: Crea la clase ThrowsAdvisor

En este paso, crearemos una clase y la llamaremos ‘ThrowsAdvisor.java’ e implementaremos la interfaz ThrowsAdvice e implementaremos el método afterThrowing() . Aquí, pondremos aquellas preocupaciones que deberán ser lanzadas incluso si se ha producido la excepción. 

Ejemplo

Java

// Java Program to Illustrate ThrowsAdvice Class
 
// Importing required classes
import org.springframework.aop.ThrowsAdvice;
 
// Class
public class ThrowsAdvisor implements ThrowsAdvice {
 
    // Method
    public void afterThrowing(Exception e)
    {
        // Print statement
        System.out.println(
            "This will be called if exception occurs..");
    }
}

Paso 3: cambiar el archivo application-context.xml

En este paso, actualizaremos nuestro archivo application-context.xml de acuerdo con ThrowsAdvisor.

XML

<?xml version="1.0" encoding="UTF-8"?>
<beans 
    xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:p="http://www.springframework.org/schema/p" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> 
   
    <bean id="geeksObj" class="com.geeksforgeeks.Geeks"></bean> 
    <bean id="throwsAdvisorObj" class="com.geeksforgeeks.ThrowsAdvisor"></bean> 
       
    <bean id="proxyObj" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" ref="geeksObj"></property> 
        <property name="interceptorNames"> 
            <list> 
            <value>throwsAdvisorObj</value> 
            </list> 
        </property> 
    </bean> 
   
</beans>

Paso 4: Creación de la clase Test.java

En este paso, crearemos una nueva clase y la llamaremos ‘Test.java’. En esta clase, inicializaremos nuestros beans y llamaremos al método message(String str) de nuestra clase de lógica empresarial Geeks.java. Pasaremos una string no válida, por lo que nuestra aplicación generará una excepción y seguirá llamando a ThrowsAdvice.

Archivo: Test.java (clase de aplicación)

Java

// Java Program to Illustrate Application Class
 
// Importing required classes
import java.util.ResourceBundle;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
 
// Main class
// Application Class
public class Test {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Reading the application-context file
        // using class path of spring context xml file
        Resource context = new ClassPathResource(
            "application-context.xml");
 
        BeanFactory beanFactory
            = new XmlBeanFactory(context);
 
        // Initializing geeks bean
        // using bean factory
        Geeks geeks
            = beanFactory.getBean("proxyObj", Geeks.class);
 
        // Calling the message() method
        // inside main() method
 
        // Try block to check for exceptions
        try {
            geeks.message("gfg");
        }
 
        // Catch block to handle exceptions
        catch (Exception e) {
 
            // Display exceptions using line number
            // using printStackTrace() method
            e.printStackTrace();
        }
    }
}

Paso 5: Ejecute la aplicación.

Producción:

Figura 4 – Salida

D. MethodInterceptor(AroundAdvice)

Procedimiento:

Es como la implementación a continuación paso a paso como se muestra a continuación de la siguiente manera: 

Paso 1: crear una clase de lógica empresarial

En este paso, actualizaremos nuestra clase de lógica empresarial Geeks.java. A continuación se muestra el código para la clase Geeks.java.

Ejemplo

// Class
public class Geeks {

    // Method
    // Define a public method to print some random text
    // for actual business logic class we will
    public void message()
    {

        // Print statement
        System.out.println("This is around advice..");
    }
}

Paso 2: Crea la clase AroundAdvice

En este paso, crearemos una nueva clase y un nombre como AroundAdvice y con esta clase, implementaremos la ‘interfaz MethodInterceptor ‘ y proporcionaremos la definición para el método de invocación().

Ejemplo

Java

// Java Program to Illustrate AroundAdvice Class
 
// Importing required classes
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
 
// Class
public class AroundAdvice implements MethodInterceptor {
 
    // Method
    public Object invoke(MethodInvocation invocation)
        throws Throwable
    {
        Object obj;
 
        System.out.println(
            "This will be run before actual business logic...");
        obj = invocation.proceed();
 
        // Print statement
        System.out.println(
            "This will be run after actual business logic...");
 
        return obj;
    }
}

Paso 3: actualice el archivo application-context.xml

Ahora, cambiaremos nuestro archivo application-context.xml según AroundAdvice.

Archivo: application-context.xml

XML

<?xml version="1.0" encoding="UTF-8"?>
<beans 
    xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:p="http://www.springframework.org/schema/p" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> 
   
    <bean id="geeksObj" class="com.geeksforgeeks.Geeks"></bean> 
    <bean id="aroundAdvisorObj" class="com.geeksforgeeks.AroundAdvice"></bean> 
       
    <bean id="proxyObj" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" ref="geeksObj"></property> 
        <property name="interceptorNames"> 
            <list> 
            <value>aroundAdvisorObj</value> 
            </list> 
        </property> 
    </bean>
</beans>

Paso 4: Cree el archivo Test.java

En este paso, usaremos nuestro ‘Test.java’ anterior y lo actualizaremos de acuerdo con los requisitos comerciales.

Archivo: Prueba.java

Java

// Java Program to Illustrate Test Class
 
// Importing required classes
import java.util.ResourceBundle;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
 
// Class
public class Test {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Reading the application-context file using
        // class path of spring context xml file
        Resource context = new ClassPathResource(
            "application-context.xml");
 
        BeanFactory beanFactory
            = new XmlBeanFactory(context);
 
        // Initializing geeks bean using bean factory
        Geeks geeks
            = beanFactory.getBean("proxyObj", Geeks.class);
 
        // Calling message() method
        // inside() main() method
        geeks.message();
    }
}

Paso 5: Salida

En este paso, ejecutaremos nuestra aplicación.

Figura 5 – Salida

Publicación traducida automáticamente

Artículo escrito por ankur035 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *