【Spring】3、AOP

AOP（概念）

1. 什么是 AOP ？

   • Aspect Oriented Programming，面向切面（方面）编程，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

   • 通俗描述，不通过修改源代码方式，在主干功能里面添加新功能

   • 使用登录例子说明 AOP：
     

AOP（底层原理）

AOP 底层使用动态代理：

有两种情况的动态代理

第一种 有接口情况，使用 JDK 动态代理

• 创建接口实现类代理对象，增强类的方法
  

第二种 没有接口的情况，使用 CGLIB 动态代理

• 创建子类的代理对象，增强子类的代理方法
  

AOP（JDK 动态代理）

使用 JDK 动态代理，需要使用 Proxy 类里面的方法创建代理对象

• 在 java.lang.reflect 里有 Proxy 类，调用这个类的 newProxyInstance 方法

Modifier and Type	Method and Description
static Object	newProxyInstance(ClassLoader loader, 类<?>[] interfaces, InvocationHandler h) 返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。

该方法有三个参数：

• 第一个参数：类加载器
• 第二个参数：增强方法所在类所实现的接口，支持多个接口
• 第三个参数：实现这个接口 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) {
           System.out.println("add方法执行了...");
           return a+b;
       }
   
       @Override
       public String update(String id) {
           System.out.println("update方法执行了...");
           return id;
       }
   }
   

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

   public class JDKProxy {
       public static void main(String[] args) {
           //创建接口实现类的代理对象
           Class[] interfaces = {UserDao.class};
   
           /*  匿名内部类的写法，（需要更改）
           *   Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
               @Override
               public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                   return null;
               }
           });*/
   
           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);
           String resultId = dao.update("123456");
           System.out.println("result:"+ resultId);
       }
   }
   
   //创建代理对象代码
   class UserDaoProxy implements InvocationHandler{
   
       //1 把创建的是谁的代理对象，谁传过来
       //有参数构造传递
       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 result = method.invoke(obj,args);
   
           //方法执行之后的增强操作
           System.out.println("在方法之后执行。方法所在类为："+obj);
   
           return result;
       }
   }
   

AOP（术语）

• 连接点

  类里面哪些方法可以被增强，这些方法称为连接点

• 切入点

  实际被真正增强的方法，称为切入点

• 通知（增强）

  1. 实际增强的逻辑部分称为通知（增强）
  2. 通知有多种类型
     • 前置通知：被增强的方法之前执行
     • 后置通知：被增强的方法之后执行，出异常不执行
     • 环绕通知：被增强的方法前后都做执行，出异常时环绕在被增强方法后的不执行
     • 异常通知：对被增强的方法进行异常处理，出异常执行
     • 最终通知：（类似 try - catch - finally 里中的 finally），不管有没有异常都执行

• 切面

  是一种动作，把通知应用到切入点的过程，叫为切面

AOP 操作（准备工作）

1. Spring 框架一般基于AspectJ 实现 AOP 操作

   • 什么是 AspectJ ？

     AspectJ 不是 Spring 组成部分，独立 AOP 框架，一般把 AspectJ 和 Spring 框架一起使用，进行 AOP 操作

2. 基于 AspectJ 实现 AOP 操作

   • 第一种方式：基于 xml 配置文件实现
   • 第二种方式：基于注解方式实现（更常使用）

3. 在项目工程里面引入 AOP 相关依赖
   

4. 切入点表达式

   切入点表达式的作用：让 Spring 知道要对哪个类里面的哪个方法进行增强

   语法结构：execution([权限修饰符] [返回类型] [类全路径].[方法名称]([参数列表]))

   • 举例一：对 com.demo1.Spring5.dao.BookDao 类里面的 add 进行增强

     execution(* com.demo1.Spring5.dao.BookDao.add(..))
     

   • 举例二：对 com.demo1.Spring5.dao.BookDao 类里面的所有方法都进行增强

     execution(* com.demo1.Spring5.dao.BookDao.*(..))
     

   • 举例三：对 com.demo1.Spring5.dao 包里面所有类，类里面所有方法进行增强

     execution(* com.demo1.Spring5.dao.*.*(..))
     

AOP 操作（基于 AspectJ 注解方式）

1. 创建类，在类里面定义方法

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

2. 创建增强类（编写增强逻辑）

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

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

