Spring核心之AOP详细解释（包含注解方式实现AOP和XML方式实现AOP）

最新推荐文章于 2022-11-04 10:20:56 发布

一个小小白的成长之路

最新推荐文章于 2022-11-04 10:20:56 发布

阅读量420

点赞数

文章标签： aop spring java

本文链接：https://blog.csdn.net/weixin_50396997/article/details/115871480

版权

1、Spring核心之AOP

1.1、什么是AOP

AOP为Aspect Oriented Programming的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

AOP的作用：不修改源码的情况下，程序运行期间对方法进行功能增强

好处：

1、减少代码的重复，提高开发效率，便于维护。

2、专注核心业务的开发。

核心业务和服务性代码混合在一起

开发中：各自做自己擅长的事情，运行的时候将服务性代码织入到核心业务中。

通过spring工厂自动实现将服务性代码以切面的方式加入到核心业务代码中。

1.2、注解方式实现AOP

开发阶段：关注核心业务和AOP代码

运行阶段：spring框架会在运行的时候将核心业务和AOP代码通过动态代理的方式编织在一起

代理方式的选择：是否实现了接口：有接口就选择JDK动态代理；没有就选择CGLIB动态代理。

接下来小白带大家用代码一步一步来实现AOP

首先，我们先创建一个Maven项目

其次，我们在pom.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>spring03</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!--单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!--Spring依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.0.8.RELEASE</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <!--编译插件-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.0</version>
                <configuration>
                    <source>11</source>
                    <target>11</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

然后在resources文件夹下创建spring.xml文件，并且在bean标签中引入AOP约束，目录以及内容如下：

接下来我们就开始在java包下编写核心业务，我们先编写一个IServer接口，内容如下：

package com.kkb.service;

public interface IService {
    void add(int id,String name);
    boolean update(int number);
    
}

然后我们再创建一个TeamService类来实现IService接口

package com.kkb.service;

/**
 * 核心业务类
 */
@Service
public class TeamService implements IService{
    @Override
    public void add(int id, String name) {
        System.out.println("TeamService----->add");
    }

    @Override
    public boolean update(int number) {
        System.out.println("TeamService----->update");
        if (number>666){
            return true;
        }
        return false;
    }
}

我们的核心业务已经写完，接下来我们来写切面

我们在aop包下创建一个MyAspect切面类，我们看一下包结构

MyAspect类内容为：

package com.kkb.aop;


/**
 * 切面类
 */
@Component //切面对象创建权限依然交给Spring容器
@Aspect    //框架的注解，标识当前类是一个切面类
public class MyAspect {
    public void before(){
        System.out.println("前置通知：在目标方法之前被调用的通知");
    }
    public void after(){
        System.out.println("后置通知：在目标方法之后被调用的通知");
    }
    public void exception(){
        System.out.println("异常通知：在目标方法执行时出现异常才会被调用的通知，否则不执行");
    }
    public void myFinally(){
        System.out.println("最后通知：无论是否出现异常都是最后被调用的通知");
    }
}

然后我们来创建一个测试类，来检测核心业务类：

 @Test
    public void test(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        TeamService teamService = (TeamService) applicationContext.getBean("teamService");
        teamService.add(1001,"湖人");
        System.out.println("---------------");
        boolean update = teamService.update(888);
        System.out.println("结果为："+update);
    }

现在如果我们直接运行测试类，会直接报错，原因是我们没在spring.xml文件中的bean标签里面引入contex约束并且进行包扫描，接下来我们来引用一下，

<?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.kkb.service"></context:component-scan>
</beans>

然后运行测试类：

