对照上图,来对应每一个区域,看看其具体含义

• 首先有一个bank银行类

  package com.lxl.www.aop.bank;
  
  interface Bank {
  
    */
    Float save(Account account, money) ;
  
    
    Float withdraw(Account account,1)"> money);
  };

   

   

• 有一个银行类的实现方法. 这里面save,withdraw就是连接点. 最终会将各种通知插入到连接点中

  package com.lxl.www.aop.bank;
  
  import org.springframework.stereotype.Service;
  
  *
   * 工商银行
   *
   *
   * DATE 2020/12/6.
   *
   * @author lxl.
   
  @Service
   IcbcBank implements Bank{
      @Override
      public Float save(Account account,1)">float money) {
          // 主业务逻辑: 增加account账户的钱数，返回账户里当前的钱数
          System.out.println(account.getName() + "账户存入" + money);
          ;
      }
  
      @Override
      public Float withdraw(Account account,1)"> 主业务逻辑: 减少account账户的钱数，返回取出的钱数
          System.账户取出;
      }
  }

   

   

• 接下来,要有一个切面,切面是一个类. 切面类里面定义了切点,通知,引用

  package com.lxl.www.aop.bank;
  
  import org.aspectj.lang.JoinPoint;
  import org.aspectj.lang.annotation.After;
  import org.aspectj.lang.annotation.AfterReturning;
  import org.aspectj.lang.annotation.AfterThrowing;
  import org.aspectj.lang.annotation.Aspect;
  import org.aspectj.lang.annotation.Before;
  import org.aspectj.lang.annotation.DeclareParents;
  import org.aspectj.lang.annotation.Pointcut;
  import org.springframework.core.annotation.Order;
  import org.springframework.stereotype.Component;
  
  *
   * 切面
   
  @Aspect  标记这是一个切面
  @Order
  @Component  将其放到ioc容器管理
   BankLogAspect {
  
    引入
     *
     * 这段话可以理解为,为com.lxl.www.aop.bank.IcbcBank 引入了一个接口 EnhanceFunctionOfBank,* 同时,引入了默认的实现类 IcbcEnhanceFunctionOfBank
     
    @DeclareParents(value = com.lxl.www.aop.bank.IcbcBank",1)"> 引入的目标类. 也就是需要引入动态实现的类
            defaultImpl = IcbcEnhanceFunctionOfBank.class)  引入的接口的默认实现
    static EnhanceFunctionOfBank enhanceFunctionOfBank;  引入的接口
  
  
    *
     * 定义一个切点
     
    @Pointcut(execution(* com.lxl.www.aop.bank.IcbcBank.*(..))")
    void pointCut() {}
  
    前置通知
     * @param joinPoint
     
    @Before(value = pointCut() beforeAdvice(JoinPoint joinPoint) {
      String methodName = joinPoint.getSignature().getName();
      System.out.println(执行目标方法"+methodName+的前置通知);
    }
  
    *
     * 定义了一个后置通知
     
    @After(value =  afterAdvice(JoinPoint joinPoint) {
      String methodName =的后置通知返回通知
     
    @AfterReturning(value = result returningAdvice(JoinPoint joinPoint,Object result) {
      String methodName =的返回通知异常通知
     
    @AfterThrowing(value =  throwingAdvice(JoinPoint joinPoint) {
      String methodName =的异常通知);
    }
  
  }

  那么这里的目标对象是谁呢? 就是我们的IcbcBank类. 这里需要注意的是引入: 引入的概念是将一个接口动态的让另一个类实现了. 这样实现了接口的类,就可以动态的拥有接口实现类的功能.

• 银行的额外功能. 也就是银行除了可以存钱,取钱. 还有一个额外的功能. 比如理财. 不是每个银行都有的. 

  *
   * 增强的功能
   */
   EnhanceFunctionOfBank {
  
       Financialanagement(Account account);
  }

   

• 具体银行额外功能的实现类

  *
   * Description
    IcbcEnhanceFunctionOfBank implements EnhanceFunctionOfBank {
      *
       * 理财功能
       * @param account
       
      @Override
       Financialanagement(Account account) {
          System.out.println(account.getName() +的账户 增加 理财功能);
      }
  
  }

  这个功能我们可以通过引入,动态增加到IcbcBank类中,原本IcbcBank只有存钱和取钱的功能. 这样,就可以增加理财功能了. 这就是引入.

• 整体配置类

  package com.lxl.www.aop.bank;
  
  import org.springframework.beans.factory.annotation.Configurable;
  import org.springframework.context.annotation.ComponentScan;
  import org.springframework.context.annotation.EnableAspectJAutoProxy;
  
  @Configurable
  // 使用注解的方式引入AOP
  @EnableAspectJAutoProxy
  @ComponentScan(com.lxl.www.aop.bank)
   BankMainConfig {
  
  }

   

  使用aop,需要引入AOP,这里使用的注解的方式引入的.