Spring AOP学习

最新推荐文章于 2025-04-12 17:39:28 发布
最新推荐文章于 2025-04-12 17:39:28 发布
阅读量177 收藏
点赞数
文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_42436233/article/details/123676616
版权

Spring——AOP

1、Spring的AOP简介

1.1 什么是AOP

​ AOP为Aspect Orented Programming的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术

​ AOP是OOP的延续，是软件开发的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生泛型，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各个部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

1.2 AOP的作用及其优势

  • 作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强
  • 优势：减少重复代码，提高开发效率，并且便于维护

1.3 AOP的底层实现

实际上，AOP的底层是通过Spring提供的动态代理实现的，在运行期间，Spring通过动态代理生成动态代理对象，代理对象方法执行时进行增强功能的介入，再去调用目标对象的方法，从而增强

  • JDK代理：基于接口的动态代理

目标对象➡️目标接口➡️JDK动态代理（代理对象–内存，Java运行时对象）

  • cglib代理：基于父类的动态代理技术

目标对象➡️代理对象（内存 Java运行时）

1.5 JDK的动态代理

步骤如下：

1、创建接口

public interface TargetInterface {
    public void save();
}

2、实现类

public class Tartget implements TargetInterface {
    public void save() {
        System.out.println("save running.....");
    }
}

3、增强类

public class Advice {
    public void before(){
        System.out.println("前置增强....");
    }

    public void after(){
        System.out.println("后置增强....");
    }
}

4、编写测试

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

        //创建目标对象
        final Tartget target = new Tartget();
        //增强对象
        final Advice ad= new Advice();
        //返回值，就是动态代理生成的代理对象
        TargetInterface o = (TargetInterface)Proxy.newProxyInstance(
                target.getClass().getClassLoader(),//目标对象类加载器
                target.getClass().getInterfaces(),//目标对象相同的接口字节码对象数组
                new InvocationHandler() {
                    //代理对象的任何方法，实质执行的都是invoke方法
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //前置增强
                        ad.before();
                        //执行目标方法
                        Object invoke = method.invoke(target, args);//执行目标方法
                        //后置增强
                        ad.after();
                        return invoke;
                    }
                }
        );
        //代理对象的方法
        o.save();
    }
}

1.6基于cglib的动态代理

1、创建目标类

2、创建增强类

3、测试

public class ProxyTest {
    public static void main(String[] args) {
        //创建目标对象
        final Tartget target = new Tartget();
        //增强对象
        final Advice ad= new Advice();
        //返回值，就是动态代理生成的代理对象，基于Cglib
        //1、创建增强器
        Enhancer enhancer = new Enhancer();
        //2、设置父类
        enhancer.setSuperclass(Tartget.class);
        //3、设置回调
        enhancer.setCallback(new MethodInterceptor() {
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                ad.before();//执行前置

                method.invoke(target,args);//执行目标

                ad.after();//执行后置

                return null;
            }
        });
        //4、创建代理对象
        Tartget o = (Tartget)enhancer.create();
        o.save();
        //代理对象的方法

    }
}

1.7 AOP相关概念

  • Target 目标对象：代理对象
  • Proxy 代理：一个类被AOP织入增强后，就产生一个结果代理类
  • Joinpoint 连接点：所谓连接点是指那些被拦截到的点，在Spring中，指的是方法，因为Spring只支持方法类型的连接点
  • Pointcut 切入点：所谓切入点是指我们要对哪些Joinpoint进行拦截定义
  • Advice 通知/增强：所谓通知是指拦截到Jointpoint之后要做的事情就是通知
  • Aspect（切面）:是切入点和通知的结合
  • Weaving（织入）：是指把增强应用到目标对象来创建的代理对象的过程，Spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入

1.8 AOP开发明确的事项

  1. 需要编写的内容
  • 编写业务核心代码（目标类，目标方法）
  • 编写切面类，切面类中有通知（增强功能方法）
  • 在配置文件中，配置织入关系，即将有哪些通知与连接点进行结合

2）AOP技术实现的内容

Spring框架监控切入点方法的执行，一旦监控到切入点方法被执行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完全完整的代码逻辑运行。

3） AOP底层使用哪种代理方式

框架根据目标类是否实现了接口来决定采用哪种动态代理的方式。

1.9 知识要点

  • aop：面向切面编程
  • aop底层实现原理：基于JDK的动态代理和基于Cglib的动态代理
  • aop的重点概念：
    • Pointcut：被增强的方法
    • Advice：封装增强业务逻辑的方法
    • Aspect：切点+通知
    • Weaving：将切点与通知结合的过程
  • 开发明确事项：
    • 谁是切点
    • 谁是通知
    • 将切点和通知进行织入

2、基于XML的AOP开发

2.1快速入门