"C:\Program Files\Java\jdk-11.0.6\bin\java.exe" -ea -Didea.test.cyclic.buffer.size=1048576 "-javaagent:E:\java IDEA\idea\ideaIU-2020.1.4.win\lib\idea_rt.jar=50631:E:\java IDEA\idea\ideaIU-2020.1.4.win\bin" -Dfile.encoding=UTF-8 -classpath "E:\java IDEA\idea\ideaIU-2020.1.4.win\lib\idea_rt.jar;E:\java IDEA\idea\ideaIU-2020.1.4.win\plugins\junit\lib\junit5-rt.jar;E:\java IDEA\idea\ideaIU-2020.1.4.win\plugins\junit\lib\junit-rt.jar;E:\java IDEA\MySpring\spring03\target\test-classes;E:\java IDEA\MySpring\spring03\target\classes;E:\maven\maven_repository\junit\junit\4.12\junit-4.12.jar;E:\maven\maven_repository\org\hamcrest\hamcrest-core\1.3\hamcrest-core-1.3.jar;E:\maven\maven_repository\org\springframework\spring-context\5.2.6.RELEASE\spring-context-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-aop\5.2.6.RELEASE\spring-aop-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-beans\5.2.6.RELEASE\spring-beans-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-core\5.2.6.RELEASE\spring-core-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-jcl\5.2.6.RELEASE\spring-jcl-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-expression\5.2.6.RELEASE\spring-expression-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-aspects\5.0.8.RELEASE\spring-aspects-5.0.8.RELEASE.jar;E:\maven\maven_repository\org\aspectj\aspectjweaver\1.8.13\aspectjweaver-1.8.13.jar" com.intellij.rt.junit.JUnitStarter -ideVersion5 -junit4 @w@C:\Users\zhao\AppData\Local\Temp\idea_working_dirs_junit.tmp @C:\Users\zhao\AppData\Local\Temp\idea_junit.tmp
TeamService----->add
---------------
TeamService----->update
结果为：true

Process finished with exit code 0

运行成功。

1.2.1、AOP实现前置通知

基于以上，我们来实现一下AOP的前置通知

首先，我们要在切面类before方法添加@Before注解，表示要在核心类运行之前进行前置通知

@Before("execution(* com.kkb.service..*.*(..))")//指定切入点为：定义在 service 包或者子包里的任意类的任意方法。“..”出现在类名中时，后面必须跟“*”，表示包、子包下的所有类。
    public void before(JoinPoint jp){
        System.out.println("前置通知：在目标方法之前被调用的通知");
        String name = jp.getSignature().getName();
        System.out.println("拦截的方法名称："+name);
        Object[] args = jp.getArgs();
        System.out.println("拦截的参数格式："+args.length);
        System.out.println("拦截的参数列表：");
        for (Object arg:args){
            System.out.println("\t"+arg);
        }
    }

然后再spring.xml文件中对aop包进行包扫描，并且开启aspectj自动代理

<?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.kkb.service,com.kkb.aop"></context:component-scan>
    <!--aspectj-autoproxy:开启aspectj自动代理  proxy-target-class：是否开启对目标类的代理 -->
    <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>
</beans>

运行测试类：

"C:\Program Files\Java\jdk-11.0.6\bin\java.exe" -ea -Didea.test.cyclic.buffer.size=1048576 "-javaagent:E:\java IDEA\idea\ideaIU-2020.1.4.win\lib\idea_rt.jar=50921:E:\java IDEA\idea\ideaIU-2020.1.4.win\bin" -Dfile.encoding=UTF-8 -classpath "E:\java IDEA\idea\ideaIU-2020.1.4.win\lib\idea_rt.jar;E:\java IDEA\idea\ideaIU-2020.1.4.win\plugins\junit\lib\junit5-rt.jar;E:\java IDEA\idea\ideaIU-2020.1.4.win\plugins\junit\lib\junit-rt.jar;E:\java IDEA\MySpring\spring03\target\test-classes;E:\java IDEA\MySpring\spring03\target\classes;E:\maven\maven_repository\junit\junit\4.12\junit-4.12.jar;E:\maven\maven_repository\org\hamcrest\hamcrest-core\1.3\hamcrest-core-1.3.jar;E:\maven\maven_repository\org\springframework\spring-context\5.2.6.RELEASE\spring-context-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-aop\5.2.6.RELEASE\spring-aop-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-beans\5.2.6.RELEASE\spring-beans-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-core\5.2.6.RELEASE\spring-core-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-jcl\5.2.6.RELEASE\spring-jcl-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-expression\5.2.6.RELEASE\spring-expression-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-aspects\5.0.8.RELEASE\spring-aspects-5.0.8.RELEASE.jar;E:\maven\maven_repository\org\aspectj\aspectjweaver\1.8.13\aspectjweaver-1.8.13.jar" com.intellij.rt.junit.JUnitStarter -ideVersion5 -junit4 @w@C:\Users\zhao\AppData\Local\Temp\idea_working_dirs_junit.tmp @C:\Users\zhao\AppData\Local\Temp\idea_junit.tmp
前置通知：在目标方法之前被调用的通知
拦截的方法名称：add
拦截的参数格式：2
拦截的参数列表：
	1001
	湖人
