Spring AOP

动态代理

1. 特点：字节码文件随用随创建，随用随加载。
2. 作用：不用修改源码的基础上对方法增强。
3. 分类:基于接口的动态代理，基于子类的动态代理。

基于接口的动态代理

1. 涉及的类：Proxy
2. 提供者：JDK官方
3. 如何创建对象：使用Proxy类中的newProxyInstance方法
4. 创建代理对象的要求：被代理类最少实现一个接口
5. newProxyInstance方法的参数：
   ClassLoader：类加载器
   用于加载代理对象字节码，和被代理对象使用相同类加载器，固定写法。
   Class[]：字节码数组
   用于让代理对象和被代理对象有相同的方法，固定写法。
   InvocationHandler：用于提供增强代码
   让我们如何写代理，一般都是写一个该接口的实现类，通常情况下都是内部匿名类，但不是必须。此接口的实现类都是谁用谁写。

package com.yaku.proxy;

public class Producer implements IProducer{
    @Override
    public void saleProduct(float money) {
        System.out.println("销售产品 获得金钱"+money);
    }

    @Override
    public void afterService(float money) {
        System.out.println("提供售后服务 获得金钱"+money);
    }
}

package com.yaku.proxy;

public class Producer implements IProducer{
    @Override
    public void saleProduct(float money) {
        System.out.println("销售产品 获得金钱"+money);
    }

    @Override
    public void afterService(float money) {
        System.out.println("提供售后服务 获得金钱"+money);
    }
}

package com.yaku.proxy;

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

public class Client {
    public static void main(String[] args) {
        final Producer producer = new Producer();
        IProducer producerpoxy = (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(), producer.getClass().getInterfaces(),
        new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Object returnValue = null;
                if("saleProduct".equals(method.getName())){
                    Float money = (Float) args[0];
                    returnValue = method.invoke(producer,money*0.8f);
                }
                return returnValue;
            }
        });
        producerpoxy.saleProduct(1000);
    }
}

基于子类的动态代理

1. 涉及的类：Enhancer
2. 提供者：第三方cglib库
3. 如何创建对象：使用Enhancer类中的create方法
4. 创建代理对象的要求：被代理类不能是最终类
5. create方法的参数：
   Class：字节码
   用于指定被代理对象的字节码。
   Callback：用于提供增强代码
   让我们如何写代理，一般都是写一个该接口的实现类，通常情况下都是内部匿名类，但不是必须。此接口的实现类都是谁用谁写。
   一般写该接口的子接口实现类。：MethodIntercepto

package com.yaku.cglib;


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

import java.lang.reflect.Method;

public class Client {
    public static void main(String[] args) {
        final Producer producer = new Producer();
        Producer cgligProducer = (Producer) Enhancer.create(producer.getClass(), new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                Object returnValue = null;
                if("saleProduct".equals(method.getName())){
                    Float money = (Float) objects[0];
                    returnValue = method.invoke(producer,money*0.8f);
                }
                return returnValue;
            }
        });
        cgligProducer.saleProduct(1000f);
    }
}

AOP

1. Joinpoint（连接点）：是指那些被拦截到的点。在spring中，这些点是指方法，因为spring只支持方法类型的连接点。
2. Pointcut（切入点）：所谓切入点是指我们要对那些JoinPoint进行拦截的定义。
3. Advice(通知/增强)：是指拦截到Joinpoint之后要做的事情就是通知。
   通知的类型：前置通知，后置通知，异常通知，最终通知，环绕通知：整个invoke方法执行就是环绕通知，有明确的切入点方法调用。
4. Target（目标对象）：代理的目标对象
5. Weaving（织入）：指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译器植入和类装载期织入。
6. Proxy（代理）：一个类被AOP织入增强后，就产生一个结果代理类。
7. Aspect（切面）：切入点和通知（引介）的结合。

package com.yaku.utils;

public class Logger {

