动态代理到AOP

动态代理

代理(proxy)是一种设计模式,通过了目标对象的另外访问方法,即通过代理对象访问目标对象.动态代理是再程序运行时动态地生成一个代理类代替原本的类.该类会拦截对目标对象的方法调用

为什么使用动态代理

• 动态代理可以帮我们减少许多冗余的代码,当你必须在类中做相同的事时,如日志记录,权限校验.若不想在每个方法里重复写这些代码,动态代理 就是帮你实现这一目标的工具,它通过拦截方法调用,在方法执行前后做一些额外的事情比如记录日志,验证权限

动态代理的实现

动态代理分别分为:JDK动态代理和CGLIB动态代理

JDK动态代理

• 适用于代理接口类型的对象

//业务接口
public interface UserService {
    void addUser();
}
//实现类
public class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("添加用户业务逻辑...");
    }
}

public class LoggingInvocationHandler implements InvocationHandler {

    private Object target;

    //封装一个绑定方法获取
    public Object newProxyInsatance(Object target) {

        this.target = target;
				
				//Proxy.newProxyInstance()方法用于在运行时动态生成代理类和实例
				
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),//被代理类类加载器
                target.getClass().getInterfaces(),//被代理类需要实现的接口列表
                this//方法调用处理器
        );
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("方法执行之前执行" + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("方法执行之后执行" + method.getName());

        return result;
    }
}

public class Test01 {
    public static void main(String[] args) {
        LoggingInvocationHandler handler = new LoggingInvocationHandler();

        UserService userService = new UserServiceImpl();

        UserService insatance = (UserService) handler.newProxyInsatance(userService);

        insatance.addUser();

    }
}
//output
//方法执行之前执行addUser
//添加用户业务逻辑...
//方法执行之后执行addUser

• Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h

  )

• 这是JDK动态代理和核心方法,用于在运行时动态生成代理类和实例,其需要传入三个参数,分别为ClassLoader loader被代理类的类加载器,Class<?>[] interfaces代理类需要实现的接口列表,InvocationHandler h,方法调用处理器

CGLIB动态代理

• CGLIB是通过生成目标类的子类来实现代理,Spring在目标类没有实现的接口时,就会采用CGLIB动态代理,CGLIB生成的代理类是目标类的子类,并覆盖目标类方法,因此其能代理没有接口的类

• 导入CGLIB依赖

  <!-- https://mvnrepository.com/artifact/cglib/cglib -->
  <dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib</artifactId>
      <version>3.3.0</version>
  </dependency>

一个没有接口的UserService

public class UserService {
    public void addUser() {
        System.out.println("添加逻辑...");
    }
}

//实现MethodInterceptor类
public class LoggingMethodInterceptor implements MethodInterceptor {

    private Object target;

    public Object newProxyInstance(Object target) {

        this.target = target;

        //创建CGLIB字节增强对象,用于生成目标类的子类代理
        Enhancer enhancer = new Enhancer();
        //设置代理类的父类
        enhancer.setSuperclass(target.getClass());

        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        methodProxy.invokeSuper(o, objects);

        return null;
    }
}

public class Test {
    public static void main(String[] args) {

        UserService userService = new UserService();
        LoggingMethodInterceptor interceptor = new LoggingMethodInterceptor();

        UserService instance = (UserService) interceptor.newProxyInstance(userService);

        instance.addUser();
    }
}

AOP(Aspect Oriented Programming)

动态代理是AOP的底层实现,其作用是把横切关注点( 如日志,事务**)**从核心业务逻辑中分离出,形成一个独立的模块.这就可以做到在不修改源代码的情况下,给程序动态统一地添加功能

• 作用:减少代码冗余,提高开发效率,易于维护

• 进一步理解

  在Spring中,AOP基于动态代理实现,其会为目标对象创建一个代理对象,在目标方法执行之前,后,或异常时执行你的配置的增强

  • 如图:原有四个接口要验证参数,日志.我们发现这些代码太冗余.比较繁琐.使用切面后将验证参数,日志等功能提取出来,四个接口我们只需要通过配置就可以直接调用对应功能,让我们更加专注于实际业务逻辑

  

AOP 的关键术语

• 目标对象(Target):
  • **目标对象指的是业务逻辑的实现类,**这些实现类是切面增强的对象.
  • 作用:目标对象是我们通常定义的业务类,切面提供了切点的功能如(日志记录,业务管理等等)
  • 假设有一个UserService业务类,其包含了一个addUser()方法.UserService类就是目标对象,AOP会在addUser()中增强功能
• 织入(Weaving):
  • 织入是将切面(通知和切入点)用于到目标对象的过程.
  • 作用:织入的过程是把定义好的增强逻辑插入到目标对象中去.这是AOP实现的关键步骤,Spring AOP通过动态代理实现
• 切面(Aspect):
  • 切面是对横切关注点的模块化,其包含了切入点和通知,切面提取出业务中一些相同的功能进行统一管理
  • 作用:切面将横切关注点上的功能封装在一起,方便重用.一个切面可以有多个增强方法(通知),这些通知可以应用到目标对象的多个方法上
  • 例如一个LogAspect就可以包含多个通知,用于不同的方法前执行插入日志记录功能等等
