Spring——AOP

Posted 2023-02-22 名字真的很急用

AOP

• 面向切面编程，Spring中的可插拔组件技术

• 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术

• 作用
  将分散在各个方法中的重复代码抽取出来，然后在程序编译或运行的时候，再将这些抽取出来的代码应用到需要执行的地方。

入门案例

• 第一步：导入依赖

  •  <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.9.4</version>
            </dependency>
    

• 第二步：添加命名空间和约束

  • 导入命名空间
    xmlns:aop="http://www.springframework.org/schema/aop"
    约束
    http://www.springframework.org/schema/aop
            http://www.springframework.org/schema/aop/spring-aop.xsd
    

• 第三步：做切面

  • package com.aop;
    
    import org.aspectj.lang.JoinPoint;
    
    public class MyAop 
    //抽取出来的共同模块，和被抽取业务无关联的
       public void method(JoinPoint joinPoint)
           //获取目标对象           获取运行时状态
           String name = joinPoint.getTarget().getClass().getName();
           String methodName = joinPoint.getSignature().getName();
    
           System.out.println("目标对象为："+name+"角色判断"+"方法名称为："+methodName);
           System.out.println("角色判断");
       
    
    
    

• 第四部:配置xml文件

  • <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://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
    ">
        <!--<bean id="book" class="com.Book"></bean>
        <bean id="user" class="com.User">
            <property name="book" ref="book"></property>
         </bean>-->
        <!--让容器扫描：需要采用注解方式注入的类-->
        <context:component-scan base-package="com"></context:component-scan>
        <!--将业务类注入ioc容器-->
    
        <bean id="admin" class="com.easthome.Admin"></bean>
        <bean id="user" class="com.easthome.User"></bean>
        <!--将切面注入ioc容器-->
        <bean id="myaop" class="com.aop.MyAop"></bean>
        <!--aop编程的相关配置-->
        <aop:config>
            <!--切面需要知道插入的位置  切点：Pointcut-->
            <aop:pointcut id="a1" expression="execution(public * com..*.*(..) )"/>
            <!--指定切面类-->
            <aop:aspect ref="myaop">
                <!--通知：何时执行-->
                <aop:before method="method" pointcut-ref="a1"></aop:before>
            </aop:aspect>
        </aop:config>
    </beans>
    

AOP关键概念

• Spring AOP 和Aspectj关系

  • Aspectj是一个面向切面的框架

• Spring AOP使用aspectjweaver该依赖实现了类和方法的匹配

• 关键概念

• 关键概念	解释
  Aspect	切面：具体的可插拔组件的功能类（通常一个切面只包含一个功能）
  Target class/Method	目标类/目标方法
  PointCut	切入点：使用表达式来明确切面的位置
  JoinPoint	连接点：包含了目标类和目标对象
  Advice	通知:说明具体的切面执行的时机

  切面：类，思想

  JoinPoint:目标 切面 ---- 》连接点 —>目标

  PoinCut:切入点： 插入的位置

  Advice:时机 ，前 ，后

• JoinPoint核心方法

  方法名	作用
  getTarget()	获取目标对象
  getSignature()	获取目标方法
  Object[] getArgs()	获取目标参数

切入点表达式

• 组成部分 public void method(参数)

  • .. * .
    .. 包 参数（可变参）
    * 通配符
    总结：一干到底
    

  • * *..*.*(..) :任意修饰符 返回值 
    * *..*（..）
    
    
    public int *..*.*(..)
    

  • public void m1();
    public void m2();
    public void m3();
    public void m4();
    public void m1();
    
    

通知的类型

通知类型	说明
before	前置通知
after	后置通知
after-returning	目标返回值后，通知执行
after-throwing	异常后通知（遇到异常通知）
around	环绕
introductionInterceptor	暂时不用

• aroud:注意

  1:切入点 一定要有返回值（Object）
  2:参数ProceesdingJionPoint
  

• 注解实现

  •  <!--开启注解扫描-->
        <context:component-scan base-package="cn"></context:component-scan>
        <!--启动AOP的注解模式-->
        <aop:aspectj-autoproxy/>
    

  • 测试代码

    • package cn;
      
      
      import org.springframework.stereotype.Component;
      
      @Component
      public class Car 
          public  void say()
              System.out.println("被环绕");
          
      
      ==================================
      package cn;
      
      import org.aspectj.lang.ProceedingJoinPoint;
      import org.aspectj.lang.annotation.Around;
      import org.aspectj.lang.annotation.Aspect;
      import org.aspectj.lang.annotation.Before;
      import org.springframework.stereotype.Component;
      
      @Component
      @Aspect
      public class Myaop 
          @Around("execution(* *(..))")
          public  Object m(ProceedingJoinPoint point)
              Object proceed =null;
              try 
                  System.out.println("======前===========");
                  proceed   = point.proceed();
                  System.out.println("==========后===========");
               catch (Throwable throwable) 
                  throwable.printStackTrace();
              
              return proceed;
          
      
      ==============================
      package cn;
      
      import org.springframework.context.support.ClassPathXmlApplicationContext;
      
      public class Test 
          public static void main(String[] args) 
              ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
              Car car = classPathXmlApplicationContext.getBean("car", Car.class);
              car.say();
          
      
      
      

设计模式

• 代理模式（静态代理和动态代理）
  • 静态代理
  • 动态代理
    • 代理类（中介），不需要自己去定义了，jdk给我们提供（需要的时候）
    • InvocationHandler
• 注意：
  • 目标类
  • 接口
    • 要有代理方法

AOP底层原理

• 采用代理的机制：
  • JDK的动态代理（Proxy）：针对接口的实现类产生代理
  • CGlib动态代理：针对没有接口的