【Spring】的AOP框架AspectJ

最新推荐文章于 2024-04-29 17:13:56 发布

qq_35029429

最新推荐文章于 2024-04-29 17:13:56 发布

阅读量141

点赞数

分类专栏： spring 文章标签： spring AspectJ

本文链接：https://blog.csdn.net/qq_35029429/article/details/79232175

版权

spring 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

1.AspectJ的介绍

AspectJ是一个基于Java语言的AOP框架
Spring2.0以后新增了对AspectJ切点表达式支持
@AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面
新版本Spring框架，建议使用AspectJ方式来开发AOP
主要用途：自定义开发

2.切入点表达式

execution() 用于描述方法 execution(* com.spring.crm.*.service..*.*(..))

语法：execution(修饰符  返回值  包.类.方法名(参数) throws异常)
        修饰符，一般省略
            public      公共方法
            *           任意
        返回值，不能省略
            void        返回没有值
            String      返回值字符串
            *           任意
        包，[省略]
            com.spring.crm              固定包
            com.spring.crm.*.service    crm包下面子包任意 （例如：com.spring.crm.staff.service）
            com.spring.crm..            crm包下面的所有子包（含自己）
            com.spring.crm.*.service..  crm包下面任意子包，固定目录service，service目录任意包
        类，[省略]
            UserServiceImpl         指定类
            *Impl                   以Impl结尾
            User*                   以User开头
            *                       任意
        方法名，不能省略
            addUser                 固定方法
            add*                    以add开头
            *Do                     以Do结尾
            *                       任意
        (参数)
            ()                          无参
            (int)                       一个整型
            (int ,int)                  两个
            (..)                        参数任意
        throws ,可省略，一般不写。

3.AspectJ 通知类型

aop联盟定义通知类型，具有特性接口，必须实现，从而确定方法名称。aspectj 通知类型，只定义类型名称。已经方法格式。
before:前置通知(应用：各种校验)
在方法执行前执行，如果通知抛出异常，阻止方法运行
afterReturning:后置通知(应用：常规数据处理)
方法正常返回后执行，如果方法中抛出异常，通知无法执行。必须在方法执行后才执行，所以可以获得方法的返回值。
around:环绕通知(应用：十分强大，可以做任何事情)
方法执行前后分别执行，可以阻止方法的执行。必须手动执行目标方法
afterThrowing:抛出异常通知(应用：包装异常信息)
方法抛出异常后执行，如果方法没有抛出异常，无法执行
after:最终通知(应用：清理现场)
方法执行完毕后执行，无论方法中是否出现异常

这里写图片描述

环绕

try{
     //前置：before
    //手动执行目标方法
    //后置：afterRetruning
} catch(){
    //抛出异常 afterThrowing
} finally{
    //最终 after
}

这里写图片描述

4.基于xml
切面类：编写多个通知，采用aspectj 通知名称任意（方法名任意）

/**
 * 切面类，含有多个通知
 */
public class MyAspect {

    public void myBefore(JoinPoint joinPoint){
        System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
    }

    public void myAfterReturning(JoinPoint joinPoint,Object ret){
        System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
    }

    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
        System.out.println("前");
        //手动执行目标方法
        Object obj = joinPoint.proceed();

        System.out.println("后");
        return obj;
    }

    public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
        System.out.println("抛出异常通知 ： " + e.getMessage());
    }

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

}

spring配置
<!-- 1 创建目标类 -->
<bean id="userServiceId" class="com.spring.demo.UserServiceImpl"></bean>
<!-- 2 创建切面类（通知） -->
<bean id="myAspectId" class="com.spring.demo.MyAspect"></bean>
<!-- 3 aop编程 
    <aop:aspect> 将切面类 声明“切面”，从而获得通知（方法）
        ref 切面类引用
    <aop:pointcut> 声明一个切入点，所有的通知都可以使用。
        expression 切入点表达式
        id 名称，用于其它通知引用
