@Aspect中@Pointcut 12种用法

落日映苍穹つ 2023-10-01 08:44 2阅读 0赞

**本文主要内容：掌握@Pointcut的12种用法。**

### Aop相关阅读 ###

阅读本文之前，需要先掌握下面3篇文章内容，不然会比较吃力。

1.  [Spring系列第15篇：代理详解（java动态代理&CGLIB代理)][Spring_15_java_CGLIB]
2.  [Spring系列第30篇：jdk动态代理和cglib代理][Spring_30_jdk_cglib]
3.  [Spring系列第31篇：Aop概念详解][Spring_31_Aop]
4.  [Spring系列第32篇：AOP核心源码、原理详解][Spring_32_AOP]
5.  [Spring系列第33篇：ProxyFactoryBean创建AOP代理][Spring_33_ProxyFactoryBean_AOP]

本文继续AOP，目前手动Aop中三种方式已经介绍2种了，本文将介绍另外一种：`AspectJProxyFactory`，可能大家对这个比较陌生，但是`@Aspect`这个注解大家应该很熟悉吧，通过这个注解在spring环境中实现aop特别的方便。

而`AspectJProxyFactory`这个类可以通过解析`@Aspect`标注的类来生成代理aop代理对象，对开发者来说，使创建代理变的更简洁了。

![img][]

### 先了解几个概念 ###

文中会涉及几个概念，先了解一下。

#### target ####

用来表示目标对象，即需要通过aop来增强的对象。

#### proxy ####

代理对象，target通过aop增强之后生成的代理对象。

### AspectJ ###

#### AspectJ是什么? ####

AspectJ是一个面向切面的框架，是目前最好用，最方便的AOP框架，和spring中的aop可以集成在一起使用，通过Aspectj提供的一些功能实现aop代理变得非常方便。

#### AspectJ使用步骤 ####

1.创建一个类，使用@Aspect标注
    2.@Aspect标注的类中，通过@Pointcut定义切入点
    3.@Aspect标注的类中，通过AspectJ提供的一些通知相关的注解定义通知
    4.使用AspectJProxyFactory结合@Ascpect标注的类，来生成代理对象

先来个案例，感受一下AspectJ是多么的方便。

来个类

package com.javacode2018.aop.demo9.test1;
     
    public class Service1 {
        
     
        public void m1() {
        
            System.out.println("我是 m1 方法");
        }
     
        public void m2() {
        
            System.out.println(10 / 0);
            System.out.println("我是 m2 方法");
        }
    }

通过`AspectJ`来对`Service1`进行增强，来2个通知，一个前置通知，一个异常通知，这2个通知需要对`Service1`中的所有方法生效，实现如下：

package com.javacode2018.aop.demo9.test1;
     
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.AfterThrowing;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
     
    //@1：这个类需要使用@Aspect进行标注
    @Aspect
    public class Aspect1 {
        
     
        //@2：定义了一个切入点，可以匹配Service1中所有方法
        @Pointcut("execution(* com.javacode2018.aop.demo9.test1.Service1.*(..))")
        public void pointcut1() {
        
        }
     
        //@3：定义了一个前置通知，这个通知对刚刚上面我们定义的切入点中的所有方法有效
        @Before(value = "pointcut1()")
        public void before(JoinPoint joinPoint) {
        
            //输出连接点的信息
            System.out.println("前置通知，" + joinPoint);
        }
     
        //@4：定义了一个异常通知，这个通知对刚刚上面我们定义的切入点中的所有方法有效
        @AfterThrowing(value = "pointcut1()", throwing = "e")
        public void afterThrowing(JoinPoint joinPoint, Exception e) {
        
            //发生异常之后输出异常信息
            System.out.println(joinPoint + ",发生异常：" + e.getMessage());
        }
     
    }

> @1：类上使用@Aspect标注
> 
> @2：通过@Pointcut注解标注在方法上面，用来定义切入点
> 
> @3：使用@Before标注在方法上面，定义了一个前置通知，通过value引用了上面已经定义的切入点，表示这个通知会对Service1中的所有方法生效，在通知中可以通过这个`类名.方法名()`引用`@Pointcut`定义的切入点，表示这个通知对这些切入点有效，若`@Before和@Pointcut`在一个类的时候，直接通过`方法名()`引用当前类中定义的切入点
> 
> @4：这个使用`@AfterThrowing`定义了一个异常通知，也是对通过value引用了上面已经定义的切入点，表示这个通知会对Service1中的所有方法生效，若Service1中的方法抛出了Exception类型的异常，都会回调`afterThrowing`方法。

来个测试类

package com.javacode2018.aop.demo9;
     
    import com.javacode2018.aop.demo9.test1.Aspect1;
    import com.javacode2018.aop.demo9.test1.Service1;
    import org.junit.Test;
    import org.springframework.aop.aspectj.annotation.AspectJProxyFactory;
     
    public class AopTest9 {
        
        @Test
        public void test1() {
        
            try {
        
                //对应目标对象
                Service1 target = new Service1();
                //创建AspectJProxyFactory对象
                AspectJProxyFactory proxyFactory = new AspectJProxyFactory();
                //设置被代理的目标对象
                proxyFactory.setTarget(target);
                //设置标注了@Aspect注解的类
                proxyFactory.addAspect(Aspect1.class);
                //生成代理对象
                Service1 proxy = proxyFactory.getProxy();
                //使用代理对象
                proxy.m1();
                proxy.m2();
            } catch (Exception e) {
        
            }
        }
    }

运行输出

前置通知，execution(void com.javacode2018.aop.demo9.test1.Service1.m1())
    我是 m1 方法
    前置通知，execution(void com.javacode2018.aop.demo9.test1.Service1.m2())
    execution(void com.javacode2018.aop.demo9.test1.Service1.m2()),发生异常：/ by zero

使用是不是特方便。

#### AspectJProxyFactory原理 ####

`@Aspect`标注的类上，这个类中，可以通过通过`@Pointcut`来定义切入点，可以通过`@Before、@Around、@After、@AfterRunning、@AfterThrowing`标注在方法上来定义通知，定义好了之后，将`@Aspect`标注的这个类交给`AspectJProxyFactory`来解析生成`Advisor`链，进而结合目标对象一起来生成代理对象，大家可以去看一下源码，比较简单，这里就不多解释了。

本文的重点在`@Aspect`标注的类上，`@Aspect`中有2个关键点比较重要

*  @Pointcut：标注在方法上，用来定义切入点，有11种用法，本文主要讲解这11种用法。
 *  @Aspect类中定义通知：可以通过`@Before、@Around、@After、@AfterRunning、@AfterThrowing`标注在方法上来定义通知，这个下一篇介绍。

### @Pointcut的12种用法 ###

