spring（3）https://developer.aliyun.com/article/1530433
3.2.3、动态代理
动态代理有两种:
- jdk动态代理，要求必须有接口，最终生成的代理类和目标类实现相同的接口在com.sun. proxy包下，类名为$proxy2
- cglib动态代理，最终生成的代理类会继承目标类，并且和目标类在相同的包下
#java/重要方法
[!note]
这里的功能主要依赖反射来实现
- newProxyInstance()：创建一个代理实例
- 其中有三个参数：
- 1、classLoader：加载动态生成的代理类的类加载器[[javase#类的加载与ClassLoader]]
- 2、interfaces：目标对象实现的所有接口的class对象所组成的数组
- 3、invocationHandler：设置代理对象实现目标对象方法的过程，即代理类中如何重写接口中的抽象方法
?怎么知道要执行的方法是什么
public class ProxyFactory { private Object target; public ProxyFactory(Object target) { this.target = target; } public Object getProxy(){ ClassLoader classLoader = target.getClass().getClassLoader(); Class<?>[] interfaces = target.getClass().getInterfaces(); InvocationHandler invocationHandler = new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { /** * proxy：代理对象 * method：代理对象需要实现的方法，即其中需要重写的方法 * args：method所对应方法的参数 */ Object result = null; try { System.out.println("[动态代理][日志] "+method.getName()+"，参数："+ Arrays.toString(args)); result = method.invoke(target, args); System.out.println("[动态代理][日志] "+method.getName()+"，结 果："+ result); } catch (Exception e) { e.printStackTrace(); System.out.println("[动态代理][日志] "+method.getName()+"，异常："+e.getMessage()); } finally { System.out.println("[动态代理][日志] "+method.getName()+"，方法执行完毕"); } return result; } }; return Proxy.newProxyInstance(classLoader, interfaces,invocationHandler); } }
3.2.4、测试
[!note]
我们不知道代理类的类型,但是我们知道代理类所实现的接口,直接向上转型即可
@Test public void testDynamicProxy(){ ProxyFactory factory = new ProxyFactory(new CalculatorLogImpl()); Calculator proxy = (Calculator) factory.getProxy(); proxy.div(1,0); //proxy.div(1,1); }
3.3、AOP概念及相关术语
在AOP中切面就是与业务逻辑独立，但又垂直存在于业务逻辑的代码结构中的通用功能组合；切面与业务逻辑相交的点就是切点；连接点就是把业务逻辑离散化后的关键节点；切点属于连接点，是连是连接点的子集；Advice（增强）就是切面在切点上要执行的功能增加的具体操作；在切点上可以把要完成增强操作的目标对象（Target）连接到切面里，这个连接的方式就叫织入。
3.3.1、概述
AOP（Aspect Oriented Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程的一种补充和完善，它以通过预编译方式和运行期动态代理方式实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。
3.3.2、相关术语
①横切关注点
从每个方法中抽取出来的同一类非核心业务。==(就比如之前的日志功能)==在同一个项目中，我们可以使用多个横切关注点对相关方法进行多个不同方面的增强。
这个概念不是语法层面天然存在的，而是根据附加功能的逻辑上的需要：有十个附加功能，就有十个横切关注点。 
②通知
横切关注点在切面中就叫做通知
每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法。
- 前置通知：在被代理的目标方法前执行
- 返回通知：在被代理的目标方法成功结束后执行（寿终正寝）
- 异常通知：在被代理的目标方法异常结束后执行（死于非命）
- 后置通知：在被代理的目标方法最终结束后执行（盖棺定论）
- 环绕通知：使用try…catch…finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所
有位置 
③切面
封装通知方法(横切关注点)的类。
④目标
被代理的目标对象。
⑤代理
向目标对象应用通知之后创建的代理对象。
⑥连接点
连接点就是我们抽取方法的位置,即抽取横切关注点的位置
这也是一个纯逻辑概念，不是语法定义的。
把方法排成一排，每一个横切位置看成x轴方向，把方法从上到下执行的顺序看成y轴，x轴和y轴的交叉点就是连接点。
⑦切入点
一个表达式,然后来定位连接点从而能让横切关注点通过切入点表达式插入在正确的位置
定位连接点的方式。
每个类的方法中都包含多个连接点，所以连接点是类中客观存在的事物（从逻辑上来说）。
如果把连接点看作数据库中的记录，那么切入点就是查询记录的 SQL 语句。
Spring 的 AOP 技术可以通过切入点定位到特定的连接点。
切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条
件。
3.3.3、作用
- 简化代码：把方法中固定位置的重复的代码抽取出来，让被抽取的方法更专注于自己的核心功能，提高内聚性。
- 代码增强：把特定的功能封装到切面类中，看哪里有需要，就往上套，被套用了切面逻辑的方法就被切面给增强了。
3.4、基于注解的AOP
3.4、基于注解的AOP
3.4.1、技术说明
- 动态代理（InvocationHandler）：JDK原生的实现方式，需要被代理的目标类必须实现接口。因
为这个技术要求代理对象和目标对象实现同样的接口（兄弟两个拜把子模式）。
- cglib：通过继承被代理的目标类（认干爹模式）实现代理，所以不需要目标类实现接口。
- AspectJ：本质上是静态代理，将代理逻辑“织入”被代理的目标类编译得到的字节码文件，所以最终效果是动态的。weaver就是织入器。Spring只是借用了AspectJ中的注解。
3.4.2、准备工作
①添加依赖
在IOC所需依赖基础上再加入下面依赖即可：
<!-- spring-aspects会帮我们传递过来aspectjweaver --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId> <version>5.3.1</version> </dependency>
②准备被代理的目标资源
接口：
public interface Calculator { int add(int i, int j); int sub(int i, int j); int mul(int i, int j); int div(int i, int j); }
实现类：
@Component public class CalculatorPureImpl implements Calculator { @Override public int add(int i, int j) { int result = i + j; System.out.println("方法内部 result = " + result); return result; } @Override public int sub(int i, int j) { int result = i - j; System.out.println("方法内部 result = " + result); return result; } @Override public int mul(int i, int j) { int result = i * j; System.out.println("方法内部 result = " + result); return result; } @Override public int div(int i, int j) { int result = i / j; System.out.println("方法内部 result = " + result); return result; } }
3.4.3、创建切面类并配置
在Spring的配置文件中配置：
<!-- 基于注解的AOP的实现： 1、将目标对象和切面交给IOC容器管理（注解+扫描） 2、开启AspectJ的自动代理，为目标对象自动生成代理 3、将切面类通过注解@Aspect标识 --> <context:component-scan base-package="com.atguigu.spring" > </context:component-scan> <!--开启基于注解的aop功能--> <aop:aspectj-autoproxy />
把前置通知通过切入点表达式放入切入点
[!note]
1.loggeraspect类相当于一个工具类，不过它会在被引用时通过@Before(切入点)引用这个方法插入到代理类，
而此时代理类并没有在aop.annotation包下
2.注意。此时aop.annotation包中并没有代理类对象，代理类对象和前面讲的动态代理一样，
代理类在底层代码被匿名创建，所以只能在text测试类中被同接口调用
@Aspect //标记为切面
@Component @Aspect //标记为切面 public class LoggerAspect { @Before("execution(public int com.atguigu.spring.pojo.Calculator.add(int,int))") public void beforeMethod(JoinPoint joinPoint){ System.out.println("Logger-->前置通知："); } }
测试
[!note]
只能通过接口来获取代理类,并且通过目标类的类型获取不到对象
joinPoint.getSignature() 用来获取连接点所对应方法的签 名信息
[!note]
切入点表达式:设置在标识通知的注解的value属性中
execution(public int com.atguigu.spring . aop.annotation.caLcuLatorImpl.add(int，int)execution(* com.atguigu.spring.aop.annotation.calculatorImpl. *(. .)第一个
*表示任意的访问修饰符和返回值类型第二个
*表示类中任意的方法
..表示任意的参数列表类的地方也可以使用
*，表示包下所有的类[!note]
在返回通知中若要获取目标对象方法的返回值
只需要通过@AfterReturning注解的leturning属性
就可以将通知方法的某个参数指定为接收目标对象方法的返回值的参数
@AfterReturning(value = "execution(*com.atguigu.aop.annotation.CalculatorImpl.*(..))", returning = "result")
设置返回值名.下面方法的参数列表中要有同名的返回值名,returning就是来设置目标对象返回值的一个参数的参数名的
public void afterReturningMethod(JoinPoint joinPoint, Object result)
[!note]
throwing属性可以将通知方法的某个参数指定为接收异常返回值的参数,在异常通知中若要获取目标对象方法的异常
只需要通过AfterThrowing注解的throwing属性
就可以将通知方法的某个参数指定为接收目标对象方法出现的异常的参数
@AfterThrowing(value = "execution(*com.atguigu.aop.annotation.CalculatorImpl.*(..))", throwing = "ex")
public void afterThrowingMethod(JoinPoint joinPoint, Throwable ex)
`
// @Aspect表示这个类是一个切面类 @Aspect // @Component注解保证这个切面类能够放入IOC容器 @Component public class LogAspect { @Before("execution(public int com.atguigu.aop.annotation.CalculatorImpl.*(..))") public void beforeMethod(JoinPoint joinPoint){ String methodName = joinPoint.getSignature().getName(); String args = Arrays.toString(joinPoint.getArgs()); System.out.println("Logger-->前置通知，方法名："+methodName+"，参数："+args); } @After("execution(* com.atguigu.aop.annotation.CalculatorImpl.*(..))") public void afterMethod(JoinPoint joinPoint){ String methodName = joinPoint.getSignature().getName(); System.out.println("Logger-->后置通知，方法名："+methodName); } @AfterReturning(value = "execution(*com.atguigu.aop.annotation.CalculatorImpl.*(..))", returning = "result") public void afterReturningMethod(JoinPoint joinPoint, Object result){ String methodName = joinPoint.getSignature().getName(); System.out.println("Logger-->返回通知，方法名："+methodName+"，结果："+result); } @AfterThrowing(value = "execution(*com.atguigu.aop.annotation.CalculatorImpl.*(..))", throwing = "ex") public void afterThrowingMethod(JoinPoint joinPoint, Throwable ex){ String methodName = joinPoint.getSignature().getName(); System.out.println("Logger-->异常通知，方法名："+methodName+"，异常："+ex); } @Around("execution(* com.atguigu.aop.annotation.CalculatorImpl.*(..))") //返回值类型需要和目标方法的返回值类型相同 public Object aroundMethod(ProceedingJoinPoint joinPoint){ String methodName = joinPoint.getSignature().getName(); String args = Arrays.toString(joinPoint.getArgs()); Object result = null; try { System.out.println("环绕通知-->目标对象方法执行之前"); //目标对象（连接点）方法的执行 result = joinPoint.proceed(); System.out.println("环绕通知-->目标对象方法返回值之后"); } catch (Throwable throwable) { throwable.printStackTrace(); System.out.println("环绕通知-->目标对象方法出现异常时"); } finally { System.out.println("环绕通知-->目标对象方法执行完毕"); } return result; } }
@Pointcut声明—个重用的切入点表达式
使用方式:@Before( “pointcut()”)
共用一个切入点表达式:通过方法获得注解,然后获得value值即共用的切入点表达式来定位切入点
3.4.4、各种通知
- 前置通知：使用@Before注解标识，在被代理的目标方法前执行
- 返回通知：使用@AfterReturning注解标识，在被代理的目标方法成功结束后执行（寿终正寝）(try的最后)
- 异常通知：使用@AfterThrowing注解标识，在被代理的目标方法异常结束后执行（死于非命）
- 后置通知：使用@After注解标识，在被代理的目标方法最终结束后执行（盖棺定论）
- 环绕通知：使用@Around注解标识，使用try…catch…finally结构围绕整个被代理的目标方法，包
括上面四种通知对应的所有位置
各种通知的执行顺序：
- Spring版本5.3.x以前：
- 前置通知
- 目标操作
- 后置通知
- 返回通知或异常通知
- Spring版本5.3.x以后：
- 前置通知
- 目标操作
- 返回通知或异常通知
- 后置通知
3.4.9、切面的优先级
相同目标方法上同时存在多个切面时，切面的优先级控制切面的内外嵌套顺序。
- 优先级高的切面：外面
- 优先级低的切面：里面
使用@Order注解可以控制切面的优先级：
默认的优先级是Integer的最大值
- @Order(较小的数)：优先级高
- @Order(较大的数)：优先级低
