15.Spring 面向切面编程

最新推荐文章于 2024-08-10 08:15:00 发布
最新推荐文章于 2024-08-10 08:15:00 发布
阅读量1k 收藏 5
点赞数 3
分类专栏： SSM框架笔记 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41775769/article/details/120208320
版权

Spring 面向切面编程

AOP 是 Spring 框架除了 IOC 之外的另一个核心概念。

  AOP：Aspect Oriented Programming，意为面向切面编程。这是一个新的概念，但是我们知道 Java 是面向对象编程(OOP：Object Oriented Programming)的，指将所有的一切都看作对象，通过对象与对象之间相互作用来解决问题。AOP 是对 OOP 的一个补充，是在另外一个维度抽象出来的对象，具体是指程序在运行时，动态地将非业务代码切入业务代码中，从而实现代码的解耦合，将非业务代码抽象成一个对象，对该对象进行编程，这就是面向切面编程。

在这里插入图片描述

AOP 的优点：

  1. 降低模块之间的耦合度；
  2. 提高了代码的可维护性；
  3. 提高了代码的复用性；
  4. 集中分开管理非业务代码和业务代码，逻辑更加清晰；
  5. 业务代码更加简洁纯粹，没有其他代码的影响；

1. 面向切面编程思想

  介绍概念过于抽象和空泛，不易于理解，下面我们通过一个实例来说明，慢慢引出 AOP 的动态代理机制以及实际开发中如何使用面向切面编程。

1、创建一个计算器接口 Cal，定义四个方法：加、减、乘、除；

public interface Cal {
    public int add(int num1,int num2);
    public int sub(int num1,int num2);
    public int mul(int num1,int num2);
    public int div(int num1,int num2);
}

2、创建接口实现类 CalImpl，并且实现上面定义的四个方法；

public class CalImpl implements Cal{

    public int add(int num1, int num2) {
        int result = num1 + num2;
        return result;
    }

    public int sub(int num1, int num2) {
        int result = num1 - num2;
        return result;
    }

    public int mul(int num1, int num2) {
        int result = num1 * num2;
        return result;
    }

    public int div(int num1, int num2) {
        int result = num1 / num2;
        return result;
    }
}

3、在测试方法中创建 CalImpl 对象，调用方法；

public class Test3 {
    public static void main(String[] args) {
        Cal cal = new CalImpl();
        cal.add(12,4); //16
        cal.sub(12,4); //8
        cal.mul(12,4); //48
        cal.div(12,4); //3
    }
}

以上这段代码很简单，现在想要添加功能：在每一个方法执行的同时，打印日志信息，即该方法的参数列表和该方法的计算结果。

这个需求很简单，只需要在每一个方法体中，运算执行之前打印参数列表，运行之后打印计算结果即可，因此，对代码做出如下修改：

public class CalImpl implements Cal{

    public int add(int num1, int num2) {
        System.out.println("add方法的参数是["+num1+","+num2+"]" );
        int result = num1 + num2;
        System.out.println("add方法的结果是"+result);
        return result;
    }

    public int sub(int num1, int num2) {
        System.out.println("sub方法的参数是["+num1+","+num2+"]" );
        int result = num1 - num2;
        System.out.println("sub方法的结果是"+result);
        return result;
    }

    public int mul(int num1, int num2) {
        System.out.println("mul方法的参数是["+num1+","+num2+"]" );
        int result = num1 * num2;
        System.out.println("mul方法的结果是"+result);
        return result;
    }

    public int div(int num1, int num2) {
        System.out.println("div方法的参数是["+num1+","+num2+"]" );
        int result = num1 / num2;
        System.out.println("div方法的结果是"+result);
        return result;
    }
}

再次运行代码，成功打印日志信息：

在这里插入图片描述

  功能已经实现了，但是我们会发现这种方式业务代码和打印日志代码的耦合性非常高，不利于代码后期的维护。例如，如果需求发生改变，需要对打印的日志内容作出修改，那么我们就必须修改4个方法中的所有相关代码，如果是100个方法呢？每次就需要手动去修改100个方法中的代码，对项目的维护成本就相当高。

  从这个例子中，我们会发现4个打印日志信息的代码基本相同，那么有没有可能将这部分的代码抽取出来进行封装，统一进行维护呢？同时也可以将日志代码和业务代码完全分离，解耦合。

  按照这个思路继续抽象，我们希望做的事情就是把这4个方法的相同位置(业务方法执行前、业务方法执行后)提取出来，形成一个横切面，并且将这个横切面封装成一个对象，将所有的打印日志代码写到这个对象中，以实现与业务代码的分离，这就是面向切面编程的思想。