TeamService----->add
---------------
前置通知：在目标方法之前被调用的通知
拦截的方法名称：update
拦截的参数格式：1
拦截的参数列表：
	888
TeamService----->update
结果为：true

Process finished with exit code 0

运行成功，我们看到切面类中的befor方法在核心类方法之前运行。

1.2.2、AOP实现后置通知

首先，我们要在切面类after方法添加@AfterReturning注解，表示要在核心类运行之后进行后置通知

    @AfterReturning("execution(* com.kkb.service..*.*(..))")
    public void after(){
        System.out.println("后置通知：在目标方法之后被调用的通知");
    }

运行测试类：

"C:\Program Files\Java\jdk-11.0.6\bin\java.exe" -ea -Didea.test.cyclic.buffer.size=1048576 "-javaagent:E:\java IDEA\idea\ideaIU-2020.1.4.win\lib\idea_rt.jar=51294:E:\java IDEA\idea\ideaIU-2020.1.4.win\bin" -Dfile.encoding=UTF-8 -classpath "E:\java IDEA\idea\ideaIU-2020.1.4.win\lib\idea_rt.jar;E:\java IDEA\idea\ideaIU-2020.1.4.win\plugins\junit\lib\junit5-rt.jar;E:\java IDEA\idea\ideaIU-2020.1.4.win\plugins\junit\lib\junit-rt.jar;E:\java IDEA\MySpring\spring03\target\test-classes;E:\java IDEA\MySpring\spring03\target\classes;E:\maven\maven_repository\junit\junit\4.12\junit-4.12.jar;E:\maven\maven_repository\org\hamcrest\hamcrest-core\1.3\hamcrest-core-1.3.jar;E:\maven\maven_repository\org\springframework\spring-context\5.2.6.RELEASE\spring-context-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-aop\5.2.6.RELEASE\spring-aop-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-beans\5.2.6.RELEASE\spring-beans-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-core\5.2.6.RELEASE\spring-core-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-jcl\5.2.6.RELEASE\spring-jcl-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-expression\5.2.6.RELEASE\spring-expression-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-aspects\5.0.8.RELEASE\spring-aspects-5.0.8.RELEASE.jar;E:\maven\maven_repository\org\aspectj\aspectjweaver\1.8.13\aspectjweaver-1.8.13.jar" com.intellij.rt.junit.JUnitStarter -ideVersion5 -junit4 @w@C:\Users\zhao\AppData\Local\Temp\idea_working_dirs_junit.tmp @C:\Users\zhao\AppData\Local\Temp\idea_junit.tmp
前置通知：在目标方法之前被调用的通知
拦截的方法名称：add
拦截的参数格式：2
拦截的参数列表：
	1001
	湖人
TeamService----->add
后置通知：在目标方法之后被调用的通知
---------------
前置通知：在目标方法之前被调用的通知
拦截的方法名称：update
拦截的参数格式：1
拦截的参数列表：
	888
TeamService----->update
后置通知：在目标方法之后被调用的通知
结果为：true

Process finished with exit code 0

运行成功，我们看到切面类中的after方法在核心类方法之后运行。

1.2.3、AOP实现异常通知

首先，我们要在切面类exception方法添加@AfterThrowing注解，表示要在核心类运行之后进行异常通知

