SpringAOP

2022-02-14 04:12:39

------------恢复内容开始------------

Spring AOP

面向切面编程，举个例子，在一个项目中在不改变原有的代码情况下添加一个权限管理，去掉权限管理模块也不回对原有的代码有任何影响。也就是说在不改变原来的代码条件，增强原有的方法，这就是面向切边编程。

AOP动态代理

AOP动态代理有两种情况：

2、没有接口的情况，使用Cglib动态代理， Spring AOP 会使用 Cglib 生成一个被代理对象的子类来作为代理，增强类的方法

JDK动态代理

1、使用JDK动态代理，使用Proxy类里面的方法创建代理对象：

　　调用newProxyInstance方法，方法有三个参数：

　　　　第一个参数：类加载器；

　　　　第二个参数：增强方法所在的类，这个类实现的接口，支持多个接口，这个参数是个数组；

　　　　第三个参数：实现这个接口InvocationHandler，创建代理对象，写增强的方法。

模拟JDK动态代理

模拟底层的动态代理实现原理

　　1）创建接口

1 public interface UserDao {
2     public int add(int a,int b);
3 
4     public String update(String id);
5 }

　　2）实现接口

 1 import com.riven.dao.UserDao;
 2 
 3 public class UserDaoImpl implements UserDao {
 4     @Override
 5     public int add(int a, int b) {
 6         System.out.println("add方法执行了");
 7         return a+b;
 8     }
 9 
10     @Override
11     public String update(String id) {
12         return id;
13     }
14 }

　　3）编写代理代码

 1 package com.riven.test;
 2 
 3 import com.riven.dao.UserDao;
 4 import com.riven.impl.UserDaoImpl;
 5 
 6 import java.lang.reflect.InvocationHandler;
 7 import java.lang.reflect.Method;
 8 import java.lang.reflect.Proxy;
 9 import java.util.Arrays;
10 
11 public class JDKProxy {
12     public static void main(String[] args) {
13         //创建接口实现类代理对象
14         Class[] interfaces = {UserDao.class};
15         /*方式一：第三个参数使用匿名内部类方式创建代理对象，编写增强类代码
16         Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
17             @Override
18             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
19                 return null;
20             }
21         });
22         */
23 //        方式二：
24         //要被代理的对象
25         UserDaoImpl userDao = new UserDaoImpl();
26         //返回代理对象
27         UserDao dao =(UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),interfaces,new UserDaoProxy(userDao));
28         int result = dao.add(1,2);
29         System.out.println("result = " + result);
30     }
31 }
32 //方式二
33 //创建代理对象代码
34 class UserDaoProxy implements InvocationHandler{
35     private Object obj;
36     //1、创建的是谁的代理对象，把谁传递进来
37     //有参构造传递
38     public UserDaoProxy(Object obj){
39         this.obj = obj;
40     }
41     //增强的逻辑
42     @Override
43     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
44         /**
45          * proxy： 代理对象
46          * method：当前的方法
47          * args：存放传递的参数
48          */
49 
50         //方法之前
51         System.out.println("方法之前执行..." + method.getName() + "：传递的参数..."+ Arrays.toString(args));
52         //被增强的方法执行
53         //传入被代理的对象、调用该方法的参数
54         Object res = method.invoke(obj,args);
55         //方法之后
56         System.out.println("方法执行之后..." + obj);
57         return res;
58     }
59 }

Spring对动态代理做了封装，我们可以通过配置，然后调用Spring内的动态代理。

AOP术语

　　1）连接点

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

　　2）切入点

　　　　实际被增强了的方法，称为切入点。

　　3）通知（增强）

　　　　（1）实际增强的逻辑部分称为通知（增强）

　　　　（2）通知有多种类型

　　　　　　1、前置通知：增强方法之前，前置通知会执行；

　　　　　　2、后置通知：增强方法之后，后置通知会执行；

　　　　　　3、环绕通知：增强方法之前之后，环绕通知都会执行；

　　　　　　4、异常通知：增强的方法出现异常，异常通知会执行；

　　　　　　5、最终通知：最终通知类似finally，无论会不会出现异常都会执行。

　　4）切面

　　　是一个动作，把通知应用到切入点的过程。例如，为登录方法添加权限管理功能的过程。

AOP操作准备

1、Spring框架一般都是基于AspectJ实现AOP操作

　　1）什么是AspectJ

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

2、基于AspectJ实现AOP操作

　　1）基于xml配置文件实现

　　2）基于注解方式实现（推荐）

3、引入AOP依赖

4、切入点表达式

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

　　2）语法结构

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

　　　　举例1：对com.springaop.UserDao类里面的add进行增强

　　　　　　execution(* com.springaop.UserDao.add(..))：