1）导入AOP的相关坐标

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.3.RELEASE</version>
</dependency>
<!--aspectj框架-->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.13</version>
</dependency>

2）创建目标接口和目标类

public interface TargetInterface {

    public void save();
}

public class Tartget implements TargetInterface {
    public void save() {
        System.out.println("save running.....");
    }
}

3）创建切面类

public class MyAspect {

    public void before(){
        System.out.println("前置增强Aspect.....");
    }

    public void after(){
        System.out.println("后置增强Aspect.....");
    }
}

4）将目标类和切面类的对象创建权交给spring

<!--目标对象-->
<bean id="target" class="com.itcast.aop.Tartget"></bean>

<!--切面对象-->
<bean id="myAspect" class="com.itcast.aop.MyAspect" ></bean>

5）在applicationContext.xml中配置织入关系

<!--织入,告诉spring框架，哪些方法（切点）需要进行哪些增强（前置、后置。。。。）-->
<aop:config>
    <!--声明切面-->
    <aop:aspect ref="myAspect">
        <!--切面，切点，通知-->
        <aop:before method="before" pointcut="execution(public void com.itcast.aop.Tartget.save())"></aop:before>
    </aop:aspect>
</aop:config>

6）测试代码

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AOPTest {
    @Autowired
    private TargetInterface targetInterface;


    @Test
    public void test(){
        targetInterface.save();
    }
}

2.2XML配置AOP详解

1、切点表达式的写法

语法execution([修饰符] 返回值类型 包名.类名.方法名(参数))

  • 访问修饰符可以省略
  • 返回值类型、包名、类名、方法名可以使用*号代表任意
  • 包名与类名之间一个点，代表当前包下的类，两个点，表示当前包下的类
  • 参数列表可以使用两个点…表示任意个数，任意类型

execution(public void com.itcast.aop.Tartget.save())
execution(void com.itcast.aop.Tartget.(…))–任意参数的所有方法
execution( com.itcast.aop..(…))
execution(* com.itcast.aop….(…))
execution(* ….*(…))

2、通知类型

配置语法：

<aop:通知类型 method=“切面类总方法名” pointcut=”切点表达式“></aop:通知类型 >

名称标签说明
前置通知<aop:before >用于配置前置通知，自定增强的方法在切入点方法前执行
后置通知<aop:after-returning >用于后置通知，指定增强的方法在切入点方法之后执行
环绕通知<aop:arround >配置环绕通知，增强的方法在切入点方法前和方法后都执行
异常抛出通知<aop:throwing >异常抛出通知，增强的方法在出现异常时执行
最终通知<aop:after >最终通知，无论增强是否有异常都执行

代码及配置如下：

<aop:config>
    <!--生命切面-->
    <aop:aspect ref="myAspect">
        <!--切面，切点，通知-->
       <!-- <aop:before method="before" pointcut="execution(public void com.itcast.aop.Tartget.save())"></aop:before>
        &lt;!&ndash;后置增强&ndash;&gt;
        <aop:after-returning method="afterReturing" pointcut="execution(public void com.itcast.aop.Tartget.save())"></aop:after-returning>-->
        <!--环绕增强-->
        <aop:around method="around" pointcut="execution(public void com.itcast.aop.Tartget.save())"></aop:around>
<!--异常增强-->
        <aop:after-throwing method="throwing" pointcut="execution(public void com.itcast.aop.Tartget.save())"></aop:after-throwing>
<!--最终增强-->
        <aop:after method="after" pointcut="execution(public void com.itcast.aop.Tartget.save())"></aop:after>
    </aop:aspect>
</aop:config>

切面

public class MyAspect {

    public void before(){
        System.out.println("前置增强Aspect.....");
    }

    public void afterReturing(){
        System.out.println("后置增强Aspect.....");
    }

    //正在执行的连接点
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕前增强");
        //切入方法
        Object proceed = pjp.proceed();
        System.out.println("后置增强");
        return proceed;
    }

    //异常抛出
    public void throwing(){
        System.out.println("异常抛出增强.....");
    }

    //最终增强
    public void after(){
        System.out.println("最终增强.....");
    }
}

目标

public class Tartget implements TargetInterface {
    public void save() {
        int i=1/0;
        System.out.println("save running.....");
    }
}

测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AOPTest {
    @Autowired
    private TargetInterface targetInterface;


    @Test
    public void test(){
        targetInterface.save();
    }
}

3、切点表达式的抽取

当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用point-ref属性来代替pointcut属性来抽取后的切点表达式

<aop:config>
    <!--声明切面-->
    <aop:aspect ref="myAspect">
        <!--抽取切点表达式-->
        <aop:pointcut id="myPointcut" expression="execution(public void com.itcast.aop.Tartget.save())"/>
        <aop:around method="around" pointcut-ref="myPointcut"/>
        <aop:after method="after" pointcut-ref="myPointcut"/>
    </aop:aspect>