@AfterThrowing(value = "execution(* com.kkb.service..*.*(..))",throwing = "ex")
    public void exception(JoinPoint jp,Throwable ex){
        //一般会把发生异常的时间，位置，原因都记录下来
        System.out.println("异常通知：在目标方法执行时出现异常才会被调用的通知，否则不执行");
        System.out.println(jp.getSignature()+"方法出现异常，异常信息是："+ex.getMessage());
    }

为了方便测试，我们将核心类TeanService中add方法中添加一个错误信息

@Override
    public void add(int id, String name) {
        int a = 3/0;//用来测试异常通知
        System.out.println("TeamService----->add");
    }

运行测试类

"C:\Program Files\Java\jdk-11.0.6\bin\java.exe" -ea -Didea.test.cyclic.buffer.size=1048576 "-javaagent:E:\java IDEA\idea\ideaIU-2020.1.4.win\lib\idea_rt.jar=51406:E:\java IDEA\idea\ideaIU-2020.1.4.win\bin" -Dfile.encoding=UTF-8 -classpath "E:\java IDEA\idea\ideaIU-2020.1.4.win\lib\idea_rt.jar;E:\java IDEA\idea\ideaIU-2020.1.4.win\plugins\junit\lib\junit5-rt.jar;E:\java IDEA\idea\ideaIU-2020.1.4.win\plugins\junit\lib\junit-rt.jar;E:\java IDEA\MySpring\spring03\target\test-classes;E:\java IDEA\MySpring\spring03\target\classes;E:\maven\maven_repository\junit\junit\4.12\junit-4.12.jar;E:\maven\maven_repository\org\hamcrest\hamcrest-core\1.3\hamcrest-core-1.3.jar;E:\maven\maven_repository\org\springframework\spring-context\5.2.6.RELEASE\spring-context-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-aop\5.2.6.RELEASE\spring-aop-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-beans\5.2.6.RELEASE\spring-beans-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-core\5.2.6.RELEASE\spring-core-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-jcl\5.2.6.RELEASE\spring-jcl-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-expression\5.2.6.RELEASE\spring-expression-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-aspects\5.0.8.RELEASE\spring-aspects-5.0.8.RELEASE.jar;E:\maven\maven_repository\org\aspectj\aspectjweaver\1.8.13\aspectjweaver-1.8.13.jar" com.intellij.rt.junit.JUnitStarter -ideVersion5 -junit4 @w@C:\Users\zhao\AppData\Local\Temp\idea_working_dirs_junit.tmp @C:\Users\zhao\AppData\Local\Temp\idea_junit.tmp
前置通知：在目标方法之前被调用的通知
拦截的方法名称：add
拦截的参数格式：2
拦截的参数列表：
	1001
	湖人
异常通知：在目标方法执行时出现异常才会被调用的通知，否则不执行
void com.kkb.service.TeamService.add(int,String)方法出现异常，异常信息是：/ by zero

java.lang.ArithmeticException: / by zero

	at com.kkb.service.TeamService.add(TeamService.java:14)
	at com.kkb.service.TeamService$$FastClassBySpringCGLIB$$3a587166.invoke(<generated>)
	at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:218)
	at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:771)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:163)
	at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:749)
	at org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor.invoke(MethodBeforeAdviceInterceptor.java:56)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:749)
	at org.springframework.aop.framework.adapter.AfterReturningAdviceInterceptor.invoke(AfterReturningAdviceInterceptor.java:55)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:749)
	at org.springframework.aop.aspectj.AspectJAfterThrowingAdvice.invoke(AspectJAfterThrowingAdvice.java:62)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:749)
	at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:95)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:749)
	at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:691)
	at com.kkb.service.TeamService$$EnhancerBySpringCGLIB$$d2e866b3.add(<generated>)
	at com.kkb.test.TeamServiceTest.test(TeamServiceTest.java:19)
	at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.base/java.lang.reflect.Method.invoke(Method.java:566)
	at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
	at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
	at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
	at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
	at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
	at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
	at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
	at org.junit.runners.Suite.runChild(Suite.java:128)
	at org.junit.runners.Suite.runChild(Suite.java:27)
	at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
	at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
	at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
	at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
	at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
	at com.intellij.rt.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:33)
	at com.intellij.rt.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:230)
	at com.intellij.rt.junit.JUnitStarter.main(JUnitStarter.java:58)


