Spring5-AOP原理及操作

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

目录

1. 什么是AOP

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

在这里插入图片描述

2. AOP底层原理

2.1 AOP底层使用动态代理

（1）第一种：有接口情况，使用JDK动态代理

创建接口实现类代理对象，增强类的方法
在这里插入图片描述

（2）第二种：没有接口情况，使用CGLIB动态代理

创建子类的代理对象，增强类的方法
在这里插入图片描述

2.2 使用JDK动态代理

使用JDK动态代理：使用Proxy类里面的方法创建代理对象
在这里插入图片描述
调用newProxyInstance方法
在这里插入图片描述
该方法的三个参数：
第一个：类加载器
第二个：增强方法所在的类，这个类实现的接口，支持多个接口
第三个：实现这个接口InvocationHandler，创建代理对象，写增强的部分

代码示例

（1）创建接口，定义发方法

public interface UserDao {

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

（2）创建接口实现类，实现方法

public class UserDaoImpl implements UserDao{
    @Override
    public int add(int a, int b) {
        System.out.println("UserDaoImpl add.....");
        return a+b;
    }

    @Override
    public String update(String id) {
        System.out.println("UserDaoImpl update.....");
        return id;
    }
}

（3）使用Proxy类创建接口代理对象

public class JDKProxy {
    public static void main(String[] args) {
        //创建接口实现类代理对象
        Class[] interfaces = {UserDao.class};
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao dao  = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        int result = dao.add(1, 2);
        System.out.println("result:"+result);
    }
}

//创建代理对象代码
class UserDaoProxy implements InvocationHandler{

    //创建的是谁的代理对象，把谁传递过来
    //有参构造传递
    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("方法执行之前。。。。"+method.getName()+",传递的参数为："+ Arrays.toString(args));
        //被增强的方法
        Object res = method.invoke(obj, args);
        //方法之后
        System.out.println("方法之后执行。。。"+obj);
        return res;
    }
}

（4）运行结果
在这里插入图片描述

3. AOP术语

（1）连接点：类里面哪些方法可以被增强，这些方法称为连接点
（2）切入点：实际被真正增强的方法称为切入点
（3）通知（增强）：实际增强的逻辑部分称为通知（增强）
	通知有多种类型：
		前置通知
		后置通知
		环绕通知
		异常通知
		最终通知
（4）切面：是动作，把通知应用到切入点过程

4. AOP操作（准备工作）

（1） Spring框架一般都是基于AspectJ实现AOP操作
		AspectJ不是Spring组成部分，独立AOP框架，一般把AspectJ和Spring框架一起使用进行AOP操作
（2）基于AspectJ实现AOP操作
		1）基于XML配置文件实现
		2）基于注解方式实现
（3）在项目工程里面引入AOP相关依赖

在这里插入图片描述

（4）切入点表达式
	作用：知道对哪个类里面的哪个方法进行增强
	语法结构：execution([权限修饰符][返回类型][类全路径][方法名称]([参数列表]))
	
	1）举例 1：对 com.wqd.dao.BookDao 类里面的 add 进行增强 
	execution(* com.wqd.dao.BookDao.add(..)) 
	
	2）举例 2：对 com.wqd.dao.BookDao 类里面的所有的方法进行增强 
	execution(* com.wqd.dao.BookDao.* (..))
	
	3）举例 3：对 com.wqd.dao 包里面所有类，类里面所有方法进行增强 
	execution(* com.wqd.dao.*.* (..))

5. AOP操作（AspectJ注解）

5.1 实例代码

（1）创建类定义方法，并使用注解创建对象

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

（2）创建增强类（编写增强逻辑），并使用注解创建对象和@Aspect

//增强的类
@Component
@Aspect
public class UserProxy {

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

（3）Spring配置文件配置，开启注解扫描，开启生成代理对象

<?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">

        <!--开启注解扫描-->
        <context:component-scan base-package="com.wqd.spring5.aopanno"></context:component-scan>
        <!--开启Aspect生成代理对象-->
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

（4）配置不同通知类型

//增强的类
@Component
@Aspect
public class UserProxy {

