概述
① AOP（Aspect Orient Programming）, 面向切面编程,AOP 是一种编程思想，是面向对象编程（OOP）的一种补充；
② 面向切面编程，不修改源代码给程序动态统一添加额外功能的一种技术，实现业务代码解耦；
③ 应用主要体现在事务处理、日志管理、权限控制、异常处理等方面，分离功能性需求和非功能性需求，增强代码的可读性和可维护性。
graph LR
日志记录---事务管理---权限验证---性能监控
静态代理
Spring Aop底层实现原理是动态代理，因此先介绍一下静态代理。
特点
① 静态代理要求目标对象和代理对象实现同一个业务接口。代理对象中的核心功能是由目标对象来完成，代理对象负责增强功能；
② 目标对象(被代理对象)必须实现接口;
③ 代理对象在程序运行前就已经存在——>扩展代理类Agent；
④ 支持目标对象灵活的切换，无法对功能灵活的处理——>动态代理可解决此问题。
<font color= 'red'>注意：静态代理只适合业务功能固定不变的情况。(业务接口方法不进行增加和减少，实现类就不需要改动)</font>
使用示例
需求描述：一个司机具有开车的能力，在开车前需要加油，开车结束后需要洗车和保养，开车前后的动作，在不改变开车内部逻辑的情况下，就可以采用静态代理实现，如下：
// 定义一个驾驶员接口，具有开车功能
public interface Driver {
/**
* 驾驶功能
*/
void drive();
}
// 小轿车驾驶员实现驾驶员接口
public class CarDriver implements Driver{
@Override
public void drive(){
System.out.println("正在开小轿车。");
}
}
// 小轿车代理类
public class CarAgent implements Driver{
@Override
public void drive(){
System.out.println("开车前要记得加油。");
CarDriver carDriver = new CarDriver();
carDriver.drive();
System.out.println("开车后记得洗车和保养");
}
}
// 测试类
public class CarAgentTest {
@Test
void testDrive(){
CarAgent carAgent = new CarAgent();
carAgent.drive();
}
}
[图片上传失败...(image-44f9d6-1684200501221)]
动态代理
1、是使用反射和字节码的技术，在运行期创建指定接口或类的子类，以及其实例对象的技术，通过这个技术可以无侵入的为代码进行增强，动态代理主要有JDK和CGLIB两种方式；
2、如果代理方法很多，我们需要在每个代理方法都要写一遍，很麻烦。而动态代理则不需要。
JDK
// 编写动态代理类
public class CarJdkAgent<T> implements InvocationHandler {
private T target;
public CarJdkAgent(T target){
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable{
System.out.println("调用方法前");
Object ret = method.invoke(target,args);
return ret;
}
}
// 动态代理测试
public class DynAgentTest {
@Test
void testJdkAgent1(){
Driver carDriver = new CarDriver();
Driver proxyCarDriver = (Driver)Proxy.newProxyInstance(carDriver.getClass().getClassLoader(),
carDriver.getClass().getInterfaces(),new InvocationHandler(){
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//args表示有几个参数，这里只有一个参数
System.out.println("动态代理-开车前记得加油");
//这里调用真实对象的方法
return method.invoke(carDriver, args);
}
});
proxyCarDriver.drive();
}
@Test
void testJdkAgent2(){
Driver carDriver = new CarDriver();
InvocationHandler carJdkAgent = new CarJdkAgent<Driver>(carDriver);
Driver proxyDriver= (Driver)Proxy.newProxyInstance(carDriver.getClass().getClassLoader(),
carDriver.getClass().getInterfaces(), carJdkAgent);
proxyDriver.drive();
}
}
以上测试类两种方式，方式一采用匿名方法调用，可以不编写动态代理类，方式二通过编写动态代理类实现。
CGLIB
1、动态代理需要被代理类实现接口，如果被代理类没有实现接口，那么这么实现动态代理？这时候就需要用到CGLib了。这种代理方式就叫做CGlib代理；
2、Cglib代理也叫作子类代理，他是通过在内存中构建一个子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，然后加入自己需要的操作。因为使用继承的方式，所以不能代理final 类；
3、需要导入cglib的jar包,另外Spring的核心包中已经包括了Cglib功能,也可以导入spring-core-3.2.5.jar。
public class CarCglibAgent implements MethodInterceptor {
public Object getProxy(Class cls) {
// CGLIB <u>enhancer</u>增强类对象
Enhancer enhancer = new Enhancer();
// 设置增强类型
enhancer.setSuperclass(cls);
// 定义代理逻辑对象为当前对象，要求当前对象实现MethodInterceptor方法
enhancer.setCallback(this);
// 生成并返回代理对象
return enhancer.create();
}
@Override
public Object intercept(Object obj, Method method, Object[] args,
MethodProxy methodProxy) throws Throwable {
System.out.println("开车前先加油");
// 执行目标对象的方法
Object result = methodProxy.invokeSuper(obj, args);
System.out.println("开完车记得洗车");
return result;
}
// 测试调用
public static void main(String[] args) {
CarCglibAgent carCglibAgent = new CarCglibAgent();
CarDriver carDriver = (CarDriver)carCglibAgent.getProxy(CarDriver.class);
carDriver.drive();
}
Spring Aop名词解释
关于AOP的概念这里不做过多介绍，我们只需要知道其中有三个非常重要的概念：
aspect（切面）、pointcut（切入点）、advice（通知）。
pointcut（切入点）
也就是具体拦截的某个业务点。
分为 execution（路径表达式）和 annotation 方式，被这两种方式修饰的代码将会被切面拦截处理;
advice（通知）
切面当中的处理方式，声明通知方法在业务层的执行位置，类型如下：
@Before：前置通知，在方法执行之前执行
@After：后置通知，在方法执行之后执行
@AfterRunning：返回通知，在方法返回结果后执行
@AfterThrowing：异常通知，在方法执行异常后执行
@Around：环绕通知，可以替代上述通知方法，并且可以控制方法是否执行以及何时执行。
aspect（切面）
即 pointcut+ advice ，和拦截器（HandlerInterceptorAdapter）的作用并没有太大的区别，只是两者的作用域不同，相对而言，切面的作用域更灵活一些。
使用介绍
基于自定义注解实现方式
// 定义自定义注解
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD,ElementType.TYPE})
public @interface CustomAnnotation {
public String ceShiValue() default "";
}
// 定义切面类
@Component
@Aspect
public class CustomAnnotationAspect {
@Pointcut(value = "@annotation(com.zhc.javabase.aop.CustomAnnotation)")
public void pointCut(){}
@Before("pointCut()")
public void beforeHandle(JoinPoint joinPoint){
System.out.println("基于注解方法执行之前调用");
}
@After("pointCut()")
public void afterHandle(JoinPoint joinPoint){
System.out.println("方法执行之后调用");
}
}
// Controller类中添加注解
@RestController
@RequestMapping("com/zhc/javabase/aop")
public class AopUseController {
@GetMapping("/firstAop")
@CustomAnnotation
public String firstAop(){
System.out.println("哈哈，aop学习");
return "hello aop";
}
}
基于路径表达式方式
// 定义切面类
@Component
@Aspect
public class CustomAnnotationAspect {
@Pointcut(value = "execution(public * com.zhc.javabase.aop..*.*(..)))")
public void executionPointCut(){}
@Before("executionPointCut()")
public void beforeHandle1(JoinPoint joinPoint){
System.out.println("基于非注解方式，方法执行之前调用");
}
}
在对应包路径下的接口会被切面所拦截，执行对应切面逻辑。
execution 切点表达式
由于Spring切面粒度最小是达到方法级别，而execution表达式可以用于明确指定方法返回类型，类名，方法名和参数名等与方法相关的部件，并且在Spring中，大部分需要使用AOP的业务场景也只需要达到方法级别即可，因而execution表达式的使用是最为广泛的。如下是execution表达式的语法：
execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)
这里问号表示当前项可以有也可以没有，其中各项的语义如下：
modifiers-pattern：方法的可见性，如public，protected；
ret-type-pattern：方法的返回值类型，如int，void等；
declaring-type-pattern：方法所在类的全路径名，如com.spring.Aspect；
name-pattern：方法名类型，如buisinessService()；
param-pattern：方法的参数类型，如java.lang.String；
throws-pattern：方法抛出的异常类型，如java.lang.Exception。