</aop:config>

知识要点

aop织入

<aop:config >
    <aop:aspect ref="myAspect">
        <aop:before method="通知方法" pointcut="切点表达式"></aop:before>
    </aop:aspect>
</aop:config>

通知类型：前置通知、后置通知、环绕通知、异常抛出通知、最终通知

切点表达式的写法：

execution([修饰符] 返回值类型 包名.类名.方法名(参数))

3、基于注解的AOP开发

3.1快速入门

步骤：

1）创建目标接口和目标类（内部切点）

2）创建切面类（内部有增强方法）

3）将目标类和切面类的对象创建权交给Spring

4）注解配置织入

5）开启组件扫描

6）测试

3.2

1、业务代码

接口
public interface TargetInt {

    public void save();
}
实现类
@Component("target")
public class TargetAnno implements TargetInt{
    public void save() {
        System.out.println("save running......");
    }
}
切面类
@Component("myAspect")
//标注当前类是一个切面类
@Aspect

public class MyAspect {
    //定义切点表达式
    @Pointcut("execution(public void com.itcast.anno.*.*(..))")
    public void pointcut(){
    }

    @Before(value="MyAspect.pointcut()")
    public void before(){
        System.out.println("前置增强Aspect.....");
    }

    @AfterReturning(value = "execution(public void com.itcast.anno..*.*(..))")
    public void afterReturing(){
        System.out.println("后置增强Aspect.....");
    }

    //正在执行的连接点
    @Around("execution(public void com.itcast.anno..*.*(..))")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕前增强");
        //切入方法
        Object proceed = pjp.proceed();
        System.out.println("后置增强");
        return proceed;
    }

    //异常抛出
    @AfterThrowing("execution(public void com.itcast.anno..*.*(..))")
    public void afterThrowing(){
        System.out.println("异常抛出增强.....");
    }

    //最终增强
    @After("execution(public void com.itcast.anno..*.*(..))")
    public void after(){
        System.out.println("最终增强.....");
    }
}

//配置
@Configuration
@ComponentScan(basePackages = {"com.itcast.anno"})
@EnableAspectJAutoProxy //AOP自动代理
public class AnnoConfig {
}


测试
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = AnnoConfig.class)
public class AnnoTest {
    @Autowired
    private TargetInt targetInterface;


    @Test
    public void test(){
        targetInterface.save();
    }
}

3.3知识要点

  • 注解AOP开发步骤
    • 使用@Aspect标注切面
    • 使用@通知注解标注通知方法
    • 在配置文件中配置aop自动代理<aop:aspectj-autoproxy />
  • 通知注解类型