#### 作用 ####

用来标注在方法上来定义切入点。

#### 定义 ####

格式：@ 注解(value=“表达标签 (表达式格式)”)

如：

@Pointcut("execution(* com.javacode2018.aop.demo9.test1.Service1.*(..))")

#### 表达式标签（10种） ####

*  execution：用于匹配方法执行的连接点
 *  within：用于匹配指定类型内的方法执行
 *  this：用于匹配当前AOP代理对象类型的执行方法；注意是AOP代理对象的类型匹配，这样就可能包括引入接口也类型匹配
 *  target：用于匹配当前目标对象类型的执行方法；注意是目标对象的类型匹配，这样就不包括引入接口也类型匹配
 *  args：用于匹配当前执行的方法传入的参数为指定类型的执行方法
 *  @within：用于匹配所以持有指定注解类型内的方法
 *  @target：用于匹配当前目标对象类型的执行方法，其中目标对象持有指定的注解
 *  @args：用于匹配当前执行的方法传入的参数持有指定注解的执行
 *  @annotation：用于匹配当前执行方法持有指定注解的方法
 *  bean：Spring AOP扩展的，AspectJ没有对于指示符，用于匹配特定名称的Bean对象的执行方法

**10种标签组成了12种用法**

#### 1、execution ####

使用`execution(方法表达式)`匹配方法执行。

execution格式

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)

*  其中带 ?号的 modifiers-pattern?，declaring-type-pattern?，hrows-pattern?是可选项
 *  ret-type-pattern,name-pattern, parameters-pattern是必选项
 *  modifier-pattern? 修饰符匹配，如public 表示匹配公有方法
 *  ret-type-pattern 返回值匹配，\* 表示任何返回值，全路径的类名等
 *  declaring-type-pattern? 类路径匹配
 *  name-pattern 方法名匹配，\* 代表所有，set\*，代表以set开头的所有方法
 *  (param-pattern) 参数匹配，指定方法参数(声明的类型)，(…)代表所有参数，(\*,String)代表第一个参数为任何值,第二个为String类型，(…,String)代表最后一个参数是String类型
 *  throws-pattern? 异常类型匹配

举例说明

![img][img 1]

类型匹配语法

很多地方会按照类型的匹配，先来说一下类型匹配的语法。

首先让我们来了解下AspectJ类型匹配的通配符：

*  \*：匹配任何数量字符
 *  ..：匹配任何数量字符的重复，如在类型模式中匹配任何数量子包；而在方法参数模式中匹配任何数量参数（0个或者多个参数）
 *  \+：匹配指定类型及其子类型；仅能作为后缀放在类型模式后边

![img][img 2]

#### 2、within ####

用法

`within(类型表达式)`：目标对象target的类型是否和within中指定的类型匹配

![img][img 3]

匹配原则

target.getClass().equals(within表达式中指定的类型)

案例

有2个类，父子关系

父类C1

package com.javacode2018.aop.demo9.test2;
     
    public class C1 {
        
        public void m1() {
        
            System.out.println("我是m1");
        }
     
        public void m2() {
        
            System.out.println("我是m2");
        }
    }

子类C2

package com.javacode2018.aop.demo9.test2;
     
    public class C2 extends C1 {
        
        @Override
        public void m2() {
        
            super.m2();
        }
     
        public void m3() {
        
            System.out.println("我是m3");
        }
    }

来个Aspect类

package com.javacode2018.aop.demo9.test2;
     
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
     
    @Aspect
    public class AspectTest2 {
        
     
        @Pointcut("within(C1)") //@1
        public void pc() {
        
        }
     
        @Before("pc()") //@2
        public void beforeAdvice(JoinPoint joinpoint) {
        
            System.out.println(joinpoint);
        }
     
    }

> 注意`@1`匹配的类型是`C1`，也就是说被代理的对象的类型必须是C1类型的才行，需要和C1完全匹配

下面我们对`C2`创建代理

@Test
    public void test2(){
        
        C2 target = new C2();
        AspectJProxyFactory proxyFactory = new AspectJProxyFactory();
        proxyFactory.setTarget(target);
        proxyFactory.addAspect(AspectTest2.class);
     
        C2 proxy = proxyFactory.getProxy();
        proxy.m1();
        proxy.m2();
        proxy.m3();
    }

运行输出

我是m1
    我是m2
    我是m3

原因是目标对象是C2类型的，C2虽然是C1的子类，但是within中表达式指定的是要求类型必须是C1类型的才匹配。

如果将within表达式修改为下面任意一种就可以匹配了

@Pointcut("within(C1+)") 
    @Pointcut("within(C2)")

再次运行输出

execution(void com.javacode2018.aop.demo9.test2.C1.m1())
    我是m1
    execution(void com.javacode2018.aop.demo9.test2.C2.m2())
    我是m2
    execution(void com.javacode2018.aop.demo9.test2.C2.m3())
    我是m3

#### 3、this ####

用法

`this(类型全限定名)`：通过aop创建的代理对象的类型是否和this中指定的类型匹配；注意判断的目标是代理对象；this中使用的表达式必须是类型全限定名，不支持通配符。

匹配原则

如:this(x)，则代理对象proxy满足下面条件时会匹配
    x.getClass().isAssignableFrom(proxy.getClass());

案例

来个接口

package com.javacode2018.aop.demo9.test3;
     
    public interface I1 {
        
        void m1();
    }

来个实现类

package com.javacode2018.aop.demo9.test3;
     
    public class Service3 implements I1 {
        
     
        @Override
        public void m1() {
        
            System.out.println("我是m1");
        }
     
    }

来个@Aspect类

package com.javacode2018.aop.demo9.test3;
     
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
     
    @Aspect
    public class AspectTest3 {
        
     
        //@1：匹配proxy是Service3类型的所有方法
        @Pointcut("this(Service3)")
        public void pc() {
        
        }
     
        @Before("pc()")
        public void beforeAdvice(JoinPoint joinpoint) {
        
            System.out.println(joinpoint);
        }
     
    }

测试代码

@Test
    public void test3() {
        
        Service3 target = new Service3();
        AspectJProxyFactory proxyFactory = new AspectJProxyFactory();
        proxyFactory.setTarget(target);
        //获取目标对象上的接口列表
        Class<?>[] allInterfaces = ClassUtils.getAllInterfaces(target);
        //设置需要代理的接口
        proxyFactory.setInterfaces(allInterfaces);
        proxyFactory.addAspect(AspectTest3.class);
        //获取代理对象
        Object proxy = proxyFactory.getProxy();
        //调用代理对象的方法
        ((I1) proxy).m1();
     
        System.out.println("proxy是否是jdk动态代理对象：" + AopUtils.isJdkDynamicProxy(proxy));
        System.out.println("proxy是否是cglib代理对象：" + AopUtils.isCglibProxy(proxy));
        //判断代理对象是否是Service3类型的
        System.out.println(Service3.class.isAssignableFrom(proxy.getClass()));
    }

