AOP的应用以及代码实现（详细剖析）

叫我老伯

已于 2022-03-29 20:14:42 修改

阅读量2.5k

点赞数 2

分类专栏： Spring 文章标签： java spring aop

于 2022-02-20 16:36:56 首次发布

本文链接： https://blog.csdn.net/weixin_51309915/article/details/123027929

版权

Spring 专栏收录该内容

8 篇文章 9 订阅

订阅专栏

1. 简介

1.1 IOC的主要流程/功能

1.2 AOP的概念图

1.3 AOP 流程图

2. 基本准备工作

------------------------------配置文件实现AOP----------------------------

3.AOP配置文件方式的入门

4. 切入点的表达式（不建议用*号）

-----------------------------注解方式实现AOP----------------------------

5.AOP注解方式入门程序

5.1 配置xml扫描注解

5.2 配置注解

5.3 给切面类添加注解 @Aspect，编写增强的方法，使用通知类型注解声明

5.4 测试类

1. 简介

1.1 IOC的主要流程/功能

1.2 AOP的概念图

1.3 AOP 流程图

1.4 spring 4-5中aop的区别

假设一个类Demo

--------------------------AOP相关术语------------------------------

Joinpoint(连接点) 类里面有哪些方法可以增强这些方法称为连接点
Pointcut(切入点) -- 所谓切入点是指我们要对哪些Joinpoint进行拦截的定义，实际要增强的方法。
Advice(通知/增强)-- 所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)。实际增强的逻辑部分就是通知

前置通知目标方法执行前，进行增强

后置通知目标方法执行成功后，进行增强。

环绕通知目标方法执行前后，都可以进行增强。目标对象的方法需要手动执行。

异常通知目标方法执行失败后，进行增强。(发生异常的时候才会执行，否则不执行)。一旦方法异常，就会通知。

最终通知目标方法执行成功或者失败，进行增强。类似于finally

Aspect(切面)-- 是切入点+通知的结合，以后咱们自己来编写和配置的。通知应用到切入点的一个过程

2. 基本准备工作

AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法,AspectJ实际上是对AOP编程思想的一个实践.

------------------------------配置文件实现AOP----------------------------

3.AOP配置文件方式的入门

3.1 创建maven项目，坐标依赖

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.12</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <!--AOP联盟-->
    <dependency>
        <groupId>aopalliance</groupId>
        <artifactId>aopalliance</artifactId>
        <version>1.0</version>
    </dependency>
    <!--Spring Aspects-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <!--aspectj-->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.3</version>
    </dependency>
</dependencies>

3.2 创建被增强的类User.java

package com.qcby;

import org.springframework.stereotype.Component;

public class User {
   public void add(){
//        int a= 10/0;
        System.out.println("add方法");
    }
}

3.3 定义切面类 UserPorxy.java

package com.qcby;

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


public class UserPorxy {
//    增强/通知  ---》前置通知
    public void before(){
        System.out.println("切面类before先执行");
    }

//    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
//        System.out.println("这是在add方法执行前执行的(around)。。。。");
//
//        // 执行被增强的方法
//        proceedingJoinPoint.proceed();
//
//        System.out.println("这是在add方法执行后执行的(around)。。。。");
//    }
    // 无论切入点成功或者失败都会进程执行，类似于finally

//    public void after(){
//        System.out.println("这是在add方法执行后执行的(after)。。。。");
//    }
    // 后置通知 : 和 after一样都是在方法执行之后执行，但是 after 无论切入点成功或者失败都会进程执行

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

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


}

3.4 将目标类配置到Spring中 SpringConfig.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="user" class="com.qcby.User"/>
<bean id="userPorxy" class="com.qcby.UserPorxy"/>


<!--配置切面-->
<aop:config>
    <!--配置切面 = 切入点 + 通知组成-->
    <aop:aspect ref="userProxy">
        <!--前置通知：UserServiceImpl的save方法执行前，会增强-->
        <!--pointcut：后边是切入点表达式，作用是知道对对面的那个方法进行增强-->
        <aop:before method="before" pointcut="execution(public void com.aopImpl.User.add())"/>
               <!--环绕通知-->
