Spring AOP

Spring AOP

AOP（Aspect Oriented Programming）面向切面编程。
OOP（Object Oriented Programming）面向对象编程，用对象化的思想来完成程序。
AOP是对OOP的一个补充，是在另外一个维度上抽象出对象。
⭐具体是指程序运行时动态地将非业务代码切入到业务代码中，从而实现程序的解耦合，将非业务代码抽象成一个对象，对对象编程就是面向切面编程。

上述形式的代码维护性差，没有代码复用性。，使用AOP进行优化，结果如下图所示

AOP的优点

1. 可以降低模块之间的耦合性
2. 提高代码的复用性
3. 提高代码的维护性
4. 集中管理非业务代码，便于维护
5. 业务代码不受非业务代码的影响，逻辑更加清晰

通过一个例子来理解AOP

1. 创建一个计算器接口Cal

package com.oyrf.aop;

public interface Cal {
    int add(int num1,int num2);
    int sub(int num1,int num2);
    int mul(int num1,int num2);
    int div(int num1,int num2);
}

2. 创建接口的实现类CalImpl

package com.oyrf.aop.impl;

import com.oyrf.aop.Cal;

public class CalImpl implements Cal {
    @Override
    public int add(int num1, int num2) {
        return num1+num2;
    }

    @Override
    public int sub(int num1, int num2) {
        return num1-num2;
    }

    @Override
    public int mul(int num1, int num2) {
        return num1*num2;
    }

    @Override
    public int div(int num1, int num2) {
        return num1/num2;
    }
}

⭐日志打印

• 在每个方法开始位置输出参数信息
• 在每个方法结束位置输出结果信息
  对于计算器来讲，加减乘除就是业务代码，日志打印就是非业务代码。

package com.oyrf.aop.impl;

import com.oyrf.aop.Cal;

public class CalImpl implements Cal {
    @Override
    public int add(int num1, int num2) {
        System.out.println("add方法的参数是["+num1+","+num2+"]");
        int result = num1 + num2;
        System.out.println("add的结果是" + result);
        return result;
    }

    @Override
    public int sub(int num1, int num2) {
        System.out.println("sub方法的参数是["+num1+","+num2+"]");
        int result = num1 - num2;
        System.out.println("sub的结果是" + result);
        return result;
    }

    @Override
    public int mul(int num1, int num2) {
        System.out.println("mul方法的参数是["+num1+","+num2+"]");
        int result = num1 * num2;
        System.out.println("mul的结果是" + result);
        return result;
    }

    @Override
    public int div(int num1, int num2) {
        System.out.println("div方法的参数是["+num1+","+num2+"]");
        int result = num1 / num2;
        System.out.println("div的结果是" + result);
        return result;
    }
}

如上述代码所示，打印参数就是代码A，打印结果就是代码B，四个方法就写了四次，耦合度太高，因此要用AOP解决。
⭐AOP如何实现？使用动态代理的方式来实现！
代理首先要具备CalImpl的所有功能，并在此基础上，扩展出打印日志的功能。

1. 删除CalImpl方法中所有打印日志的代码，只保留业务代码。
2. 创建MyInvocationHandler类，实现InvocationHandler接口，生成动态代理。
   动态代理类，需要动态生成，需要获取到委托类的接口信息，根据这些接口信息动态生成一个代理类，然后由ClassLoader用来将动态生成的类加载到JVM
   MyInvocationHandler.java

package com.oyrf.aop.impl;

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

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);
    }

    @Override
    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.println(method.getName()+"方法的结果是："+result);
        return result;
    }
}

Test.java

package com.oyrf.aop;

import com.oyrf.aop.impl.CalImpl;
import com.oyrf.aop.impl.MyInvocationHandler;

public class Test {
    public static void main(String[] args) {
        //实例化委托对象
        Cal cal = new CalImpl();
        //获取代理对象
        MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
        Cal proxy = (Cal)myInvocationHandler.bind(cal);
        proxy.add(10,3);
        proxy.sub(10,3);
        proxy.mul(10,3);
        proxy.div(10,3);
    }
}

上述代码通过动态代理机制实现了业务代码和非业务代码的解耦合，这是Spring AOP的底层实现机制，真正在使用Spring AOP进行开发时，不需要这么复杂，可以用更好理解的方式来完成开发。

Spring AOP的开发步骤

1. 创建切面类

package com.oyrf.aop;

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

import java.util.Arrays;

@Component
@Aspect
public class LoggerAspect {
    @Before("execution(public int com.oyrf.aop.impl.CalImpl.*(..))")
    public void before(JoinPoint joinPoint){
        String name = joinPoint.getSignature().getName();
        String args = Arrays.toString(joinPoint.getArgs());
        System.out.println(name+"方法的参数是"+args);
    }
    @After("execution(public int com.oyrf.aop.impl.CalImpl.*(..))")
    public void after(JoinPoint joinPoint){
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法执行完毕");
    }
    @AfterReturning(value ="execution(public int com.oyrf.aop.impl.CalImpl.*(..))",returning = "result")
    public void afterReturn(JoinPoint joinPoint,Object result){
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法的结果是"+result);
    }
    @AfterThrowing(value = "execution(public int com.oyrf.aop.impl.CalImpl.*(..))",throwing = "exception")
    public void afterThrowing(JoinPoint joinPoint,Exception exception){
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法抛出异常"+exception);

    }
}

• ⭐@Component，将切面类加载到IoC容器中。
• ⭐@Aspect，表示该类是一个切面类。
• ⭐@Before，表示方法的执行时机是在业务方法之前，execution表达式表示切入点是CalImpl类中add方法。
• ⭐@After，表示方法的执行时机是在业务方法之前，execution表达式表示切入点是CalImpl类中的add方法。
• ⭐AfterReturning，表示方法的执行时机是在业务方法返回结果之后，execution表达式表示切入点是CalImpl类中的add方法，returning是将业务方法的返回值与切面类方法的形参进行绑定。
• ⭐AfterThrowing，表示方法执行的时机是在业务方法抛出异常之后，execution表达式表示切入点是CalImpl类中的add方法，throwing是将业务方法的异常与切面类方法的形参进行绑定。

2. 委托类也需要添加@Component注解

package com.oyrf.aop.impl;

import com.oyrf.aop.Cal;
import org.springframework.stereotype.Component;

@Component
public class CalImpl implements Cal {
    @Override
    public int add(int num1, int num2) {
        int result = num1 + num2;
        return result;
    }

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

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

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

3. spring.xml中需要配一个自动扫包

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns="http://www.springframework.org/schema/beans" 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.oyrf.aop"></context:component-scan>
    <!--为委托类自动生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

• ⭐aop:aspectj-autoproxy，Spring IoC容器会结合切面对象和委托对象自动生成动态代理对象，AOP底层就是通过动态代理机制来实现的。

AOP的概念

• 切面对象：根据切面抽象出来的对象，CalImpl所有方法中需要加入日志的部分，抽象成一个切面类LoggerAspect。
• 通知：切面对象具体执行的代码，即非业务代码，LoggerAspect对象打印日志的代码。
• 目标：被横切的对象，即CalImpl，将通知加入其中。
• 代理：切面对象、通知、目标混合之后的结果，即我们使用JDK动态代理机制创建的对象。
• 连接点：需要被横切的位置，即通知要插入业务代码的具体位置。