Spring5学习：AOP（面向切面编程）

已于 2022-08-09 10:40:12 修改
阅读量202 收藏
点赞数
分类专栏： Spring5学习 文章标签： 学习 java spring
于 2022-08-03 16:41:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cj_sun6/article/details/126134871
版权

文章目录

前言

跟随尚硅谷学习Spring5
AOP（面向切面编程）

一、AOP（概念和原理）

  • 什么是 AOP
    • 面向切面编程（方面）， 利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得
      业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
    • 通俗描述：不通过修改源代码方式，在主干功能里面添加新功能
  • AOP（底层原理）
    • AOP 底层使用动态代理
        有接口情况，使用 JDK 动态代理：创建接口实现类代理对象，增强类的方法
        没有接口情况，使用 CGLIB 动态代理：创建子类的代理对象，增强类的方法
  • AOP本质
    • 就是在原先方法的基础上增加新的方法，但是为了不影响之前的方法，使用AOP融合新方法和旧方法，可以做到不影旧的方法

二、AOP（JDK 动态代理）

  • 使用 JDK 动态代理，使用 Proxy 类里面的方法创建代理对象
    • 调用 newProxyInstance 方法
static object nevProxyInstance(ClassLoader loader，类<?>[] interfaces，InvocationHandler h)
返回指定接口的代理类的实例,该接口将方法调用分派给指定的调用处理程序。

  该方法有三个参数：
  第一参数，类加载器
  第二参数，增强方法所在的类，这个类实现的接口，支持多个接口
  第三参数，实现这个接口 InvocationHandler，创建代理对象，写增强的部分

  • 编写 JDK 动态代理代码
     创建接口，定义方法
package com.atguigu.spring5.aop.jdk.dao;

public interface UserDao {
    public int add(int a, int b);
    public void sendMsg(String msg);
}

package com.atguigu.spring5.aop.jdk.dao;

import org.springframework.stereotype.Repository;

@Repository
public class UserDaoImpl implements UserDao {

    public int add(int a, int b) {
        System.out.println("UserDaoImpl.add()方法执行了");
        return a + b;
    }

    public void sendMsg(String msg) {
        System.out.println("UserDaoImpl.sendMsg()方法执行了，内容为：" + msg);
    }
}

  创建接口实现类，实现方法

package com.atguigu.spring5.aop.jdk.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Arrays;

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

    // 1、创建谁的代理对象，把谁传递过来；这里为了通用一些，写成Object
    private Object object;

    // 有参数构造传递
    public UserDaoProxy(Object object) {
        this.object = object;
    }

    // 增强的逻辑，需要传入被代理的接口
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        // 方法之前
        System.out.println("UserDaoProxy.invoke() - 方法之前执行了，方法名为：" + method.getName() + "：传递的参数..." + Arrays.toString(args) + "当前对象：" + object);

        // 被增强的方法执行
        Object res = method.invoke(object, args);

        // 方法之后
        System.out.println("UserDaoProxy.invoke() - 方法之后执行了，方法名为："  + method.getName() + "：传递的参数..." + Arrays.toString(args) + "当前对象：" + object);

        return res;
    }
}

package com.atguigu.spring5.aop.jdk.proxy;

import com.atguigu.spring5.aop.jdk.dao.UserDao;
import com.atguigu.spring5.aop.jdk.dao.UserDaoImpl;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

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

        Class[] interfaces = {UserDao.class};
        UserDaoImpl userDaoImpl = new UserDaoImpl();

        // 创建接口实现类的代理对象

        // 写法1， InvocationHandler使用匿名内部类
        /*
        Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                return null;
            }
        });
        */

        // 写法2：不使用InvocationHandler匿名内部类；而是使用一个实现InvocationHandler的代理类实例
        // 接口 = 实现类
        /**
         * Proxy.newProxyInstance()方法参数说明：
         * 第一个参数：当前类自身的类加载器；
         * 第二个参数：需要被代理的类所实现的（一个或多个）接口
         * 第三个参数：InvocationHandler接口实现类，写增强的地方，这里需要传入被代理的实现类对象"userDaoImpl"
         */
        UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDaoImpl));

        System.out.println("\n---------- 开始测试第一个方法：有返回值 ----------");
        int result = dao.add(1, 2);
        System.out.println("返回值为：" + result);

        System.out.println("\n---------- 开始测试第二个方法：没有返回值 ----------");
        dao.sendMsg("你好啊");
    }
}

