重要概念：

Aspect（切面）：
切面由切点与通知组成，可以看出是具有相同类型功能的一个类，比如日志输出与事务管理，就可以看成是两个切面。

Joint point（连接点）：
连接点就是一些需要增强方法，spring也只支持方法类型的连接点，spring也只能对方法进行增强。

Pointcut（切点）：
表示一组 joint point（因为按照功能分，可以分为很多切面，而每个切面并不是对所有的连接点都进行服务，所以按功能将一些连接点组合起来，这些就是某个切面的切点，不同切面的功能不一样，所以连接点组合不一样，切点也就不一样），这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，切面切入的地方。

Advice（通知）：
Advice 定义了在 Pointcut 里面定义的连接点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是环绕执行。

Target（目标对象）：
织入 Advice 的目标对象.。可以理解为一个bean，一个被代理对象。

Weaving（织入）：
将切面和目标对象连接起来, 并创建代理对象的过程。spring的织入可以在编译的时候，也可以在运行的时候，编译的时候织入就是静态代理，运行的时候织入就是动态代理。

Advisor（顾问）：
Advisor是切面的另外一种实现，能够将通知以更为复杂的方式织入到目标对象中，是将通知包装为更复杂切面的装配器。Advisor由切点和Advice组成。与Aspect不同的就是切面可以有很多通知与切点，而顾问只有一个切点与通知。

基于注解的方式实现aop

@Component
@Aspect
public class MyTestAspect {

    //需要注意切点必须配置在切面里面（用@Aspect修饰的类里面）
    @Pointcut("execution(* com.dahuici.zyb.service.impl.UserServiceImpl.save(..))")
    public void pointcut(){}

    //配置前置通知
    @Before("pointcut()")
    public void before(){
        System.out.println("前置通知");
    }

    //配置后置通知
    @After("pointcut()")
    public void after(){
        System.out.println("后置通知");
    }

}

测试与输出

@Test
    public void testLamda(){
        //该userService是一个bean
        userService.save();
    }

image.png

spring的aop原理（个人查看博客后的理解）：spring在加载bean的时候，会判断该bean是否是切面（用了@Aspect），如果是切面，它会将切面分解成一个一个的（顾问）Advisor，然后在创建号所有的bean后会用这些advisor对bean进行判断是否满足切点条件，如果满足，就将advice通知注入进去（实际就是创建一个代理对象来替换掉原来的bean，然后就实现了对bean的aop增强）。需要注意的是，默认情况下，自动注入切面创建代理bean这个功能是关闭的，需要手动打开。

自定义Advisor

首先必须知道几个对象：Advice，PointCut，MethodMatcher，Advisor的关系

Advisor（顾问）由Advice（通知）与PointCut（切点）组成，Advice（通知）用于执行具体需要增强的逻辑，切点用于设置那些方法需要增强，而PointCut（切点）是通过MethodMatcher对象筛选出那些类与方法需要增强。

Advisor

package com.dahuici.zyb.advisor;

import org.aopalliance.aop.Advice;
import org.springframework.aop.Pointcut;
import org.springframework.aop.PointcutAdvisor;
import org.springframework.stereotype.Component;

@Component
public class MyAdvisor implements PointcutAdvisor {

    @Override
    //使用自定义的切点
    public Pointcut getPointcut() {
        return new MyPointCut();
    }

    @Override
    //使用自定义的前置增强
    public Advice getAdvice() {
        return new MyBeforeAdvice();
    }

    //目前该方法作用是啥不知道
    @Override
    public boolean isPerInstance() {
        return true;
    }


}

切点

package com.dahuici.zyb.advisor;

import org.springframework.aop.ClassFilter;
import org.springframework.aop.MethodMatcher;
import org.springframework.aop.Pointcut;

public class MyPointCut implements Pointcut {

    //用于过滤类，先过滤类，如果类不满足，
    // 那么就不会判断方法是否匹配
    @Override
    public ClassFilter getClassFilter() {
        //这里返回ClassFilter.TRUE表示所有类都匹配
        return ClassFilter.TRUE;
    }

    @Override
    //用于过滤方法，需要一个MyMethodMatcher用于方法逻辑判断
    public MethodMatcher getMethodMatcher() {
        return new MyMethodMatcher();
    }

}

切点的方法匹配器MethodMatcher

package com.dahuici.zyb.advisor;

import org.springframework.aop.MethodMatcher;

import java.lang.reflect.Method;

public class MyMethodMatcher implements MethodMatcher {

    @Override
    //用得最多的是这个方法，另外两个方法不知干啥用的，暂时就都返回false
    //判断该方法上有@MyAnnotation
    public boolean matches(Method method, Class<?> aClass) {

        //注意自定义注解必须使用内置注解@Retention(RetentionPolicy.RUNTIME)
        //不然获取不了
        MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
        //判断方法是否使用了MyAnnotation注解。
        if (annotation != null) return true;
        return false;
    }

    @Override
    public boolean isRuntime() {
        return false;
    }

    @Override
    public boolean matches(Method method, Class<?> aClass, Object... objects) {
        return false;
    }
}

自定义前置通知

package com.dahuici.zyb.advisor;

import com.dahuici.zyb.controller.MyTestController;
import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class MyBeforeAdvice implements MethodBeforeAdvice {

    /*
    * 参数：
    * method-当前执行的方法
    * objects-当前执行方法的参数数组（这里可以对参数进行修改）
    * o-当前执行的方法的实例对象
    *
    * */
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("我的前置通知");

    }

}

自定义注解

package com.dahuici.zyb.advisor;

import java.lang.annotation.*;

//@Target(ElementType.METHOD)
//使用该注解设置为RetentionPolicy.RUNTIME
// 才能通过反射访问到
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation {

    String value() default "";

}

配置spring自动扫描Advisor并创建代理
这一步非常重要，如果不添加该bean，那么spring扫描到Advisor后也不会创建代理对象替换掉原来的bean。

    @Bean
    @ConditionalOnMissingBean
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator defaultAAP = new DefaultAdvisorAutoProxyCreator();
        defaultAAP.setProxyTargetClass(true);
        return defaultAAP;
    }

给测试方法添加注解并测试

    @GetMapping("/isLogin")
    @MyAnnotation
    public String isLogin(){
        System.out.println("已经登录");
        return "isLogin";
    }

测试结果：

image.png

shiro的启用注解授权大概就是使用的这种方式，也是通过Advisor代理来实现注解授权和角色验证的。除了以上的前置通知以外，还有后置通知于环绕通知，实现方式如下。

后置通知

package com.dahuici.zyb.advisor;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class MyAfterAdvice implements AfterReturningAdvice {
    /*
     * 参数：
     * method-当前执行的方法
     * objects-当前执行方法的参数数组（这里可以对参数进行修改）
     * o-代理方法的返回值对象
     * o1-代理的目标对象，注意是目标对象，不是代理对象
     *
     * */
    @Override
    public void afterReturning(Object o, Method method, 
                                Object[] objects, Object o1) throws Throwable {
        System.out.println("后置通知"+o1);

    }
}

环绕通知

package com.dahuici.zyb.advisor;


import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class MyAroundAdvice implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        System.out.println("前");
        //执行目标方法,proceed为目标方法的返回值
        
        Object proceed = methodInvocation.proceed();
        System.out.println(proceed);

        System.out.println("后");
        return proceed;
    }
}

spring的aop实现与自定义Advisor

spring的aop实现与自定义Advisor

基于注解的方式实现aop

自定义Advisor