运行输出

我是m1
    proxy是否是jdk动态代理对象：true
    proxy是否是cglib代理对象：false
    false

从输出中可以看出m1方法没有被增强，原因：this表达式要求代理对象必须是Service3类型的，输出中可以看出代理对象并不是Service3类型的，此处代理对象proxy是使用jdk动态代理生成的。

我们可以将代码调整一下，使用cglib来创建代理

proxyFactory.setProxyTargetClass(true);

再次运行，会发现m2被拦截了，结果如下

execution(void com.javacode2018.aop.demo9.test3.Service3.m1())
    我是m1
    proxy是否是jdk动态代理对象：false
    proxy是否是cglib代理对象：true
    true

#### 4、target ####

用法

`target(类型全限定名)`：判断目标对象的类型是否和指定的类型匹配；注意判断的是目标对象的类型；表达式必须是类型全限定名，不支持通配符。

匹配原则

如:target(x)，则目标对象target满足下面条件时会匹配
    x.getClass().isAssignableFrom(target.getClass());

案例

package com.javacode2018.aop.demo9.test4;
     
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
     
    @Aspect
    public class AspectTest4 {
        
     
        //@1：目标类型必须是Service3类型的
        @Pointcut("target(com.javacode2018.aop.demo9.test3.Service3)")
        public void pc() {
        
        }
     
        @Before("pc()")
        public void beforeAdvice(JoinPoint joinpoint) {
        
            System.out.println(joinpoint);
        }
     
    }

测试代码

@Test
    public void test4() {
        
        Service3 target = new Service3();
        AspectJProxyFactory proxyFactory = new AspectJProxyFactory();
        proxyFactory.setProxyTargetClass(true);
        proxyFactory.setTarget(target);
        proxyFactory.addAspect(AspectTest4.class);
        //获取代理对象
        Object proxy = proxyFactory.getProxy();
        //调用代理对象的方法
        ((I1) proxy).m1();
        //判断target对象是否是Service3类型的
        System.out.println(Service3.class.isAssignableFrom(target.getClass()));
    }

运行输出

execution(void com.javacode2018.aop.demo9.test3.Service3.m1())
    我是m1
    true

within、this、target对比

![img][img 4]

#### 5、args ####

用法

`args(参数类型列表)`匹配当前执行的方法传入的参数是否为args中指定的类型；注意是匹配传入的参数类型，不是匹配方法签名的参数类型；参数类型列表中的参数必须是类型全限定名，不支持通配符；args属于动态切入点，也就是执行方法的时候进行判断的，这种切入点开销非常大，非特殊情况最好不要使用。

举例说明

![img][img 5]

案例

下面的m1方法参数是Object类型的。

package com.javacode2018.aop.demo9.test5;
     
    public class Service5 {
        
        public void m1(Object object) {
        
            System.out.println("我是m1方法,参数：" + object);
        }
    }

Aspect类

package com.javacode2018.aop.demo9.test5;
     
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
     
    import java.util.Arrays;
    import java.util.stream.Collectors;
     
    @Aspect
    public class AspectTest5 {
        
        //@1：匹配只有1个参数其类型是String类型的
        @Pointcut("args(String)")
        public void pc() {
        
        }
     
        @Before("pc()")
        public void beforeAdvice(JoinPoint joinpoint) {
        
            System.out.println("请求参数：" + Arrays.stream(joinpoint.getArgs()).collect(Collectors.toList()));
        }
    }

测试代码，调用2次m1方法，第一次传入一个String类型的，第二次传入一个int类型的，看看效果

@Test
    public void test5() {
        
        Service5 target = new Service5();
        AspectJProxyFactory proxyFactory = new AspectJProxyFactory();
        proxyFactory.setTarget(target);
        proxyFactory.addAspect(AspectTest5.class);
        Service5 proxy = proxyFactory.getProxy();
        proxy.m1("路人");
        proxy.m1(100);
    }

运行输出

请求参数：[路人]
    我是m1方法,参数：路人
    我是m1方法,参数：100

输出中可以看出，m1第一次调用被增强了，第二次没有被增强。

**args会在调用的过程中对参数实际的类型进行匹配，比较耗时，慎用。**

#### 6、@within ####

用法

`@within(注解类型)`：匹配指定的注解内定义的方法。

匹配规则

调用目标方法的时候，通过java中`Method.getDeclaringClass()`获取当前的方法是哪个类中定义的，然后会看这个类上是否有指定的注解。

被调用的目标方法Method对象.getDeclaringClass().getAnnotation(within中指定的注解类型) != null

来看3个案例。

案例1

**目标对象上有@within中指定的注解，这种情况时，目标对象的所有方法都会被拦截。**

来个注解

package com.javacode2018.aop.demo9.test9;
     
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
     
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    public @interface Ann9 {
        
    }

来个目标类，用@Ann9标注

package com.javacode2018.aop.demo9.test9;
     
    @Ann9
    public class S9 {
        
        public void m1() {
        
            System.out.println("我是m1方法");
        }
    }

来个Aspect类

package com.javacode2018.aop.demo9.test9;
     
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
     
    @Aspect
    public class AspectTest9 {
        
        /**
         * 定义目标方法的类上有Ann9注解
         */
        @Pointcut("@within(Ann9)")
        public void pc() {
        
        }
     
        @Before("pc()")
        public void beforeAdvice(JoinPoint joinPoint) {
        
            System.out.println(joinPoint);
        }
    }

测试代码

@Test
    public void test9() {
        
        S9 target = new S9();
        AspectJProxyFactory proxyFactory = new AspectJProxyFactory();
        proxyFactory.setTarget(target);
        proxyFactory.addAspect(AspectTest9.class);
        S9 proxy = proxyFactory.getProxy();
        proxy.m1();
    }

> m1方法在类S9中定义的，S9上面有Ann9注解，所以匹配成功

运行输出

execution(void com.javacode2018.aop.demo9.test9.S9.m1())
    我是m1方法

案例2

**定义注解时未使用`@Inherited`，说明子类无法继承父类上的注解**，这个案例中我们将定义一个这样的注解，将注解放在目标类的父类上，来看一下效果。

定义注解Ann10

package com.javacode2018.aop.demo9.test10;
     
    import java.lang.annotation.*;
     
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    @Inherited
    public @interface Ann10 {
        
    }

来2个父子类

> 注意：
> 
> S10Parent为父类，并且使用了Anno10注解，内部定义了2个方法大家注意一下
> 
> 而S10位代理的目标类，继承了S10Parent，内部重写了父类的m2方法，并且又新增了一个m3方法

