spring基础之aop（面向切面编程）

瑟瑟发抖的萌新学徒

于 2023-04-05 21:36:47 发布

阅读量91

点赞数

文章标签： spring java maven

本文链接：https://blog.csdn.net/m0_56420338/article/details/129977491

版权

1.pm.xml导入配置文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>Spring_04_aop</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
<dependencies>
    <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.6</version>
        <scope>runtime</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/aspectj/aspectjrt -->
    <dependency>
        <groupId>aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>1.5.3</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.1</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.21.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>5.2.22.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>5.2.22.RELEASE</version>
    </dependency>

</dependencies>
</project>

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: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">
<!--切入点组件-->

3.切入组件组件及通知配置

3.1切入点组件

 <bean id="tanrget" class="com.dltt.service.Target"/>

3.2切面程序组件

<bean id="testBefore" class="com.dltt.aspect.TestBefore"/>

3.3设置通知

<!--设置通知（aop）
<aop:config >面向切面编程的根标签，所有的aop配置都在他的内部
-->
 <aop:config >
<!--        1.配置aop的切入点,id为切入点 expression切入点表达式，代表了
哪些目标程序组件中的方法执行时被插入了切面程序 within表示按类匹配，匹配类中的所有方法都为切入点-->
        <aop:pointcut id="targetPointcut" expression="within(com.dltt.service.Target)"/>
<!--       配置切面，ref属性：切面对象-->
        <aop:aspect ref="testBefore">
<!--            配置切面的通知方式
            method属性配置切面方法
            pointcut-ref配置切入点id
             aop:before前置通知：前置通知的参数类型arg。aspectJ。lang。JoinPoint（也可以无参） */-->
            <aop:before method="doBefore" pointcut-ref="targetPointcut"/>
<!--           aop:after-returning后置通知：切面程序：可以获取到目标方法返回值的参数Object ret，但是需要在配置文件中声明改参数名  ，在方法正常结束之后
         retutning配置返回值参数名-->
            <aop:after-returning method="doAfterReturning" pointcut-ref="targetPointcut"
                                 returning="ret"/>
 <!--      aop:after-throwing 异常通知：：异常通知的切面程序中可以获取到目标罪案抛出的异常
* 需要在配置文件上声明异常参数名
         throwing配置切面程序异常参数名
-->

<aop:after-throwing method="doAfterThrowing" pointcut-ref="targetPointcut"
                    throwing="e"/>
<!-- aop:after最终通知：在目标组件的方法正常执行后执行，后置通知前执行，或在异常通知之前执行-->
<aop:after method="doAfter" pointcut-ref="targetPointcut"/>
 <!-- aop:around环绕通知：环绕通知方法的返回类型要和目标组件方法的返回类型的值一致，最终通知后将该值返回，容器会自动打印返回值-->

<aop:around method="doAround" pointcut-ref="targetPointcut"/>
        </aop:aspect>

    </aop:config>

java类切点，切面类：

package com.dltt.service;
//切入点程序，可以是spring组件中的任何一个方法，不限返回类型参数类型等

public class Target {

    public void save(String name){
        System.out.println("执行save方法，保存名字:"+name);

    }
    public int add(int a,int b){
        System.out.println("执行add方法");
        return a+b;
    }
    public int addExp(int a,int b){
        System.out.println(10/0);
        System.out.println("执行add方法");
        return a+b;
    }
}

package com.dltt.aspect;

import org.aopalliance.intercept.Joinpoint;
import org.aspectj.lang.JoinPoint;

/*切面程序（aspect）：是spring组件中的某个方法，没有返回类型，参数类型与通知类型有关
前置通知的参数类型arg。aspectJ。lang。JoinPoint（也可以无参） */
public class TestBefore {
    public void doBefore(JoinPoint jp){
        //jp.getArgs()传入切入点参数的值，参数列表的参数个数不定，所以返回的是数组类型【Object【】】
        System.out.println("获取传递给切入点方法的参数值"+jp.getArgs()[0]);
        System.out.println("获取切入点方法的java反射对象"+jp.getSignature());
        System.out.println("获取切入点对象"+jp.getTarget());
        System.out.println("testBefore组件的doBefore方法执行了");
    }
}

package com.dltt.aspect;

import org.aspectj.lang.JoinPoint;

public class TestAfterReturning {
//    后置通知，切面程序：可以获取到目标方法返回值的参数Object ret，但是需要在配置文件中声明改参数名
//    在方法正常结束之后
    public void doAfterReturning(JoinPoint jb,Object ret){
        System.out.println("ret为目标组件方法返回值："+ret);
        System.out.println("后置通知在目标组件方法返回之后执行");

    }
}


package com.dltt.aspect;

import org.aspectj.lang.JoinPoint;

public class TestAfterThrowing {
/*
* aop异常通知：在目标组件的方法抛出异常信息后执行的程序
* 切面程序：异常通知的切面程序中可以获取到目标罪案抛出的异常
* 需要在配置文件上声明异常参数名
* */
    public void doAfterThrowing(JoinPoint jp,Exception e){
        System.out.println("e为目标程序方法抛出的异常信息:"+e.getMessage());


    }
}


package com.dltt.aspect;

import org.aspectj.lang.JoinPoint;

public class TestAfter {
    /*
    * 最终通知：在目标组件的方法正常执行后执行，后置通知前执行，或在异常通知之前执行
    * */
    public void doAfter(JoinPoint jp){
        System.out.println("最终通知，目标组件正常运行或抛出异常都会执行");

    }
}


package com.dltt.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
//环绕通知方法的返回类型要和目标组件方法的返回类型的值一致，最终通知后将该值返回，容器会自动打印返回值
public class TestAround {
    int obj=0;
    public int doAround(ProceedingJoinPoint pjp){
        System.out.println("目标组件的前置通知程序,传入的第一个参数："+pjp.getArgs()[0]);
        try {
            //运行了，目标组件，接收了参数obj
             obj=(int)pjp.proceed();
            System.out.println("目标组件的后置通知，接收的返回值为："+obj);
        } catch (Throwable e) {
            System.out.println("目标组件的异常通知，异常信息wei"+e.getMessage());
        }
        System.out.println("目标组件的最终通知");
        return obj;
    }
}