    /**
     * 前置通知
     */
    public void beforePrintLog(){
        System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了。。。。");
    }

    /**
     * 后置通知
     */
    public void afterReturningPrintLog(){
        System.out.println("后置通知Logger类中的afterReturningLog方法开始记录日志了。。。。");
    }

    /**
     * 异常通知
     */
    public void afterThrowingPrintLog(){
        System.out.println("异常通知Logger类中的afterThrowingLog方法开始记录日志了。。。。");
    }

    /**
     * 最终通知
     */
    public void afterPrintLog(){
        System.out.println("最终通知Logger类中的afterLog方法开始记录日志了。。。。");
    }
}

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="accountService" class="com.yaku.service.impl.AccountServiceImpl"/>

    <!-- spring基于XML的AOP配置步骤
        1.把通知bean也交给spring来管理
        2.使用aop:config标签表明开始配置AOP
        3.使用aop:aspect标签表明配置切面
                id:切面的唯一表示
                ref:指定通知类bean的id
        4.在aop:aspect标签内部使用对应标签来配置通知类型
            让printLog方法在切入点方法执行之前执行，所以是前置通知
            aop:before标签：配置前置通知
                method:用于指定Logger类中那个方法是前置通知
                pointcut:用于指定切入点表达式，该表达式的含义是对业务层中那些方法增强
            切入点表达式的写法：
                execution(表达式)
                表达式:访问修饰符 返回值 包名.包名...类名.方法名(参数列表)
                标准的表达式写法：
                        public void com.yaku.service.impl.AccountServiceImpl.saveAccount()
                访问修饰符可以省略
                全通配写法
                * *..*.*(..)
                参数列表:*表示必须有参数 ..表示可有可无
                基本类型写名称：int
                引用类型写全限定类名： String java.lang.String
    -->

    <!-- 配置Logger类-->
    <bean id="logger" class="com.yaku.utils.Logger"/>

    <!-- 配置AOP -->

    <aop:config>
        <!-- 配置切入点表达式，id属性指定表达式唯一属性。expression属性指定表达式内容
             此标签写在aop:aspect标签内部只能当前标签内使用还可以写在外面，全局可用，但是必须在aop:aspect切面标签上面-->
        <aop:pointcut id="pt1" expression="execution(public void com.yaku.service.impl.AccountServiceImpl.saveAccount())"/>
        <!-- 配置切面 -->
        <aop:aspect id="logAdvice" ref="logger">
            <!-- 前置通知:切入点方法前执行 -->
            <aop:before method="beforePrintLog" pointcut-ref="pt1"/>
            <!-- 后置通知:切入点方法后执行，产生异常就不执行 -->
            <aop:after-returning method="afterReturningPrintLog" pointcut="execution(public void com.yaku.service.impl.AccountServiceImpl.saveAccount())"/>
            <!-- 异常通知:切入点方法产生异常之后执行 -->
            <aop:after-throwing method="afterThrowingPrintLog" pointcut="execution(public void com.yaku.service.impl.AccountServiceImpl.saveAccount())"/>
            <!-- 最终通知:无论切入点方法是否正常执行它都在其后面前执行 -->
            <aop:after method="afterPrintLog" pointcut="execution(public void com.yaku.service.impl.AccountServiceImpl.saveAccount())"/>

        </aop:aspect>
    </aop:config>
</beans>

package com.yaku.utils;

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

@Component("logger")
@Aspect
public class Logger {

    @Pointcut("execution(void com.yaku.service.impl.AccountServiceImpl.*())")
    private void pt1(){
        
    }
    
    @Before("pt1()")
    public void beforeLog(){
        System.out.println("前置通知");
    }

    @AfterReturning("pt1()")
    public void afterReturning(){
        System.out.println("后置通知");
    }

    @AfterThrowing("pt1()")
    public void afterThrowing(){
        System.out.println("异常通知");
    }

    @After("pt1()")
    public void afterLog(){
        System.out.println("最终通知");
    }

}