-->
<aop:config>
    <aop:aspect ref="myAspectId">
        <aop:pointcut expression="execution(* com.spring.demo.UserServiceImpl..*.*(..))" id="myPointCut"/>

        <!-- 3.1 前置通知 
            <aop:before method="" pointcut="" pointcut-ref=""/>
                method : 通知，及方法名
                pointcut :切入点表达式，此表达式只能当前通知使用。
                pointcut-ref ： 切入点引用，可以与其他通知共享切入点。
            通知方法格式：public void myBefore(JoinPoint joinPoint){
                参数1：org.aspectj.lang.JoinPoint  用于描述连接点（目标方法），获得目标方法名等
            例如：
        <aop:before method="myBefore" pointcut-ref="myPointCut"/>
        -->

        <!-- 3.2后置通知  ,目标方法后执行，获得返回值
            <aop:after-returning method="" pointcut-ref="" returning=""/>
                returning 通知方法第二个参数的名称
            通知方法格式：public void myAfterReturning(JoinPoint joinPoint,Object ret){
                参数1：连接点描述
                参数2：类型Object，参数名 returning="ret" 配置的
            例如：
        <aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="ret" />
        -->

        <!-- 3.3 环绕通知 
            <aop:around method="" pointcut-ref=""/>
            通知方法格式：public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
                返回值类型：Object
                方法名：任意
                参数：org.aspectj.lang.ProceedingJoinPoint
                抛出异常
            执行目标方法：Object obj = joinPoint.proceed();
            例如：
        <aop:around method="myAround" pointcut-ref="myPointCut"/>
        -->
        <!-- 3.4 抛出异常
            <aop:after-throwing method="" pointcut-ref="" throwing=""/>
                throwing ：通知方法的第二个参数名称
            通知方法格式：public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
                参数1：连接点描述对象
                参数2：获得异常信息，类型Throwable ，参数名由throwing="e" 配置
            例如：
        <aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e"/>
        -->
        <!-- 3.5 最终通知 -->           
        <aop:after method="myAfter" pointcut-ref="myPointCut"/>

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

5.基于注解

5.1 替换bean
<!-- 1 创建目标类 -->
<bean id="userServiceId" class="com.spring.demo.UserServiceImpl"></bean>
<!-- 2 创建切面类（通知） -->
<bean id="myAspectId" class="com.spring.demo.MyAspect"></bean>

这里写图片描述

<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/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">
    <!-- 1.扫描 注解类 -->
    <context:component-scan base-package="com.spring.demo"></context:component-scan>


5.2 替换aop
必须进行aspectj 自动代理
    <!-- 2.确定 aop注解生效 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
声明切面
    <aop:aspect ref="myAspectId">

这里写图片描述

替换前置通知
<aop:before method="myBefore" pointcut="execution(* com.spring.demo.UserServiceImpl..*.*(..))"/>
//切入点当前有效
@Before("execution(* com.spring.demo.UserServiceImpl.*(..))")
public void myBefore(JoinPoint joinPoint){
    System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
}

替换公共切入点
<aop:pointcut expression="execution(* com.spring.demo.UserServiceImpl..*.*(..))" id="myPointCut"/>
//声明公共切入点
@Pointcut("execution(* com.spring.demo.UserServiceImpl..*.*(..))")
private void myPointCut(){
}

替换后置
<aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="ret" />
@AfterReturning(value="myPointCut()" ,returning="ret")
public void myAfterReturning(JoinPoint joinPoint,Object ret){
    System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
}

替换环绕
<aop:around method="myAround" pointcut-ref="myPointCut"/>
@Around(value = "myPointCut()")
public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
    System.out.println("前");
    //手动执行目标方法
    Object obj = joinPoint.proceed();

    System.out.println("后");
    return obj;
}

替换抛出异常
<aop:after-throwing method="myAfterThrowing" pointcut="execution(* com.spring.demo.UserServiceImpl..*.*(..))" throwing="e"/>
@AfterThrowing(value="execution(* com.spring.demo.UserServiceImpl..*.*(..))" ,throwing="e")
public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
    System.out.println("抛出异常通知 ： " + e.getMessage());
}


5.3 切面类
/**
 * 切面类，含有多个通知
 */
@Component
@Aspect
public class MyAspect {

    //切入点当前有效
//  @Before("execution(* com.spring.demo.UserServiceImpl..*.*(..))")
    public void myBefore(JoinPoint joinPoint){
        System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
    }

    //声明公共切入点
    @Pointcut("execution(* com.spring.demo.UserServiceImpl..*.*(..))")
    private void myPointCut(){
    }

//  @AfterReturning(value="myPointCut()" ,returning="ret")
    public void myAfterReturning(JoinPoint joinPoint,Object ret){
        System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
    }

//  @Around(value = "myPointCut()")
    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
        System.out.println("前");
        //手动执行目标方法
        Object obj = joinPoint.proceed();

        System.out.println("后");
        return obj;
    }

//  @AfterThrowing(value="execution(* com.spring.demo.UserServiceImpl..*.*(..))" ,throwing="e")
    public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
        System.out.println("抛出异常通知 ： " + e.getMessage());
    }

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

}

5.4 spring配置
<!-- 1.扫描 注解类 -->
<context:component-scan base-package="com.spring.demo"></context:component-scan>

<!-- 2.确定 aop注解生效 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

6.aop注解总结
@Aspect 声明切面，修饰切面类，从而获得通知。

@Before 前置
@AfterReturning 后置
@Around 环绕
@AfterThrowing 抛出异常
@After 最终

切入点

@PointCut ，修饰方法 private void xxx(){}  之后通过“方法名”获得切入点引用

qq_35029429

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【Spring】的AOP框架AspectJ

1.AspectJ的介绍AspectJ是一个基于Java语言的AOP框架Spring2.0以后新增了对AspectJ切点表达式支持@AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面新版本Spring框架，建议使用AspectJ方式来开发AOP主要用途：自定义开发2.切入点表达式execution() 用于描述方法 executio
复制链接

扫一扫