AOP的应用以及代码实现（详细剖析）

已于 2022-03-29 20:14:42 修改
阅读量2.2k 收藏 6
点赞数 2
分类专栏： Spring 文章标签： java spring aop
于 2022-02-20 16:36:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51309915/article/details/123027929
版权

目录

1. 简介

1.1 IOC的主要流程/功能

1.2 AOP的概念图

1.3 AOP 流程图

2. 基本准备工作

------------------------------配置文件实现AOP----------------------------

3.AOP配置文件方式的入门

4. 切入点的表达式（不建议用*号）

-----------------------------注解方式实现AOP----------------------------

5.AOP注解方式入门程序

5.1  配置xml扫描注解

5.2 配置注解

5.3 给切面类添加注解 @Aspect，编写增强的方法，使用通知类型注解声明

5.4 测试类

1. 简介

1.1 IOC的主要流程/功能

1.2 AOP的概念图

1.3 AOP 流程图

1.4 spring 4-5中aop的区别

 

假设一个类Demo

--------------------------AOP相关术语------------------------------

  • Joinpoint(连接点) 类里面有哪些方法可以增强这些方法称为连接点
  • Pointcut(切入点) -- 所谓切入点是指我们要对哪些Joinpoint进行拦截的定义，实际要增强的方法。
  • Advice(通知/增强)-- 所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)。实际增强的逻辑部分就是通知

    • 前置通知 目标方法执行前，进行增强

    • 后置通知 目标方法执行成功后，进行增强。

    • 环绕通知 目标方法执行前后，都可以进行增强。目标对象的方法需要手动执行。

    • 异常通知 目标方法执行失败后，进行增强。(发生异常的时候才会执行，否则不执行)。一旦方法异常，就会通知。

    • 最终通知 目标方法执行成功或者失败，进行增强。类似于finally  

  • Aspect(切面)-- 是 切入点+通知 的结合，以后咱们自己来编写和配置的。通知应用到切入点的一个过程

2. 基本准备工作

AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法,AspectJ实际上是对AOP编程思想的一个实践.

------------------------------配置文件实现AOP----------------------------

3.AOP配置文件方式的入门

3.1 创建maven项目，坐标依赖

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.12</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <!--AOP联盟-->
    <dependency>
        <groupId>aopalliance</groupId>
        <artifactId>aopalliance</artifactId>
        <version>1.0</version>
    </dependency>
    <!--Spring Aspects-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <!--aspectj-->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.3</version>
    </dependency>
</dependencies>

3.2 创建被增强的类User.java

package com.qcby;

import org.springframework.stereotype.Component;

public class User {
   public void add(){
//        int a= 10/0;
        System.out.println("add方法");
    }
}

3.3 定义切面类 UserPorxy.java

package com.qcby;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;


public class UserPorxy {
//    增强/通知  ---》前置通知
    public void before(){
        System.out.println("切面类before先执行");
    }

//    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
//        System.out.println("这是在add方法执行前执行的(around)。。。。");
//
//        // 执行被增强的方法
//        proceedingJoinPoint.proceed();
//
//        System.out.println("这是在add方法执行后执行的(around)。。。。");
//    }
    // 无论切入点成功或者失败都会进程执行，类似于finally

//    public void after(){
//        System.out.println("这是在add方法执行后执行的(after)。。。。");
//    }
    // 后置通知 : 和 after一样都是在方法执行之后执行，但是 after 无论切入点成功或者失败都会进程执行

//    public void afterReturning(){
//        System.out.println("afterReturning");
//    }

//    public void afterThrowing(){
//        System.out.println("afterThrowing....");
//    }


}

3.4 将目标类配置到Spring中 SpringConfig.xml

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">


<bean id="user" class="com.qcby.User"/>
<bean id="userPorxy" class="com.qcby.UserPorxy"/>


<!--配置切面-->
<aop:config>
    <!--配置切面 = 切入点 + 通知组成-->
    <aop:aspect ref="userProxy">
        <!--前置通知：UserServiceImpl的save方法执行前，会增强-->
        <!--pointcut：后边是切入点表达式，作用是知道对对面的那个方法进行增强-->
        <aop:before method="before" pointcut="execution(public void com.aopImpl.User.add())"/>
               <!--环绕通知-->
<!--                <aop:around method="around" pointcut="execution(public void com.qcby.User.add())"/>-->
                <!--最终通知-->
<!--                <aop:after method="after" pointcut="execution(public void com.qcby.User.add())"/>-->
                <!--后置通知-->
<!--                <aop:after-returning method="afterReturning" pointcut="execution(public void com.qcby.User.add())"/>-->
                <!--异常通知-->
<!--                <aop:after-throwing method="afterThrowing" pointcut="execution(public void com.qcby.User.add())"/>
         
    </aop:aspect>
</aop:config>


</beans>

3.4 完成测试 DemoTest.java

package com.qcby.test;

