Spring学习-第二节-AOP

1. 什么是AOP
   面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率

1. AOP底层使用了动态代理
   （1）有两种情况的动态代理
   有接口：使用JDK动态代理，创建接口实现类的代理对象
   
   无接口：使用CGLIB动态代理，创建当前类子类的代理对象
   

1. 所在包
   
2. 方法及参数介绍
   
   方法有三个参数：
   第一个：类加载器
   第二个：被代理类所实现的接口
   第三个：创建代理对象，实现InvocationHandler接口，写增强方法
3. 示例代码
   （1）接口

package spring.aop.jdk;


public interface JdkInterface {
    public int add(int a, int b);
    public String update(String a);
}

（2）接口实现类

package spring.aop.jdk;


public class JdkInterfaceImpl implements JdkInterface{
    @Override
    public int add(int a, int b) {
        System.out.println("add方法执行了");
        return a+b;
    }

    @Override
    public String update(String a) {
        return "更新成功";
    }
}

（3）代理类

package spring.aop.jdk;

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


public class JdkProxyInterface implements InvocationHandler {

    private Object obj;

    public JdkProxyInterface(Object obj) {
        this.obj = obj;
    }

    @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("在方法" + method.getName() + "之后执行："+res);
        return res;
    }
}

（4）测试类

package spring.aop.jdk;

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


public class JdkProxy{
    public static void main(String[] args) {
        Class [] interfaces = {JdkInterface.class};
        JdkInterface jdkInterface = (JdkInterface) Proxy.newProxyInstance(JdkProxy.class.getClassLoader(),interfaces,new JdkProxyInterface(new JdkInterfaceImpl()));

        jdkInterface.add(10,20);
    }
}

1. 被代理类

package spring.aop.cglib;

import javax.xml.ws.soap.Addressing;


public class Cglib {
    public int add(int a, int b){
        return a+b;
    }
}

2. 代理类

package spring.aop.cglib;

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

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


public class CglibAgent implements MethodInterceptor {


    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        //方法之前执行
        System.out.println("在方法" + method.getName() + "之前执行，" + "方法参数为：" + Arrays.toString(objects));

        //原方法
//        Object res = method.invoke(o, objects);
        Object res = methodProxy.invokeSuper(o,objects);
                //方法之后执行
        System.out.println("在方法" + method.getName() + "之后执行："+res);
        return res;
    }
}

3. 测试类

package spring.aop.cglib;

import net.sf.cglib.proxy.Enhancer;

import javax.sound.midi.Soundbank;


public class CglibTest {
    public static void main(String[] args) {
        //被代理对象
        Cglib cglib = new Cglib();
        
        Cglib cglibs = (Cglib) Enhancer.create(cglib.getClass(), new CglibAgent());
        int add = cglibs.add(10, 20);
        System.out.println(add);
    }
}

1. 连接点：可以被增强的方法，被称为连接点
2. 切点：实际被增强的方法被称为切点
3. 通知（增强）：方法实际被增强的部分被称为通知
   （1）前置通知：在被增强的方法之前执行
   （2）后置通知：在被增强的方法之后执行
   （3）环绕通知：在被增强的方法之前和之后都执行
   （4）异常通知：在被增强的方法出现异常时执行
   （5）最终通知：无论被增强方法是否出现异常，最终通知一定会被执行
4. 切面：将通知应用到切点的过程称为切面