三、AOP（术语）

  • 连接点
    • 类里面哪些方法可以被增强,这些方法称为连接点
  • 切入点
    • 实际被真正增强的方法,称为切入点
  • 通知（增强）
    • 实际增强的逻辑部分称为通知（增强)
    • 通知有多钟类型
      前置通知@Before
      后置通知@After
      环绕通知@Around
      异常通知@AfterThrowing
      最终通知@AfterReturning
  • 切面
    • 把通知应用到切入点过程

四、AOP 操作（准备工作）

  • Spring 框架一般都是基于 AspectJ 实现 AOP 操作
    • AspectJ 不是 Spring 组成部分，独立 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使
      用，进行 AOP 操作
  • 基于 AspectJ 实现 AOP 操作
    • 基于 xml 配置文件实现
    • 基于注解方式实现（通常使用）
  • 在项目工程里面引入 AOP 相关依赖
  • 切入点表达式
    • 切入点表达式作用：知道对哪个类里面的哪个方法进行增强
    • 语法结构： execution( [权限修饰符] [返回类型] [类全路径] [方法名称] ([参数列表]))
举例 1：
	对 com.atguigu.dao.BookDao 类里面的 add 进行增强
execution(* com.atguigu.dao.BookDao.add(..))
举例 2：
	对 com.atguigu.dao.BookDao 类里面的所有的方法进行增强
execution(* com.atguigu.dao.BookDao.* (..))
举例 3：
	对 com.atguigu.dao 包里面所有类，类里面所有方法进行增强
execution(* com.atguigu.dao.*.* (..))

五、AOP 操作（AspectJ 注解）

  • 创建类，在类里面定义方法
package com.atguigu.spring5.aop.annotation;

import org.springframework.stereotype.Component;

//需要被增强的类
@Component
public class User {
    public void add() {
//        int i = 10/0; // 这里用于测试抛出异常情况
        System.out.println("User.add()...");
    }
}
  • 创建增强类（编写增强逻辑）
//增强的类
public class UserProxy {
	public void before() {//前置通知
		System.out.println("before.. . ...");
	}
}
  • 进行通知的配置
     （1）在 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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 完全注解写法可以消除该配置文件，写法如下
        1、创建一个配置类在类里面添加如下注解
            @Configuration
            @ComponentScan(basePackages = {"com.atguigu"})
            @EnableAspectJAutoProxy(proxyTargetClass = true)
            public class SpringConfig {
            }
    -->

    <!--开启组件扫面 - 等同于 @ComponentScan(basePackages = {"com.atguigu"})-->
    <context:component-scan base-package="com.atguigu.spring5.aop.annotation"/>
    
</beans>

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

@Component
public class User {

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

  （3）在增强类上面添加注解 @Aspect

//增强的类
@Component
@Aspect // 生成代理对象
public class UserProxy {

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

<!--开启Aspect生成代理对象 - 等同于 @EnableAspectJAutoProxy(proxyTargetClass = true)-->
    <aop:aspectj-autoproxy/>
  • 配置不同类型的通知
     （1）在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

//增强的类
@Component
@Aspect // 生成代理对象
public class UserProxy {

    //环绕通知 - 之前之后都执行
    @Around(value = "execution(* com.atguigu.spring5.aop.annotation.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("UserProxy.around()...环绕之前");
        System.out.println("UserProxy.around()...环绕之后");
    }

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

    //后置通知（最终通知）
    @After(value = "execution(* com.atguigu.spring5.aop.annotation.User.add(..))")
    public void after() {
		System.out.println("UserProxy.after()...后置通知（最终通知）");
    }

    //后置返回通知（返回结果执行）
    @AfterReturning(value = "execution(* com.atguigu.spring5.aop.annotation.User.add(..))")
    public void afterReturning() {
		 System.out.println("UserProxy.afterReturning()...后置返回通知（返回结果执行）");
    }

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

  （2）总结
    @AfterReturning方法之后通知，在返回结果之后执行，有异常不执行
    @AfterThrowing有异常才通知
    @After方法之后通知，直接在方法后执行，有异常也执行
    @Before方法之前通知
    @Around方法之前和之后都通知

  • 相同的切入点抽取
//增强的类
@Component
@Aspect // 生成代理对象
public class UserProxy {

    @Pointcut(value = "execution(* com.atguigu.spring5.aop.annotation.User.add(..))")
    public void pointcutAddMethod() {
    }