import com.qcby.User;
import javafx.application.Application;
import jdk.nashorn.internal.ir.CallNode;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class DemoTest {
    @Test
    public void aopTest(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("SpringConfig.xml");
        User user = (User) ac.getBean("user");
        user.add();
    }

}

五种类型要分别测试，测试完一个注释一个

4. 切入点的表达式（不建议用*号）

 @Pointcut("execution(public * com.qcby.demo.proxyaop.controller..*.*(..))")
    public void viewRecordsPoinCut() {

    }

再配置切入点的时候，需要定义表达式，具体展开如下：

切入点表达式的格式如下：

execution([修饰符] [返回值类型] [类全路径] [方法名 ( [参数] )])

修饰符可以省略不写，不是必须要出现的。

返回值类型是不能省略不写的，根据你的方法来编写返回值，可以使用 * 代替。

-----------------------------注解方式实现AOP----------------------------

5.AOP注解方式入门程序

创建maven工程，导入坐标。编写接口，完成IOC的操作。步骤略。

编写切面类

给切面类添加注解 @Aspect，编写增强的方法，使用通知类型注解声明

5.1  配置xml扫描注解

<?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.qcby"/>
    <!--开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    
</beans>

5.2 配置注解

package com.qcby;

import org.springframework.stereotype.Component;

@Component
public class User {

    public void add(){
//        int a= 10/0;
        System.out.println("add方法");
    }

}

5.3 给切面类添加注解 @Aspect，编写增强的方法，使用通知类型注解声明

package com.qcby;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class UserPorxy {
//    增强/通知  ---》前置通知
    @Before(value = "execution(public void com.qcby.User.add())")
    public void before(){
        System.out.println("切面类before先执行");
    }

//@Around(value = "execution(public void com.qcby.User.add())")
//    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
//        System.out.println("这是在add方法执行前执行的(around)。。。。");
//
//        // 执行被增强的方法
//        proceedingJoinPoint.proceed();
//
//        System.out.println("这是在add方法执行后执行的(around)。。。。");
//    }
    // 无论切入点成功或者失败都会进程执行，类似于finally

//    @After(value = "execution(public void com.qcby.User.add())")
//    public void after(){
//        System.out.println("这是在add方法执行后执行的(after)。。。。");
//    }
    // 后置通知 : 和 after一样都是在方法执行之后执行，但是 after 无论切入点成功或者失败都会进程执行

//    @AfterReturning(value = "execution(public void com.qcby.User.add())")
//    public void afterReturning(){
//        System.out.println("afterReturning");
//    }

//   @AfterThrowing(value = "execution(public void com.qcby.User.add())")
//    public void afterThrowing(){
//        System.out.println("afterThrowing....");
//    }


}

5.4 测试类

package com.qcby.test;

import com.qcby.User;
import javafx.application.Application;
import jdk.nashorn.internal.ir.CallNode;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class DemoTest {
    @Test
    public void aopTest(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("SpringConfig.xml");
        User user = (User) ac.getBean("user");
        user.add();
    }

}

 5.5 结果呈现（五个分别测试，在测试异常的时候，需要在User.java中写个除0异常）

 

