El principio subyacente del marco AOP-Spring

Que es AOP

1. ¿Qué es AOP
(1) Programación orientada a aspectos (aspecto), el uso de AOP puede aislar varias partes de la lógica empresarial, reduciendo así el acoplamiento entre varias partes de la lógica empresarial, mejorando la reutilización del programa y mejorando la Eficiencia de desarrollo.
(2) Descripción popular: agregue nuevas funciones a la función principal sin modificar el código fuente
(3) Use ejemplos de inicio de sesión para ilustrar AOP

El principio subyacente de AOP

Hay dos casos de proxy dinámico

• Utilice el proxy dinámico JDK cuando haya interfaces
• Si no hay interfaz, use CGLIB

(1) Utilice el proxy dinámico JDK si hay interfaces

Crear objeto de proxy de clase de implementación de interfaz, mejorar el método de clase

(2) Si no hay una interfaz, use el proxy dinámico CGLIB

Cree objetos proxy de subclases y mejore los métodos de clase

Realización de proxy dinámico JDK

• Módulo java.base
• Paquete java.lang.reflect
• Para obtener detalles de Class Proxy, consulte

方法有三个参数：
第一参数，类加载器 
第二参数，增强方法所在的类，这个类实现的接口，支持多个接口 
第三参数，实现这个接口 InvocationHandler，创建代理对象，写增强的部分

paso

(1) Crear interfaz y definir método

(2) Cree una clase de implementación de interfaz e implemente métodos

(3) Utilice la clase Proxy para crear un objeto proxy de interfaz

• El método de construcción parametrizado pasa el objeto mejorado
• invocar mejora de objeto
  
• Código

package com.LinXiaoDe.spring5;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class JDKProxy {
    
    
    public static void main(String[] args) {
    
    
        Class[] interfaces={
    
    UserDao.class};
        //1.类加载器
        //2.增强方法所在的类，这个类实现的接口，支持多个接口
        //3.实现这个接口 InvocationHandler，创建代理对象，写增强的部分
        /*匿名内部类,可以写在内部
        Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                return null;
            }
        });*/
        UserDaoImpl userDao=new UserDaoImpl();
        UserDao dao= (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces,new UserDaoProxy(userDao));
        int res=dao.add(1,2);
        System.out.println("result: "+res);
    }
}
//创建代理对象，实现InvocationHandler,用于增强
class UserDaoProxy implements InvocationHandler {
    
    

    //1.把创建是谁的代理对象，那么把谁传进来
    //有参构造方式传入
    private Object obj;
    public UserDaoProxy(Object obj)
    {
    
    
        this.obj=obj;
    }
    //2.只要对象被创建，那么方法将会被调用
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
    
        //方法之前
        System.out.println("方法执行之前，"+method.getName()+" ,   传递的参数："+ Arrays.toString(args));

        //被增强方法执行
        Object res=method.invoke(obj,args);

        //方法之后
        System.out.println("方法之后执行："+obj);
        return res;
    }
}