2. 动态代理实现AOP

  根据上述的需求，我们希望在 CalImpl 中只进行业务运算，不进行打印日志的工作，那么就需要有一个对象来代替 CalImpl 进行打印日志的工作，这就是代理对象。所以一个很直观的实现思路就是使用动态代理的方式。

1、删除 CalImpl 方法中所有的打印日志代码，只保留业务代码；

public class CalImpl implements Cal{

    public int add(int num1, int num2) {
        int result = num1 + num2;
        return result;
    }

    public int sub(int num1, int num2) {
        int result = num1 - num2;
        return result;
    }

    public int mul(int num1, int num2) {
        int result = num1 * num2;
        return result;
    }

    public int div(int num1, int num2) {
        int result = num1 / num2;
        return result;
    }
}

2、创建 MyInvocationHandler 类，并实现 InvocationHandler 接口，成为一个动态代理类；

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

public class MyInvocationHandler implements InvocationHandler {
    //委托对象，因为不知道委托对象的类型，所以定义成Object(多态)
    private Object object = null;

    //返回代理对象
    public Object bind(Object object){
        this.object = object;
        return Proxy.newProxyInstance(object.getClass().getClassLoader(),
                object.getClass().getInterfaces(),
                this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(method.getName()+"的参数是:"+ Arrays.toString(args));
        Object result = method.invoke(object,args);
        System.out.println(method.getName()+"的结果是:"+result);
        return result;
    }
}

bind 方法是 MyInvocationHandler 类提供给外部调用的方法，传入需要被代理的对象，bind 方法会返回一个代理对象。bind 方法完成了两项工作：

  1. 将外部传进来的委托对象保存到成员变量中，因为业务方法调用时需要用到委托对象。

  2. 通过 Proxy.newProxyInstance 方法创建一个代理对象：

    解释一下 Proxy.newProxyInstance 方法的参数：

    • 我们知道对象是 JVM 根据运行时类来创建的，此时需要动态创建一个代理对象，可以使用委托对象的运行时类来创建代理对象：object.getClass().getClassLoader() 获取委托对象的运行时类；
    • 同时代理对象需要具备委托对象的所有方法，即需要用于委托对象的所有接口，所以传入 object.getClass().getInterfaces()；
    • this 指的是当前 MyInvocationHandler 类的对象；

invoke 方法：method 是描述委托对象的所有方法的对象，args 是描述委托对象方法的参数列表的对象。

method.invoke(object,args) 是通过反射机制来调用被代理对象的方法，即业务方法。

所以在 method.invoke(object, args) 前后添加打印日志的信息，就等同于在委托对象的业务方法前后添加打印日志信息，并且已经做到了分离，业务方法在委托对象中，打印日志信息在代理对象中。

3、测试方法中执行代码

public class Test3 {
    public static void main(String[] args) {
        //委托对象
        Cal cal = new CalImpl();
        MyInvocationHandler handler = new MyInvocationHandler();
        //代理对象
        Cal cals = (Cal)handler.bind(cal);
        cals.add(12,4);
        cals.sub(12,4);
        cals.mul(12,4);
        cals.div(12,4);
    }
}

在这里插入图片描述

可以看到和上面的执行结果一样，但是我们现在已经做到了代码分离，CalImpl 类中只有业务方法，打印日志的代码写在了 MyInvocationHandler 类中。

以上就是通过动态代理实现 AOP 的过程，我们在使用 Spring 框架的 AOP 时，并不需要那么复杂，Spring 已经对这个过程进行了封装，让开发者可以更加便捷的使用 AOP 进行开发。

3. Spring 框架的AOP操作

  在 Spring 框架中，我们不需要创建动态代理类，只需要创建一个切面类，Spring 底层自动会根据切面类以及目标类生成一个代理对象。

第一步：在 pom.xml 配置文件中添加 aspect 注解相关的依赖

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.5</version>
</dependency>

第二步：创建切面类 LoggerAspect

@Component
@Aspect
public class LoggerAspect {

    @Before("execution(public int com.trainingl.aop.CalImpl.*(..))")
    public void before(JoinPoint joinPoint){
        //获取方法名
        String name = joinPoint.getSignature().getName();
        //获取参数列表
        String args = Arrays.toString(joinPoint.getArgs());
        System.out.println(name + "的参数是:" + args);
    }

    @After("execution(public int com.trainingl.aop.CalImpl.*(..))")
    public void after(JoinPoint joinPoint){
        //获取方法名
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法结束");
    }

    @AfterReturning(value = "execution(public int com.trainingl.aop.CalImpl.*(..))",returning = "result")
    public void afterReturn(JoinPoint joinPoint, Object result){
        //获取方法名
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法的结果是"+result);
    }

    @AfterThrowing(value = "execution(public int com.trainingl.aop.CalImpl.*(..))",throwing = "exception")
    public void afterThrowing(JoinPoint joinPoint,Exception exception){
        //获取方法名
        String name = joinPoint.getSignature().getName();
    }
}

LoggerAspect 类名处添加了两个注解：

