Spring AOP

最新推荐文章于 2023-07-10 12:00:42 发布
最新推荐文章于 2023-07-10 12:00:42 发布
阅读量316 收藏
点赞数
分类专栏： Spring 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53946134/article/details/124437660
版权

耐心读完相信你会有所收获 

目录

什么是AOP

初步认识Spring AOP

通过注解配置Spring AOP

通过注解 声明5种通知类型

什么是AOP

AOP直译过来就是 面向切面编程。AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面。

将多个开发模块中某段重复的方法，抽出来。这

初步认识Spring AOP

Spring 中的 AOP 是通过动态代理实现的。不同的 AOP 框架支持的连接点也有所区别，例如，AspectJ 和 JBoss,除了支持方法切点，它们还支持字段和构造器的连接点。而 Spring AOP 不能拦截对对象字段的修改，也不支持构造器连接点,我们无法在 Bean 创建时应用通知。

package com.dome.test1;

public interface AB {
    String eat();
}

A实现AB接口

package com.dome.test1;

@Component
public class A implements AB {
    @Override
    public String aeat() {
        System.out.println("a吃饭");
        return "吃饭";
    }
}

B实现AB接口

package com.dome.test1;

@Component
public class B implements AB {
    @Override
    public String beat() {
        System.out.println("b不吃饭");
        return "不吃饭";
    }
}

配置文件
package com.demo;
@Configuration
@ComponentScan(basePackageClasses = {com.demo.test1.eat.class})
public class AppConfig {
}

测试类
package com.demo;

public class AppTest {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        A a = context.getBean("a",A.class);
        B b = (b) context.getBean("b");
        a.eat();
        b.eat();
    }
}

运行结果
a吃饭
b不吃饭

 如果我们想在a，b输出结果之前加入一个其他的方法是不是a，b两个方法都需要改呢。

这是就用到了Spring AOP很见简单的你就可以完成了。

package com.demo.test1;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class EatAspectJ {
    @Before("execution(* com.demo.test1.AB.eat(..))")
    public void ceshi(){
        System.out.println("AB喜欢的东西");
    }
}

 这个类，注解  @Component  表明它是一个Spring Bean 被装配，通过 @Aspect  表示它是一个切面。
类中方法  ceshi  前的@Before 注解，表示他将在方法执行之前执行。
参数 ("exection(* com.demo.test1.AB.eat(..))")声明了切点位置，表明在该位置切入切点。

package com.demo;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan(basePackageClasses = {com.demo.test1.AB.class})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class AppConfig {
}

 你能看到运行结果是：AB喜欢的东西

                                        a吃饭

                                     AB喜欢的东西

                                        b不吃饭

 

配置文件中的@EnableAspectJAutoProxy注解，是用于启动AOP功能的，参数proxyTargetClass的值设为True；如果我们不写参数，默认为 false。这个时候运行程序，程序抛出异常。

这是由于proxyTargetClass参数决定了代理的机制，当这个参数为false时，通过jdk的基于接口的方式进行织入，这时候代理生成的是一个接口对象，将这个接口对象强制转换为实现该接口的一个类，自然就抛出了上述类型转换异常。

当这个参数为true时，会使用cglib的动态代理方式这种方式的缺点是拓展类的方法被final修饰时，无法进行织入。

测试一下，把final加入aeat()方法中

A实现AB接口

package com.dome.test1;

@Component
public class A implements AB {
    @Override
    public final String aeat() {
        System.out.println("a吃饭");
        return "吃饭";
    }
}


运行结果：你可以看到切面组织唯有生效

通过注解配置Spring AOP

AspectJ指示器描述
arg()限制连接点匹配参数为指定类型的执行方法
@args()限制连接点匹配参数由指定注解标注的执行方法
execution()用于匹配是连接点的执行方法
this()限制连接点匹配AOP代理的Bean引用为指定类型的类
target()限制连接点匹配目标对象为指定类型的类
@target()限制连接点匹配特定的执行对象，这些对象对应的类要具备指定类型的注解
within()限制连接点匹配指定的类型
@within()限制连接点匹配指定注解所标注的类型（当前使用Spring AOP时，方法定义在有指定的注解所标注的类里）
@annotation限制连接点匹配带有指定注解连接点

 其他都是限制链接只有execution指示器是唯一的执行匹配，这说明execution在编写切点时非常的重要。

 execution(* com.demo.test1.AB.eat(...))

