Los dos Núcleo elástico AOP

Los dos Núcleo elástico AOP

AOP ventajas:

• Reducir el acoplamiento entre los módulos.
• Hacer que el sistema sea más fácil de extender.
• Una mejor reutilización de código.
• código no profesional sea más concentrada, no se dispersa para facilitar la gestión unificada.
• código de negocio más concisa mantuvo pura, que no afecta a otro código de dopaje.

AOP es una adición a la programación orientada a objetos, en tiempo de ejecución, el código cortado de forma dinámica en los métodos de la clase especificada, la programación de las ideas para la ubicación especificada es la programación orientada. La misma posición de los diferentes métodos en una sección del programa objeto abstracto es una sección objeto de la AOP.

Modo de empleo?

• Crear proyectos de Maven, complemento pom.xml

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.11.RELEASE</version>
    </dependency>
    
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>5.0.11.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.0.11.RELEASE</version>
    </dependency>
</dependencies>

• Creación de una interfaz de calculadora para Cal, la definición de los cuatro métodos.

package com.southwind.utils;

public interface Cal {
    public int add(int num1,int num2);
    public int sub(int num1,int num2);
    public int mul(int num1,int num2);
    public int div(int num1,int num2);
}

• Crear una clase que implementa CalImpl interfaz.

package com.southwind.utils.impl;

import com.southwind.utils.Cal;

public class CalImpl implements Cal {
    public int add(int num1, int num2) {
        System.out.println("add方法的参数是["+num1+","+num2+"]");
        int result = num1+num2;
        System.out.println("add方法的结果是"+result);
        return result;
    }

    public int sub(int num1, int num2) {
        System.out.println("sub方法的参数是["+num1+","+num2+"]");
        int result = num1-num2;
        System.out.println("sub方法的结果是"+result);
        return result;
    }

    public int mul(int num1, int num2) {
        System.out.println("mul方法的参数是["+num1+","+num2+"]");
        int result = num1*num2;
        System.out.println("mul方法的结果是"+result);
        return result;
    }

    public int div(int num1, int num2) {
        System.out.println("div方法的参数是["+num1+","+num2+"]");
        int result = num1/num2;
        System.out.println("div方法的结果是"+result);
        return result;
    }
}

El código anterior, la información del registro de acoplamiento y alta lógica de negocio, no es propicio para el mantenimiento del sistema, usando AOP se puede optimizar, cómo lograr AOP? proxies de manera dinámica.

código de negocio para encontrar un agente, imprimir la información de registro de un trabajo para pagar el agente que hacer, por lo que sólo tiene que centrarse en el código de negocio de su propio negocio puede ser.

package com.southwind.utils;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class MyInvocationHandler implements InvocationHandler {
    //接收委托对象
    private Object object = null;

    //返回代理对象
    public Object bind(Object object){
        this.object = object;
        return Proxy.newProxyInstance(object.getClass().getClassLoader(),object.getClass().getInterfaces(),this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(method.getName()+"方法的参数是："+ Arrays.toString(args));
        Object result = method.invoke(this.object,args);
        System.out.println(method.getName()+"的结果是"+result);
        return result;
    }
}

prueba

public class test1 {
    public static void main(String[] args){
        Cal cal = new CalImpl();
        MyInvocationHandler handler = new MyInvocationHandler();
        //注意Cal为接口
        Cal cal1 =(Cal) handler.bind(cal);
        cal1.add(1,2);
    }
}

Lo anterior se consigue mediante un proceso de AOP dinámico proxy, más complejo, difícil de entender, marco AOP resorte del paquete, utilizando el pensamiento orientado a objetos Spring Framework se puede realizar AOP.

Spring Framework de necesidad InvocationHandler para crear, sólo es necesario para crear un objeto de sección, toda la sección de código no-negocio puede ser completada en un sujeto, el Spring Framework subyacente automáticamente cortar una clase de objeto proxy y el objetivo de generación de clase de acuerdo a.

LoggerAspect

package com.southwind.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

@Aspect
@Component
public class LoggerAspect {

    @Before(value = "execution(public int com.southwind.utils.impl.CalImpl.*(..))")
    public void before(JoinPoint joinPoint){
        //获取方法名
        String name = joinPoint.getSignature().getName();
        //获取参数
        String args = Arrays.toString(joinPoint.getArgs());
        System.out.println(name+"方法的参数是："+ args);
    }

    @After(value = "execution(public int com.southwind.utils.impl.CalImpl.*(..))")
    public void after(JoinPoint joinPoint){
        //获取方法名
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法执行完毕");
    }

    @AfterReturning(value = "execution(public int com.southwind.utils.impl.CalImpl.*(..))",returning = "result")
    public void afterReturning(JoinPoint joinPoint,Object result){
        //获取方法名
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法的结果是"+result);
    }

    @AfterThrowing(value = "execution(public int com.southwind.utils.impl.CalImpl.*(..))",throwing = "exception")
    public void afterThrowing(JoinPoint joinPoint,Exception exception){
        //获取方法名
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法抛出异常："+exception);
    }

}

LoggerAspect definición de clase para agregar dos notas en:

• @Aspect: Indica la clase es la clase de corte.
• @Component: La clase del objeto se inyecta en el recipiente COI.

El método específico para añadir notas en:

@BeforeEso lugar y tiempo y método de ejecución específico.

CalImpl también hay que añadir @Component, al contenedor IoC de manejar.

package com.southwind.utils.impl;

import com.southwind.utils.Cal;
import org.springframework.stereotype.Component;

@Component
public class CalImpl implements Cal {
    public int add(int num1, int num2) {
        int result = num1+num2;
        return result;
    }

    public int sub(int num1, int num2) {
        int result = num1-num2;
        return result;
    }

    public int mul(int num1, int num2) {
        int result = num1*num2;
        return result;
    }

    public int div(int num1, int num2) {
        int result = num1/num2;
        return result;
    }
}

AOP configurar spring.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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
">

    <!-- 自动扫描 -->
    <context:component-scan base-package="com.southwind"></context:component-scan>

    <!-- 是Aspect注解生效，为目标类自动生成代理对象 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

context:component-scanLos com.southwindtodas las clases en un paquete se digitalizan, si una clase añadieron simultáneamente @Component, a continuación, escaneada en un contenedor IoC tal que IoC objeto gestionado.

aop:aspectj-autoproxy clase clase y el objetivo del Resorte del marco en conjunción con la sección generar automáticamente objetos proxy dinámicos.

• Sección: preocupaciones transversales son objetos abstractos modulares.
• Notificación: corte de destino para completar el trabajo.
• Objetivo: El objeto de ser notificado, es decir, transversal al objeto.
• Agente: sección de objetos después de la notificación, mezclar el objetivo.
• El punto de unión: Para insertar el código de notificación de servicio de localización específica.
• punto tangente: AOP está posicionado para el punto de conexión a través del punto de tangencia.