Spring框架——AOP

Spring AOP 面向切面编程，OOP面向对象编程，将程序中所有参与模块都抽象成对象，然后通过对象之间的相互调用完成需求。

AOP是OOP的一种补充，是在另外一个维度上抽象出对象，具体是指程序运行时动态地将非业务代码切入到业务代码中，从而实现代码的解耦合，将非业务代码抽象成一个对象，对该对象进行编程就是面向切面编程思想。

AOP的优点：

　　1、大大降低模块之间的耦合性；

　　2、提高代码的维护性；

　　3、提高代码的复用性；

　　4、集中管理非业务代码，便于维护；

　　5、业务代码不受非业务代码的影响，逻辑更加清晰；

JDK代理方式

委托类

package com.sunjian.aop;

/**
 * @author sunjian
 * @date 2020/3/16 8:12
 */
public interface Cal {
    public int add(int num1, int num2);
    public int sub(int num1, int num2);
    public int mul(int num1, int num2);
    public int div(int num1, int num2);
}

package com.sunjian.aop;

/**
 * @author sunjian
 * @date 2020/3/16 8:13
 */
public class MyCal implements Cal {
    public int add(int num1, int num2) {
        int result = num1 + num2;
        return result;
    }

    public int sub(int num1, int num2) {
        int result = num1 - num2;
        return result;
    }

    public int mul(int num1, int num2) {
        int result = num1 * num2;
        return result;
    }

    public int div(int num1, int num2) {
        int result = num1 / num2;
        return result;
    }
}

代理类

package com.sunjian.aop;

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

/**
 * @author sunjian
 * @date 2020/3/16 8:14
 */
public class MyInvocationHandler implements InvocationHandler {
    private Object object = null; // 委托对象

    // 返回代理对象
    public Object bind(Object object){
        this.object = object;
        return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(), this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(method.getName() + "的参数是 " + Arrays.toString(args));
        Object result = method.invoke(this.object, args);
        System.out.print(method.getName() + "的结果是 ");
        return result;
    }
}

测试类

package com.sunjian.aop;

/**
 * @author sunjian
 * @date 2020/3/16 8:19
 */
public class Test {
    public static void main(String[] args) {
        Cal cal = new MyCal();
        MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
        Cal proxy = (Cal) myInvocationHandler.bind(cal);
        System.out.println(proxy.add(10,3));
        System.out.println(proxy.sub(10,3));
        System.out.println(proxy.mul(10,3));
        System.out.println(proxy.div(10,3));
    }
}

打印结果

add的参数是 [10, 3]
add的结果是 13

sub的参数是 [10, 3]
sub的结果是 7

mul的参数是 [10, 3]
mul的结果是 30

div的参数是 [10, 3]
div的结果是 3

Spring 方式
　　AOP 核心概念

　　　　1、切面对象，根据切面抽象出来的对象，在实现类 MyCal 的所有方法中加入日志部分，抽象成一个切面对象LoggerAspect；

　　　　2、通知，切面对象的具体代码，即非业务代码，loggerAspect打印日志的各种操作；

　　　　3、目标，被切割的对象，MyCal；

　　　　4、代理，切面对象，通知，目标混合之后的产物，Spring通过JDK动态代理创建，真正执行代码的对象；

　　　　5、连接点，需要被横切的位置，即通知要插入业务代码的具体位置；

委托类

package com.sunjian.aop;

/**
 * @author sunjian
 * @date 2020/3/16 8:12
 */
public interface Cal {
    public int add(int num1, int num2);
    public int sub(int num1, int num2);
    public int mul(int num1, int num2);
    public int div(int num1, int num2);
}

package com.sunjian.aop;

import org.springframework.stereotype.Component;

/**
 * @author sunjian
 * @date 2020/3/16 8:13
 */
@Component("myCal")
public class MyCal implements Cal {
    public int add(int num1, int num2) {
        int result = num1 + num2;
        return result;
    }

    public int sub(int num1, int num2) {
        int result = num1 - num2;
        return result;
    }

    public int mul(int num1, int num2) {
        int result = num1 * num2;
        return result;
    }

    public int div(int num1, int num2) {
        int result = num1 / num2;
        return result;
    }
}

代理类

package com.sunjian.aop;

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

import java.util.Arrays;

/**
 * @author sunjian
 * @date 2020/3/16 9:20
 */
@Aspect
@Component
public class LoggerAspect {
    @Before(value = "execution(public int com.sunjian.aop.MyCal.*(..))")
    public void before(JoinPoint joinPoint) {
        // 获取方法名
        String name = joinPoint.getSignature().getName();
        // 参数列表
        String args = Arrays.toString(joinPoint.getArgs());
        System.out.println(name + "的参数是 " + args);
    }

    @AfterReturning(value = "execution(public int com.sunjian.aop.MyCal.*(..))", returning = "result")
    public void after(JoinPoint joinPoint, Object result) {
        System.out.println(joinPoint.getSignature().getName() + "方法的执行结果是 " + result);
    }

    @After(value = "execution(public int com.sunjian.aop.MyCal.*(..))")
    public void after(JoinPoint joinPoint){
        System.out.println(joinPoint.getSignature().getName() + "业务执行完毕...");
    }

    @AfterThrowing(value = "execution(public int com.sunjian.aop.MyCal.*(..))", throwing = "e")
    public void afterThrowing(JoinPoint joinPoint, Exception e){
        System.out.println(joinPoint.getSignature().getName() + "方法抛出异常 " + e);
    }
}

xml 配置

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

    <!-- 自动扫描 -->
    <context:component-scan base-package="com.sunjian"></context:component-scan>

    <!-- 为目标类自动生成代理对象 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

　　将⽬标类和切⾯类交给 IoC 容器管理， IoC 容器会自动创建实例化对象，结合 JDK 动态代理，自动实现 InvocationHandler 接口，整合完成业务代码和非业务代码的解耦合。

　　context:component-scan   将 com.sunjian 包中的所有类扫描到 IoC 容器中，需要结合 @Component 注解完成。
　　aop:aspectj-autoproxy       Spring 会结合切面类和目标类自动生成动态代理对象，代理对象完成非业务代码（日志打印）。

测试类

package com.sunjian.aop;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author sunjian
 * @date 2020/3/16 8:19
 */
public class Test {
    public static void main(String[] args) {

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("aop.xml");
        Cal cal = (Cal) applicationContext.getBean("myCal");
        System.out.println(cal.add(10,3));
        System.out.println(cal.sub(10,3));
        System.out.println(cal.mul(10,3));
        System.out.println(cal.div(10,3));

    }
}

打印结果

add的参数是 [10, 3]
add业务执行完毕...
add方法的执行结果是 13
13

sub的参数是 [10, 3]
sub业务执行完毕...
sub方法的执行结果是 7
7

mul的参数是 [10, 3]
mul业务执行完毕...
mul方法的执行结果是 30
30

div的参数是 [10, 3]
div业务执行完毕...
div方法的执行结果是 3
3

另：同时给一个目标添加多个切面时的执行顺序，实现 org.springframework.Ordered 接口， ordered 越⼩最先执⾏。