<!--                <aop:around method="around" pointcut="execution(public void com.qcby.User.add())"/>-->
                <!--最终通知-->
<!--                <aop:after method="after" pointcut="execution(public void com.qcby.User.add())"/>-->
                <!--后置通知-->
<!--                <aop:after-returning method="afterReturning" pointcut="execution(public void com.qcby.User.add())"/>-->
                <!--异常通知-->
<!--                <aop:after-throwing method="afterThrowing" pointcut="execution(public void com.qcby.User.add())"/>
         
    </aop:aspect>
</aop:config>


</beans>

3.4 完成测试 DemoTest.java

package com.qcby.test;

import com.qcby.User;
import javafx.application.Application;
import jdk.nashorn.internal.ir.CallNode;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class DemoTest {
    @Test
    public void aopTest(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("SpringConfig.xml");
        User user = (User) ac.getBean("user");
        user.add();
    }

}

五种类型要分别测试，测试完一个注释一个

4. 切入点的表达式（不建议用*号）

 @Pointcut("execution(public * com.qcby.demo.proxyaop.controller..*.*(..))")
    public void viewRecordsPoinCut() {

    }

再配置切入点的时候，需要定义表达式，具体展开如下：

切入点表达式的格式如下：

execution([修饰符] [返回值类型] [类全路径] [方法名 ( [参数] )])

修饰符可以省略不写，不是必须要出现的。

返回值类型是不能省略不写的，根据你的方法来编写返回值，可以使用 * 代替。

-----------------------------注解方式实现AOP----------------------------

5.AOP注解方式入门程序

创建maven工程，导入坐标。编写接口，完成IOC的操作。步骤略。

编写切面类

给切面类添加注解 @Aspect，编写增强的方法，使用通知类型注解声明

5.1 配置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: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/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

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

5.2 配置注解

package com.qcby;

import org.springframework.stereotype.Component;

@Component
public class User {

    public void add(){
//        int a= 10/0;
        System.out.println("add方法");
    }

}

5.3 给切面类添加注解 @Aspect，编写增强的方法，使用通知类型注解声明

package com.qcby;

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

@Component
@Aspect
public class UserPorxy {
//    增强/通知  ---》前置通知
    @Before(value = "execution(public void com.qcby.User.add())")
    public void before(){
        System.out.println("切面类before先执行");
    }

//@Around(value = "execution(public void com.qcby.User.add())")
//    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
//        System.out.println("这是在add方法执行前执行的(around)。。。。");
//
//        // 执行被增强的方法
//        proceedingJoinPoint.proceed();
//
//        System.out.println("这是在add方法执行后执行的(around)。。。。");
//    }
    // 无论切入点成功或者失败都会进程执行，类似于finally

//    @After(value = "execution(public void com.qcby.User.add())")
//    public void after(){
//        System.out.println("这是在add方法执行后执行的(after)。。。。");
//    }
    // 后置通知 : 和 after一样都是在方法执行之后执行，但是 after 无论切入点成功或者失败都会进程执行

//    @AfterReturning(value = "execution(public void com.qcby.User.add())")
//    public void afterReturning(){
//        System.out.println("afterReturning");
//    }

//   @AfterThrowing(value = "execution(public void com.qcby.User.add())")
//    public void afterThrowing(){
//        System.out.println("afterThrowing....");
//    }


}

5.4 测试类

package com.qcby.test;

import com.qcby.User;
import javafx.application.Application;
import jdk.nashorn.internal.ir.CallNode;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class DemoTest {
    @Test
    public void aopTest(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("SpringConfig.xml");
        User user = (User) ac.getBean("user");
        user.add();
    }

}

5.5 结果呈现（五个分别测试，在测试异常的时候，需要在User.java中写个除0异常）