Spring框架-AOP

1.什么是AOP？

• 面向切面编程，可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率
• 通过不修改源代码方式，在主干功能里面添加新功能

---

2.底层原理

• 底层使用动态代理：

  • 有接口的情况，使用 JDK 动态代理：创建接口的实现类的代理对象，通过代理对象实现方法的增强

  // 存在的接口
  public interface UserDao {
      public void login();
  }
  // 接口的实现类
  public class UserDaoImpl implements UserDao {
      // 原始方法
      @Override
      public void login() {
          System.out.println("实现登录功能");
          System.out.println("对代码增强");
      }
  }
  

  • 没有接口的情况，使用 cglib 动态代理：创建当前类的子类的代理对象，通过代理对象实现方法的增强

  // 当前的类
  public class Emp {
      public void add(){
          System.out.println("原始功能的实现");
      }
  }
  // 当前类的子类
  public class EmpMen extends Emp{
      // 原始方法
      @Override
      public void add() {
          super.add();
          System.out.println("对功能的增强");
      }
  }
  

2.1 JDK 动态代理

• 使用 Proxy 类里面的方法创建代理对象：调用 newProxyInstance 方法，方法中的参数如下：

  • 类加载器
  • 增强方法所在的类实现的接口，支持多个接口
  • 实现接口 InvocationHandler，创建代理对象，写增强的部分

• 编写 JDK 动态代理代码：

  1. 创建接口，定义方法：

  public interface UserDao {
      public int add(int a,int b);
      public String update(String id);
  }
  

  2. 创建接口实现类，实现方法：

  public class UserDaoImpl implements UserDao {
      @Override
      public int add(int a, int b) {
          return a+b;
      }
      @Override
      public String update(String id) {
          return id;
      }
  }
  

  3. 使用 Proxy 类创建接口代理对象：

  public class JDKProxy {
      public static void main(String[] args) {
          //创建接口实现类代理对象
          Class[] interfaces = {UserDao.class};
          // 创建接口的实现类
          UserDaoImpl userDao = new UserDaoImpl();
          UserDao dao = (UserDao)Proxy.newProxyInstance
              (JDKProxy.class.getClassLoader(),interfaces,new UserDaoProxy(userDao));
          int result = dao.add(1, 2);  // 调用哪个方法就对哪个方法实现增强
          System.out.println("result:"+result);
      }
  }
  // 创建代理对象
  class UserDaoProxy implements InvocationHandler {
      // 创建的是谁的代理对象就把谁传递过来(通过有参数构造传递）
      private Object obj;
      public UserDaoProxy(Object obj) {
          this.obj = obj;
      }
  
      // 增强的代码
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
          //执行原始方法代码之前增强的功能
          System.out.println("方法之前执行...."+method.getName()+" :传递的参数..."+ Arrays.toString(args));
          //被增强的方法执行
          Object res = method.invoke(obj, args);
          //执行完原始方法代码之后增强的功能
          System.out.println("方法之后执行...."+obj);
          return res;
      }
  }
  // 输出：
  // 方法之前执行....add :传递的参数...[1, 2]
  // 方法之后执行....com.psj.AOP.UserDaoImpl@153f5a29
  // result:3
  

---

3.AOP术语

• 连接点：类中哪些方法可以被增强，这些方法被称为连接点
• 切入点：实际被真正增强的方法
• 通知(增强)：实际增强方法中的逻辑部分(即新加入的代码)。通知有多个类型(假设切入点为add方法)：
  • 前置通知：在add方法执行前执行的代码
  • 后置通知：在add方法执行后执行的代码，有异常就不会执行
  • 环绕通知：在add方法执行前以及执行后执行的代码
  • 异常通知：当执行add方法出现异常时会执行的代码
  • 最终通知：类似于try-catch-finally中的finally代码块。如果add方法出现异常，则后置通知就不会执行，但是最终通知还是会执行(但是并不意味着最终通知是最后执行的，没有异常时后置通知是最后执行的。和try-catch-finally一样先执行完finally代码块再执行try中的return语句)
• 切面：把通知应用到切入点的过程，是一个动作

---

4.AOP 操作

4.1 准备工作

• 引入AOP的依赖：在Spring中有多种方式实现AOP的操作，但是一般使用AspectJ。它不是Spring 组成部分，是一个独立于Spring的AOP 框架，一般把AspectJ和Spirng框架一起使用
• 切入点表达式：知道对哪个类里面的哪个方法进行增强
  • 语法：execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )
  • 举例 ：
    • 对 com.psj.dao.BookDao 类里面的 add 进行增强：execution(* com.psj.dao.BookDao.add(..))。其中*表示任意的权限修饰符，返回类型可以省略，..表示add方法的参数
    • 对 com.psj.dao.BookDao 类里面的所有的方法进行增强：execution(* com.atguigu.dao.BookDao.* (..))。其中第二个*表示对BookDao下的所有方法增强
    • 对 com.psj.dao 包里面所有类，类里面所有方法进行增强：execution(* com.atguigu.dao.*.*(..))