package com.javacode2018.aop.demo9.test10;
     
    @Ann10
    class S10Parent {
        
     
        public void m1() {
        
            System.out.println("我是S10Parent.m1()方法");
        }
     
        public void m2() {
        
            System.out.println("我是S10Parent.m2()方法");
        }
    }
     
    public class S10 extends S10Parent {
        
     
        @Override
        public void m2() {
        
            System.out.println("我是S10.m2()方法");
        }
     
        public void m3() {
        
            System.out.println("我是S10.m3()方法");
        }
    }

来个Aspect类

package com.javacode2018.aop.demo9.test10;
     
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
     
    @Aspect
    public class AspectTest10 {
        
        //匹配目标方法声明的类上有@Anno10注解
        @Pointcut("@within(com.javacode2018.aop.demo9.test10.Ann10)")
        public void pc() {
        
        }
     
        @Before("pc()")
        public void beforeAdvice(JoinPoint joinPoint) {
        
            System.out.println(joinPoint);
        }
    }

测试用例

> S10为目标类，依次执行代理对象的m1、m2、m3方法，最终会调用目标类target中对应的方法。

@Test
    public void test10() {
        
        S10 target = new S10();
        AspectJProxyFactory proxyFactory = new AspectJProxyFactory();
        proxyFactory.setTarget(target);
        proxyFactory.addAspect(AspectTest10.class);
        S10 proxy = proxyFactory.getProxy();
        proxy.m1();
        proxy.m2();
        proxy.m3();
    }

运行输出

execution(void com.javacode2018.aop.demo9.test10.S10Parent.m1())
    我是S10Parent.m1()方法
    我是S10.m2()方法
    我是S10.m3()方法

分析结果

从输出中可以看出，只有m1方法被拦截了，其他2个方法没有被拦截。

确实是这样的，m1方法的是由S10Parent定义的，这个类上面有Ann10注解。

而m2方法虽然也在S10Parent中定义了，但是这个方法被子类S10重写了，所以调用目标对象中的m2方法的时候，此时发现m2方法是由S10定义的，而`S10.class.getAnnotation(Ann10.class)`为空，所以这个方法不会被拦截。

同样m3方法也是S10中定义的，也不会被拦截。

案例3

对案例2进行改造，在注解的定义上面加上`@Inherited`，此时子类可以继承父类的注解，此时3个方法都会被拦截了。

下面上代码，下面代码为案例2代码的一个拷贝，不同地方只是注解的定义上多了`@Inherited`

定义注解Ann11

import java.lang.annotation.*;
     
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    @Inherited
    public @interface Ann11 {
        
    }

2个父子类

package com.javacode2018.aop.demo9.test11;
     
    @Ann11
    class S11Parent {
        
     
        public void m1() {
        
            System.out.println("我是S11Parent.m1()方法");
        }
     
        public void m2() {
        
            System.out.println("我是S11Parent.m2()方法");
        }
    }
     
    public class S11 extends S11Parent {
        
     
        @Override
        public void m2() {
        
            System.out.println("我是S11.m2()方法");
        }
     
        public void m3() {
        
            System.out.println("我是S11.m3()方法");
        }
    }

Aspect类

package com.javacode2018.aop.demo9.test11;
     
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
     
    @Aspect
    public class AspectTest11 {
        
     
        @Pointcut("@within(com.javacode2018.aop.demo9.test11.Ann11)")
        public void pc() {
        
        }
     
        @Before("pc()")
        public void beforeAdvice(JoinPoint joinPoint) {
        
            System.out.println(joinPoint);
        }
    }

测试用例

@Test
    public void test11() {
        
        S11 target = new S11();
        AspectJProxyFactory proxyFactory = new AspectJProxyFactory();
        proxyFactory.setTarget(target);
        proxyFactory.addAspect(AspectTest11.class);
        S11 proxy = proxyFactory.getProxy();
        proxy.m1();
        proxy.m2();
        proxy.m3();
    }

运行输出

execution(void com.javacode2018.aop.demo9.test11.S11Parent.m1())
    我是S11Parent.m1()方法
    execution(void com.javacode2018.aop.demo9.test11.S11.m2())
    我是S11.m2()方法
    execution(void com.javacode2018.aop.demo9.test11.S11.m3())
    我是S11.m3()方法

> 这次3个方法都被拦截了。

#### 7、@target ####

用法

`@target(注解类型)`：判断目标对象target类型上是否有指定的注解；@target中注解类型也必须是全限定类型名。

匹配规则

target.class.getAnnotation(指定的注解类型) != null

2种情况可以匹配

*  注解直接标注在目标类上
 *  注解标注在父类上，但是注解必须是可以继承的，即定义注解的时候，需要使用`@Inherited`标注

案例1

**注解直接标注在目标类上，这种情况目标类会被匹配到。**

自定义一个注解`Ann6`

package com.javacode2018.aop.demo9.test6;
     
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
     
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    public @interface Ann6 {
        
    }

目标类`S6`上直接使用`@Ann1`

package com.javacode2018.aop.demo9.test6;
     
    @Ann6
    public class S6 {
        
        public void m1() {
        
            System.out.println("我是m1");
        }
    }

来个`Aspect`类

package com.javacode2018.aop.demo9.test6;
     
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
     
    @Aspect
    public class AspectTest6 {
        
        //@1：目标类上有@Ann1注解
        @Pointcut("@target(Ann1)")
        public void pc() {
        
        }
     
        @Before("pc()")
        public void beforeAdvice(JoinPoint joinPoint) {
        
            System.out.println(joinPoint);
        }
    }

测试代码

@Test
    public void test6() {
        
        S6 target = new S6();
        AspectJProxyFactory proxyFactory = new AspectJProxyFactory();
        proxyFactory.setTarget(target);
        proxyFactory.addAspect(AspectTest6.class);
        S6 proxy = proxyFactory.getProxy();
        proxy.m1();
        System.out.println("目标类上是否有 @Ann6 注解：" + (target.getClass().getAnnotation(Ann6.class) != null));
    }

运行输出

execution(void com.javacode2018.aop.demo9.test6.S6.m1())
    我是m1
    目标类上是否有 @Ann6 注解：true

案例2

**注解标注在父类上，注解上没有`@Inherited`，这种情况下，目标类无法匹配到，下面看代码**

注解Ann7

package com.javacode2018.aop.demo9.test7;
     
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
     
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    public @interface Ann7 {
        
    }

来2个父子类，父类上有`@Ann7`，之类`S7`为目标类

