首页 > 编程入门 文章详情

专项攻克——AOP

编程入门 行业动态 更新时间:2024-10-07 04:24:01

<a href=https://www.elefans.com/category/jswz/34/1768146.html style=专项攻克——AOP"/>

专项攻克——AOP

文章目录

  • 1 什么是AOP
  • 2 AOP作用、使用场景
  • 3 AOP底层实现原理
    • 3.1 AOP的JDK动态代理
      • 3.1.1 Proxy类及InvocationHandler类
      • 3.1.2 JDK动态代理代码案例
    • 3.2 AspectJ框架（CGLIB）【重点】
      • 3.2.1 AspectJ是什么？
      • 3.2.2 基于AspectJ实现AOP操作
      • 3.2.3 补充知识——切点表达式execution
      • 3.2.4 AspectJ注解方式（CGLIB）-案例【重要】
  • 6. AOP是如何运行的？

  • 参考博客：AOP的使用（详细讲解）

  • 参考B站视频1

    5分钟精通SpringAOP-视频

  • 参考B站视频2

    史上最完整的AOP底层原理-视频

1 什么是AOP

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程
（1）面向切面编程（方面），利用AOP可以对业务逻辑的各个部分进行隔离，从而是的业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
（2）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能
（3）使用登录的例子说明AOP

2 AOP作用、使用场景

应用场景：

  1. 拦截器、
  2. RPC接口统一日志打印、
  3. 接口入参数据校验、
  4. 权限控制、
  5. 监控方法运行时间、
  6. 缓存优化 （第一次调用查询数据库，将查询结果放入内存对象， 第二次调用， 直接从内存对象返回，不需要查询数据库 ）
  7. 接口限流（推荐wx文章：Redis 做接口限流，一个注解的事！）
  8. 多数据源处理（推荐wx文章：AOP多数据源动态切换）
  9. 事务管理 （调用方法前开启事务， 调用方法后提交关闭事务 ）

补充知识

  • 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …
  • 切面（Aspect）：切面是一个类，其中包含了多个通知和切点。切面用于描述在哪些类、哪些方法的什么位置上执行哪些通知。切面是切点和通知的组合称谓，就是变相给组合起了个名字。
  • 切点（PointCut）：切点是一个表达式，用于描述哪些类的哪些方法会被拦截。通常情况下，切点会使用表达式语言（@execution、within、this 与 target、bean）来定义。在一个应用程序中，通常会有多个切点。（参考：AOP中常见的切点标志符）
  • 通知/增强（Advice）：通知是在切点处执行的代码。通知定义了在目标方法执行前、执行后或异常抛出时需要执行的代码。通知有多种类型。
  • 目标（Target）：被通知对象。
  • 代理（Proxy）：向目标对象应用通知之后创建的对象。
  • 连接点（JointPoint）：与切入点匹配的执行点。连接点可以说是切点的全集，切点是连接点的子集。。

举个例子，下面是一个AOP切面模型图，在某一个方法执行前后执行的一些操作，并且这些操作不会影响程序本身的运行。可以发现，在执行业务逻辑代码的前后，都需要做“验证参数、前置日志、后置日志”的相同操作。这些相同操作可以抽象出来，放在切面类里，在切面类里通过execution（切点）指定要在哪些业务逻辑（连接点）的前或后织入通知代码（advice）。

3 AOP底层实现原理

关于动态代理和静态代理的概念，推荐博客：静态代理和动态代理

AOP底层使用动态代理，有JDK动态代理和CGLIB动态代理

  • （1）动态代理有接口情况，==使用JDK动态代理，即创建接口实现类代理对象，增强类的方法。

  • （2）动态代理没有接口情况，==使用CGLIB动态代理，即创建子类的代理对象，增强类的方法。

代理设计模式：AOP的实现原理是动态代理，讲到动态代理之前先说一下代理模式， 代理模式是指给某一个对象提供一个代理，并由代理对象控制对原对象的引用。代理模式包含如下角色：

  • subject：抽象主题角色，是一个接口。该接口是对象和它的代理共用的接口;
  • RealSubject：真实主题角色，是实现抽象主题接口的类;
  • Proxy:代理角色，内部含有对真实对象RealSubject的引用，从而可以操作真实对象。