    //前置通知
    @Before(value = "execution(* com.wqd.spring5.aopanno.User.add(..))")
    public void before(){
        System.out.println("before.....");
    }

    //后置通知（返回通知）
    @AfterReturning(value = "execution(* com.wqd.spring5.aopanno.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning.....");
    }

    //最终通知
    @After(value = "execution(* com.wqd.spring5.aopanno.User.add(..))")
    public void after(){
        System.out.println("after.....");
    }

    //异常通知
    @AfterThrowing(value = "execution(* com.wqd.spring5.aopanno.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing.....");
    }

    //环绕通知
    @Around(value = "execution(* com.wqd.spring5.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("Around环绕之前.....");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("Around环绕之后.....");
    }
}

（5）测试

@Test
    public void test1(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

        User user = context.getBean("user", User.class);
        user.add();
    }

（6）结果
在这里插入图片描述
如果没有异常，不会执行异常通知
（7）添加异常

@Component
public class User {
    public void add(){
        int i=1/0;
        System.out.println("add....");
    }
}

（8）测试结果
在这里插入图片描述
如果出现异常：环绕之后不执行，AfterReturning后置通知不执行，after不管有没有异常都会执行

5.2 相同切入点抽取

//增强的类
@Component
@Aspect
public class UserProxy {

    //相同切入点抽取
    @Pointcut(value = "execution(* com.wqd.spring5.aopanno.User.add(..))")
    public void pointdemo(){

    }
    //前置通知
    @Before(value = "pointdemo()")
    public void before(){
        System.out.println("before.....");
    }

    //后置通知（返回通知）
    @AfterReturning(value = "pointdemo()")
    public void afterReturning(){
        System.out.println("afterReturning.....");
    }
}

5.3 设置增强类优先级

有多个增强类对同一个方法进行增强，可以在增强类上面添加注解@Order（数字类型），数字类型值越小优先级越高

//增强的类
@Component
@Aspect
@Order(2)
public class UserProxy {

    //相同切入点抽取
    @Pointcut(value = "execution(* com.wqd.spring5.aopanno.User.add(..))")
    public void pointdemo(){

    }
    //前置通知
    @Before(value = "pointdemo()")
    public void before(){
        System.out.println("UserProxy 的 before.....");
    }

@Component
@Aspect
@Order(1)
public class UserProxy1 {
    //相同切入点抽取
    @Pointcut(value = "execution(* com.wqd.spring5.aopanno.User.add(..))")
    public void pointdemo(){

    }
    //前置通知
    @Before(value = "pointdemo()")
    public void before(){
        System.out.println("UserProxy1 的 before.....");
    }

}

在这里插入图片描述

5.4 使用全注解替换xml

原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">