package com.javacode2018.aop.demo9.test7;
     
    import java.lang.annotation.Target;
     
    @Ann7
    class S7Parent {
        
    }
     
    public class S7 extends S7Parent {
        
        public void m1() {
        
            System.out.println("我是m1");
        }
     
        public static void main(String[] args) {
        
            System.out.println(S7.class.getAnnotation(Target.class));
        }
    }

来个Aspect类

package com.javacode2018.aop.demo9.test7;
     
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
     
    @Aspect
    public class AspectTest7 {
        
        /**
         * 匹配目标类上有Ann7注解
         */
        @Pointcut("@target(com.javacode2018.aop.demo9.test7.Ann7)")
        public void pc() {
        
        }
     
        @Before("pc()")
        public void beforeAdvice(JoinPoint joinPoint) {
        
            System.out.println(joinPoint);
        }
    }

测试代码

@Test
    public void test7() {
        
        S7 target = new S7();
        AspectJProxyFactory proxyFactory = new AspectJProxyFactory();
        proxyFactory.setTarget(target);
        proxyFactory.addAspect(AspectTest7.class);
        S7 proxy = proxyFactory.getProxy();
        proxy.m1();
        System.out.println("目标类上是否有 @Ann7 注解：" + (target.getClass().getAnnotation(Ann7.class) != null));
    }

运行输出

我是m1
    目标类上是否有 @Ann7 注解：false

分析结果

@Ann7标注在了父类上，但是@Ann7定义的时候没有使用`@Inherited`，说明之类无法继承父类上面的注解，所以上面的目标类没有被拦截，下面我们将`@Ann7`的定义改一下，加上`@Inherited`

package com.javacode2018.aop.demo9.test7;
     
    import java.lang.annotation.*;
     
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    @Inherited
    public @interface Ann7 {
        
    }

再次运行输出

execution(void com.javacode2018.aop.demo9.test7.S7.m1())
    我是m1
    目标类上是否有 @Ann7 注解：true

此时目标对象被拦截了。

#### 8、@args ####

用法

@args(注解类型)：方法参数所属的类上有指定的注解；注意不是参数上有指定的注解，而是参数类型的类上有指定的注解。

案例1

@Pointcut("@args(Ann8)")：匹配方法只有一个参数，并且参数所属的类上有Ann8注解

可以匹配下面的代码，m1方法的第一个参数类型是Car类型，Car类型上有注解Ann8

@Ann8
    class Car {
        
    }
     
    public void m1(Car car) {
        
        System.out.println("我是m1");
    }

案例2

@Pointcut("@args(*,Ann8)")：匹配方法只有2个参数，且第2个参数所属的类型上有Ann8注解

可以匹配下面代码

@Ann8
    class Car {
        
    }
     
    public void m1(String name,Car car) {
        
        System.out.println("我是m1");
    }

案例3

@Pointcut("@args(..,com.javacode2018.aop.demo9.test8.Ann8)")：匹配参数数量大于等于1，且最后一个参数所属的类型上有Ann8注解
    @Pointcut("@args(*,com.javacode2018.aop.demo9.test8.Ann8,..)")：匹配参数数量大于等于2，且第2个参数所属的类型上有Ann8注解
    @Pointcut("@args(..,com.javacode2018.aop.demo9.test8.Ann8,*)")：匹配参数数量大于等于2，且倒数第2个参数所属的类型上有Ann8注解

这个案例代码，大家自己写一下，体验一下。

#### 9、@annotation ####

用法

@annotation(注解类型)：匹配被调用的方法上有指定的注解。

案例

定义一个注解，可以用在方法上

package com.javacode2018.aop.demo9.test12;
     
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
     
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public @interface Ann12 {
        
    }

定义2个类

> S12Parent为父类，内部定义了2个方法，2个方法上都有@Ann12注解
> 
> S12是代理的目标类，也是S12Parent的子类，内部重写了m2方法，重写之后m2方法上并没有@Ann12注解，S12内部还定义2个方法m3和m4，而m3上面有注解@Ann12

package com.javacode2018.aop.demo9.test12;
     
    class S12Parent {
        
     
        @Ann12
        public void m1() {
        
            System.out.println("我是S12Parent.m1()方法");
        }
     
        @Ann12
        public void m2() {
        
            System.out.println("我是S12Parent.m2()方法");
        }
    }
     
    public class S12 extends S12Parent {
        
     
        @Override
        public void m2() {
        
            System.out.println("我是S12.m2()方法");
        }
     
        @Ann12
        public void m3() {
        
            System.out.println("我是S12.m3()方法");
        }
     
        public void m4() {
        
            System.out.println("我是S12.m4()方法");
        }
    }

来个Aspect类

> 当被调用的目标方法上有@Ann12注解的时，会被beforeAdvice处理。

package com.javacode2018.aop.demo9.test12;
     
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
     
    @Aspect
    public class AspectTest12 {
        
     
        @Pointcut("@annotation(com.javacode2018.aop.demo9.test12.Ann12)")
        public void pc() {
        
        }
     
        @Before("pc()")
        public void beforeAdvice(JoinPoint joinPoint) {
        
            System.out.println(joinPoint);
        }
    }

测试用例

> S12作为目标对象，创建代理，然后分别调用4个方法

@Test
    public void test12() {
        
        S12 target = new S12();
        AspectJProxyFactory proxyFactory = new AspectJProxyFactory();
        proxyFactory.setTarget(target);
        proxyFactory.addAspect(AspectTest12.class);
        S12 proxy = proxyFactory.getProxy();
        proxy.m1();
        proxy.m2();
        proxy.m3();
        proxy.m4();
    }

运行输出

execution(void com.javacode2018.aop.demo9.test12.S12Parent.m1())
    我是S12Parent.m1()方法
    我是S12.m2()方法
    execution(void com.javacode2018.aop.demo9.test12.S12.m3())
    我是S12.m3()方法
    我是S12.m4()方法

分析结果

m1方法位于S12Parent中，上面有@Ann12注解，被连接了，m3方法上有@Ann12注解，被拦截了，而m4上没有@Ann12注解，没有被拦截，这3个方法的执行结果都很容易理解。

重点在于m2方法的执行结果，没有被拦截，m2方法虽然在S12Parent中定义的时候也有@Ann12注解标注，但是这个方法被S1给重写了，在S1中定义的时候并没有@Ann12注解，代码中实际上调用的是S1中的m2方法，发现这个方法上并没有@Ann12注解，所以没有被拦截。

#### 10、bean ####

用法

bean(bean名称)：这个用在spring环境中，匹配容器中指定名称的bean。

案例

来个类BeanService

package com.javacode2018.aop.demo9.test13;
     
    public class BeanService {
        
        private String beanName;
     
        public BeanService(String beanName) {
        
            this.beanName = beanName;
        }
     
        public void m1() {
        
            System.out.println(this.beanName);
        }
    }