通知类型注解说明
前置通知@Before用于配置前置通知
后置通知@AfterReturning配置后置通知
环绕通知@Around配置环绕通知
异常抛出通知@AfterThrowing配置异常抛出通知
最终通知@After配置最终通知
SpringAOP学习--SpringAOP简介及原理
drhrht的博客
08-02 4229
为了标准化AOP，Spring引入了一套AOP顶级API--AOP联盟，用来定义和使用AOP。底层根据配置生成JDK或CGLIB动态代理对象。SpringAOP不是一种新的AOP实现，使用JDK动态代理和CGLIB动态代理实现SpringAOP配置方式核心是Advisor，可以自定义Advisor，也可以通过AspectJ间接定义AdvisorSpringAOP的实现遵循了AOP联盟规范，AOP联盟顶级API接口贯穿了整个AOP过程httpshttpshttpshttpshttps。...
SpringAOP学习
好学而不勤问非真好学者
09-01 421
什么是 AOP? OP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 AOP 是 OOP 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 ...
Spring学习-2（AOP）
最新发布
qq_64522411的博客
04-12 335
使用JoinPoint接口的getArgs()方法获取原始方法的参数，该接口是ProceedingJoinPoint接口的父接口，所以ProceedingJoinPoint也可以调用getArgs()方法获取原始方法的参数。若原始方法有返回值，则增强方法也需定义对应的返回值，并在调用原始方法后，经过增强的原始方法返回值为增强方法的返回值。（4）切面：在确定切入点和通知后，需要将切入点和通知进行绑定，以确保对对应的方法进行增强，那么这种进行切入点和通知绑定的操作就是切面。（5）绑定切入点和通知。
Spring-AOP的学习
weixin_57143533的博客
06-10 153
1 动态代理 实现方式：
SpringAop学习
qq_45891099的博客
07-25 351
AOP是一种思想，一种编写方式。编写一段代码在合适的时机找到切入点然后执行。不直接修改原来的代码，而是在源代码执行前后执行一段额外的代码。AOP之代理AOP是通过代理方式实现的，由代理对象持有原对象，在执行原对象目标方法的前后执行增强的方法。代理对象需要是原对象接口的实现或原对象的子类。代理方式分为静态代理和动态代理，区别在于代理对象生成方式不同。静态代理编译器增强，编写代理class，使用代理类替换原有类进行调用。动态代理运行期增强，内存中动态生成代理类，使用反射动态调用原对象方法。.........
spring aop 学习
gouze4419的博客
11-19 159
spring aop 学习 1.匹配包、类型 //匹配ProductService类里头的所有方法 @pointcut("within(com.imooc.service.ProductService)") public void matchType(){} //匹配com.imooc包及子包下所有类的方法 @poincut("within(com.imooc..*)") public void...
springaop学习
03-28
### Spring AOP 学习知识点详解 #### 一、Spring AOP 原理 **Spring AOP**（面向切面编程）是 Spring 框架中的一个关键特性，它提供了一种优雅的方式来处理横切关注点（cross-cutting concerns）。在实际应用中，...
spring aop 学习笔记
05-27
本学习笔记将深入探讨Spring AOP的核心概念、工作原理以及实际应用。 1. **核心概念** - **切面（Aspect）**：切面是关注点的模块化，包含业务逻辑之外的横切关注点，如日志、事务管理。 - **连接点（Join Point...
JavaEE之Spring AOP 学习（含练习实例代码之登录操作Java）
10-14
在本项目中，我们将深入学习Spring AOP的相关知识，并通过一个具体的练习实例来加深理解。该实例涉及到了Java语言编写的登录操作功能，通过AOP的方式将横切逻辑应用到登录操作中。使用AOP可以将横切关注点与业务逻辑...
spring AOP 学习
weixin_39454194的博客
09-20 290
1、spring aop 基础       spring 有两大核心功能，DI 和 AOP。DI有助于应用之间的解耦，而AOP可以实现横切关注点与他们所影响的对象之间的解耦。spring 只支持方法级别的连接点。      什么是面向切面编程？切面能帮助我们模块化横切关注点。横切关注点可以被模块化为特殊的类，这些类被称为切面。面向切面编程，可以让我们把更多的注意力放在最重要的业务逻辑代码，而次...
SpringAop学习（一）
BushRo
09-23 1449
Aop面向切面编程 AOP是Spring提供的关键特性之一。AOP即面向切面编程，是OOP编程的有效补充。使用AOP技术，可以将一些系统性相关的编程工作，独立提取出来，独立实现，然后通过切面切入进系统。从而避免了在业务逻辑的代码中混入很多的系统相关的逻辑——比如权限管理，事物管理，日志记录等等。这些系统性的编程工作都可以独立编码实现，然后通过AOP技术切入进系统即可。从而达到了将不同的关注点分离...
Spring学习记录（六）：Spring AOP学习
weixin_44544536的博客
09-09 146
Spring学习记录（六）：Spring AOP学习 文章目录Spring学习记录（六）：Spring AOP学习前言一、AOP是什么？二、使用AOP的好处三、AOP底层原理实现四、AOP的相关术语1.Target（目标对象）2.Proxy（代理）3.Joinpoint（连接点）4.Pointcut（切入点）5.Advice（通知）6.Aspect（切面）7.Weaving（织入）五、注意事项六、基于XML实现AOP开发1.导入坐标2. 创建目标接口以及实现类3.创建通知类以及方法4.创建xml文件5.测试
Spring学习之AOP
shuaishuai123485615的专栏
11-25 617
什么是AOP AOP（Aspect-OrientedProgramming，面向切面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。底层是通过Java的动态代理来实现，可以参考之前的文章 http://blog.youkuaiyun.com/shuaishuai123485615/article/details/52539798#t1   ， 主
回顾---AOP
www_ly的博客
10-27 233
学习aop之前 , 我们要先了解一下代理模式！ 为什么要学习代理模式 因为AOP的底层机制就是动态代理 代理模式： 静态代理 动态代理 静态代理 代理的三要素: 有共同的⾏为（比如结婚） - 接⼝ ⽬标⻆⾊（新⼈） - 实现⾏为 代理⻆⾊（婚庆公司） - 实现⾏为 增强⽬标对象⾏为 静态代理的特点： ⽬标⻆⾊固定 在应⽤程序执⾏前就得到⽬标⻆⾊ 代理对象会增强⽬标对象的⾏为 有可能存在多个代理 引起"类爆炸"（缺点） 静态代理的实现： 定义⾏为（共同） 定义接⼝ /** * 定义⾏为 */
spring---AOP学习知识汇总
m0_64015460的博客
06-06 270
AOP(Aspect Oriented Programming)面向切面编程, 一种编程范式, 指导开发者如何组织程序结构OOP(Object Oriented Programming)面向对象编程AOP作用: 在不惊动原始设计的基础上为其进行功能增强Spring的理念: 无侵入式\无入侵式编程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值