execution：在方法执行时触发
*：返回任意类型
com.demo.test1.AB ：方法所属的类型
eat：此方法
... ：使用任意参数


多个匹配之间我们可以使用链接符 &&、||、！来表示 “且”、“或”、“非”的关系。
但是在使用 XML 文件配置时，这些符号有特殊的含义，所以我们使用 “and”、“or”、“not”来表示。

package com.demo.test1;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class EatAspectJ {
    @Before("execution(* com.demo.test1.AB.eat(..)) 
    && within(* com.demo.*) && bean(girl)")
    public void ceshi(){
        System.out.println("AB喜欢的东西");
    }
}

此时运行时结果：  a吃饭

                                AB喜欢的东西

                                b不吃饭

通过注解 声明5种通知类型

注解通知
@Beforre通知方法会在目标方法调用之前执行
@After通知方法会在目标方法返回或异常后调用

@AfterReturning

通知方法会在目标方法返回调用
@AfterThrowing通知方法会在目标方法抛出异常后调用
@Around通知方法会目标方法封装起来

package com.sharpcj.aopdemo.test1;

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

@Aspect
@Component
public class EatAspectJ {
    @Before("execution(* com.demo.test1.AB.eat(..))")
    public void hehe() {
        System.out.println("before ...");
    }

    @After("execution(* com.demo.test1.AB.eat(..))")
    public void haha() {
        System.out.println("After ...");
    }

    @AfterReturning("execution(* com.demo.test1.AB.eat(..))")
    public void xixi() {
        System.out.println("AfterReturning ...");
    }

    @Around("execution(* com.demo.test1.AB.eat(..))")
    public void xxx(ProceedingJoinPoint pj) {
        try {
            System.out.println("Around aaa ...");
            pj.proceed();
            System.out.println("Around bbb ...");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }

}


测试类
package com.demo;

public class AppTest {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        A a = context.getBean("a",A.class);    
        a.eat();
    }
}

运行结果
Around aaa...
before...
a吃饭
Around bbb...
After ...
AfterReturning ...

 @Around修饰的环绕通知类型，将整个目标方法封装起来了，在使用时，我们传入了ProceedingJoinPoint  类型的参数，这个对象是必须要有的，并且需要调用ProceedingJoinPoint 的 proceed() 方法。 如果没有将不会环绕，

执行结果为
before...
a吃饭

Around aaa...
Around bbb...
After ...
AfterReturning ...

如果不调用对象proceed方法，表示原目标方法被堵塞了

多个通知使用相同的切点表达式，可以使用 @Pointcut 注解声明切点表达式

package com.sharpcj.aopdemo.test1;

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

@Aspect
@Component
public class EatAspectJ {

    @Pointcut("execution(* com.demo.test1.AB.eat(..))")
    public void test(){}

    @Before("test()")
    public void hehe() {
        System.out.println("before ...");
    }

    @After("test()")
    public void haha() {
        System.out.println("After ...");
    }

    @AfterReturning("test())")
    public void xixi() {
        System.out.println("AfterReturning ...");
    }

    @Around("test()")
    public void xxx(ProceedingJoinPoint pj) {
        try {
            System.out.println("Around aaa ...");
            pj.proceed();
            System.out.println("Around bbb ...");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }

}
    @Pointcut("execution(* com.demo.test1.AB.eat(..))")
    public void test(){}

这个方法相当于作为一个表示供通知使用。 

在说一下 *的用法，你如果不关心返回值是什么用*  ，后边的 ... 表示任意参数。

如果需要传参数和需要返回值的时候，需要自己编写传参类型和返回值类型

编写返回类型和传入参数与未编写进行对比

package com.sharpcj.aopdemo.test1;

@Aspect
@Component
public class EatAspectJ {

    @Pointcut("execution(String com.demo.test1.AB.eat(String))")
    public void test(String a){}

    @Before("test(a)")
    public void hehe() {
        System.out.println("before ...");
    }


    @Around("test(a)")
    public void xxx(ProceedingJoinPoint pj,String a) {
        try {
            System.out.println("Around aaa ...");
            pj.proceed();
            System.out.println("Around bbb ...");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }

@Pointcut("execution(* com.demo.test1.AB.eat(..))")
    public void test(){}

    @Before("test()")
    public void hehe() {
        System.out.println("before ...");
    }

    @After("test()")
    public void haha() {
        System.out.println("After ...");
    }

    @AfterReturning("test())")
    public void xixi() {
        System.out.println("AfterReturning ...");
    }

    @Around("test()")
    public void xxx(ProceedingJoinPoint pj) {
        try {
            System.out.println("Around aaa ...");
            pj.proceed();
            System.out.println("Around bbb ...");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }

}

 

 参考来源Spring AOP——Spring 中面向切面编程 - SharpCJ - 博客园 (cnblogs.com)参考来源

✘迟暮
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AOP与OOP有什么区别，谈谈AOP的原理是什么
Android_SE的博客
10-12 2379
本专栏专注分享大型Bat面试知识，后续会持续更新，喜欢的话麻烦点击一个关注 面试官: 你知道什么是AOP吗？AOP与OOP有什么区别，谈谈AOP的原理是什么 心理分析：一旦问到aop面试官在开发自己的项目中 肯定是用到了aop切面编程的。这个时候求职者需要格外注意，特别是aop 在编译时的性能优势，apk编译的原理讲起。切勿将aop的概念弄混，一定要将oop面向对象与aop面向切面的场景说出来 求...
Spring AOP教程
12-07
Spring框架的关键组件之一是面向方面编程(AOP)框架。 面向方面的编程需要将程序逻辑分解成不同的部分。 此教程将通过简单实用的方法来学习Spring框架提供的AOP/面向方面编程。
AOP与OOP
管子（zero）的杂乱空间
05-22 170
面向对象的编程（OOP）方法是在面向过程的编程方法基础上进行的改进，而面向方面编程（AOP）方法又是在面向对象编程（OOP）方法的基础上进行改进而来的一种创新的软件开发方法。 1.面向领域不同 AOP和OOP虽然在字面上十分相似，但是却是面向不同领域的两种设计思想。OOP（面向对象编程）针对问题领域中以及业务处理过程中存在的实体及其属性和操作进行抽象和封装，面向...
以此之长，补彼之短----AOP（Filter）
Just Do It!
03-15 894
AOP（Aspect-Oriented Programming，面向切面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP利用封装、继承和多态把一切事物打造成对象结构，但是对于所有对象中都存在的一些公共行为，OOP就显得无能为力，抽象和接口虽好，但对所有不相干的对象建立共同的接口或父类未免有些生硬，例如日志功能，日志代码几乎散布在所有的
Spring（一）——闲扯AOP与OOP
jishublog
08-07 269
学Java也有一段时间了，其实一直心存疑虑。人家donet程序部署在服务器就能运行，而你Java程序凭什么就得多一道工序，非得部署在容器里面才能运行呢？J2EE为什么要区分J2EE容器和J2EE应用系统呢？ 通过这两天接触Java的开源框架，自己有了一点想法。然后又在在网上查了一些资料之后，得出结论：J2EE容器实际上是分离一般应用系统中通用的部分。像事务、安全、数据库连接池等等这些功能，将...
OOP与AOP的区别与联系
weixin_42870923的博客
05-07 525
OOP是面向对象编程，核心思想是将客观存在的不同事物抽象成相互独立的类，然后把与事物相关的属性和行为封装到类里，并通过继承和多态来定义类彼此间的关系，最后通过操作类的实例来完成实际业务逻辑的功能需求。 AOP是面向切面编程，核心思想是将业务逻辑中与类不相关的通用功能切面式的提取分离出来，让多个类共享一个行为，一旦这个行为发生改变，不必修改类，而只需要修改这个行为即可。 1、区别： 面向领域不同 A...
Spring aop失效的几种解决方案
08-19
Spring AOP失效解决方案详解 作为一名IT行业大师，我将从给定的文件中生成相关知识点，主要介绍Spring AOP失效的几种解决方案。 标题解释 Spring AOP失效的几种解决方案是指在使用Spring框架时，Aspect Oriented ...
spring aop
03-28
Spring AOP，全称为Aspect-Oriented Programming（面向切面编程），是Spring框架的重要组成部分，它为Java应用程序提供了声明式的企业级服务，如事务管理、日志记录等。AOP的核心概念是切面（Aspect）和通知（Advice...
spring aop jar 包
07-26
Spring AOP(Aspect Oriented Programming，面向切面编程)是Spring框架的重要组成部分，它提供了一种在不修改源代码的情况下，对程序进行功能增强的技术。这个"spring aop jar 包"包含了实现这一功能所需的类和接口，...
Spring AOP 16道面试题及答案.docx
06-29
Spring AOP，全称为Aspect Oriented Programming，是面向切面编程的一种编程范式，它是对传统的面向对象编程（OOP）的一种补充。在OOP中，核心是对象，而在AOP中，核心则是切面。切面是关注点的模块化，即程序中的...
AOP与OOP有什么区别
weixin_69620038的博客
04-04 1294
但是也有它的缺点，最明显的就是关注点聚焦时，面向对象无法简单的解决这个问题，一个关注点是面向所有而不是单一的类，不受类的边界的约束，因此OOP无法将关注点聚焦来解决，只能分散到各个类中。，是软件开发中的一个热点，也是很多框架如 java中的Spring框架中的一个重要内容，是函数式编程的一种衍生范型。将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。
spring_aop
liuxiaoyuxxx的博客
04-01 1183
AOP （Aspect Orient Programming）,直译过来就是 面向切面(方面)编程。AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面。 AOP编程可不是Spring独有的，Spring只是支持AOP编程的框架之一。 AOP分两类，一类可以对方法的参数进行拦截，一类是对方法进行拦截，SpringAOP属于后 者，所以Sprin 1.1 基础案例说明 为了更好说明，我们接下来，要讲解的知识点，我们以一
SpringAOP的基本概念以及和OOP的不同和比较
weixin_51423778的博客
09-13 517
SpringAOP的基本概念以及和OOP的不同和比较
OOP和AOP的区别联系
yingyu的博客
07-29 499
OOP是面向对象编程，是将客观存在的不同事物抽象成相互独立的类，然后把与事物相关的属性和行为封装到类里，并通过继承和多态来定义类彼此间的关系，最后通过操作类的实例来完成实际业务逻辑的功能需求。 AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。是将业务逻辑中与类不相关的通用功能切面式的提取分离出来，让多个类共享一个行为，一旦这个行为发生改变，不必修改类，而只需要修改这个行为即可。 面向对象的编程（OOP）
OOP与AOP关系
何毅
06-26 692
OOP与AOP 的小总结               AOP(Aspect Oriented Programing )——面向切面编程OOP(ObjectOriented Programing )——面向对象编程AOP 是OOP的有益补充，它为程序提供了一个崭新的编程思考角度，可以重复性的横切逻辑抽取到一个统一的模块中，只要通过纵向抽象和AOP 的横向抽取，程序员才可以真正解决重复性代码问题，提
spring之aop
凉快
03-31 197
AOP 面向切面编程，它是对oop（面向对象编程）的一种补充。 在oop中，有很多与对象核心功能无关的代码大量重复的存在，使得模块复用难度增加。而aop则将封装好的对象剖开，找出其中对多对象产生影响的公共行为，并将其封装为一个可重用的模块，这个模块被命名为“切面”（Aspect）。 相关名词 通知：切面必须完成的工作 目标：被通知的对象 代理：向目标对象应用通知后创建的对象 ...
关于Spring Aop的深入理解
最新发布
qq_42077317的博客
07-10 777
生成的代理类实现了原来那个类的所有接口，并对接口的方法进行了代理，我们通过代理对象调用这些方法时，底层将通过反射，调用我们实现的invoke方法。我们在使用JDK的动态代理时，需要编写一个类，去实现这个接口，然后重写invoke方法，这个方法其实就是我们提供的代理方法。Spring默认使用JDK的动态代理实现AOP，类如果实现了接口，Spring就会使用这种方式实现动态代理。Cglib是一个强大的、高性能的代码生成包，它广泛被许多AOP框架使用，为他们提供方法的拦截。5.Spring AOP的实现原理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值