        <!--开启注解扫描-->
        <context:component-scan base-package="com.wqd.spring5.aopanno"></context:component-scan>
        <!--开启Aspect生成代理对象-->
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

新注解配置

@Configuration
@ComponentScan(basePackages = {"com.wqd"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class AOPConfig {
}
测试
@Test
    public void test2(){
        ApplicationContext context = new AnnotationConfigApplicationContext(AOPConfig.class);

        User user = context.getBean("user", User.class);
        user.add();
    }

在这里插入图片描述

6. AOP操作（AspectJ配置文件）

（1）创建2各类，增强类和被增强类，创建方法

public class Book {
    public void add(){
        System.out.println("add...");
    }
}

public class BookProxy {

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

（2）配置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="book" class="com.wqd.spring5.aopxml.Book"></bean>
        <bean id="bookProxy" class="com.wqd.spring5.aopxml.BookProxy"></bean>
        <!--配置aop增强-->
        <aop:config>
                <!--切入点-->
                <aop:pointcut id="p" expression="execution(* com.wqd.spring5.aopxml.Book.add(..))"/>
                <!--配置切面-->
                <aop:aspect ref="bookProxy">
                        <!--增强作用在具体的方法上-->
                        <aop:before method="beforeBook" pointcut-ref="p"></aop:before>
                </aop:aspect>
        </aop:config>
</beans>

（3）测试

@Test
    public void testXml(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");

        Book book = context.getBean("book", Book.class);
        book.add();
    }

在这里插入图片描述

自律成就自由
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AOP原理及在架构设计中的应用
thunder09的专栏--没事就写点儿
11-16 1937
 AOP原理及在架构设计中的应用 【关键词】AOP  JavaEE 架构设计 1.       AOP原理1.1.    AOP是什么       AOP(Aspect-Oriented Programming)就是面向方面的编程，这一概念最初由Xerox PARC研究中心提出。       AOP技术使得应用开发者仅仅关注于业务逻辑本身的开发，而不用纠缠于那些诸如安全、事务、
【小家Spring】spring aop 目录
blog_zxb的博客
06-12 402
【小家Spring】面向切面编程Spring AOP创建代理的方式：ProxyFactoryBean、ProxyFactory、AspectJProxyFactory（JDK Proxy和CGLIB） 【小家Spring】Spring AOP原理使用的基础类打点（AopInfrastructureBean、ProxyProcessorSupport、Advised、AjType） 【小家Spring】详解Spring AOP的底层代理JdkDynamicAopProxy和ObjenesisCglibAo
面向切面编程（AOP）的理解
热门推荐
Intlgj的专栏
06-14 6万+
<br />在传统的编写业务逻辑处理代码时，我们通常会习惯性地做几件事情：日志记录、事务控制及权限控制等，然后才是编写核心的业务逻辑处理代码。当代码编写完成回头再看时，不禁发现，扬扬洒洒上百行代码中，真正用于核心业务逻辑处理才那么几行，如图6-4所示。方法复方法，类复类，就这样子带着无可奈何遗憾地度过了多少个春秋。这倒也罢，倘若到了项目的尾声，突然决定在权限控制上需要进行大的变动时，成千上万个方法又得一一"登门拜访"，痛苦"雪上加霜"。 <br />如果能把图6-4中众多方法中的所有共有代码全部抽取出来，放
Spring核心AOP（面向切面编程）总结
冷血之心的博客
07-16 3万+
（尊重劳动成果，转载请注明出处：http://blog.csdn.net/qq_25827845/article/details/75208354冷血之心的博客） 目录 1、AOP概念： 2、AOP特点： 3、AOP底层实现： JDK动态代理实现： cglib动态代理实现： 代理方式的选择： 静态代理和动态代理的区别： 4、AOP原理 5、AOP操作术语： 6、AOP操作案例...
Java AOP实践指南：切面编程详解
xuewenyu_的博客
11-06 3329
通过本文的讲解，我们深入了解了切面编程的核心概念、动态代理的实现原理，并通过一个实际的例子展示了使用Java AOP的完整过程。AOP可以帮助我们将横切关注点（例如日志记录、事务管理等）从核心业务逻辑中解耦出来，提高代码的可维护性和重用性。同时，AOP也是实现设计模式和架构思想的重要手段之一，我们在开发中可以灵活运用AOP来优化代码结构并提高系统的整体性能。
spring-aop
06-13
Spring AOP的工作原理如下： - **代理模式**：Spring AOP通过代理对象拦截对目标对象的调用，从而在调用前后插入切面代码。可以是JDK动态代理或者CGLIB代理。 - **切点（Pointcut）**：定义了通知应该在哪些方法上...
spring-aop.rar_java aop_spring aop
09-23
【标题】"spring-aop.rar_java aop_spring aop" 涉及的主要知识点是Spring框架中的面向切面编程（AOP）以及Java基础知识。这个压缩包可能包含了一个简单的Spring AOP应用示例，同时也涵盖了Java的一些核心概念，如...
Spring5_AOP.pdf
01-02
从Spring5-AOP的概念->底层原理->相关术语->AOP操作(AspectJ注解)->AOP操作（AspectJ配置文件）说明AOP的相关笔记
spring-aop-review-tcf.zip
06-08
本示例代码实现了Spring AOP的基础概念，并以静态代理和动态代理两种方式来展示其工作原理。 首先，我们要理解什么是代理设计模式。代理模式提供了一个接口，使得客户端可以通过这个接口与目标对象进行交互，而代理...
spring-aop.rar
07-17
本篇将深入探讨Spring AOP的核心概念、工作原理以及实际应用。 一、Spring AOP基础 1. 切面（Aspect）：切面是程序中的一个关注点，如日志、事务处理，它跨越多个对象。在Spring AOP中，切面由通知（Advice）和...
spring aop 五个依赖jar
05-16
spring aop依赖包，想要的可以下，我用的spring 3.1,其他版本的不知道支不支持。
Spring5-AOP详解
郭松源的博客
11-21 803
1. 什么是AOP 在软件业，AOP为 Aspect Oriented Programming 的缩写，意为面向切面编程，是通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring 框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 通俗描述：不通过修改源代码的方式，在主干功能中添加新功能。 这里，我们通过一个登
SpringBoot实现AOP面向切面编程
weixin_52536274的博客
04-25 2150
SpringBoot实现AOP 面向切面编程，掌握AOP术语，学会使用前置通知、后置通知、返回通知、异常通知与环绕通知以及execution表达式的使用。
Spring切面编程
BadBoyxiaolin的博客
05-08 1476
*** @Description: 操作日志注解*/ @Documented @Target(ElementType . METHOD) // 作用在方法上 @Retention(RetentionPolicy . RUNTIME) // 运行时有效 public @interface Operation {/*** 操作模块/*** 操作类型/*** 操作说明。
切面编程的理解和使用，Java小白入门（五）
最新发布
鸡毛掸子
12-29 1321
面向切面编程（AOP）是软件开发领域的游戏规则改变者。@Aspect 和 @Pointcut 注解等工具，实现 AOP 变得更加简化，使开发人员能够专注于应用程序的核心逻辑，同时单独管理横切点。如果使用得当，这些注解可以带来更清晰、更易于维护和更高效的代码结构。
Spring5 学习总结-AOP
m0_52901132的博客
04-10 548
AOP概念 1.什么是AOP 1.1 面向切面编程，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的 耦合度降低 ，提高程序的可重用性，同时提高了开发的效率。 1.2 通俗地讲：不通过修改源代码方式，在主干功能中添加新功能。 AOP底层原理 1.AOP底层使用动态代理 有俩种情况动态代理 第一种，有接口情况，使用JDK动态代理 ...
Spring5 学习笔记 四 、AOP
weixin_46703850的博客
11-20 547
（1）面向切面编程（方面），利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 （2）通俗描述：**不通过修改源代码方式，在主干功能里面添加新功能** 功能模块可插入可拔出
Spring：AOP
AmorFati1996的博客
11-02 190
1. AOP基本概念 什么是AOP? AOP为Aspect Oriented Programming的缩写，意为面向切面编程。用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 通俗描述：不通过修改源代码的方式，在主干功能里添加新功能。 如： 2. AOP底层原理 AOP底层使用动态代理 （1）有两种情况的动态代理 第一种：有接口的情况，使用JDK动态代理 创建接口实现类代理对象，增强类的方法 第二种：没有接口的情况，使用C
读Spring5核心原理自己总结的一些面试时的干货（IOC-AOP 及简单的设计模式）
shifeng3705的博客
08-04 260
工作一段时间了，基本的编程工作是可以胜任的，与一些老码农在一起，也学到不少设计上和选型上的东西，这段时间开始重读spring，深读一下spring框架，内容主要是自己在学习时的一些笔记，希望分享出来，多多指点： IOC和AOP都有解耦的作用，在解耦作用外，还要分别强调各自的主要点 1、IOC 讲IOC的时候讲到了接口，接口是用来定义能力和规范的 讲IOC的重点，要点到一个重点，就是多态 多态–供用父类的地方，都可以使用子类 如果不使用IOC的话，X被带入时，传入A/B/C都需要分别NEW，并且改变代码内容
SpringIOC和AOP的原理
07-23
2. Spring AOP原理： - AOP的核心思想是通过在程序运行过程中动态地将一些通用的功能织入到目标对象中，从而实现横切关注点的分离。 - Spring AOP基于动态代理实现，它通过代理对象来实现对目标对象的增强。Spring...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值