Process finished with exit code -1

我们可以看到异常的信息被打印了出来，并且add后面的方法也执行不了

1.2.4、AOP实现最终通知

首先，我们要在切面类myFinally方法添加@After注解，表示无论是否出现异常都是最后被调用的通知

 @After("execution(* com.kkb.service..*.*(..))")
    public void myFinally(){
        System.out.println("最终通知：无论是否出现异常都是最后被调用的通知");
    }

运行测试类

"C:\Program Files\Java\jdk-11.0.6\bin\java.exe" -ea -Didea.test.cyclic.buffer.size=1048576 "-javaagent:E:\java IDEA\idea\ideaIU-2020.1.4.win\lib\idea_rt.jar=51533:E:\java IDEA\idea\ideaIU-2020.1.4.win\bin" -Dfile.encoding=UTF-8 -classpath "E:\java IDEA\idea\ideaIU-2020.1.4.win\lib\idea_rt.jar;E:\java IDEA\idea\ideaIU-2020.1.4.win\plugins\junit\lib\junit5-rt.jar;E:\java IDEA\idea\ideaIU-2020.1.4.win\plugins\junit\lib\junit-rt.jar;E:\java IDEA\MySpring\spring03\target\test-classes;E:\java IDEA\MySpring\spring03\target\classes;E:\maven\maven_repository\junit\junit\4.12\junit-4.12.jar;E:\maven\maven_repository\org\hamcrest\hamcrest-core\1.3\hamcrest-core-1.3.jar;E:\maven\maven_repository\org\springframework\spring-context\5.2.6.RELEASE\spring-context-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-aop\5.2.6.RELEASE\spring-aop-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-beans\5.2.6.RELEASE\spring-beans-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-core\5.2.6.RELEASE\spring-core-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-jcl\5.2.6.RELEASE\spring-jcl-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-expression\5.2.6.RELEASE\spring-expression-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-aspects\5.0.8.RELEASE\spring-aspects-5.0.8.RELEASE.jar;E:\maven\maven_repository\org\aspectj\aspectjweaver\1.8.13\aspectjweaver-1.8.13.jar" com.intellij.rt.junit.JUnitStarter -ideVersion5 -junit4 @w@C:\Users\zhao\AppData\Local\Temp\idea_working_dirs_junit.tmp @C:\Users\zhao\AppData\Local\Temp\idea_junit.tmp
前置通知：在目标方法之前被调用的通知
拦截的方法名称：add
拦截的参数格式：2
拦截的参数列表：
	1001
	湖人
TeamService----->add
最后通知：无论是否出现异常都是最后被调用的通知
后置通知：在目标方法之后被调用的通知
---------------
前置通知：在目标方法之前被调用的通知
拦截的方法名称：update
拦截的参数格式：1
拦截的参数列表：
	888
TeamService----->update
最后通知：无论是否出现异常都是最后被调用的通知
后置通知：在目标方法之后被调用的通知
结果为：true

Process finished with exit code 0

运行成功。

1.2.5、环绕通知

首先，我们要在切面类around方法添加@Around注解，表示无论是否出现异常都是最后被调用的通知

/**
     * Around注解声明环绕通知
     * ProceedingJoinPoint：中的proceed表示目标方法被执行
     * @param pjp
     * @return
     * @throws Throwable
     */
    @Around(value = "execution(* com.kkb.service..*.*(..))")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕方法------->目标方法之前执行");
        Object proceed = pjp.proceed();
        System.out.println("环绕方法------->目标方法之后执行");
        return proceed;
    }

运行测试类