叫我老伯
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
AOP的实现机制
执着之道
10-18 535
附件中有本文的源代码和Pdf版。本文写的很长的原因，是不希望大家学习AOP时到处找资料，大家有时间可以按照本文动手实践下，相信会有非常大的收获的，有什么问题互相交流，有问必答！ 1 AOP各种的实现     AOP就是面向切面编程，我们可以从几个层面来实现AOP。 在编译器修改源代码，在运行期字节码加载前修改字节码或字节码加载后动态创建代理类的字节码，以下是各种实现机制的比较。    ...
AOP的详解及代码演示
weixin_68829057的博客
03-28 404
所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。然而需求总是变化的，有一天，新增了一个需求，需要再多出做修改，我们需要再抽象出一个方法，然后再在需要的地方分别调用这个方法，又或者我们不需要这个方法了，我们还是得删除掉每一处调用该方法的地方。这种散布在各处的无关的代码被称为横切（cross-cutting）代码，在OOP设计中，它导致了大量代码的重复，而不利于各个模块的复用。
Java的AOP(三大组件之一)入门到+案例详解
最新发布
Java_sqcs的博客
04-27 1321
AOP AOP AOP 重要的事情说三遍.非常重要的奥
AOP实现的三种方式
weixin_45264992的博客
04-20 7947
AOP实现的三种方式 说说为什么要使用AOP编程： AOP（面向切面编程）是OOP（面向对象编程）发展而来，在OOP编程中，每一个对象都有自己特定的功能，但是如果我们需要引入公共的功能时候，那么如果继续使用OOP编程思想的话，就会导致大量代码重用，而不利于模块的重用。而AOP编程则是将一些公共业务封装起来，为每一个需要使用这些公共业务的对象提供相应业务（通过代理实现）。一般将公共业务封装起来的类就是切面类，也就是我们切面编程所说的切面。 下面我们给对象添加一个公共业务：日志输出。 即在方法执行前后都在控制台
实现AOP的三种方式
clf20731的博客
03-25 2233
实现AOP的三种方式 概念 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 AOP在Spring中的作用 提供声明性事务 允许用户自定义切面 使用Spri
什么是AOP，如何实现？（有落地代码）
java小白翻身
05-25 1720
好的，下面是 AOP 的总结：AOP（Aspect-Oriented Programming）是一种编程范式，它通过将横切关注点（如日志记录、事务管理等）从业务逻辑中分离出来，以模块化的方式实现这些关注点。AOP 的核心思想是将程序的功能分解成不同的关注点，然后通过切面将这些关注点模块化，从而提高代码的可维护性和可重用性。AOP 的主要概念包括：切面（Aspect）：横切关注点的模块化，它包括切点和通知。切点（Pointcut）：程序中需要被拦截的方法或者类。
AOP的三种实现方法
柒七的博客
02-05 4277
Spring AOP的3种实现方式 对于框架的学习，我觉得得先会用，然后再深入原理。关于Spring AOP的实现我在这里划分成3个方式（以日志管理为例）废话不多说，直接上代码了。（以下代码是基于我之前所写的SSM框架整合的例子，如果有需要可查看我之前的博客） 配置之前注意配置文件要加上命名空间：xmlns:aop="http://www.springframework.org/schema/aop" 1.基于xml配置的实现 spring-mvc.xml <!-- 使用xml配...
spring源代码分析：aop的实现
05-03
《Spring源代码分析：AOP的实现》 在软件开发领域，Spring框架因其强大的功能和易用性，已经成为Java企业级应用的事实标准。其中，面向切面编程（Aspect Oriented Programming，简称AOP）是Spring的重要特性之一，...
应用AOP提高软件代码质量的研究
06-20
为了提高软件代码质量,笔者从开发与审核两个过程分析了可以改进代码质量的关键环节,并在此基础上利用AOP提供的连接点模型,提出了一个灵活的、面向扩展的代码质量框架AjCQFr(AspectJ-based Code Quality Framework)。...
Springaop原理及各种应用场景
01-27
静态代理通常在编译时通过AOP框架产生的代理类来实现，如AspectJ，它可以在编译阶段增强源代码。动态代理则在运行时生成，如Spring AOP中利用JDK动态代理或CGLIB。JDK动态代理适用于实现了接口的目标对象，而CGLIB则...
Spring AOP应用
06-30
在本应用中，我们将探讨如何使用Spring AOP来实现动态数据源以及数据缓存操作。 **一、Spring AOP基础** 1. **切面（Aspect）**：切面是关注点的模块化，包括关注点的声明和实现。在Spring AOP中，切面通常由一个...
基于AOP策略模式的实现机制
07-20
本文首先将传统基于OOP策略模式的局限性进行分析说明，提出基本的策略模式以及“链式”策略模式基于AOP的具体实现，解决传统策略模式可能出现的代码分散、代码混乱问题；接着进行复杂度方面的实验对比分析；最后分析...
AOP的三种实现方式
qq_51447436的博客
02-09 5737
AOP的三种实现方式
AOP的四种实现方式
d1451545368的博客
10-13 834
AOP实现方式
Spring源码之AOP实现
qq_38706652的博客
08-20 1279
Spring源码之AOP
AOP的实现方式
qq_45754346的博客
05-05 3476
AOP在代码中的实现方式有三种： 1.采用spring的原生API进行实现 先定义通知类： after通知类型的通知类实现AfterRuturnAdvice接口，实现内部的方法，在方法中加入你要通知的操作 before通知类型的通知类实现MethodBeforeAdvice接口，实现内部的方法，在方法中加入你要通知的操作 还有其他的通知类型就不一一列举了，之后便是在application配置文件中声明通知类bean、插入类bean，配置切入点、通知 然后，当你运行被切入的类的切入点方法时
Spring框架 第4章 AOP概述
尚硅谷铁杆粉丝的博客
04-29 186
第4章 AOP概述 4.1 AOP概述 AOP(Aspect-Oriented Programming，面向切面编程)：是一种新的方法论，是对传 统 OOP(Object-Oriented Programming，面向对象编程)的补充。 AOP编程操作的主要对象是切面(aspect)，而切面模块化横切关注点。 在应用AOP编程时，仍然需要定义公共功能，但可以明确的定义...
AOP如何实现及实现原理
weixin_34224941的博客
11-23 5059
概述： 最近在开发中遇到了一个刚好可以用AOP实现的例子，就顺便研究了AOP的实现原理，把学习到的东西进行一个总结。文章中用到的编程语言为kotlin，需要的可以在IDEA中直接转为java。 这篇文章将会按照如下目录展开： AOP简介 代码中实现举例 AOP实现原理 部分源码解析 1. AOP简介 相信大家或多或少的了解过AOP，都知道它是面向切面编程，在网上搜索可以找到很多的解释。这里我用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

叫我老伯

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值