代理对象提供与真实对象相同的接口，以便代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。
eg：一个班上的学生需要交作业，现在由班长代理交作业，那么班长就是代理，学生就是被代理的对象。

按照代理的创建时期，代理类可以分为静态代理和动态代理，他们的区别如下

  1. 静态代理：由程序员创建代理类或特定工具自动生成源代码再对其编译。在程序运行前代理类的.class文件就已经存在了。
  2. 动态代理：动态代理是指java程序运行过程（程序已经启动正在运行中）由jvm生成代理类的class信息，该class信息生成后是直接处于内存中的，并没有写入磁盘保存起来，然后通过反射方式实例化代理类对象。因为代理类的class信息已经存在于内存中，所以可以通过反射方式实例化。

静态代理的缺点：静态代理在代码运行之前就已经存在代理类了，每一个代理对象都需要去建一个代理类去代理，当需要代理的对象有很多时，就需要创建很多的代理类，降低了程序可维护性。所以有了动态代理，动态代理可以很方便的对代理类的函数进行统一处理，而不用修改每个代理类中的方法。

3.1 AOP的JDK动态代理

3.1.1 Proxy类及InvocationHandler类

JDK动态代理，需要使用Proxy类的newProxyInstance 方法创建代理对象，该方法有三个参数：
(1) loader，类加载器
(2) interfaces，增强方法所在的类，这个类实现的接口，支持多个接口
(3) h，实现这个接口 InvocationHandler，创建代理对象，写增强的部分

public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)

3.1.2 JDK动态代理代码案例

  1. 创建接口，定义方法

    public interface UserDao {public int add(int a,int b);public String update(String id);}

  2. 创建接口实现类、方法

    public class UserDaoImpl implements UserDao{@Overridepublic int add(int a,int b) {return a+b;}@Overridepublic String update(String id) {return id;}}

  3. 创建代理对象代码

    //创建代理对象（把手）
public class UserDaoProxy implements InvocationHandler {//把创建的是谁的代理对象，把谁传递过来//有参构造传递private Object obj;public UserDaoProxy(Object obj) {this.obj = obj;}//增强的逻辑@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//方法之前System.out.println("方法之前执行..."+method.getName()+":传递的参数..."+ Arrays.toString(args));//被增强的方法执行Object res = method.invoke(obj, args);//方法之后System.out.println("方法之后执行..."+obj);return res;}
}

  4. 调用：使用 Proxy 类创建接口代理对象

    //使用 Proxy 类创建接口代理对象
public class JDKProxy {public static void main(String[] args) {//创建接口实现类代理对象Class[] interfaces = {UserDao.class};UserDaoImpl userDaoImpl = new UserDaoImpl();UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), //JDK代理的类加载器interfaces, //接口new UserDaoProxy(userDaoImpl));//将接口实现类交给处理器增强int res = dao.add(1, 2);System.out.println("result:"+res);}}

3.2 AspectJ框架（CGLIB）【重点】

Spring框架一般都是基于AspectJ实现AOP操作

3.2.1 AspectJ是什么？

AspectJ不是Spring组成部分，独立AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作。

3.2.2 基于AspectJ实现AOP操作

（1）在项目工程里面引入AOP相关依赖
（2）基于xml配置文件实现
（3）基于注解方式实现

<dependency><groupId>org.springframework</groupId><artifactId>spring-aspects</artifactId><version>5.2.15.RELEASE</version></dependency><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.9</version></dependency><dependency><groupId>aopalliance</groupId><artifactId>aopalliance</artifactId><version>1.0</version></dependency><dependency><groupId>org.aspectj</groupId><artifactId>aspectjtools</artifactId><version>1.9.9</version></dependency><dependency><groupId>cglib</groupId><artifactId>cglib</artifactId><version>3.3.0</version></dependency>

3.2.3 补充知识——切点表达式execution

  • 切点表达式作用：知道对哪个类里面的哪个方法进行增强

