Spring le permite especificar aspectos, recomendaciones y cortes de puntos en un archivo XML. Se utilizaron anotaciones en los ejemplos de aop de la página anterior. El archivo de configuración XML ahora nos mostrará las mismas muestras.
Veamos los componentes XML que describen consejos.
- aop:before: se usa antes de que se llame al procedimiento de lógica de negocios real.
- aop:after: se utiliza después de que se haya llamado al método de lógica de negocio real.
- aop:after-returning: Se aplica después de invocar el método de lógica de negocios real utilizado. Puede usarse para interceptar el valor de retorno de aviso.
- aop:around: se utiliza tanto antes como después de llamar al método de lógica empresarial real.
- aop: after-throwing: si el procedimiento de lógica empresarial real genera una excepción, se utiliza.
A. aop:before Ejemplo
Antes del procedimiento de lógica de negocios principal, se utiliza AspectJ Before Advice. Aquí se puede realizar cualquier acción, como conversión o autenticación. Cree una clase con lógica comercial real.
Archivo: Operación.java
Java
// Java Program to Illustrate Operation Class
package com.Geeksforgeeks;
// Class
public class Operation {
// Method 1
public void msg()
{
System.out.println("msg() method invoked");
}
// Method 2
public int m()
{
System.out.println("m() method invoked");
return 2;
}
// Method 3
public int k()
{
System.out.println("k() method invoked");
return 3;
}
}
Archivo: TrackOperation.java
Java
package com.Geeksforgeeks;
import org.aspectj.lang.JoinPoint;
public class TrackOperation{
public void myadvice(JoinPoint jp)//it is advice
{
System.out.println("additional concern");
//System.out.println("Method Signature: " + jp.getSignature());
}
}
Archivo: applicationContext.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:aop="http://www.springframework.org/schema/aop" 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 "> <aop:aspectj-autoproxy /> <bean id="opBean" class="com.Geeksforgeeks.Operation"> </bean> <bean id="trackAspect" class="com.Geeksforgeeks.TrackOperation"></bean> <aop:config> <aop:aspect id="myaspect" ref="trackAspect" > <!-- @Before --> <aop:pointcut id="pointCutBefore" expression="execution(* com.Geeksforgeeks.Operation.*(..))" /> <aop:before method="myadvice" pointcut-ref="pointCutBefore" /> </aop:aspect> </aop:config> </beans>
Archivo: Prueba.java
Java
// Java Program to Illustrate Application Class
package com.Geeksforgeeks;
// Importing required classes
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
// Class
public class Test {
// Main driver method
public static void main(String[] args)
{
// Creating object of ApplicationContext
// and Operation Class
ApplicationContext context
= new ClassPathXmlApplicationContext(
"applicationContext.xml");
Operation e = (Operation)context.getBean("opBean");
// Print statements adn calling methods
/ as defined in other class above System.out.println
("calling msg...");
e.msg();
System.out.println("calling m...");
e.m();
System.out.println("calling k...");
e.k();
}
}
Producción:
B. aop:después del Ejemplo
Después de invocar los métodos de lógica comercial real, se implementa la guía AspectJ después. Puede usarse para realizar un seguimiento de los registros, la seguridad y las notificaciones, entre otras cosas. Asumiremos que los archivos Operation.java, TrackOperation.java y Test.java son idénticos a los del ejemplo aop:before.
Cree el archivo applicationContext.xml, que contiene las definiciones de bean.
Archivo: applicationContext.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:aop="http://www.springframework.org/schema/aop" 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 "> <aop:aspectj-autoproxy /> <bean id="opBean" class="com.Geeksforgeeks.Operation"> </bean> <bean id="trackAspect" class="com.Geeksforgeeks.TrackOperation"></bean> <aop:config> <aop:aspect id="myaspect" ref="trackAspect" > <!-- @After --> <aop:pointcut id="pointCutAfter" expression="execution(* com.Geeksforgeeks.Operation.*(..))" /> <aop:after method="myadvice" pointcut-ref="pointCutAfter" /> </aop:aspect> </aop:config> </beans>
Producción:
Puede ver que se imprime una preocupación adicional después de llamar a los métodos msg(), m() y k().
C. aop: ejemplo después de regresar
Podemos recibir el resultado en el consejo usando después de devolver el consejo. Cree una clase para contener la lógica empresarial.
Archivo: Operación.java
Java
package com.Geeksforgeeks;
public class Operation{
public int m(){System.out.println("m() method invoked");return 2;}
public int k(){System.out.println("k() method invoked");return 3;}
}
Archivo: TrackOperation.java
Java
package com.Geeksforgeeks;
import org.aspectj.lang.JoinPoint;
public class TrackOperation{
public void myadvice(JoinPoint jp,Object result)//it is advice (after advice)
{
System.out.println("additional concern");
System.out.println("Method Signature: " + jp.getSignature());
System.out.println("Result in advice: "+result);
System.out.println("end of after returning advice...");
}
}
Archivo: applicationContext.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:aop="http://www.springframework.org/schema/aop" 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 "> <aop:aspectj-autoproxy /> <bean id="opBean" class="com.Geeksforgeeks.Operation"> </bean> <bean id="trackAspect" class="com.Geeksforgeeks.TrackOperation"></bean> <aop:config> <aop:aspect id="myaspect" ref="trackAspect" > <!-- @AfterReturning --> <aop:pointcut id="pointCutAfterReturning" expression="execution(* com.Geeksforgeeks.Operation.*(..))" /> <aop:after-returning method="myadvice" returning="result" pointcut-ref="pointCutAfterReturning" /> </aop:aspect> </aop:config> </beans>
Archivo: Prueba.java
Java
package com.Geeksforgeeks;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test{
public static void main(String[] args){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Operation e = (Operation) context.getBean("opBean");
System.out.println("calling m...");
System.out.println(e.m());
System.out.println("calling k...");
System.out.println(e.k());
}
}
Producción:
D. aop:alrededor Ejemplo
Antes y después de invocar los métodos de lógica comercial real, se aplica la guía circundante de AspectJ. Cree una clase con lógica comercial real.
Archivo: Operación.java
Java
// Java Program to Illustrate Operation Class
package com.geeksforgeeks;
// Class
public class Operation {
// Method 1
public void msg()
{
System.out.println("msg() is invoked");
}
// Method 2
public void display()
{
System.out.println("display() is invoked");
}
}
Cree una clase que contenga consejos como un aspecto.
Debe proporcionar la referencia PreceedingJoinPoint a la función de aviso para que podamos ejecutar el método proceder() para continuar con la solicitud.
Archivo: TrackOperation.java
Java
// Java Program to Illustrate TrackOperation Class
package com.geeksforgeeks;
// Importing required classes
import org.aspectj.lang.ProceedingJoinPoint;
// Class
public class TrackOperation {
// Method
public Object myadvice(ProceedingJoinPoint pjp)
throws Throwable
{
// Display message
System.out.println(
"Additional Concern Before calling actual method");
Object obj = pjp.proceed();
// Display message
System.out.println(
"Additional Concern After calling actual method");
return obj;
}
}
Archivo: applicationContext.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:aop="http://www.springframework.org/schema/aop" 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 "> <aop:aspectj-autoproxy /> <bean id="opBean" class="com.geeksforgeeks.Operation"> </bean> <bean id="trackAspect" class="com.geeksforgeeks.TrackOperation"></bean> <aop:config> <aop:aspect id="myaspect" ref="trackAspect" > <!-- @Around --> <aop:pointcut id="pointCutAround" expression="execution(* com.geeksforgeeks.Operation.*(..))" /> <aop:around method="myadvice" pointcut-ref="pointCutAround" /> </aop:aspect> </aop:config> </beans>
Archivo: Prueba.java
Ahora crea la clase Test que llama a los métodos reales.
Java
// Java Program to Illustrate Application class
package com.geeksforgeeks;
// Importing required classes
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
// Application class
public class Test {
// Main driver method
public static void main(String[] args)
{
// Creating an object of ApplicationContext class
ApplicationContext context
= new classPathXmlApplicationContext(
"applicationContext.xml");
// Creating an object of Operation class
Operation op = (Operation)context.getBean("opBean");
op.msg();
op.display();
}
}
Producción:
E. aop: ejemplo después de lanzar
Podemos imprimir la excepción en la clase TrackOperation utilizándola después de lanzar consejos. Echemos un vistazo a la sugerencia AfterThrowing de AspectJ como ejemplo.
Cree una clase para contener la lógica empresarial.
Archivo: Operación.java
Java
// Java Program to Illustrate Operation Class
package com.geeksforgeeks;
// Class
public class Operation {
// Method
public void validate(int age) throws Exception
{
if (age < 18) {
throw new ArithmeticException("Not valid age");
}
else {
System.out.println("Thanks for vote");
}
}
}
Cree una clase de aspecto que contenga consejos después de que se haya lanzado.
Además, debemos dar la referencia Throwable aquí para interceptar la excepción.
Archivo: TrackOperation.java
Java
// Java Program to Illustrate TrackOperation Class
package com.geeksforgeeks;
// Importing required classes
import org.aspectj.lang.JoinPoint;
// Class
public class TrackOperation {
// Main driver method
public void myadvice(JoinPoint jp, Throwable error)
{
// Print statements
System.out.println("additional concern");
System.out.println("Method Signature: "
+ jp.getSignature());
System.out.println("Exception is: " + error);
System.out.println(
"end of after throwing advice...");
}
}
Archivo: applicationContext.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:aop="http://www.springframework.org/schema/aop" 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 "> <aop:aspectj-autoproxy /> <bean id="opBean" class="com.geeksforgeeks.Operation"> </bean> <bean id="trackAspect" class="com.geeksforgeeks.TrackOperation"></bean> <aop:config> <aop:aspect id="myaspect" ref="trackAspect" > <!-- @AfterThrowing --> <aop:pointcut id="pointCutAfterThrowing" expression="execution(* com.geeksforgeeks.Operation.*(..))" /> <aop:after-throwing method="myadvice" throwing="error" pointcut-ref="pointCutAfterThrowing" /> </aop:aspect> </aop:config> </beans>
Archivo: Prueba.java
Ahora crea la clase Test que llama a los métodos reales.
Java
// Java Program to Illustrate Application Class
package com.geeksforgeeks;
// Importing required classes
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
// Main Class
public class Test {
// Main driver method
public static void main(String[] args)
{
// Creating object of ApplicationContext
// and Operation class
ApplicationContext context
= new ClassPathXmlApplicationContext(
"applicationContext.xml");
Operation op = (Operation)context.getBean("opBean");
// Display message
System.out.println("calling validate...");
// Try block to check for exceptions
try {
op.validate(19);
}
// Catch block to handle the exceptions
catch (Exception e) {
System.out.println(e);
}
// Display message only
System.out.println("calling validate again...");
try {
op.validate(11);
}
catch (Exception e) {
System.out.println(e);
}
}
}
Producción:
Publicación traducida automáticamente
Artículo escrito por dikshanandre2403 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA