专注于 JetBrains IDEA 全家桶，永久激活，教程
持续更新 PyCharm，IDEA，WebStorm，PhpStorm，DataGrip，RubyMine，CLion，AppCode 永久激活教程
当前位置：搜云库技术团队 Java汇总 正文

spring的AspectJ基于XML和注解(前置、后置、环绕、抛出异常、最终通知)

2020-07-21 分类：Java汇总 阅读(398)

1、概念

（1）AspectJ是一个基于Java语言的AOP框架

（2）Spring2.0以后新增了对AspectJ切入点表达式的支持

（3）AspectJ是AspectJ1.5的新增功能，通过JDK5注解技术，允许在Bean类中定义切面。新版本的Spring框架建议使用AspectJ方式来开发AOP

2、切入点表达式

（1）execution（）：用语描述方法

语法：execution(修饰符、返回值、包、类、方法(参数)、异常)

修饰符：一般省略

public：公共方法

*：任意

返回值

void：没有返回值

String：返回值为字符串

*：返回值任意

方法：不能省略

参数

（..）参数任意

（2）案例：

 <aop:pointcut id="myPointCut" expression="execution(* pers.zhb.proxy.*.*(..))"></aop:pointcut>

（3）其他表达式

within：匹配包或者子包中的方法

this：匹配接口中代理对象中的方法

target：匹配实现接口的目标对象的方法

args：匹配参数格式符合标准的方法

bean：对指定bean所有的方法

2、AspectJ通知类型

（1）aop联盟定义通知类型：具有特性接口，必须实现，从而确定方法名称。
（2）aspectj通知类型：只定义类型名称。已经方法格式。
before：前置通知（应用：各种校验）

在方法执行前执行，如果通知抛出异常，阻止方法运行

afterRetuming：后置通知（应用：常规数据处理）

方法正常返回后执行，如果方法中抛出异常，通知无法执行

必须在方法执行后才执行，所以可以获得方法的返回值

around：环统通知（应用：十分强大，可以做任何事情）

方法执行前后分别执行，可以阻止方法的执行。
必须手动执行目标方法

afterThrowing：抛出异常通知（应用：包装异常信息）

方法抛出异常后执行，如果方法没有抛出异常，无法执行

after最终通知（应用：清理现场）

方法执行完毕后执行，无论方法中是否出现异常

3、导入jar包（四个）

aop联盟规范

122_1.png

spring aop实现

122_2.png

aspect规范

122_3.png

spring aspect实现

122_4.png

122_5.png

4、源码

（1）AspectJAfterThrowingAdvice

122_6.png

（2）AspectJAfterAdvice

122_7.png

5、基于XML文件的配置（前置通知）

（1）目标类的接口和实现类：

public interface StudentService {
     void addStudent();
     void updateStudent();
     void deleteStudent();
}

public class StudentServiceImpl implements StudentService {
    @Override
    public void addStudent() {
        System.out.println("addStudent");
    }

    @Override
    public void updateStudent() {
        System.out.println("updateStudent");
    }

    @Override
    public void deleteStudent() {
        System.out.println("deleteStudent");
    }
}

（2）切面类（含有通知）：

public class MyAspect {
    public void before(JoinPoint joinPoint){
        System.out.println("前置通知:"+ joinPoint.getSignature().getName());
    }
}

（3）配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns="http://www.springframework.org/schema/beans"
       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">
    <!--目标类-->
    <bean id="studentService" class="pers.zhb.aspectxml.StudentServiceImpl"></bean>
    <!--切面类-->
    <bean id="myAspect" class="pers.zhb.aspectxml.MyAspect"></bean>
    <!--aop编程
    将切面类声明为切面，从而获得通知（方法）
    ref：切面类引用
    -->
    <aop:config>
        <aop:aspect ref="myAspect">
            <!--引入切面类，从中获得通知（方法）
                expression:切入点表达式
                id：名称，用于其他通知引用
            -->
            <aop:pointcut id="myPointCut" expression="execution(* pers.zhb.aspectxml.StudentServiceImpl.*(..))"></aop:pointcut>
            <!--
            method:通知，即方法名
            pointcut：切入点表达式，此表达式只能当前通知使用
            pointcut-ref:切入点的引用，可以和其它通知共享切入点
            -->
            <aop:before method="before" pointcut-ref="myPointCut"></aop:before>
        </aop:aspect>
    </aop:config>
</beans>

（4）测试类：

public class TestAspectXml {
    public static void main(String[] args) {
        ApplicationContext applicationContext=new
                ClassPathXmlApplicationContext("applicationContext.xml");
        //获得目标类
        pers.zhb.aspectxml.StudentService studentService= (StudentService) applicationContext.getBean("studentService");
        studentService.addStudent();
        studentService.deleteStudent();
        studentService.updateStudent();
    }
}

前置通知:addStudent
addStudent
前置通知:deleteStudent
deleteStudent
前置通知:updateStudent
updateStudent

6、基于XML文件的配置（后置通知）

（1）定义接口和接口的实现类：

public interface StudentService {
     void addStudent();
     void updateStudent();
     String deleteStudent();
}

public class StudentServiceImpl implements StudentService {
    @Override
    public void addStudent() {
        System.out.println("addStudent");
    }

    @Override
    public void updateStudent() {
        System.out.println("updateStudent");
    }

    @Override
    public String deleteStudent() {
        System.out.println("deleteStudent");
        return "nihao";
    }
}

（2）切面类：

public class MyAspect {
    public void before(JoinPoint joinPoint){
        System.out.println("前置通知:"+ joinPoint.getSignature().getName());
    }

    public void after(JoinPoint joinPoint,Object ret){//参数一：连接点描述
        //参数二：类型Object，参数名returning配置的
        System.out.println("后置通知:"+ joinPoint.getSignature().getName()+"   "+ret);
    }
}

（3）配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns="http://www.springframework.org/schema/beans"
       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">
    <!--目标类-->
    <bean id="studentService" class="pers.zhb.aspectxml.StudentServiceImpl"></bean>
    <!--切面类-->
    <bean id="myAspect" class="pers.zhb.aspectxml.MyAspect"></bean>
    <!--aop编程
    将切面类声明为切面，从而获得通知（方法）
    ref：切面类引用
    -->
    <aop:config>
        <aop:aspect ref="myAspect">
            <!--引入切面类，从中获得通知（方法）
                expression:切入点表达式
                id：名称，用于其他通知引用
            -->
            <aop:pointcut id="myPointCut" expression="execution(* pers.zhb.aspectxml.StudentServiceImpl.*(..))"></aop:pointcut>
            <!--
            method:通知，即方法名
            pointcut：切入点表达式，此表达式只能当前通知使用
            pointcut-ref:切入点的引用，可以和其它通知共享切入点
            returning:通知方法第二个参数的名称
            -->
            <aop:before method="before" pointcut-ref="myPointCut"></aop:before>
            <aop:after-returning method="after" pointcut-ref="myPointCut" returning="ret"></aop:after-returning>

        </aop:aspect>
    </aop:config>
</beans>

（4）测试类：

public class TestAspectXml {
    public static void main(String[] args) {
        ApplicationContext applicationContext=new
                ClassPathXmlApplicationContext("applicationContext.xml");
        //获得目标类
        pers.zhb.aspectxml.StudentService studentService= (StudentService) applicationContext.getBean("studentService");
        studentService.addStudent();
        studentService.deleteStudent();
        studentService.updateStudent();
    }
}

前置通知:addStudent
addStudent
后置通知:addStudent   null
前置通知:deleteStudent
deleteStudent
后置通知:deleteStudent   nihao
前置通知:updateStudent
updateStudent
后置通知:updateStudent   null

7、基于XML文件的配置（环绕通知）

（1）切面类：

public class MyAspect {
    public void before(JoinPoint joinPoint){
        System.out.println("前置通知:"+ joinPoint.getSignature().getName());
    }

    public void after(JoinPoint joinPoint,Object ret){//参数一：连接点描述
        //参数二：类型Object，参数名returning配置的
        System.out.println("后置通知:"+ joinPoint.getSignature().getName()+"   "+ret);
    }
    public Object around(ProceedingJoinPoint proceedingJoinPoint)throws Throwable{
        //手动执行目标方法
        System.out.println("前");
        Object object=proceedingJoinPoint.proceed();
        System.out.println("后");
        return null;
    }
}

（2）配置文件：

 <aop:around method="around" pointcut-ref="myPointCut"></aop:around>

（3）测试结果：

前置通知:addStudent
前
addStudent
后
后置通知:addStudent   null
前置通知:deleteStudent
前
deleteStudent
后
后置通知:deleteStudent   null
前置通知:updateStudent
前
updateStudent
后
后置通知:updateStudent   null

8、基于XML文件的配置（抛出异常）

（1）定义目标类的接口和接口的实现类：

public interface StudentService {
     void addStudent();
     void updateStudent();
     String deleteStudent();
}

在方法中制造异常：

public class StudentServiceImpl implements StudentService {
    @Override
    public void addStudent() {
        System.out.println("addStudent");
    }

    @Override
    public void updateStudent() {
        int num=9/0;
        System.out.println("updateStudent");
    }

    @Override
    public String deleteStudent() {
        System.out.println("deleteStudent");
        return "nihao";
    }
}

（2）切面类：

public class MyAspect {
    public void before(JoinPoint joinPoint){
        System.out.println("前置通知:"+ joinPoint.getSignature().getName());
    }

    public void after(JoinPoint joinPoint,Object ret){//参数一：连接点描述
        //参数二：类型Object，参数名returning配置的
        System.out.println("后置通知:"+ joinPoint.getSignature().getName()+"   "+ret);
    }
    public Object around(ProceedingJoinPoint proceedingJoinPoint)throws Throwable{
        //手动执行目标方法
        System.out.println("前");
        Object object=proceedingJoinPoint.proceed();
        System.out.println("后");
        return null;
    }
    public void AfterThrowing(JoinPoint joinPoint,Throwable throwable){
        System.out.println("抛出异常的通知："+throwable.getMessage());
    }
}

（3）配置文件：

 <aop:after-throwing method="AfterThrowing" pointcut-ref="myPointCut" throwing="throwable"></aop:after-throwing>

（4）测试：

前置通知:addStudent
前
addStudent
后
后置通知:addStudent   null
前置通知:deleteStudent
前
deleteStudent
后
后置通知:deleteStudent   null
前置通知:updateStudent
前
抛出异常的通知：/ by zero
Exception in thread "main" java.lang.ArithmeticException: / by zero

9、基于XML文件的配置（最终通知）

（1）目标类的接口和接口的实现类：

public interface StudentService {
     void addStudent();
     void updateStudent();
     String deleteStudent();
}

public class StudentServiceImpl implements StudentService {
    @Override
    public void addStudent() {
        System.out.println("addStudent");
    }

    @Override
    public void updateStudent() {
        int num=9/0;
        System.out.println("updateStudent");
    }

    @Override
    public String deleteStudent() {
        System.out.println("deleteStudent");
        return "nihao";
    }
}

（2）切面类：

public class MyAspect {
    public void before(JoinPoint joinPoint){
        System.out.println("前置通知:"+ joinPoint.getSignature().getName());
    }

    public void after(JoinPoint joinPoint,Object ret){//参数一：连接点描述
        //参数二：类型Object，参数名returning配置的
        System.out.println("后置通知:"+ joinPoint.getSignature().getName()+"   "+ret);
    }
    public Object around(ProceedingJoinPoint proceedingJoinPoint)throws Throwable{
        //手动执行目标方法
        System.out.println("前");
        Object object=proceedingJoinPoint.proceed();
        System.out.println("后");
        return null;
    }
    public void AfterThrowing(JoinPoint joinPoint,Throwable throwable){
        System.out.println("抛出异常的通知："+throwable.getMessage());
    }

    public void myafter(JoinPoint joinPoint){
        System.out.println("最终通知");
    }
}

（3）配置文件：

 <aop:after method="myafter" pointcut-ref="myPointCut"></aop:after>

（4）测试结果：

前置通知:addStudent
前
addStudent
最终通知
后

后置通知:addStudent   null
前置通知:deleteStudent
前
deleteStudent
最终通知
后

后置通知:deleteStudent   null
前置通知:updateStudent
前
最终通知
抛出异常的通知：/ by zero
Exception in thread "main" java.lang.ArithmeticException: / by zero

不管有没有异常都会执行最终通知。

10、基于注解的配置

（1）目标类的接口和接口的实现类：

public interface StudentService {
     void addStudent();
     void updateStudent();
     String deleteStudent();
}

import org.springframework.stereotype.Service;
@Service("studentService")
public class StudentServiceImpl implements StudentService {
    @Override
    public void addStudent() {
        System.out.println("addStudent");
    }

    @Override
    public void updateStudent() {
        int num=9/0;
        System.out.println("updateStudent");
    }

    @Override
    public String deleteStudent() {
        System.out.println("deleteStudent");
        return "nihao";
    }
}

（2）配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<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"
       xmlns="http://www.springframework.org/schema/beans"
       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="pers.zhb.aspectxml"></context:component-scan>
    <!--确定aop注解生效-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

（3）切面：

@Component
@Aspect//声明切面
public class MyAspect {
    @Before("execution(* pers.zhb.aspectxml.StudentServiceImpl.*(..))")
    public void before(JoinPoint joinPoint){
        System.out.println("前置通知:"+ joinPoint.getSignature().getName());
    }

    //声明公共切入点
    @Pointcut("execution(* pers.zhb.aspectxml.StudentServiceImpl.*(..))")
    private void myPointCut(){

    }
    @AfterReturning(value = "myPointCut()",returning = "ret")
    public void after(JoinPoint joinPoint,Object ret){//参数一：连接点描述
        //参数二：类型Object，参数名returning配置的
        System.out.println("后置通知:"+ joinPoint.getSignature().getName()+"   "+ret);
    }

    @Around(value = "myPointCut()")
    public Object around(ProceedingJoinPoint proceedingJoinPoint)throws Throwable{
        //手动执行目标方法
        System.out.println("前");
        Object object=proceedingJoinPoint.proceed();
        System.out.println("后");
        return null;
    }

@AfterThrowing(value = "execution(* pers.zhb.aspectxml.StudentServiceImpl.*(..))",throwing = "throwable")
    public void AfterThrowing(JoinPoint joinPoint,Throwable throwable){
        System.out.println("抛出异常的通知："+throwable.getMessage());
    }

    @After(value = "myPointCut()")
    public void myafter(JoinPoint joinPoint){
        System.out.println("最终通知");
    }
}

（4）测试：

public class TestAspectXml {
    public static void main(String[] args) {
        ApplicationContext applicationContext=new
                ClassPathXmlApplicationContext("applicationContext.xml");
        //获得目标类
        pers.zhb.aspectxml.StudentService studentService= (StudentService) applicationContext.getBean("studentService");
        studentService.addStudent();
        studentService.deleteStudent();
        studentService.updateStudent();
    }
}

前
前置通知:addStudent
addStudent
后
最终通知
后置通知:addStudent   null
前
前置通知:deleteStudent
deleteStudent
后
最终通知
后置通知:deleteStudent   null
前
前置通知:updateStudent
最终通知
抛出异常的通知：/ by zero
Exception in thread "main" java.lang.ArithmeticException: / by zero
AD：【JetBrains 全家桶，激活、破解、教程】获取 IDEA 激活码、PyCharm 激活码、WebStorm 激活码和 DataGrip 激活码，提供详细破解教程与永久激活方法。支持 IDEA 永久激活与破解，免费获取注册码与激活码，解决 2024/2025 版本激活问题，轻松实现所有 JetBrains 工具的激活。
未经允许不得转载：搜云库技术团队 » spring的AspectJ基于XML和注解(前置、后置、环绕、抛出异常、最终通知)

相关推荐

JetBrains 全家桶，激活、破解、教程

提供 JetBrains 全家桶激活码、注册码、破解补丁下载及详细激活教程，支持 IntelliJ IDEA、PyCharm、WebStorm 等工具的永久激活。无论是破解教程，还是最新激活码，均可免费获得，帮助开发者解决常见激活问题，确保轻松破解并快速使用 JetBrains 软件。获取免费的破解补丁和激活码，快速解决激活难题，全面覆盖 2024/2025 版本！

联系我们联系我们