• 需要导入的包：
  • spring-aspects-xxx.jar
  • com.springsource.net.sf.cglib-xxx.jar
  • com.springsource.org.aopalliance-xxx.jar
  • com.springsource.org.aspectj.weaver-xxx.jar

4.2 AspectJ 注解

1. 创建被增强的类：

public class User {
    public void add() {
        System.out.println("add.......");
    }
}

2. 创建增强类：在增强类里面创建方法，让不同方法代表不同通知类型

public class UserProxy {
    public void before() {//前置通知
        System.out.println("before......");
    }
}

3. 进行通知的配置(采用注解方式)：

   • 开启注解扫描：

   # 要加上名称空间
   <context:component-scan base-package="com.psj"></context:component-scan>
   

   • 使用注解创建 User 和 UserProxy 对象，并在增强类UserProxy 上面添加注解 @Aspect：：

   @Component 
   public class User {
       public void add() {
           System.out.println("add.......");
       }
   }
   @Component
   @Aspect // 表示生成代理对象
   public class UserProxy {
       public void before() {//前置通知
           System.out.println("before......");
       }
   }
   

   • 在 spring 配置文件中开启生成代理对象：

   <!-- 开启 Aspect 生成代理对象，其实就是看创建的对象上是否有@AspectJ，有的话就创建代理对象-->
   <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
   

4. 配置不同类型的通知：在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置

@Component
@Aspect // 表示生成代理对象
public class UserProxy {
    //前置通知
    //@Before 注解表示作为前置通知
    @Before(value = "execution(* com.psj.AOP.User.add(..))")
    public void before() {
        System.out.println("before.........");
    }
    //后置通知（返回通知，执行完return语句后执行）
    @AfterReturning(value = "execution(* com.psj.AOP.User.add(..))")
    public void afterReturning() {
        System.out.println("afterReturning.........");
    }
    //最终通知
    @After(value = "execution(* com.psj.AOP.User.add(..))")
    public void after() {
        System.out.println("after.........");
    }
    //异常通知
    @AfterThrowing(value = "execution(* com.psj.AOP.User.add(..))")
    public void afterThrowing() {
        System.out.println("afterThrowing.........");
    }
    //环绕通知
    @Around(value = "execution(* com.psj.AOP.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前.........");
        //执行被增强的方法，即add方法
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后.........");
    }
}
// 测试：
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
User user = context.getBean("user", User.class);
user.add();
// 输出：
// 当add方法正常执行时
环绕之前.........
before.........
add.......
环绕之后.........
after.........
afterReturning.........
// 当add方法出现异常时
环绕之前.........
before.........
after.........
afterThrowing.........

tips:

• 后置通知在出现异常时不会执行时因为像try-catch-finally代码块中，出现异常后不会再执行try中的下面的代码(即执行不到add方法的return语句，也就不会执行到后置通知)
• 在上述通知中切入点都是一样的，所以会出现重复的切入点声明代码，可以将相同的切入点抽取出来：

@Pointcut(value = "execution(* com.psj.AOP.User.add(..))")
public void pointDemo(){
}
@Before(value = "pointDemo()")
public void before() {
    System.out.println("before.........");
}

• 假设有多个增强类对add方法做增强，可以设置优先级决定先执行哪个增强类的增强代码(所有增强类的增强代码都会执行，只不过决定哪个先执行)：

@Component
@Aspect
@Order(1)  // 值越小，优先级越高
public class UserProxy2 {
    @Pointcut(value = "execution(* com.psj.AOP.User.add(..))")
    public void pointDemo(){
    }
    @Before(value = "pointDemo()")
    public void before() {
        System.out.println("another before.........");
    }
}

• 如果采取完全注解方式，需要将bean.xml中的配置信息改为在config类上加注解：

@Configuration
@ComponentScan(basePackages = {"com.psj"})  // 替代开启注解扫描
@EnableAspectJAutoProxy(proxyTargetClass = true)  // 替代开启Aspect生成代理对象
public class configAop {
}

4.3 AspectJ 配置文件

1. 创建增强类和被增强类以及被增强的方法
2. 在 spring 配置文件中创建两个类对象：

<bean id="user" class="com.psj.AOP.User"></bean>
<bean id="userProxy" class="com.psj.AOP.UserProxy"></bean>

3. 在 spring 配置文件中配置切入点：

<!--配置 aop 增强-->
<aop:config>
    <!--切入点-->
    <aop:pointcut id="p" expression="execution(* com.psj.AOP.User.add(..))"/>
    <!--配置切面-->
    <aop:aspect ref="userProxy">
        <!--增强作用在具体的方法上-->
        <aop:before method="before" pointcut-ref="p"/>
    </aop:aspect>
</aop:config>

---