来个Aspect类

package com.javacode2018.aop.demo9.test13;
     
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.stereotype.Component;
     
    @Aspect
    public class Aspect13 {
        
        //拦截spring容器中名称为beanService2的bean
        @Pointcut("bean(beanService2)")
        public void pc() {
        
        }
     
        @Before("pc()")
        public void beforeAdvice(JoinPoint joinPoint) {
        
            System.out.println(joinPoint);
        }
    }

来个spring配置类

package com.javacode2018.aop.demo9.test13;
     
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.EnableAspectJAutoProxy;
     
    @Configuration
    @EnableAspectJAutoProxy // 这个可以启用通过AspectJ方式自动为符合条件的bean创建代理
    public class MainConfig13 {
        
     
        //将Aspect13注册到spring容器
        @Bean
        public Aspect13 aspect13() {
        
            return new Aspect13();
        }
     
        @Bean
        public BeanService beanService1() {
        
            return new BeanService("beanService1");
        }
     
        @Bean
        public BeanService beanService2() {
        
            return new BeanService("beanService2");
        }
    }

> 这个配置类中有个`@EnableAspectJAutoProxy`，这个注解大家可能比较陌生，这个属于aop中自动代理的范围，后面会有文章详细介绍这块，这里大家暂时先不用关注。

测试用例

> 下面启动spring容器，加载配置类MainConfig13，然后分别获取beanService1和beanService2，调用他们的m1方法，看看效果

@Test
    public void test13() {
        
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig13.class);
        //从容器中获取beanService1
        BeanService beanService1 = context.getBean("beanService1", BeanService.class);
        beanService1.m1();
        //从容器中获取beanService2
        BeanService beanService2 = context.getBean("beanService2", BeanService.class);
        beanService2.m1();
    }

运行输出

beanService1
    execution(void com.javacode2018.aop.demo9.test13.BeanService.m1())
    beanService2

> beanService2的m1方法被拦截了。

#### 11、reference pointcut ####

表示引用其他命名切入点。

有时，我们可以将切入专门放在一个类中集中定义。

其他地方可以通过引用的方式引入其他类中定义的切入点。

语法如下：

@Pointcut("完整包名类名.方法名称()")

> 若引用同一个类中定义切入点，包名和类名可以省略，直接通过方法就可以引用。

比如下面，我们可以将所有切入点定义在一个类中

package com.javacode2018.aop.demo9.test14;
     
    import org.aspectj.lang.annotation.Pointcut;
     
    public class AspectPcDefine {
        
        @Pointcut("bean(bean1)")
        public void pc1() {
        
        }
     
        @Pointcut("bean(bean2)")
        public void pc2() {
        
        }
    }

下面顶一个一个Aspect类，来引用上面的切入点

package com.javacode2018.aop.demo9.test14;
     
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
     
    @Aspect
    public class Aspect14 {
        
     
        @Pointcut("com.javacode2018.aop.demo9.test14.AspectPcDefine.pc1()")
        public void pointcut1() {
        
        }
     
        @Pointcut("com.javacode2018.aop.demo9.test14.AspectPcDefine.pc1() || com.javacode2018.aop.demo9.test14.AspectPcDefine.pc2()")
        public void pointcut2() {
        
        }
     
    }

![img][img 6]

#### 12、组合型的pointcut ####

Pointcut定义时，还可以使用&&、||、!运算符。

*  &&：多个匹配都需要满足
 *  ||：多个匹配中只需满足一个
 *  !：匹配不满足的情况下

@Pointcut("bean(bean1) || bean(bean2)") //匹配bean1或者bean2
    @Pointcut("@target(Ann1) && @Annotation(Ann2)") //匹配目标类上有Ann1注解并且目标方法上有Ann2注解
    @Pointcut("@target(Ann1) && !@target(Ann2)") // 匹配目标类上有Ann1注解但是没有Ann2注解

### 总结 ###

本文详解了@Pointcut的12种用法，案例大家一定要敲一遍，敲的过程中，会遇到问题，然后解决问题，才能够加深理解。

有问题的也欢迎大家留言交流，谢谢！

![img][img 7]

### Spring系列 ###

1.  [Spring系列第1篇：为何要学spring？][Spring_1_spring]
2.  [Spring系列第2篇：控制反转（IoC）与依赖注入（DI）][Spring_2_IoC_DI]
3.  [Spring系列第3篇：Spring容器基本使用及原理][Spring_3_Spring]
4.  [Spring系列第4篇：xml中bean定义详解(-)][Spring_4_xml_bean_-]
5.  [Spring系列第5篇：创建bean实例这些方式你们都知道？][Spring_5_bean]
6.  [Spring系列第6篇：玩转bean scope，避免跳坑里！][Spring_6_bean scope]
7.  [Spring系列第7篇：依赖注入之手动注入][Spring_7]
8.  [Spring系列第8篇：自动注入（autowire）详解，高手在于坚持][Spring_8_autowire]
9.  [Spring系列第9篇：depend-on到底是干什么的？][Spring_9_depend-on]
10. [Spring系列第10篇：primary可以解决什么问题？][Spring_10_primary]
11. [Spring系列第11篇：bean中的autowire-candidate又是干什么的？][Spring_11_bean_autowire-candidate]
12. [Spring系列第12篇：lazy-init：bean延迟初始化][Spring_12_lazy-init_bean]
13. [Spring系列第13篇：使用继承简化bean配置(abstract & parent)][Spring_13_bean_abstract _ parent]
14. [Spring系列第14篇：lookup-method和replaced-method比较陌生，怎么玩的？][Spring_14_lookup-method_replaced-method]
15. [Spring系列第15篇：代理详解（Java动态代理&cglib代理）？][Spring_15_java_CGLIB]
16. [Spring系列第16篇：深入理解java注解及spring对注解的增强（预备知识）][Spring_16_java_spring]
17. [Spring系列第17篇：@Configration和@Bean注解详解(bean批量注册)][Spring_17_Configration_Bean_bean]
18. [Spring系列第18篇：@ComponentScan、@ComponentScans详解(bean批量注册)][Spring_18_ComponentScan_ComponentScans_bean]
19. [Spring系列第18篇：@import详解(bean批量注册)][Spring_18_import_bean]
20. [Spring系列第20篇：@Conditional通过条件来控制bean的注册][Spring_20_Conditional_bean]
21. [Spring系列第21篇：注解实现依赖注入（@Autowired、@Resource、@Primary、@Qulifier）][Spring_21_Autowired_Resource_Primary_Qulifier]
22. [Spring系列第22篇：@Scope、@DependsOn、@ImportResource、@Lazy 详解][Spring_22_Scope_DependsOn_ImportResource_Lazy]
23. [Spring系列第23篇：Bean生命周期详解][Spring_23_Bean]
24. [Spring系列第24篇：父子容器详解][Spring_24]
25. [Spring系列第25篇：@Value【用法、数据来源、动态刷新】][Spring_25_Value]
26. [Spring系列第26篇：国际化详解][Spring_26]
27. [Spring系列第27篇：spring事件机制详解][Spring_27_spring]
28. [Spring系列第28篇：Bean循环依赖详解][Spring_28_Bean]
29. [Spring系列第29篇：BeanFactory扩展（BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor）][Spring_29_BeanFactory_BeanFactoryPostProcessor_BeanDefinitionRegistryPostProcessor]
30. [Spring系列第30篇：jdk动态代理和cglib代理][Spring_30_jdk_cglib 1]
31. [Spring系列第31篇：aop概念详解][Spring_31_aop]
32. [Spring系列第32篇：AOP核心源码、原理详解][Spring_32_AOP 1]
33. [Spring系列第33篇：ProxyFactoryBean创建AOP代理][Spring_33_ProxyFactoryBean_AOP 1]