• 通知(Advice):
  • 通知是指在切点执行时,执行增强的代码,通知可以在方法执行的不同阶段执行,包括方法执行前,执行后,围绕方法执行的前后
  • 常见分为
    • 前置通知(Before):在目标方法执行之前执行
    • 后置通知(After):在目标方法执行之后执行,无论是否抛出异常
    • 后置返回通知(AfterReturning):在目标方法执行之后执行,有异常时不执行
    • 后置异常通知(AfterThrowing):在目标方法抛出异常时执行
    • 环绕通知(Around):最为常用的通知,在目标方法执行前后执行
• 切入点(PointCut):
  • 切入点指通知应用的具体位置条件,其决定了哪些连接点可以被增强,通常使用切入点达式来定义
  • 作用:切入点是AOP的核心,其决定了哪些方法可以被增强.通过切入点表达式,开发者可以灵活选择要增强的方法
  • 通过execution(* com.company.service.UserService.*(..))切入点表达式,可以表示UserService类中的所有方法都被增强,下面的内容会展开讲解
• 连接点(JoinPoint):
  • 连接点是程序执行的一个具体位置,其指的是可以被切面拦截的方法.连接点是AOP的关键概念.所有的通知都会在某个连接点处执行.在Spring AOP中通常指的是方法调用
  • 作用:连接点定义了切面可以织入的程序位置,通常是目标方法执行的位置.在 Spring AOP中,连接点仅限于方法的执行.

AOP的使用

导入依赖

• 对于普通的Spring项目导入的AOP依赖

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.6</version>
</dependency>

• 对于SpringBoot项目导入的AOP依赖

   <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>

AOP的实现分为XML文件配置和注解配置,XML文件配置都是老掉骨头的东西我们就不学了,注解配置避免了繁琐的XM 配置,使得开发更加灵活,易于理解.我们着重对注解配置进行掌握即可

使用注解实现AOP

• 配置类

  • 配置类是用于启动Spring AOP的注解和扫描指定位置的包.我们创建一个AppConfig类,使用@Comfiguration,@ComponentScan和EnableAspectAutoProxy来启动Spring AOP

  @Configuration
  @ComponentScan({"com.mashang.service", "com.mashang.aspect"})
  @EnableAspectJAutoProxy
  public class APPConfig {
  }

  • @Comfiguration:指明当前类为一个配置类,类似于XML配置文件
  • @EnableAspectAutoProxy:启用Spring AOP注解支持,允许在上下文中应用@Aspect注解标记切面
  • @ComponentScan({"com.mashang.service", "com.mashang.aspect"}):扫描指定包中的组件

• 切面类

  • 接着创建切面类,使用@Aspect注解来标记该类是切面类,切面类中可以通过注解标记不同的增强方法(如@Before,@After,@Around)

  @Component
  //配置切面类得注解
  @Aspect
  @Order(1)
  public class LogAspect {
  
      //定义切点,拦截service包下所有方法
      @Pointcut("execution(* com.mashang.service.*.*(..))")
      public void serviceMethod() {
  
      }
  
      //前置通知
      @Before("serviceMethod()")
      public void before() {
          System.out.println("[前置通知] 方法执行");
      }
  
      //环绕通知,通常用于记录性能耗时
      @Around("serviceMethod()")
      public Object around(ProceedingJoinPoint pjp) throws Throwable {
  
          Long startTime = System.currentTimeMillis();
          for (int i = 0; i < 100000; i++) {
  
          }
          System.out.println("[环绕通知]开始执行方法 " + pjp.getSignature().getName());
  
          Object proceed = pjp.proceed();
  
          Long endTime = System.currentTimeMillis();
          System.out.println("方法耗时: " + (endTime - startTime) + "ms");
  
          return proceed;
      }
      
  		//后置通知
      @After("serviceMethod()")
      public void after() {
          System.out.println("[后置通知] 方法执行");
      }
  
      //异常通知
      @AfterThrowing(pointcut = "serviceMethod()", throwing = "e")
      public void afterThrowing(Exception e) {
          System.out.println("[异常通知]" + e.getMessage());
      }
  }

  • ＠Aspect表示该类为切面类
  • @Order(int):控制切面类的顺序
  • @Component标记交为Spring容器管理,允许注入容器中
  • @Before,@After,@Around,@AroundThrowing表明不同类型的通知
  • 切入点表达式

    • 切入点表达式是AOP的核心语法,用于定义哪些方法需要被增强,与@PointCut注解一同使用

    • 核心语法结构

      execution([修饰符] 返回类型 [包名.类名.方法名(参数列表) [throws 异常类型]])

      • 可以使用通配符
        • *表示匹配任意字符除了.
        • ..表示任意子包或任意参数
      • 如匹配com.mashang.service下包的所有方法

      @PointCut("excution(* com.mashang.service.*.*(..))")

• 测试

  public class Test {
      public static void main(String[] args) {
          //加载Spring配置
          AnnotationConfigApplicationContext cxt
                  = new AnnotationConfigApplicationContext(APPConfig.class);
  
          //获取Userservice实例
          UserService userService = cxt.getBean(UserService.class);
  
          System.out.println("=======测试正常方法=========");
          userService.getUser("张三");
  
          System.out.println("=======测试异常方法=========");
  
          try {
              userService.throwException();
          } catch (Exception e) {
              e.printStackTrace();
          }
  
          cxt.close();
      }
  }