  1. @Aspect：表示该类是切面类；
  2. @Component：将该类注入到 IOC 容器；

分别来说明类中的 4 个方法的注解的含义：

@Before("execution(public int com.trainingl.aop.CalImpl.*(..))")
public void before(JoinPoint joinPoint){
    //获取方法名
    String name = joinPoint.getSignature().getName();
    //获取参数列表
    String args = Arrays.toString(joinPoint.getArgs());
    System.out.println(name + "的参数是:" + args);
}
  1. @Before：表示 before 方法执行的时机；
  2. execution(public int com.trainingl.aop.CalImpl.*(..))：表示切入点是 com.trainingl.aop 包下 CalImpl 类中的所有方法；

@Before 表示 CalImpl 所有方法在执行之前会首先执行 LoggerAspect 类中的 before 方法。

@after 注解同理，表示 CalImpl 所有方法在执行之后会首先执行 LoggerAspect 类中的 after 方法；

@afterReturning 注解表示 CalImpl 所有方法在 return 之后会执行 LoggerAspect 类中的方法；

@afterThrowing 注解表示 CalImpl 所有方法在抛出异常时会执行 LoggerAspect 类中的 afterThrowing 方法。

所以，开发者可以根据具体的切入需求，选择在 before、after、afterReturn、afterThrowing 方法中添加相应的代码。

第三步：目标类也需要添加 @Component 注解

@Component
public class CalImpl implements Cal{

    public int add(int num1, int num2) {
        int result = num1 + num2;
        return result;
    }

    public int sub(int num1, int num2) {
        int result = num1 - num2;
        return result;
    }

    public int mul(int num1, int num2) {
        int result = num1 * num2;
        return result;
    }

    public int div(int num1, int num2) {
        int result = num1 / num2;
        return result;
    }
}

第四步：spring.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:context="http://www.springframework.org/schema/context"
       xmlns:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
	   http://www.springframework.org/schema/context
	   http://www.springframework.org/schema/context/spring-context-4.3.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--将指定包下的类扫描到IOC容器中-->
    <context:component-scan base-package="com.trainingl.aop"></context:component-scan>

    <!--使Aspect注解生效，为目标类自动生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

  1. 将 com.trainingl.ioc 包中的类扫描到 IOC 容器中；

  2. 添加 aop:aspectj-autoproxy 注解，Spring 容器会结合切面类和目标类自动生成动态代理对象，Spring 框架的 AOP 底层就是通过动态代理的方式完成 AOP；

第五步：测试方法执行如下代码

从 IOC 容器中获取代理对象，执行方法

public class Test4 {
    public static void main(String[] args) {
        //加载spring.xml
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        //获取代理对象
        Cal cal = (Cal) applicationContext.getBean(Cal.class);
        cal.add(12,4);
        cal.sub(12,4);
        cal.mul(12,4);
        cal.div(12,4);
    }
}

执行结果如下：

在这里插入图片描述

结合代码和图示，重新理解几个概念：

在这里插入图片描述