"C:\Program Files\Java\jdk-11.0.6\bin\java.exe" -ea -Didea.test.cyclic.buffer.size=1048576 "-javaagent:E:\java IDEA\idea\ideaIU-2020.1.4.win\lib\idea_rt.jar=52164:E:\java IDEA\idea\ideaIU-2020.1.4.win\bin" -Dfile.encoding=UTF-8 -classpath "E:\java IDEA\idea\ideaIU-2020.1.4.win\lib\idea_rt.jar;E:\java IDEA\idea\ideaIU-2020.1.4.win\plugins\junit\lib\junit5-rt.jar;E:\java IDEA\idea\ideaIU-2020.1.4.win\plugins\junit\lib\junit-rt.jar;E:\java IDEA\MySpring\spring03\target\test-classes;E:\java IDEA\MySpring\spring03\target\classes;E:\maven\maven_repository\junit\junit\4.12\junit-4.12.jar;E:\maven\maven_repository\org\hamcrest\hamcrest-core\1.3\hamcrest-core-1.3.jar;E:\maven\maven_repository\org\springframework\spring-context\5.2.6.RELEASE\spring-context-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-aop\5.2.6.RELEASE\spring-aop-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-beans\5.2.6.RELEASE\spring-beans-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-core\5.2.6.RELEASE\spring-core-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-jcl\5.2.6.RELEASE\spring-jcl-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-expression\5.2.6.RELEASE\spring-expression-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-aspects\5.0.8.RELEASE\spring-aspects-5.0.8.RELEASE.jar;E:\maven\maven_repository\org\aspectj\aspectjweaver\1.8.13\aspectjweaver-1.8.13.jar" com.intellij.rt.junit.JUnitStarter -ideVersion5 -junit4 @w@C:\Users\zhao\AppData\Local\Temp\idea_working_dirs_junit.tmp @C:\Users\zhao\AppData\Local\Temp\idea_junit.tmp
环绕方法------->目标方法之前执行
前置通知：在目标方法之前被调用的通知
拦截的方法名称：add
拦截的参数格式：2
拦截的参数列表：
	1001
	湖人
TeamService----->add
环绕方法------->目标方法之后执行
最终通知：无论是否出现异常都是最后被调用的通知
后置通知：在目标方法之后被调用的通知
---------------
环绕方法------->目标方法之前执行
前置通知：在目标方法之前被调用的通知
拦截的方法名称：update
拦截的参数格式：1
拦截的参数列表：
	888
TeamService----->update
环绕方法------->目标方法之后执行
最终通知：无论是否出现异常都是最后被调用的通知
后置通知：在目标方法之后被调用的通知
结果为：true

Process finished with exit code 0

运行成功。

1.3 XML方式实现AOP

首先我们先创建一个MyAop切面类，将MyAspect类里面的内容复制到MyAop里面，并且进行一些删改，如下：

package com.kkb.aop;

/**
 * @Author: ZhangPengCheng
 * @Date: 2021/4/20 18:34
 * @Version 1.0
 */

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

/**
 * 切面类
 */
@Component //切面对象创建权限依然交给Spring容器
public class MyAop {


    public void before(JoinPoint jp) {
        System.out.println("AOP前置通知：在目标方法之前被调用的通知");
    }

    public void after() {
        System.out.println("AOP后置通知：在目标方法之后被调用的通知");
    }

    public void exception(Throwable ex) {
        System.out.println("AOP异常通知：在目标方法执行时出现异常才会被调用的通知，否则不执行");
    }

    public void myFinally() {
        System.out.println("AOP最终通知：无论是否出现异常都是最后被调用的通知");
    }

    /**
     * Around注解声明环绕通知
     * ProceedingJoinPoint：中的proceed表示目标方法被执行
     * @param pjp
     * @return
     * @throws Throwable
     */
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("AOP环绕方法------->目标方法之前执行");
        Object proceed = pjp.proceed();
        System.out.println("AOP环绕方法------->目标方法之后执行");
        return proceed;
    }
}