　　　　　　　　* com.springaop.UserDao.add(..)：*：表示任意权限修饰符，返回类型可以不写（这里没写）类全路径点方法名，".." 表示所有参数。

　　　　举例3：对com.springaop.UserDao类里面的所有方法进行增强

　　　　　　execution(* com.springaop.UserDao.*(..))：

AOP示例演示

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

1 //被增强的类
2 public class User {
3     public void add(){
4         System.out.println("add...");
5     }
6 }

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

1 //增强的类
2 public class UserProxy {
3     //前置通知
4     public void before(){
5         System.out.println("before....");
6     }
7 }

3、进行通知的配置

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

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xmlns:context="http://www.springframework.org/schema/context"
 5        xmlns:aop="http://www.springframework.org/schema/aop"
 6        xmlns:p="http://www.springframework.org/schema/p"
 7        xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
 8        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
 9   http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
10 ">
11 
12     <!-- 自动扫描
13     base-package值为扫描该包下（包括子包）的所有类
14     -->
15     <context:component-scan base-package="com.riven.aopanno"></context:component-scan>
16 
17     <!-- 是Aspect注解生效，为目标类自动生成代理对象 -->
18     <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
19 
20 </beans>

　　2）使用注解创建 User 和 UserProxt

　　　　在这两个类上添加 @Component 注解

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

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

4、配置不同类型的通知

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

 1 import org.aspectj.lang.annotation.Aspect;
 2 import org.aspectj.lang.annotation.Before;
 3 import org.springframework.stereotype.Component;
 4 
 5 //增强的类
 6 @Component
 7 @Aspect //生成代理对象
 8 public class UserProxy {
 9 
10     //前置通知
11     @Before(value = "execution(* com.riven.aopanno.User.add(..))")
12     public void before(){
13         System.out.println("before....");
14     }
15 }

5、相同的切入点抽取

 1 //相同切入点抽取
 2     @Pointcut(value = "execution(* com.riven.aopanno.User.add(..))")
 3     public void pointdemo(){
 4         
 5     }
 6     //前置通知
 7     @Before(value = "pointdemo()")
 8     public void before(){
 9         System.out.println("你人呢before....");
10     }

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

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

UserProxy

 1 //被增强的类
 2 @Component
 3 @Aspect //生成代理对象
 4 @Order(2)

 5 public class UserProxy {  
 6 //相同切入点抽取  
 7 @Pointcut(value = "execution(* com.riven.aopanno.User.add(..))")  
 8 public void pointdemo(){  
 9
 10  }
11 //前置通知
 12 @Before(value = "pointdemo()")
13 public void before(){
14 System.out.println("你人呢before...."); 

 15  }
16 @AfterReturning(value = "execution(* com.riven.aopanno.User.add(..))")
17 public void afterReturning(){
18 System.out.println("你人呢afterReturning....");
19  }
20 @After(value = "execution(* com.riven.aopanno.User.add(..))")
21 public void aftere(){
22 System.out.println("你人呢after....");
23  }
24 @AfterThrowing(value = "execution(* com.riven.aopanno.User.add(..))")
25 public void afterThrowing(){
26 System.out.println("你人呢afterThrowing....");
27  }
28 //环绕通知，在方法执行之前之后都会执行
29 //方法执行之前先执行这个方法然后再执行前置通知
30 //方法执行之后先执行这个方法然后在执行后置通知
 31 @Around(value = "execution(* com.riven.aopanno.User.add(..))")
32 public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
33 System.out.println("环绕之前.....");
34
 35 //被增强的方法执行
 36  proceedingJoinPoint.proceed();
37
 38 System.out.println("环绕之后....");
39  }
40 }

新创建UserProxy2

 1 package com.riven.aopanno;
 2 
 3 import org.aspectj.lang.annotation.Aspect;
 4 import org.aspectj.lang.annotation.Before;
 5 import org.springframework.core.annotation.Order;
 6 import org.springframework.stereotype.Component;
 7 
 8 @Component
 9 @Aspect
10 @Order(1)
11 public class UserProxy2 {
12     @Before(value = "execution(* com.riven.aopanno.User.add(..))")
13     public void before(){
14         System.out.println("你人呢before2....");
15     }
16 }

创建运行类

1 public class TestAOP {
2     public static void main(String[] args) {
3         ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
4         User user = context.getBean("user", User.class);
5         user.add();
6     }
7 }

运行结果：

1、没有出现异常

先运行UserProxy2的 @Before ==> UserProxy的@Around环绕(前)代码 ==> @Before ==> 执行被增强方法内容 ==> @Around环绕(后)代码 ==> @After ==>@AfterReturning

2、出现异常

先运行UserProxy2的 @Before ==> UserProxy的@Around环绕(前)代码 ==> @Before ==> @After ==>@AfterThrowing

　　2)使用配置文件