    //环绕通知 - 之前之后都执行
    @Around(value = "pointcutAddMethod()")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("UserProxy.around()...环绕之前");
        System.out.println("UserProxy.around()...环绕之后");
    }
}
  • 有多个增强类多同一个方法进行增强，设置增强类优先级
     在增强类上面添加注解 @Order(数字类型值)，数字类型值越小优先级越高
@Component
@Aspect // 生成代理对象
@Order(1) // 在增强类上添加注解@Order(数字类型值)，数字类型值越小优先级越高
public class UserProxy {

@Component
@Aspect // 生成代理对象
@Order(2) // 在增强类上添加注解@Order(数字类型值)，数字类型值越小优先级越高
public class UserProxy2 {

//增强的类
@Component
@Aspect // 生成代理对象
@Order(3) // 在增强类上添加注解@Order(数字类型值)，数字类型值越小优先级越高
public class UserProxy3 {
  • 完全使用注解开发
     创建配置类，不需要创建 xml 配置文件
@Configuration
@ComponentScan(basePackages = {" com. atguigu"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
	public class ConfigAop {
	
}

  以上几项操作测试：

package com.atguigu.sprint5;

import com.atguigu.spring5.aop.annotation.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestAop {

    @Test
    public void testAopAnnotations() {
        ApplicationContext context = new ClassPathXmlApplicationContext("aop.xml");
        User user = context.getBean("user", User.class);
        user.add();
    }
}

六、AOP 操作（AspectJ 配置文件）

  创建两个类，增强类和被增强类，创建方法

package com.atguigu.spring5.aop.xml;

//需要被增强的类
public class User {
    public void add() {
        System.out.println("User.add()...");
    }
}


package com.atguigu.spring5.aop.xml;

//增强的类
public class UserProxy {
    public void before() {
		System.out.println("UserProxy.before()...前置通知");
    }
}

  在 spring 配置文件中创建两个类对象
  在 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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">


    <!-- 1. 创建两个类的对象 -->
    <bean id="user" class="com.atguigu.spring5.aop.xml.User"></bean>
    <bean id="userProxy" class="com.atguigu.spring5.aop.xml.UserProxy"></bean>

    <!-- 2. 配置aop增强-->
    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="pointcutAddMethod" expression="execution(* com.atguigu.spring5.aop.xml.User.add(..))"/>

        <!--配置切面: ref引用代理类-->
        <aop:aspect ref="userProxy">
            <!--配置增强作用在具体的方法上，这里是UserProxy类上的before方法作用在切入点add()方法上-->
            <aop:before method="before" pointcut-ref="pointcutAddMethod"/>
        </aop:aspect>
    </aop:config>

</beans>

  测试：

package com.atguigu.sprint5;

import com.atguigu.spring5.aop.xml.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestAop {

    @Test
    public void testAopXML() {
        ApplicationContext context = new ClassPathXmlApplicationContext("aop.xml");
        User user = context.getBean("user", User.class);
        user.add();
    }
}
cj_sun6
关注
专栏目录
Spring5（3）-面向切面编程
weixin_52972575的博客
05-08 301
Spring核心技术：AOP面向切面，前置增强和后置增强
骑着蜗牛行天下
10-05 1286
Spring核心技术：AOP面向切面 所谓的面向切面编程，是一种通过预编译和运行期动态代理的方式，实现在不修改源代码的情况下给程序动态添加功能的技术。 面向对象的延续，Spring框架的重要内容，是函数式编程的一种衍生泛型。 利用AOP可以对业务逻辑各部分之间耦合度降低，提高程序的重用性，提高开发效率。 AOP的原理：(1)将复杂的需求分解出不同的方面，将散布在系统中的公共功能集中解决。 (2)采用代理机制组装起来运行，在不改变原程序的基础上对代码段进行增强处理，增加新的功能。 AOP相
Spring-AOP概念及使用教程
热门推荐
学而时习
07-02 1万+
Spring-AOP 1、AOP 基本概念 ​ （1）面向切面编程（方面），利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得 业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 ​ （2）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能 ​ （3）使用登录例子说明 AOP 2、AOP（底层原理） ​ a）AOP 底层使用动态代理 ，动态代理有两种情况： 第一种 有接口情况，使用 JDK 动态代理 ；创建接口实现类代理对象，增强类的方法 第二种 没有接口情况
Spring5 学习笔记 四 、AOP
weixin_46703850的博客
11-20 581
（1）面向切面编程（方面），利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 （2）通俗描述：**不通过修改源代码方式，在主干功能里面添加新功能** 功能模块可插入可拔出
5.2（Spring）AOP
weixin_46401545的博客
12-04 318
AOP（面向切面） （1）面向切面编程（方面），利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得 业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 （2）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能 AOP解析 AOP 底层使用动态代理 有两种情况动态代理 第一种 有接口情况，使用 JDK 动态代理 创建接口实现类代理对象，增强类的方法 第二种 没有接口情况，使用 CGLIB 动态代理 创建子类的代理对象，增强类的方法 JDK动态代理 使用 JDK 动态代理
Spring5之面向切面编程（AoP）
静水流深，沧笙踏歌
04-06 1322
前面讲过IoC操作bean管理，这里主要对Spring的另一核心AoP做个描述。AoP：面向切面编程，它可以在不通过修改源代码的基础之上，在主干功能里增加新的功能。
Spring框架+Spring工作原理+AOP面向切面编程+JDK代理+Cglib代理
03-13
1. **Spring Core**：提供了Spring框架的基础，包括依赖注入（DI）和面向切面编程（AOP）的基础支持。它是所有其他模块的基础。 2. **Spring AOP**：支持面向切面编程，允许开发者定义方法拦截器和切入点，从而分离...
Spring AOP面向切面编程实现原理方法详解
08-18
Spring AOP面向切面编程实现原理方法详解 面向切面编程（AOP）是Spring框架中的一个重要内容，通过预编译方式和运行期动态代理实现，在不修改源代码的情况下，给程序动态统一添加功能的一种技术。AOP可以对业务逻辑...
16.2 Spring框架-AOP面向切面编程
最新发布
04-12
面向切面编程（AOP，Aspect Oriented Programming）是Spring框架中的一个重要组成部分，它提供了一种模块化和声明式的方式来处理程序中的横切关注点，如日志、事务管理、性能监控等。在传统的OOP（面向对象编程）中...
spring-aop-5.2.7.RELEASE.jar
06-21
这是一个jar，用来支持spring框架中的aop部分，版本是5.2.7，官网可以下到，我的前几篇博客里也有写下载网址。本来不想设置积分，但是转念一想又设置了，我觉得不设置对不起我的网。
spring aop 五个依赖jar
05-16
spring aop依赖包，想要的可以下，我用的spring 3.1,其他版本的不知道支不支持。
spring aop依赖jar包
11-22
springaop依赖的jar包，spring版本2.5.6，如果需要，可以下载使用，欢迎各位评论指出不足
Spring5,AOP相关jar包.zip
03-08
com.springsource.net.sf.cglib-2.2.0.jar com.springsource.org.aopalliance-1.0.0.jar com.springsource.org.aspectj.weaver-1.6.6.release.jar commons-logging-1.2.jar druid-1.0.9.jar spring-aop-5.3.4.jar spring-aspects-5.3.4.jar spring-beans-5.3.4.jar spring-context-5.3.4.jar spring-core-5.3.4.jar spring-expression-5.3.4.jar
Spring AOP依赖jar包
07-30
Spring中基于AOP开发的项目依赖jar包
二、Spring5框架之AOP
qq_41231318的博客
07-30 206
AOP AOP（概念） （1）面向切面编程（方面），利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得 业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 （2）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能 （3）使用例子说明 AOP AOP 底层使用动态代理 1、什么是 AOP （1）有两种情况动态代理 第一种 有接口情况，使用 JDK 动态代理 1、创建接口实现类代理对象，增强类的方法 第二种 没有接口情况，使用 CGLIB 动态代理 1、创建子类的代理对
Spring基础学习5——spring AOP基本使用
子敬的技术博客
06-22 292
Spring基础学习5——spring AOP基本使用 Spring增强 1、导入AOP相关的包 2、在context中引入对应的约束 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="h...
Spring5 AOP AspectJ依赖的jar包
u010227042的博客
04-12 959
链接：https://pan.baidu.com/s/122JwcfBTkhRqFPTGho38jA 提取码：23dt
Spring5.2.5AOP
司天宏的博客
11-07 275
环境的搭建 package com.sth.spring.advisor; import org.aopalliance.intercept.MethodInterceptor; import org.aopalliance.intercept.MethodInvocation; public class MyAdvisor implements MethodInterceptor { @Override public Object invoke(MethodInvocation i
Spring AOP：面向切面编程详解与实战
CH03-AOP面向切面编程 本章节深入探讨了面向切面编程(AOP)这一强大的软件设计模式，它是软件开发中的一种热点技术，特别在Spring框架中占有重要地位。AOP旨在通过预先编译或运行时动态代理，实现对程序功能的集中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值