编写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: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.kkb.service,com.kkb.aop"></context:component-scan>
    <!--aspectj-autoproxy:开启aspectj自动代理  proxy-target-class：是否开启对目标类的代理 -->
    <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>

    <!--xml方式实现AOP-->
    <aop:config>
        <!--声明切入点表达式，可以声明多个-->
        <aop:pointcut id="pt1" expression="execution(* com.kkb.service..*.*(..))"/>
        <aop:aspect ref="myAop">
            <aop:before method="before" pointcut-ref="pt1"></aop:before>
            <aop:after-returning method="after" pointcut-ref="pt1"></aop:after-returning>
            <aop:after-throwing method="exception" pointcut-ref="pt1" throwing="ex"></aop:after-throwing>
            <aop:after method="myFinally" pointcut-ref="pt1"></aop:after>
            <aop:around method="around" pointcut-ref="pt1" ></aop:around>
        </aop:aspect>
    </aop:config>
</beans>

运行测试类：

"C:\Program Files\Java\jdk-11.0.6\bin\java.exe" -ea -Didea.test.cyclic.buffer.size=1048576 "-javaagent:E:\java IDEA\idea\ideaIU-2020.1.4.win\lib\idea_rt.jar=63222:E:\java IDEA\idea\ideaIU-2020.1.4.win\bin" -Dfile.encoding=UTF-8 -classpath "E:\java IDEA\idea\ideaIU-2020.1.4.win\lib\idea_rt.jar;E:\java IDEA\idea\ideaIU-2020.1.4.win\plugins\junit\lib\junit5-rt.jar;E:\java IDEA\idea\ideaIU-2020.1.4.win\plugins\junit\lib\junit-rt.jar;E:\java IDEA\MySpring\spring03\target\test-classes;E:\java IDEA\MySpring\spring03\target\classes;E:\maven\maven_repository\junit\junit\4.12\junit-4.12.jar;E:\maven\maven_repository\org\hamcrest\hamcrest-core\1.3\hamcrest-core-1.3.jar;E:\maven\maven_repository\org\springframework\spring-context\5.2.6.RELEASE\spring-context-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-aop\5.2.6.RELEASE\spring-aop-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-beans\5.2.6.RELEASE\spring-beans-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-core\5.2.6.RELEASE\spring-core-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-jcl\5.2.6.RELEASE\spring-jcl-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-expression\5.2.6.RELEASE\spring-expression-5.2.6.RELEASE.jar;E:\maven\maven_repository\org\springframework\spring-aspects\5.0.8.RELEASE\spring-aspects-5.0.8.RELEASE.jar;E:\maven\maven_repository\org\aspectj\aspectjweaver\1.8.13\aspectjweaver-1.8.13.jar" com.intellij.rt.junit.JUnitStarter -ideVersion5 -junit4 com.kkb.test.TeamServiceTest,test
AOP前置通知：在目标方法之前被调用的通知
AOP环绕方法------->目标方法之前执行
TeamService----->add
AOP环绕方法------->目标方法之后执行
AOP最终通知：无论是否出现异常都是最后被调用的通知
AOP后置通知：在目标方法之后被调用的通知
---------------
AOP前置通知：在目标方法之前被调用的通知
AOP环绕方法------->目标方法之前执行
TeamService----->update
AOP环绕方法------->目标方法之后执行
AOP最终通知：无论是否出现异常都是最后被调用的通知
AOP后置通知：在目标方法之后被调用的通知
结果为：true

Process finished with exit code 0

在实际开发中，我们一般用注解的方式实现AOP，但也能用XML的方式实现，这就看个人喜好了。

一个小小白的成长之路

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spring核心之AOP详细解释（包含注解方式实现AOP和XML方式实现AOP）

1、Spring核心之AOP1.1、什么是AOPAOP为Aspect Oriented Programming的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP的作用：不修改源码的情况下，程序运行期间对方法进行功能增强好处： 1、减少代码的重复，提高开发效率，便于维护。 2、专注核心业务的开发。核心业务和服务性代码混合在一起开发中：各自做自己擅长的事情，运行的时候将服务性代码织入到核心业务中。通过...
复制链接

扫一扫