Spring学习-第二节-AOP

一、AOP概述

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

二、AOP底层原理

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

三、AOP-JDK动态代理

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

package spring.aop.jdk;

/**
 * 概述：
 * 作者：zhujie
 * 创建时间：2021/10/30 14:37
 */
public interface JdkInterface {
    public int add(int a, int b);
    public String update(String a);
}

（2）接口实现类

package spring.aop.jdk;

/**
 * 概述：
 * 作者：zhujie
 * 创建时间：2021/10/30 14:39
 */
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;

/**
 * 概述：
 * 作者：zhujie
 * 创建时间：2021/10/30 14:45
 */
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;

/**
 * 概述：
 * 作者：zhujie
 * 创建时间：2021/10/30 14:40
 */
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);
    }
}

四、AOP-CGLIB动态代理

1. 被代理类

package spring.aop.cglib;

import javax.xml.ws.soap.Addressing;

/**
 * 概述：
 * 作者：zhujie
 * 创建时间：2021/10/30 15:42
 */
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;

/**
 * 概述：
 * 作者：zhujie
 * 创建时间：2021/10/30 15:44
 */
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;

/**
 * 概述：
 * 作者：zhujie
 * 创建时间：2021/10/30 15:49
 */
public class CglibTest {
    public static void main(String[] args) {
        //被代理对象
        Cglib cglib = new Cglib();
        /**
         * 概述：
         *@param1 被代理对象类型
         *@param2 代理对象实例
         */
        Cglib cglibs = (Cglib) Enhancer.create(cglib.getClass(), new CglibAgent());
        int add = cglibs.add(10, 20);
        System.out.println(add);
    }
}

五、静态代理

1. 房屋出租接口

package spring.aop.staticproxy;

/**
 * 概述：
 * 作者：zhujie
 * 创建时间：2021/11/01 11:57
 */
public interface RentHouse {
    public void rent();
}

2. 房东类

package spring.aop.staticproxy;

/**
 * 概述：
 * 作者：zhujie
 * 创建时间：2021/11/01 11:58
 */
public class Landlord implements RentHouse{
    @Override
    public void rent() {
        System.out.println("房东出租房子");
    }
}

3. 房屋中介类

package spring.aop.staticproxy;

/**
 * 概述：
 * 作者：zhujie
 * 创建时间：2021/11/01 11:58
 */
public class Intermediary implements RentHouse{

    //房东
    private Landlord landlord;

    public Intermediary(Landlord landlord){
       this.landlord = landlord;
    }

    @Override
    public void rent() {
        seeHouse();
        landlord.rent();
        hetong();
        fare();
    }

    public void seeHouse(){
        System.out.println("中介带看房子");
    }

    public void hetong(){
        System.out.println("签合同");
    }

    public void fare(){
        System.out.println("收中介费");
    }
}

4. 测试类

package spring.aop.staticproxy;

/**
 * 概述：
 * 作者：zhujie
 * 创建时间：2021/11/01 12:04
 */
public class Test {
    public static void main(String[] args) {
        Landlord landlord = new Landlord();

        Intermediary intermediary = new Intermediary(landlord);

        intermediary.rent();
    }
}

五、AOP术语

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