3. 进行通知的配置

   1）在 spring 配置文件中，开启注解扫描

   <?xml version="1.0" encoding="UTF-8"?>
   <beans xmlns="http://www.springframework.org/schema/beans"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xmlns:context="http://www.springframework.org/schema/context"
          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.demo1.Spring5.aopanno"></context:component-scan>
   
   </beans>
   

   2）使用注解创建 User 和 UserProxy 对象 （用@Component注解）

   3）在增强类上面添加注解 @Aspect

   4）在 spring 配置文件中开启生成代理对象

   <!--开启 AspectJ 生成代理对象-->
   <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
   

4. 配置不同类型的通知

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

   @Component
   @Aspect //生成代理对象
   public class UserProxy {
       //前置通知
       @Before(value = "execution(* com.demo1.Spring5.aopanno.User.add(..))")
       public void before(){
           System.out.println("before...");
       }
   
       //最终通知
       @After(value = "execution(* com.demo1.Spring5.aopanno.User.add(..))")
       public void after(){
           System.out.println("after...");
       }
   
       //后置通知（返回通知）
       @AfterReturning(value = "execution(* com.demo1.Spring5.aopanno.User.add(..))")
       public void afterReturning(){
           System.out.println("afterReturning...");
       }
   
       //异常通知
       @AfterThrowing(value = "execution(* com.demo1.Spring5.aopanno.User.add(..))")
       public void afterThrowing(){
           System.out.println("afterThrowing...");
       }
   
       //环绕通知
       @Around(value = "execution(* com.demo1.Spring5.aopanno.User.add(..))")
       public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
           System.out.println("环绕之前...");
           //被增强的方法执行
           proceedingJoinPoint.proceed();
           System.out.println("环绕之后...");
       }
   }
   

   最终输出结果如下：

   环绕之前...
   before...
   add...
   环绕之后...
   after...
   afterReturning...
   

AOP 操作（基于 AspectJ 注解方式_补充）

1. 相同切入点抽取

       //相同切入点抽取
       @Pointcut(value = "execution(* com.demo1.Spring5.aopanno.User.add(..))")
       public void comPointcut(){
   
       }
   
       //前置通知
       @Before(value = "comPointcut()")
       public void before(){
           System.out.println("before...");
       }
   
       //最终通知
       @After(value = "comPointcut()")
       public void after(){
           System.out.println("after...");
       }
   

   也可以使用 final修饰的字符串来提取切入点值（注解 value值 必须是常量）

   final String string = "execution(* com.demo1.Spring5.aopanno.User.add(..))";
   

2. 有多个增强类对同一个方法进行增强，设置增强类优先级

   在增强类上面添加注解 @Order(数字类型值)，数字类型值越小优先级越高

   @Component
   @Aspect //生成代理对象
   @Order(0)
   public class UserProxy {
   

3. 完全使用注解开发

   创建配置类，不需要创建 xml 配置文件

   //配置类
   @Configuration
   //开启组件扫描
   @ComponentScan(basePackages = {"com.demo1.Spring5.aopanno"})
   //开启AspectJ生成代理对象
   @EnableAspectJAutoProxy()
   public class ConfigAop {
   }
   

   测试方法：

   @Test
   public void TestAopAnno1(){
       ApplicationContext context =
               new AnnotationConfigApplicationContext(ConfigAop.class);
       User user =context.getBean("user", User.class);
       user.add();
   }
   

AOP 操作（基于 AspectJ xml配置文件方式）

1. 创建两个类，增强类和被增强类，创建方法

   public class Book {
       public void buy(){
           System.out.println("buy...");
       }
   }
   

   public class BookProxy {
       public void before(){
           System.out.println("before...");
       }
   }
   

2. 在 Spring 配置文件中创建两个类对象

   <!--创建两个类的对象-->
   <bean id="book" class="com.demo1.Spring5.aopxml.Book"></bean>
   <bean id="bookProxy" class="com.demo1.Spring5.aopxml.BookProxy"></bean>
   

3. 在 Spring 配置文件中配置切入点

   <!--配置aop增强-->
   <aop:config>
       <!--配置切入点-->
       <aop:pointcut id="p" expression="execution(* com.demo1.Spring5.aopxml.Book.buy(..))"/>
       <!--配置切面-->
       <aop:aspect ref="bookProxy">
           <!--配置增强作用在具体哪个方法上-->
           <aop:before method="before" pointcut-ref="p"/>
       </aop:aspect>
   </aop:config>