第五章、面向切片、AOP
1、场景模拟
1、先搭建一个子模块：spring6-aop
1、声明接口
1、Calculator.java
package com.atqt.spring6.aop.example;
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);
}2、创建实现类
1、CalculatorImpl.java
package com.atqt.spring6.aop.example;
public class CalculatorImpl 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;
}
}2、CalculatorLogImpl.java
package com.atqt.spring6.aop.example;
/**
* 带日志的实现类
*/
public class CalculatorLogImpl implements Calculator{
@Override
public int add(int i, int j) {
System.out.println("[日志] add 方法开始了，参数是：" + i + "," + j);
int result = i + j;
System.out.println("方法内部 result = " + result);
System.out.println("[日志] add 方法结束了，结果是：" + result);
return result;
}
@Override
public int sub(int i, int j) {
System.out.println("[日志] sub 方法开始了，参数是：" + i + "," + j);
int result = i - j;
System.out.println("方法内部 result = " + result);
System.out.println("[日志] sub 方法结束了，结果是：" + result);
return result;
}
@Override
public int mul(int i, int j) {
System.out.println("[日志] mul 方法开始了，参数是：" + i + "," + j);
int result = i * j;
System.out.println("方法内部 result = " + result);
System.out.println("[日志] mul 方法结束了，结果是：" + result);
return result;
}
@Override
public int div(int i, int j) {
System.out.println("[日志] div 方法开始了，参数是：" + i + "," + j);
int result = i / j;
System.out.println("方法内部 result = " + result);
System.out.println("[日志] div 方法结束了，结果是：" + result);
return result;
}
}3、需求及问题
1、我们想实现带有日志的代码功能
2、但是发现直接在核心代码中写日志，会对核心业务进行干扰
3、这样写这个功能，会发现，维护起来十分麻烦，所以我们需要引进新技术或其他方法
4、方法
1、解决这个问题，我们可以解耦，就是把业务功能（注解）从核心功能代码中抽取出来
5、困难
1、要抽取出来的代码，在核心方法内部，以前的方法（子类中重复代码抽取到父类中）没办法解决。所以需要引进新的技术
2、代理模式
1、概念
1、是二十三种设计模式的其中一种，属于结构型模式
2、作用是通过一个代理类，让我们在调用目标方法的时候，不再直接对目标方法进行调用，而是通过代理的间接调用
3、让不属于目标方法核心逻辑代码，从目标方法中剥离出来—解耦
4、调用目标方法时，先调用代理对象的方法，减少对目标方法的调用和打扰
5、让附加功能能够集中在一起也有利于统一和维护
1、图解
1、使用代理前（图解）
2、使用代理后（图解）
2、例子
1、明星有经纪人，就是代理的思想
3、相关术语
1、代理：将非核心逻辑代码剥离出来，封装这些非核心逻辑的类，方法，对象
2、目标：被代理“套用”了非核心逻辑代码的类，方法，对象
2、静态代理
1、这里我们还以场景模拟为例子
1、创建CalculatorStaticProxy代理类
1、就是用这个类来封装那些非核心逻辑代码
2、重新创建一个类，类里面写的代码，与核心逻辑代码的结构一样，只是把通过类，把核心逻辑代码的方法调用过来
3、CalculatorStaticProxy.java
package com.atqt.spring6.aop.example;
public class CalculatorStaticProxy implements Calculator{
// 把被代理的目标对象传递过来
private Calculator calculator;
public CalculatorStaticProxy(Calculator calculator) {
this.calculator = calculator;
}
//以添加为例
@Override
public int add(int i, int j) {
// 输出日志
System.out.println("[日志] add 方法开始了，参数是：" + i + "," + j);
// 调用目标对象的方法实现核心业务
int addResult = calculator.add(i,j);
System.out.println("[日志] add 方法结束了，结果是：" + addResult);
//
return addResult;
}
@Override
public int sub(int i, int j) {
// 输出日志
System.out.println("[日志] add 方法开始了，参数是：" + i + "," + j);
// 调用目标对象的方法实现核心业务
int subResult = calculator.sub(i,j);
System.out.println("[日志] add 方法结束了，结果是：" + subResult);
//
return subResult;
}
@Override
public int mul(int i, int j) {
// 输出日志
System.out.println("[日志] add 方法开始了，参数是：" + i + "," + j);
// 调用目标对象的方法实现核心业务
int mulResult = calculator.mul(i,j);
System.out.println("[日志] add 方法结束了，结果是：" + mulResult);
//
return mulResult;
}
@Override
public int div(int i, int j) {
// 输出日志
System.out.println("[日志] add 方法开始了，参数是：" + i + "," + j);
// 调用目标对象的方法实现核心业务
int divResult = calculator.div(i,j);
System.out.println("[日志] add 方法结束了，结果是：" + divResult);
//
return divResult;
}
}2、发现问题
1、这样的代码确实可以解决解耦的问题，但是我们会发现十分的不灵活
2、就以刚刚的例子说，如果其他功能也需要用到日志的话，我们就得重复创建很多个这样的代理对象
3、也没办法做到统一的管理
3、改进方法
1、我们发现以上的问题
2、所以我们需要使用动态代理，去实现任何一个类都可以使用这个代理
3、动态代理
1、生产代理对象的工厂类
2、分类
- JDK动态代理：JDK原生的实现方式，需要被代理的目标类必须实现接口！他会根据目标类的接口动态生成一个代理对象！代理对象和目标对象有相同的接口！（拜把子）。java原生
- cglib：通过继承被代理的目标类实现代理，所以不需要目标类实现接口！（认干爹）。第三方，但是已经集成到spring中了
1、具体步骤
1、就是写一个工厂类
2、在这个代理类中编写一个构造器，用来对目标对象的传递
3、在这个类中编写一个返回代理对象的方法
4、方法中调用Proxy.newProxyInstance()系统方法
5、这个系统方法中需要三个参数
* 这个方法有三个参数
* 第一个参数：ClassLoader:加载动态生成代理类的来加载器
* 第二个参数：Class[] interfaces：目标对象实现的所有接口的class类型的数组
* 第三个参数：InvocationHandler：设置代理对象实现目标对象方法的过程
*/
第一个参数：ClassLoader:加载动态生成代理类的来加载器
ClassLoader classLoader = target.getClass().getClassLoader();
// 第二个参数：Class[] interfaces：目标对象实现的所有接口的class类型的数组
Class[] interfaces = target.getClass().getInterfaces();
// 第三个参数：InvocationHandler：设置代理对象实现目标对象方法的过程，第三个参数是个方法又有3个参数
InvocationHandler invocationHandler = new InvocationHandler(){
//第1个参数：代理对象
//第2个参数：需要重新目标对象的方法
//第3个参数：method方法里面参数
@Override
public Object invoke(Object proxy,
Method method,
Object[] args) throws Throwable {
//方法调用之前输出
System.out.println("[动态代理][日志] "+method.getName()+"，参数："+ Arrays.toString(args));
//调用目标方法
Object result = method.invoke(target,args);
//方法调用之后输出
System.out.println("[动态代理][日志] "+method.getName()+"，结果："+ result);6、最后进行返回
2、代码实现
1、还是以上面场景模拟为例子弄计算器中添加具体的日志
2、ProxyFactory.java创建
package com.atqt.spring6.aop.example;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
public class ProxyFactory {
//目标对象进行传递
private Object target;
public ProxyFactory(Object target) {
this.target = target;
}
// 创建一个方法，返回代理的对象
public Object getProxy(){
/**
* 这个方法有三个参数
* 第一个参数：ClassLoader:加载动态生成代理类的来加载器
* 第二个参数：Class[] interfaces：目标对象实现的所有接口的class类型的数组
* 第三个参数：InvocationHandler：设置代理对象实现目标对象方法的过程
*/
// 第一个参数：ClassLoader:加载动态生成代理类的来加载器
ClassLoader classLoader = target.getClass().getClassLoader();
// 第二个参数：Class[] interfaces：目标对象实现的所有接口的class类型的数组
Class[] interfaces = target.getClass().getInterfaces();
// 第三个参数：InvocationHandler：设置代理对象实现目标对象方法的过程
InvocationHandler invocationHandler = new InvocationHandler(){
//第一个参数：代理对象
//第二个参数：需要重新目标对象的方法
//第三个参数：method方法里面参数
@Override
public Object invoke(Object proxy,
Method method,
Object[] args) throws Throwable {
//方法调用之前输出
System.out.println("[动态代理][日志] "+method.getName()+"，参数："+ Arrays.toString(args));
//调用目标方法
Object result = method.invoke(target,args);
//方法调用之后输出
System.out.println("[动态代理][日志] "+method.getName()+"，结果："+ result);
return result;
}
};
//参数1：类加载器。参数2：目标类的接口们。参数3：具体要进行的代理动作
return Proxy.newProxyInstance(classLoader,interfaces,invocationHandler);
}
}3、测试
1、我们发现核心代码中没有日志代码，都是代理所做的功能（CalculatorStaticProxy.java）
2、TestCalculator.java
package com.atqt.spring6.aop.example;
public class TestCalcualtor {
public static void main(String[] args) {
// 创建代理对象（动态方式）
ProxyFactory proxyFactory = new ProxyFactory(new CalculatorImpl());
Calculator proxy = (Calculator) proxyFactory.getProxy();
proxy.add(1,2);
proxy.mul(2,4);
}
}3、AOP概念及相关术语
1、概念
1、是一种设计思想，是软件设计领域中的面向切面编程，是面向对象编程的一种补充和完善
2、?通过预编译方式和运行期动态代理方式实现，在不修改源代码的情况下，给程序动态统一添加额外功能的一种技术
3、利用AOP可以对业务逻辑的各个办法进行隔离，从而使得业务逻辑各部分之间的耦合度降低
4、提高程序的可重用性，同时提高了开发的效率
5、就是横向的编写代码。把方法解刨开，根据动态代理技术，将非核心业务代码插入到方法中，是对OOP面向对象编程的补充
6、OOP面向对象，就是串行的编写代码。但对于局部难以修改。所以引入AOP面向切片的编程
7、AOP就是解决业务代码中的非核心业务代码冗余的问题。
2、相关术语
1、横切关注点
1、就是说：根据附加功能的逻辑需要，有几个附加功能，就有几个横切关注点
2、例如：分布在各个模块中解决同一样的问题，用户验证，日志管理、事务处理、数据缓存都是横切关注点
3、从每个方法中抽取出来的同一类非核心业务，在同一个项目中，我们可以使用多个横切关注点进行多个不同方面的增强
4、图例
2、通知（增强）
1、就是说：你想要增强的功能
2、例如：安全、事务、日志、权限认证
3、通知方法
- 前置通知：在被代理的目标方法**前**执行
- 返回通知：在被代理的目标方法**成功结束**后执行（**寿终正寝**）
- 异常通知：在被代理的目标方法**异常结束**后执行（**死于非命**）
- 后置通知：在被代理的目标方法**最终结束**后执行（**盖棺定论**）
- 环绕通知：使用try...catch...finally结构围绕**整个**被代理的目标方法，包括上面四种通知对应的所有位置4、图示
3、切面
1、封装通知方法的类
2、图解
4、目标
1、就是被代理的目标对象
5、连接点
1、俗话说：就是spring允许你使用通知的方法
2、是一个纯逻辑，没有语法意义
3、横坐标：就是各个模块的横切位置
4、纵坐标：就是每个方法从上到下执行的方法
5、连接诶的就是横坐标和纵坐标的交错点
6、图解
7、切入点
1、定位连接点的方式
2、每个类方法中都有多个连接点，所以连接点是客观存在的事务（从逻辑上看）
3、如果把连接点看作数据库中的记录，切入点就是查询记录的sql语句
4、AOP可以通过切入点定位到特定 的连接点，目的是：要实际去增强的方法
5、切点通过org.springframework.aop.Pointcut接口进行描述，使用类和方法为连接点的查询条件
8、目标target
1、向目标对象应用通知之后创建的代理对象
9、织入 weave
1、指把通知应用到目标上、生成代理对象的过程。可以在编译期织入、也可以在运行期织入、spring采用后者
10、概念助记
3、作用
1、简化代码：把方法中固定的重复代码抽取出来，让被抽取的方法更专注于自己的核心功能，提高内聚性
2、代码增强：把特定的功能封装到切面类中，哪有需要就往哪里套用，被套用了切面逻辑，就被增强了
4、AOP思维和SpringAOP框架和核心关注点问题的区别
1、如图
2、我们只要使用AOP框架，写配置文件或注解就行。这个框架的底层还是代理技术。但我们不用管
4、基于注解的AOP
1、技术说明
1、图解
2、动态代理分为JDK动态代理、cglib动态代理
3、当前的目标类如果有接口，就使用JDK、cglib动态代理，如果没有接口，就只能用cglib动态代理
4、JDK动态代理动态生成的代理类会在com.sun.proxy包下，类名为$proxy1，和目标实现相同的接口
5、动态代理：JDK原生的实现方式，需要被代理的目标类必须实现接口。因为这个技术要求代理对象和目标对象实现同样的接口（兄弟两个拜把子结构）
6、cglib：通过继承被代理的目标类（认干爹模式）实现代理，所以不需要目标类实现接口
7、Aspectj：是AOP思想的一种实现。本质上是静态代理，将逻辑“织入”被代理的目标类编译得到的字节码文件，所以最终效果是动态的。weaver就是织入器。spring只是借用了AspectJ中的注解。目的是为了保持使用AspectJ的编程习惯
2、准备工作
1、基本操作步骤图
1、引入相关的依赖
<!--spring aop依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>6.0.2</version>
</dependency>
<!--spring aspects依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>6.0.2</version>
</dependency>2、创建目标资源
1、Calculator.java创建
package com.atqt.spring6.aop.annoaop;
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);
}2、CalculatorImpl.java创建
package com.atqt.spring6.aop.annoaop;
import org.springframework.stereotype.Component;
/**
* 这个是核心的类和业务
*/
@Component
public class CalculatorImpl 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、创建切面类
1、需要创建切面的类
2、在切面类中，要
1、切入点及表达式
1、切入点表达式
execution(访问权限修饰符+增强返回值类型+增强方法全类名+方法名(参数))
其中*号代替任意2、切入点是要放在通知类型（注解中）
3、其中JoinPoint是切入点的一个子接口
2、通知类型
1、有@before：前置
2、@after：后置
3、@afterReturning：返回
4、@AfterThrowing：异常
5、@Around：环绕
6、其中环绕around相当于try-catch-finally
3、代码实现
1、LogAspect.java
package com.atqt.spring6.aop.annoaop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import java.util.Arrays;
/**
* 切面类
*/
@Aspect//切面类
@Component//在ioc的内容中进行管理
public class LogAspect {
// 设置切入点和通知类型
// 切入点表达式：execution(访问权限修饰符+增强返回值类型+增强方法全类名+方法名(参数)) 其中*号代替任意
//
// 通知类型：前置@Before(value="切入点表达式配置切入点“)
// @Before(value = "execution(* com.atqt.spring6.aop.annoaop.*.*(..))")
@Before(value = "execution(public int com.atqt.spring6.aop.annoaop.CalculatorImpl.*(..))")
public void beforeMethod(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();//获取增强方法的名字
Object[] args = joinPoint.getArgs();
System.out.println("Logger-->前置，增强的方法是："+methodName+"参数为："+ Arrays.toString(args));
}
// 返回@AfterReturning
@AfterReturning(value = "execution(public int com.atqt.spring6.aop.annoaop.CalculatorImpl.*(..))",returning = "result")//returning得到增强方法的返回值
public void afterReturningMethod(JoinPoint joinPoint,Object result){
String methodName = joinPoint.getSignature().getName();
System.out.println("Logger-->返回，增强的方法是："+methodName+"，返回的结果："+result);
}
// 异常@AfterThrowing
// 目标方法出现异常，这个通知会执行
@AfterThrowing(value ="execution(public int com.atqt.spring6.aop.annoaop.CalculatorImpl.*(..))",throwing = "ex")
public void AfterThrowingMethod(JoinPoint joinPoint,Throwable ex){
String methodName = joinPoint.getSignature().getName();
System.out.println("Logger-->异常，增强的方法是："+methodName+"，目标方法的异常信息"+ex);
}
// 后置@After()
@After(value = "execution(* com.atqt.spring6.aop.annoaop.CalculatorImpl.*(..)))")
public void afterMethod(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();//获取增强方法的名字
System.out.println("Logger-->后置，增强的方法是："+methodName);
}
// 环绕@Around()
@Around(value ="execution(public int com.atqt.spring6.aop.annoaop.CalculatorImpl.*(..))")
// 这个时候要用功能更牛的类，这个类能调用目标方法
public Object aroundMethod(ProceedingJoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
System.out.println("Logger-->环绕，增强的方法是："+methodName);
String method = joinPoint.getSignature().getName();
Object [] args = joinPoint.getArgs();
String argString = Arrays.toString(args);
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;
}
}4、细节（重用切入点表达式）
1、就是把重用点包装成一个方法
2、然后通过调用实现
3、在同一个切面内直接使用
4、在不同切面就需要添加
切入点方法的全路径+类名+切入点方法()5、例子
// 实现重用切入点表达式：这是在同一个切面中
// 后置@After()
// @After(value = "pointcut")
// public void afterMethod(JoinPoint joinPoint){
// String methodName = joinPoint.getSignature().getName();//获取增强方法的名字
// System.out.println("Logger-->后置，增强的方法是："+methodName);
// }
// 实现重用切入点表达式：这是在不同切面中
// 后置@After()
// @After(value = "xxxxxxx.yyyy.pointcut") 其中xxxxx是切入点方法的全类名,yyyy是类的名字
// public void afterMethod(JoinPoint joinPoint){
// String methodName = joinPoint.getSignature().getName();//获取增强方法的名字
// System.out.println("Logger-->后置，增强的方法是："+methodName);
// }5、代码测试
1、TestAop.java
package com.atqt.spring6.aop.annoaop;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestAop {
@Test
public void testAdd(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
Calculator calculator = context.getBean(Calculator.class);
calculator.add(2,3);
}
}4、切面的优先级
1、优先级大小
1、相同目标方法同时存在多个切面时，切面的优先级控制切面的内外嵌套的顺序
2、优先级高的切面：外面
3、优先级低的切面：里面
4、图解
2、@Order注解控制切面的优先级
1、@Order(数值小)：优先级越高
2、@Order(数值大)：优先级越低
5、基于XML的AOP
1、准备工作
1、参考注解的AOP环境
2、就是caculator的接口、CaculatorImpl实现类、和LogAspect切面类、TestAop测试类进行复制
2、配置相关变量
1、创建并配置beanaop.xml
1、代码
<?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.atqt.spring6.aop.xmlaop"></context:component-scan>
<!-- 配置aop的五种通知类型-->
<aop:config>
<!-- 配置切面类-->
<aop:aspect ref="logAspect">
<!-- 配置切入点-->
<aop:pointcut id="pointcut" expression="execution(* com.atqt.spring6.aop.xmlaop.CalculatorImpl.*(..))"/>
<!-- 配置五种通知类型-->
<!-- 前置通知-->
<aop:before method="beforeMethod" pointcut-ref="pointcut"></aop:before>
<!-- 后置通知-->
<aop:after method="afterMethod" pointcut-ref="pointcut"></aop:after>
<!-- 返回通知-->
<aop:after-returning method="afterReturningMethod" returning="result" pointcut-ref="pointcut"></aop:after-returning>
<!-- 异常通知-->
<aop:after-throwing method="AfterThrowingMethod" throwing="ex" pointcut-ref="pointcut"></aop:after-throwing>
<!-- 环绕通知-->
<aop:around method="aroundMethod" pointcut-ref="pointcut"></aop:around>
</aop:aspect>
</aop:config>
</beans>2、测试代码
package com.atqt.spring6.aop.xmlaop;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestAop {
@Test
public void testAdd(){
ApplicationContext context = new ClassPathXmlApplicationContext("beanaop.xml");
Calculator calculator = context.getBean(Calculator.class);
calculator.add(6,3);
}
}