Spring5详解——AOP

AOP容器

面向切面编程（面向方面编程）

利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序 的可重用性，同时提高了开发的效率。

将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码汇总划分出来，通过对这些行为的分离，我们可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。

简单来说：不通过修改源代码方式，在主干功能里面添加新的功能

AOP底层原理

AOP底层使用动态代理

1. 创建接口实现类代理对象，增强类方法
   

2. 没有接口情况，使用CGLIB动态代理

AOP（JDK动态代理）

java.lang.reflect.Proxy

1. 调用newProxyInstance方法；
   newProxyInstance(ClassLoader loader , 类<?>[] interfaces , InvocationHandler h)返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。
   第一个参数：类加载器
   第二个参数：增强方法所在的类，这个类实现的接口，支持多个接口
   第三个参数：实现这个接口InvocationHandler，创建代理对象写增强的部分。
2. 编写JDK动态代理方法
   （1）创建接口，定义方法
   （2）创建接口实现类，实现方法。
   （3）使用Proxy类创建接口代理对象。

public interface UserDao {
   
    void add(int a,int b);
    void update();
}

@Repository
public class UserDaoImpl implements UserDao{
   


    @Override
    public void add(int a, int b) {
   
        System.out.println("add方法执行ing....");
        System.out.println(a+b);
    }

    @Override
    public void update() {
   
        System.out.println("update方法执行ing....");
    }
}

package com.study.spring5.proxy;

import com.study.spring5.dao.UserDao;
import com.study.spring5.dao.UserDaoImpl;

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.写一个匿名内部类
        /*Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),
                interfaces,new InvocationHandler(){
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                return null;
            }
        });*/
        //2.写个类实现接口
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        dao.add(1, 2);
    }
}


//创建代理对象的代码
class UserDaoProxy implements InvocationHandler{
   
    private  Object obj;
    //1.把创建的是谁的代理对象，就把谁给传过来
    //有参构造
    public UserDaoProxy(Object obj){
   
        this.obj=obj;
    }


    @Override//这个方法里写增强的逻辑
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   
        /*输出的语句就是增加的方法，比如登录检验的功能就要写在这，这里省事一些就直接打印语句效果是一样的。*/
        //方法之前
        System.out.println("方法之前...method="+method.getName()+"传递的参数："+ Arrays.toString(args));

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

        //方法之后
        System.out.println("方法之后...");
        return null;
    }
}

输出结果：

方法之前...method=add传递的参数：[1,