spring-AOP

已于 2022-02-22 11:32:32 修改
阅读量136 收藏
点赞数
文章标签： spring jar java
于 2022-02-21 22:25:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44571444/article/details/123057660
版权

AOP

面向切面编程 ，利用AOP可以对业务的部分进行隔离，从而使得业务逻辑部分之间的耦合度降低，提高程序的可重复性。

一、AOP的底层原理

AOP的底层使用的是动态代理

(1). 有两种情况的动态代理

  • 有接口情况

    • 使用JDK的动态代理

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

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

      public class JdkProxy{
    public static void main(String[] args){
        Class[] interfaces = {UserDao.class};
        UserDao userDao = new UserDaoImpl();
        UserDao dao = Proxy.newProxyInstance(JdkProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        int res = dao.add(1, 2);
        System.out.println(res);
    }
}
class UserDaoProxy implements Proxy{
    private Object obj;
    
    public UserDaoProxy(Object obj){
        this.obj = obj;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
        System.out.println("方法执行之前");
        Object invoke = method.invoke(obj, args);
        System.out.println("方法执行之后");
        return invoke;
    }
}

  • 没有接口情况

    • 使用cglib的动态代理
工厂模式创建
public class UserFactory{
    public static UserDao getUserDao(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean1.xml");
        User user = applicationContext.getBean("user",User.class);
        // 通过反射获取到类对象
        Class clazz = Class.forName(User.class);
        // 通过类对象的一个方法获取该对象实例
        return (UserDao)clazz.newInstance();
    }
}

二、 AOP术语

  • 连接点

    • 类里面的哪些方法可以被增强，这些方法称为连接点

  • 切入点

    • 实际被真正增强的方法，这些方法被称为切入点

  • 通知(增强)

    • 实际增强的逻辑部分被称为通知
    • 通知有多种类型
      • 前置通知
      • 后置通知
      • 环绕通知
      • 异常通知
      • 最终通知

  • 切面

    • 把通知应用到切入点的过程就是切面

三、AOP操作

spring框架一般基于AspectJ实现AOP操作

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

准备工作

引入aop的依赖spring-aspectj.jar,aop-alliance.jar,aspectjweaver.jar,com.springsource.net.sf.cglib.jar

配置文件表头信息

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       <!-- p命名空间使用 -->
       xmlns:p="http://www.springframework.org/schema/p"
		<!-- 扫描注解包使用 -->
       xmlns:context="http://www.springframework.org/schema/context"
		<!-- aop使用 -->
       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/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">
</beans>

切入点表达式

作用：知道对哪个类里面的哪个方法进行增强

语法结构：execution([权限修饰符][返回值类型][方法名称]([参数列表]))

<!-- 对com.wyxz.dao.Book对add方法增强 -->
execution(*com.wyxz.dao.Book.add(..))
<!-- 对com.wyxz.dao.Book对所有方法增强 -->
execution(*com.wyxz.dao.Book.*(..))
<!-- 对com.wyxz.dao.Book对所有类所有方法增强 -->
execution(*com.wyxz.dao.*.*(..))

四、基于xml配置文件实现

  1. 创建两个类，一个增强类，一个被增强类

    public class Book {

    public void buy() {
        System.out.println("买数~~~");
    }
}

    public class BookProxy {

    public void before() {
        System.out.println("before~~~");
    }
}

  2. 在spring配置文件中，创建两个类对象进行配置

    <bean id="Book" class="com.wyxz.config.Book"></bean>
<bean id="bookProxy" class="com.wyxz.config.BookProxy"></bean>

  3. 在spring配置文件中，配置切入点

    <!--    配置aop增强   -->
<aop:config>
		<!-- 这里的id为p表示的是要切的是哪个类，id的值可以自定义，expression中就是对这个类中的哪个方法进行增强 -->
    <aop:pointcut id="p" expression="execution(* com.wyxz.config.Book.buy(..))"/>
    <!-- 声明切入点是哪个类 -->
    <aop:aspect ref="bookProxy">
    		<!--    配置切面
               method:表示使用哪个方法
               pointcut-ref : 切入点使用在哪个类的哪个方法上
       -->
        <aop:before method="before" pointcut-ref="p"/>
    </aop:aspect>
</aop:config>

五、基于注解方式实现(常用)

  1. 创建类，在类里面定义方法

    @Component
public class User{
    public void add(){
        System.out.println("add~~~");
    }
}

  2. 创建一个类（增强类）, 让不同的类代表不同的增强

    @Component
@Aspect
public class UserProxy {

    // 前置通知
    @Before(value = "execution(* com.wyxz..annotation.User.add(..))")
    public void before() {
        System.out.println("before~~~");
    }
	// 当增强的方法发生异常的时候执行
    @AfterThrowing(value = "execution(* com.wyxz..annatation.User.add(..))")
    public void afterThrowsing() {
        System.out.println("after~~~");
    }
	// 当增强方法执行之后执行
    @After(value = "execution(* com.wyxz..annotation.User.add(..))")
    public void after() {
        System.out.println("after~~~");
    }
	// 当增强方法返回之后执行
    @AfterReturning(value = "execution(* com.wyxz.annotation.User.add(..))")
    public void afterReturning() {
        System.out.println("afterReturning~~~");
    }
	// 在增强方法执行前后都会执行
    @Around(value = "execution(* com.wyxz.annatation.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("around之前~~~");
        proceedingJoinPoint.proceed();
        System.out.println("around之后~~~");
    }
}

  3. 进行通知的配置

    1. 在spring配置文件中，开启注解扫描

      <context:component-scan base-package="com.wyxz.annotation"></context:component-scan>

    2. 使用注解创建User和UserProxy对象

      @Component
// 在上面两个类上边加上这个注解

    3. 在增强类上面添加注解@AspectJ

      // 在UserProxy中添加注解
@Aspect

    4. 在spring配置文件中开启生成代理对象

      <!-- 开启注解扫描 -->
<context:component-scan base-package="com.wyxz.annotation"></context:component-scan>
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

    5. 使用class配置类的方式(不适用xml配置文件，完全配置类实现方式)

      @Configuration
@ComponentScan(basePackages = "com.wyxz")
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class Config {
}

  4. 配置不同类型的通知

    1. 在增强类里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置

      // 在UserProxy中的方法中添加如下内容
@Before(value = "execution(* com.wyxz..annotation.User.add(..))")
@AfterThrowing(value = "execution(* com.wyxz..annatation.User.add(..))")
@AfterReturning(value="execution(* com.wyxz.annatation.User.add(..))")
@Around(value="execution(* com.wyxz.annatation.User.add(..))")
@After(value="execution(* com.wyxz.annatation.User.add(..))")

  5. 将表达式的公式抽取使用

    @PointCut(value="execution(* com.wyxz.annatation.User.)")
public void point(){
    
}
@Before(value = "point()")
    public void before() {
        System.out.println("before~~~");
    }

  6. 设置增强类的优先级

    //在增强类上加注解@Order()值越小优先级越高
码农先生eee
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Spring Boot - spring-boot-starter-aop
学无止境
06-12 1046
然后，我们创建了一个切面类LoggingAspect，它使用@Before和@After注解来定义前置通知和后置通知，这些通知将在UserService类的getUser()在工作中，spring-boot-starter-aop常用于在应用程序中实现切面编程，例如日志记录、性能监控、事务管理等。最后，在Application类的main()方法中，我们获取UserService的实例并调用getUser()方法。在这个示例中，我们创建了一个UserService类，它有一个getUser()
JavaSpring-AOP详解（Maven导入 深入浅出）
Garson的博客
10-07 2791
在CSDN上看了很多关于配置AOP的文章，不是很复杂就是省略了很多步骤。本文用最简单并且最清晰的方法从导入依赖到AOP底层原理。逐步讲解SpringAOP的相关操作帮你快速了解AOP。
Spring-Aop的使用
软泥人的博客
10-08 1475
Spring-Aop的使用
关于spring-aop和@PostConstruct
weixin_45051415的博客
04-28 911
被@PostConstruct注解的方法在初始化调用的时候并不会受spring-aop的增强，需要通过注入自身再调用对应方法才可以 暂时不猜测原因，等看了源码之后再来
SpringAOP学习--SpringAOP简介及原理
热门推荐
u012098021的博客
05-15 6万+
前文对AOP做了介绍，实际项目中，一般不会直接上手手动实现aop，而是使用一些高级封装的aop实现，如SpringAOP。 Spring是一个广泛应用的框架，SpringAOP则是Spring提供的一个标准易用的aop框架，依托Spring的IOC容器，提供了极强的AOP扩展增强能力，对项目开发提供了极大地便利。 前文提到AOP的实现有AspectJ、JDK动态代理、CGLIB动态代理，SpringAOP不是一种新的AOP实现，其底层采用的是JDK/CGLIB动态代理。 JDK动态代理回顾 上一篇简单介绍了
spring-aop jar包需求
zh199609的博客
03-27 4898
SpringAop:的底层就是通过JDK动态代理"或"CGLib动态代理为技术目标织入横切逻辑。  做aop:需要导入：   spring-aop-4.1.5.RELEASE.jar spring-beans-4.1.5.RELEASE.jar spring-context-4.1.5.RELEASE.jar spring-context-support-4.1.5.RELEASE.jar ...
Spring-AOP
Java小白的博客 致力分享每一天学到的知识
05-09 1026
讲解有关Spring-AOP的有关知识
实现spring-aop例子
灰太狼
04-01 1496
1.Spring aop的定义：Spring aop是spring的2大核心之一，又叫面向切面编程，是对oop的一种完善。通俗地说就是不改变原来的类的功能，额外地增加功能。所以aop采用的是动态代理模式：有java动态代理模式（默认），cglib动态代理模式。当需要代理的类不是接口类型的时候，Spring会自动切换为CGLIB来进行代理，也可以强制的选择使用CGLIB来进行代理动态代理分为两种： ...
spring-boot-starter-aop及其使用场景说明
吴声子夜歌的博客
11-21 1万+
如今，AOP（Aspect Oriented Programming）已经不是什么崭新的概念了，在经历了代码生成、动态代理、字节码增强甚至静态编译等不同时代的洗礼之后，Java 平台上的 AOP 方案基本上已经以 SpringAOP 结合 AspectJ 的方式稳固下来（虽然大家依然可以自己通过各种字节码工具偶尔“打造一些轮子”）。 现在 Spring 框架提供的 AOP 方案倡导了一种各取所长的...
Spring-AOP概述
小工匠
08-12 1万+
概述 AOP是什么 AOP专业术语 连接点Joinpoint 切点Pointcut 增强Advice 目标对象Target 引介Introduction 织入Weaving 代理Proxy 切面Aspect AOP的实现者 AspectJ AspectWerkz JBoss AOP Spring AOP概述Spring AOP是AOP技术在Spring中的具体实现，它是Spring框架的另外一个重要
开发工具 spring-aop-4.3.6.RELEASE
05-31
开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE...
spring-aop-5.2.0.RELEASE-API文档-中文版.zip
07-13
赠送jar包：spring-aop-5.2.0.RELEASE.jar； 赠送原API文档：spring-aop-5.2.0.RELEASE-javadoc.jar； 赠送源代码：spring-aop-5.2.0.RELEASE-sources.jar； 赠送Maven依赖信息文件：spring-aop-5.2.0.RELEASE.pom；...
spring-aop-5.0.10.RELEASE-API文档-中文版.zip
04-23
赠送jar包：spring-aop-5.0.10.RELEASE.jar； 赠送原API文档：spring-aop-5.0.10.RELEASE-javadoc.jar； 赠送源代码：spring-aop-5.0.10.RELEASE-sources.jar； 赠送Maven依赖信息文件：spring-aop-5.0.10.RELEASE....
spring-aop
03-17
Spring AOP，全称为Aspect-Oriented Programming（面向切面编程），是Spring框架的重要组成部分，它为Java应用程序提供了强大的横切关注点管理能力。在传统的面向对象编程中，我们往往需要在多个类或方法中重复编写...
spring-aop-jar
12-14
"spring-aop-jar"这个主题涉及到Spring框架中的核心组件之一——Spring AOP。这里我们将深入探讨Spring AOP、相关jar文件以及它们在实际开发中的作用。 首先，我们来看一下提供的文件： 1. aopalliance.jar：这是一...
Spring中的Bean作用域有哪些
2301_76166241的博客
06-28 999
Spring中的BeanScope决定了容器在何时创建一个新的Bean实例以及何时重用现有实例。这对于控制应用程序中各个Bean的生命周期和状态非常重要。
SpringBoot中使用多线程调用异步方法，异步方法有无返回值例子。
L
06-26 388
快速了解@Async注解的用法，包括异步方法无返回值、有返回值，最后总结@Async注解失效的几个坑。在我们的 SpringBoot 应用中，经常会遇到在一个接口中，同时做事情1，事情2，事情3，如果同步执行的话，则本次接口时间取决于事情1 2 3执行时间之和；如果三件事同时执行的话，那么本次接口的运行时间取决于事情1 2 3执行时间最长的那个。合理的使用多线程，可以大大缩短接口的运行时间。几个例子简单的介绍了一下多线程如何调用异步方法的例子。
SpringSecurity中文文档（Servlet Session Management）
最新发布
znjy111的博客
07-01 846
一旦您拥有了正在对请求进行身份验证的应用程序，就必须考虑如何在将来的请求中持久化和恢复结果身份验证。默认情况下，这是自动完成的，因此不需要额外的代码，尽管了解 requireExplicitSave在 HttpSecurity 中的含义非常重要。如果您愿意，您可以阅读更多关于 RequureExplicSave 正在做什么或者为什么它很重要的内容。否则，在大多数情况下您将完成本节。
Springboot下使用Redis管道(pipeline)进行批量操作
weixin_45817985的博客
06-29 594
Springboot下使用Redis管道(pipeline)进行批量操作
spring-aop maven
12-21
Spring AOP是Spring框架中的一个模块，用于实现面向切面编程（AOP）。在Maven中，你可以通过添加以下Maven坐标来引入Spring AOP依赖： ```xml <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop</artifactId> <version>5.2.0.RELEASE</version> </dependency> ``` 这个Maven坐标指定了Spring AOP的组织ID（org.springframework）、模块ID（spring-aop）和版本号（5.2.0.RELEASE）。通过在你的项目的pom.xml文件中添加这个依赖，Maven会自动下载并管理Spring AOP的jar包。 如果你想了解更多关于Spring AOP的信息，你可以解压翻译后的API文档，并用浏览器打开"index.html"文件，即可查看文档内容。 另外，如果你想测试Spring AOP的功能，你可以创建一个测试方法，并在该方法中使用Spring容器加载配置文件，并获取一个被Spring管理的Bean对象，然后调用该对象的方法。例如： ```java @Test public void test1() { ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml"); User user = applicationContext.getBean("user", User.class); user.add(); } ``` 这个测试方法使用了Spring的ApplicationContext来加载名为"spring.xml"的配置文件，并通过getBean方法获取了一个名为"user"的Bean对象。然后，调用该对象的add方法进行测试。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

码农先生eee

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

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

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

打赏作者

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

抵扣说明：

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

余额充值