[Spring_15_java_CGLIB]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&chksm=88621efcbf1597eab943b064147b8fb8fd3dfbac0dc03f41d15d477ef94b60d4e8f78c66b262&idx=1&lang=zh_CN&mid=2648934082&scene=21&sn=c919886400135a0152da23eaa1f276c7&token=1042984313#wechat_redirect
[Spring_30_jdk_cglib]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&chksm=88621141bf159857bc19d7bb545ed3ddc4152dcda9e126f27b83afc2e975dee1682de2d98ad6&idx=1&lang=zh_CN&mid=2648934783&scene=21&sn=5531f14475a4addc6d4d47f0948b3208&token=1672930952#wechat_redirect
[Spring_31_Aop]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&chksm=886211e2bf1598f4e0e636170a4b36a5a5edd8811c8b7c30d61135cb114b0ce506a6fa84df0b&idx=1&lang=zh_CN&mid=2648934876&scene=21&sn=7794b50e658e0ec3e0aff6cf5ed4aa2e&token=1672930952#wechat_redirect
[Spring_32_AOP]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&idx=1&mid=2648934930&scene=21&sn=4030960657cc72006122ef8b6f0de889#wechat_redirect
[Spring_33_ProxyFactoryBean_AOP]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&idx=1&mid=2648934977&scene=21&sn=8e4caf6a17bf5e123884df81a6382214#wechat_redirect
[img]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL3N6X21tYml6X3BuZy94aWNFSmhXbEswNkJpYjE1QmJnTGtXZk1wT2hXTVlkRGM3REU2R2JjckFDeGVCdjB4QUFxekxOTkRaRUVnb1cwdzhVckxRQWtWc1BQMzdjcW9RMmhZSHhnLzY0MA?x-oss-process=image/format,png
[img 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL3N6X21tYml6X3BuZy94aWNFSmhXbEswNkJpYjE1QmJnTGtXZk1wT2hXTVlkRGM3ZjBmYk1MNlByYmJNeUdCWTZ2ekdaaWFBSXpMaWFFZ2xMbnJjUVJiTmxJN2xOQzJkQzg1ZkRGWXcvNjQw?x-oss-process=image/format,png
[img 2]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL3N6X21tYml6X3BuZy94aWNFSmhXbEswNkJpYjE1QmJnTGtXZk1wT2hXTVlkRGM3VjNsazNSRjROeXNqYVFBSTNRYU9lVnkwOXlBbFE5c1lpYjhEcTFLM0J3M1pnNmcyMmQ1RkNHdy82NDA?x-oss-process=image/format,png
[img 3]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL3N6X21tYml6X3BuZy94aWNFSmhXbEswNkJpYjE1QmJnTGtXZk1wT2hXTVlkRGM3WXBBM1VoRTJMaWJLQTJXNU9tZGJleHhIWVFzakc5ZnEwc3BCY2liQlR2cExQNmljY1NZU1lpY0VzZy82NDA?x-oss-process=image/format,png
[img 4]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL3N6X21tYml6X3BuZy94aWNFSmhXbEswNkJpYjE1QmJnTGtXZk1wT2hXTVlkRGM3WGVNekZWWW1pY3RZanlxZW0wUVlzMGZ3UlVZU3hkTmpvcnlCcDM5ZEFqNXZ6NEh6SmhENHdldy82NDA?x-oss-process=image/format,png
[img 5]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL3N6X21tYml6X3BuZy94aWNFSmhXbEswNkJpYjE1QmJnTGtXZk1wT2hXTVlkRGM3eGJNaWFMVjVTQ2ljMk5VNURPOWliZ005aEtDR3dKUktrTGNvaWJQS2Q3ZmlhaFk5aEZkMmliTUpRak5BLzY0MA?x-oss-process=image/format,png
[img 6]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL3N6X21tYml6X3BuZy94aWNFSmhXbEswNkJpYjE1QmJnTGtXZk1wT2hXTVlkRGM3c2lhRFo2OTFsSjBpY0ZmQnhHN0ttcWMweER5eFJiY2FNV1QzOHJVOXpuWFFLTlhuNGhrUGN6WHcvNjQw?x-oss-process=image/format,png
[img 7]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL3N6X21tYml6X3BuZy94aWNFSmhXbEswNkJpYjE1QmJnTGtXZk1wT2hXTVlkRGM3VW9aZ05LN1FMU05TZVFPZWxPQTFVaWNNSlBrWWFnWmliTnhyaWNSQ2liaWN4M0VJcGd2RnR4c2dEeFEvNjQw?x-oss-process=image/format,png
[Spring_1_spring]: https://blog.csdn.net/likun557/article/details/104177877
[Spring_2_IoC_DI]: https://blog.csdn.net/likun557/article/details/104218177
[Spring_3_Spring]: https://blog.csdn.net/likun557/article/details/104243424
[Spring_4_xml_bean_-]: https://blog.csdn.net/likun557/article/details/104284839
[Spring_5_bean]: https://blog.csdn.net/likun557/article/details/104284840
[Spring_6_bean scope]: https://blog.csdn.net/likun557/article/details/104284841
[Spring_7]: https://blog.csdn.net/likun557/article/details/104322440
[Spring_8_autowire]: https://blog.csdn.net/likun557/article/details/104337827
[Spring_9_depend-on]: https://blog.csdn.net/likun557/article/details/104368546
[Spring_10_primary]: https://blog.csdn.net/likun557/article/details/104404333
[Spring_11_bean_autowire-candidate]: https://blog.csdn.net/likun557/article/details/104438417
[Spring_12_lazy-init_bean]: https://blog.csdn.net/likun557/article/details/104623980
[Spring_13_bean_abstract _ parent]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&chksm=88621e91bf159787351880d2217b9f3fb7b06d251caa32995657cd2ca9613765bf87ff7e04a0&idx=1&lang=zh_CN&mid=2648934063&scene=21&sn=d529258a955ed5b53c9081219c8391e7&token=1656183666#wechat_redirect
[Spring_14_lookup-method_replaced-method]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&chksm=88621e84bf1597923127e459e11da5c27741f080a0bfd033019ccc52cf67915ec4999d76b6dd&idx=1&lang=zh_CN&mid=2648934074&scene=21&sn=5b7ccbef079053d9af4027f0dc642c56&token=1283885571#wechat_redirect
[Spring_16_java_spring]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&chksm=88621ef1bf1597e756ccaeb6c6c6f4b74c6e3ba22ca6adba496b05e81558cd3801c62b21b8d9&idx=1&lang=zh_CN&mid=2648934095&scene=21&sn=26d539ef61389bae5d293f1b2f5210b2&token=1042984313#wechat_redirect
[Spring_17_Configration_Bean_bean]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&chksm=88621ec7bf1597d1b16d91cfb28e63bef485f10883c7ca30d09838667f65e3d214b9e1cebd47&idx=1&lang=zh_CN&mid=2648934137&scene=21&sn=3775d5d7a23c43616d1274b0b52a9f99&token=1372043037#wechat_redirect
[Spring_18_ComponentScan_ComponentScans_bean]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&chksm=88621f38bf15962e324888161d0b91f34c26e4b8a53da87f1364e5af7010dbdcabc9fb555476&idx=1&lang=zh_CN&mid=2648934150&scene=21&sn=6e466720d78f212cbd7d003bc5c2eec2&token=1346356013#wechat_redirect
[Spring_18_import_bean]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&chksm=88621f23bf15963589f06b7ce4e521a7c8d615b1675788f383cbb0bcbb05b117365327e1941a&idx=1&lang=zh_CN&mid=2648934173&scene=21&sn=60bb7d58fd408db985a785bfed6e1eb2&token=704646761#wechat_redirect
[Spring_20_Conditional_bean]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&chksm=88621f03bf1596159eeb40d75620db03457f4aa831066052ebc6e1efc2d7b18802a49a7afe8a&idx=1&lang=zh_CN&mid=2648934205&scene=21&sn=5407aa7c49eb34f7fb661084b8873cfe&token=332995799#wechat_redirect
[Spring_21_Autowired_Resource_Primary_Qulifier]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&chksm=88621f66bf159670a8268f8db74db075634a24a58b75589e4e7db2f06e6166c971074feae764&idx=1&lang=zh_CN&mid=2648934232&scene=21&sn=fd2f34d8d1342fe819c5a71059e440a7&token=979575345#wechat_redirect
[Spring_22_Scope_DependsOn_ImportResource_Lazy]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&chksm=88621fb2bf1596a41563db5c474873c62d552ec9a440037d913704f018742ffca9be9b598680&idx=1&lang=zh_CN&mid=2648934284&scene=21&sn=00126ad4b435cb31726a5ef10c31af25&token=887127000#wechat_redirect
[Spring_23_Bean]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&chksm=88621f8cbf15969af1c5396903dcce312c1f316add1af325327d287e90be49bbeda52bc1e736&idx=1&lang=zh_CN&mid=2648934322&scene=21&sn=647edffeedeb8978c18ad403b1f3d8d7&token=718443976#wechat_redirect
[Spring_24]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&chksm=88621fd0bf1596c6c9f60c966eb325c6dfe0e200666ee0bcdd1ff418597691795ad209e444f2&idx=1&lang=zh_CN&mid=2648934382&scene=21&sn=7d37aef61cd18ec295f268c902dfb84f&token=749715143#wechat_redirect
[Spring_25_Value]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&chksm=8862103fbf15992981183abef03b4774ab1dfd990a203a183efb8d118455ee4b477dc6cba50d&idx=1&lang=zh_CN&mid=2648934401&scene=21&sn=98e726ec9adda6d40663f624705ba2e4&token=636643900#wechat_redirect
[Spring_26]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&chksm=8862106abf15997c39a3387ce7b2e044cfb3abd92b908eb0971d084c8238ff5f99af412d6054&idx=1&lang=zh_CN&mid=2648934484&scene=21&sn=ef0a704c891f318a7c23fe000d9003d5&token=1299257585#wechat_redirect
[Spring_27_spring]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&chksm=88621044bf15995257129e33068f66fc5e39291e159e5e0de367a14e0195595c866b3aaa1972&idx=1&lang=zh_CN&mid=2648934522&scene=21&sn=7653141d01b260875797bbf1305dd196&token=1081910573#wechat_redirect
[Spring_28_Bean]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&idx=1&mid=2648934550&scene=21&sn=2cf05f53a63d12f74e853a10a11dcc98#wechat_redirect
[Spring_29_BeanFactory_BeanFactoryPostProcessor_BeanDefinitionRegistryPostProcessor]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&chksm=886210c1bf1599d7c42919a8b883a7cd2dd8e42212627a32e6d91dfb1f6da1b9536079ec4f6d&idx=1&lang=zh_CN&mid=2648934655&scene=21&sn=5b6c360de7eda0ca83d38e9db3616761&token=1804011114#wechat_redirect
[Spring_30_jdk_cglib 1]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&chksm=88621141bf159857bc19d7bb545ed3ddc4152dcda9e126f27b83afc2e975dee1682de2d98ad6&idx=1&lang=zh_CN&mid=2648934783&scene=21&sn=5531f14475a4addc6d4d47f0948b3208&token=690771459#wechat_redirect
[Spring_31_aop]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&chksm=886211e2bf1598f4e0e636170a4b36a5a5edd8811c8b7c30d61135cb114b0ce506a6fa84df0b&idx=1&lang=zh_CN&mid=2648934876&scene=21&sn=7794b50e658e0ec3e0aff6cf5ed4aa2e&token=690771459#wechat_redirect
[Spring_32_AOP 1]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&chksm=8862122cbf159b3a4823a7f6b93add5ae1ad0e60cdedf8ed2d558c0f67bd6b0158a900d270eb&idx=1&mid=2648934930&scene=21&sn=4030960657cc72006122ef8b6f0de889#wechat_redirect
[Spring_33_ProxyFactoryBean_AOP 1]: https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ%3D%3D&chksm=8862127fbf159b699c4456afe35a17f0d7bed119a635b11c154751dd95f59917487c895ccb84&idx=1&mid=2648934977&scene=21&sn=8e4caf6a17bf5e123884df81a6382214#wechat_redirect