  • 切面：横切关注点被模块化的特殊对象，即本例中 CalImpl 所有方法中需要加入日志的部分，抽象成一个切面对象 LoggerAspect；
  • 切点：AOP 通过切点定位到连接点；
  • 连接点：程序要执行的某个特定位置，切面方法要插入业务代码的具体位置。
Training.L
关注
专栏目录
使用Spring进行面向切面编程
02-09 1万+
Chapter 6. 使用Spring进行面向切面编程（AOP） 6.1. 简介 面向切面编程（AOP）通过提供另外一种思考程序结构的途经来弥补面向对象编程（OOP）的不足。在OOP中模块化的关键单元是类（classes），而在AOP中模块化的单元则是切面。切面能对关注点进行模块化，例如横切多个类型和对象的事务管理。（在AOP术语中通常称作横切（crosscutti
Spring面向切面编程
qq_43031585的博客
10-10 2708
Spring面向切面编程 一、在Spring容器中详细配置（增强） 首先导入以下jar包 接着写好Dao层和Service层，最后写Aop实体类以及在Spring容器中的配置（以下详细描述四种增强） 第一种：Throws异常增强（当目标方法抛出异常时调用） Aop实体类： /** * @param joinPoint 所有动态代理的类的信息 */ public...
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操作案例...
Spring AOP（面向切面编程）
最新发布
m0_70066267的博客
08-10 729
AOP是一种编程范式，它允许开发者将横切关注点（如日志、安全、事务管理等）从业务逻辑中分离出来，形成独立的切面（Aspect），然后在运行时通过动态代理技术将这些切面织入到业务代码中，从而实现非侵入式的代码增强。
Spring之面向切面编程（AOP）
旭日的芬芳
10-29 7274
1. 面向切面编程 以下内容来自百度百科： 定义：面向切面编程（AOP，Aspect Oriented Programming）是通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。 作用：利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 主要功能：日志记录、性能统计、安全控制、事务处理、异常处理等。 总结：面向切面编程是希望能够将通用需求功能从不相关的类当中分离出来，能够使得很多类共享一个行为，一旦发生
Spring 面向切面编程
形容的博客
03-18 304
Spring 面向切面编程 什么是 AOP AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 AOP 是 OOP 的补充，是软件开发中的一个重要的技术，同时也是Spring框架中的核心内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的 耦合度降低 ，提高程序的可重用性，同时提高了开发的效率。 AOP 的作用及其优势 作用：在程序运行期间，在不修改源码的情况下对
Spring切面编程
BadBoyxiaolin的博客
05-08 1816
*** @Description: 操作日志注解*/ @Documented @Target(ElementType . METHOD) // 作用在方法上 @Retention(RetentionPolicy . RUNTIME) // 运行时有效 public @interface Operation {/*** 操作模块/*** 操作类型/*** 操作说明。
Spring——面向切面编程
记录只为更好地前行
05-01 370
本文主要依据《Spring实战》第四章内容进行总结 1、面向切面编程术语 1.1、横切关注点 散布于应用中多处的功能被称为横切关注点，通常来讲，这些横切关注点从概念上是与应用的业务逻辑相分离的（但是往往会直接嵌入到应用的业务逻辑中），把这些横切关注点与业务逻辑相分离正是面向切面编程（AOP）所要解决的问题。AOP可以实现横切关注点与它们所影响的对象之间的解耦。 横切关注点可以被...
Spring 面向切面编程AOP实现详解
08-25
Spring 面向切面编程AOP实现详解 面向切面编程（AOP）是一种编程技术，旨在将横切关注点从业务逻辑中分离出来，提高系统的可扩展性和可维护性。Spring 作为一个流行的 Java 框架，提供了完备的 AOP 实现机制。 1. ...
Spring——面向切面编程(AOP)
行者无疆的博客
06-05 3718
本文介绍了切向切面编程(AOP)中的各个概念，并用两个案例分别讲解了如何通过注解和XML配置的方式使用AOP。
Spring AOP面向切面编程实现原理方法详解
08-18
Spring AOP面向切面编程实现原理方法详解 面向切面编程（AOP）是Spring框架中的一个重要内容，通过预编译方式和运行期动态代理实现，在不修改源代码的情况下，给程序动态统一添加功能的一种技术。AOP可以对业务逻辑...
aop.rar_面向切面编程
09-24
在这个“aop.rar”压缩包中，我们可以预期它包含了关于如何使用Spring AOP进行面向切面编程的教程或示例代码。通常，这种资源会通过注解的方式来简化AOP的实现，使得学习过程更加直观和有趣。 首先，我们要理解...
SpringAOP切面编程依赖jar包.rar
04-30
学习Spring开发的AOP面向切面编程时所需要的jar包，包括com.springsource.net.sf.cglib-2.2.0.jar com.springsource.org.aopalliance-1.0.0.jar com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
Spring基础篇：面向切面编程
七叔的博客
12-03 1万+
Spring基础篇：面向切面编程
Spring 面向切面编程(aop)
m0_64899073的博客
02-16 267
概念： 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个 热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑 的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 练习代码： AdminCheck: BankDaoImpl: pub
Spring之面向切面编程
博客
06-01 325
1
Spring的面向切面编程
Damon_zqt的博客
05-20 423
面向切面编程 在使用面向切面编程时，我们仍然在一个地方定义通用功能，但是可以通过声明的方式定义这个功能要以何种方式在何处应用，而无需修改受影响的类。横切关注点可以被模块化为特殊的类，这些类被称为切面（aspect）。 术语 描述切面的常用术语有通知（advice）、切点（pointcut）和连接点（join point）。 通知（Advice） 在AOP术语中，切面的工作被称为通知。 Spring切面可以应用5种类型的通知： 前置通知（Before）：在目标方法被调用之前调用通知功能； 后置通知（After
Spring面向切面编程——Spring实现AOP方式——通过Spring API实现
奔跑的蜗牛
10-07 460
Log.class: package log; import org.springframework.aop.MethodBeforeAdvice; import java.lang.reflect.Method; /** * Description: 使用spring实现aop---使用spring API来实现 前置通知 */ public class Log implement
Spring AOP：面向切面编程详解与实战
本章节深入探讨了面向切面编程(AOP)这一强大的软件设计模式，它是软件开发中的一种热点技术，特别在Spring框架中占有重要地位。AOP旨在通过预先编译或运行时动态代理，实现对程序功能的集中管理和维护，从而提高代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值