  • 语法结构：

    execution （【权限修饰符public private等】【返回类型 int long等】【类全路径】【方法名称】(【参数列表】)）

  • 举例

    1. 增强某方法，如com.jin.dao.UserDao类的add方法
      execution(* com.jin.dao.UserDao.add(..))
    2. 增强类的所有方法，如com.jin.dao.UserDao类的所有方法
      execution(* com.jin.dao.UserDao.*(..))
    3. 增强某包里的所有类的所有方法，如com.jin.dao包里所有类的所有方法
      	execution(* com.jin.dao.*.*(..))

3.2.4 AspectJ注解方式（CGLIB）-案例【重要】

  1. 进行通知的配置
    （1）方式一、在spring配置文件中，开启注解扫描；在spring配置文件中开启生成代理对象

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns=""xmlns:xsi=""xmlns:context=""xmlns:aop=""xsi:schemaLocation="://www.springframework/schema/beans/spring-beans.xsd://www.springframework/schema/context/spring-context.xsd://www.springframework/schema/aop/spring-aop.xsd
"><!--开启注解扫描-->
<context:component-scan base-package="com.jin.aopanno"></context:component-scan>
</beans><!--开启Aspect生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

    （2）方式二、完全使用注解开发，创建配置类，不需要创建xml配置文件

    @ComponentScan(basePackages = {"com.jin.pojo"})
@Configuration
//默认EnableAspectJAutoProxy为false，True则使用CGLIB
@EnableAspectJAutoProxy(proxyTargetClass = true) 
public class SpringConfig {
}

    测试代码：

    @Testpublic void MyTest01(){AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);User user = context.getBean("user", User.class);user.add();}

  2. 使用注解创建被增强类User类（目标对象）

    //被增强的类
@Component
public class User {public void add(){System.out.println("add ...");}

  3. 使用注解@Aspect创建增强类UserProxy类，在增加类的通知方法上添加通知类型注解@Before、@After、@AfterReturning、@AfterThrowing、@Around，并使用切点表达式指明代理的目标。

    补充知识

    • @Aspect 设置当前类为切面类
    • @Pointcut 使用当前方法名作为切入点引用名称，例如
      @Pointcut("execution(* *(..))")
public void pt() {
}
    • @Before 标注当前方法作为前置通知
    • @After 标注当前方法作为后置通知
    • @AfterReturning 标注当前方法作为返回后通知
    • @AfterThrowing 标注当前方法作为异常后通知
    • @Around 标注当前方法作为环绕通知

    增强类（切面）

    //增强类
/**
如果有多个增强类对同一个方法进行增强，可以通过
Order设置增强类优先级，数字类型值越小优先级越高
*/
@Component
@Aspect //@Aspect注解指明该类为代理对象
@Order(1)
public class UserProxy {//前置通知//@Before注解表示作为前置通知@Before(value = "execution(* com.jin.aopanno.User.add(..))")public void before(){System.out.println("before ...");}//返回之后的通知@AfterReturning(value = "execution(* com.jin.aopanno.User.add(..))")public void afterReturning(){System.out.println("afterReturning ...");}//@After(value = "execution(* com.jin.aopanno.User.add(..))")public void after(){System.out.println("after ...");}//异常通知@AfterThrowing(value = "execution(* com.jin.aopanno.User.add(..))")public void afterThrowing(){System.out.println("AfterThrowing ...");}//？？@Around(value = "execution(* com.jin.aopanno.User.add(..))")public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {System.out.println("环绕之前 ...");proceedingJoinPoint.proceed();System.out.println("环绕之后 ...");}
}

6. AOP是如何运行的？

更多推荐

专项攻克——AOP

本文发布于:2024-02-07 05:29:28，感谢您对本站的认可！
本文链接:https://www.elefans.com/category/jswz/34/1753257.html
版权声明:本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系，我们将在24小时内删除。
本文标签：专项   AOP

发布评论

评论列表 （有 0 条评论）

最近发表

草根站长

>www.elefans.com

编程频道|电子爱好者 - 技术资讯及电子产品介绍！

热门文章

标签列表