AspectJ

最新推荐文章于 2020-12-05 19:59:07 发布
最新推荐文章于 2020-12-05 19:59:07 发布
阅读量339 收藏
点赞数
分类专栏： Spring 文章标签： AspectJ spring切入点表达式 AspectJ通知类型 AspectJ基于xml AspectJ基于注解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shaonianbz/article/details/79343639
版权

一、AspectJ介绍

1、介绍

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

二、切入点表达式

1、切入点表达式概念

（1）execution() 用于描述方法；
（2）语法：execution(修饰符 返回值 包.类.方法名(参数) throws异常)

2、切入点表达式写法

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

三、AspectJ 通知类型

1、通知类型定义

（1）aop联盟定义通知类型，具有特性接口，必须实现，从而确定方法名称

2、具体通知

（1）before：前置通知(应用：各种校验)

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

（2）afterReturning：后置通知(应用：常规数据处理)

  • 方法正常返回后执行，如果方法中抛出异常，通知无法执行必须在方法执行后才执行，所以可以获得方法的返回值

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

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

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

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

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

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

3、通知图解

（1）图解1
这里写图片描述
（2）图解2
这里写图片描述
（3）图解3
这里写图片描述
（4）图解4
这里写图片描述

四、基于 xml

1、环境搭建

（1）aop联盟规范；spring aop 实现；aspect 规范；spring aspect 实现
这里写图片描述

2、代码实现

（1）切面类

/**
 * 切面类，含有多个通知
 */
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("最终通知");
    }

}

（2）spring配置

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

五、基于注解

1、替换Bean

<!-- 1 创建目标类 -->
    <bean id="userServiceId" class="com.san.d_aspect.b_anno.UserServiceImpl"></bean>
    <!-- 2 创建切面类（通知） -->
    <bean id="myAspectId" class="com.san.d_aspect.b_anno.MyAspect"></bean>

这里写图片描述
这里写图片描述

2、替换aop

（1）aspectj 自动代理（必须）

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

（2）声明切面

<aop:aspect ref="myAspectId">

这里写图片描述

（3）替换前置通知

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

（4）替换 公共切入点

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

（5）替换后置

<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);
    }

（6）替换环绕

<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;
    }

（7）替换抛出异常

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

3、切面类

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

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

    //声明公共切入点
    @Pointcut("execution(* com.itheima.d_aspect.b_anno.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.itheima.d_aspect.b_anno.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("最终通知");
    }

}

4、spring配置

<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.itheima.d_aspect.b_anno"></context:component-scan>
<!-- 2.确定 aop注解生效 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
shaonianbz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
aspectJ
05-28
【AspectJ】是一种强大的面向切面编程（AOP）框架，它允许开发者在Java应用程序中进行声明式的横切关注点编程。AOP的核心思想是将系统中的横切关注点（如日志、事务管理、权限控制等）与业务逻辑分离，以提高代码的...
Aspectj
03-01
AspectJ是一种广泛使用的Java语言的面向切面编程(AOP)扩展。它允许开发者将关注点模块化，使得系统中的交叉切面（如日志、事务管理、安全性等）可以独立于核心业务逻辑进行处理。本指南将深入探讨AspectJ的核心概念...
AspectJ之Advice定义之After throwing advice
夏季版
12-08 348
After throwing advice:
spring23:Aspectj实现异常通知@AfterThrowing
m0_37564426的博客
03-27 1244
切入类: package com.atChina.Test4; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.AfterReturning; import org.aspectj.lang.annotat...
Spring AOP - AspectJ - @AfterThrowing example
qq_31230529的博客
09-17 518
Last few pages talked about spring advices (before advice, after return advice, around advice and pointcut examples). In this page you will get an idea about how to integrate AspectJ annotations with S
AspectJ 切面注解中五种通知注解：@Before、@After、@AfterReturning、@AfterThrowing、@Around
热门推荐
u010502101的博客
12-16 16万+
要在 Spring 中声明 AspectJ 切面, 只需要在 IOC 容器中将切面声明为 Bean 实例. 当在 Spring IOC 容器中初始化 AspectJ 切面之后, Spring IOC 容器就会为那些与 AspectJ 切面相匹配的 Bean 创建代理。 在切面类中需要定义切面方法用于响应响应的目标方法，切面方法即为通知方法，通知方法需要用注解标识，AspectJ 支持 5 种类型的
spring AOP中的@AfterThrowing处理异常与try...catch...的区别
wqh0830的博客
08-09 6154
spring AOP中的AfterThrowing增强处理可以对目标方法的异常进行处理，但这种处理与直接使用catch捕捉处理异常的方式不同，catch捕捉意味着能完全处理异常，即只要catch块本身不抛出新的异常，则被处理的异常不会往上级调用者进一步传播下去；但是如果使用了AfterThrowing增强处理用于对异常进行处理，处理后异常仍然会往上一级调用者传播，如果是在main中调用的目标方法，...
aspectj jar
06-26
AspectJ和Spring的整合在Java开发中扮演着重要的角色，特别是在实现面向切面编程（AOP）时。AspectJ是一个强大的、成熟的库，它扩展了Java语言，允许开发者定义和执行切面，这是一种分离关注点的方式，使得业务逻辑...
AspectJ 文档
02-19
Aop框架AspectJ 的语法介绍JPoint Pointcut Signature
AspectJ的基本用法
08-30
AspectJ是一种广泛使用的面向切面编程(AOP)的语言，它扩展了Java，使其能够支持切面的概念，从而更好地实现关注点分离。AOP的核心在于将应用程序的横切关注点（如日志、事务管理等）从核心业务逻辑中解耦出来，...
@AfterThrowing(处理未处理的java异常)
IT_COOKIE_SAM的博客
02-21 1万+
正如题目所说,@afterthrowing是对于java异常的处理,但是你会说Java本身也有异常机制啊 error throwable exception runtimexception 并且也有一系列的自定义异常  也有对于异常的描述   譬如:e 是异常对象,我们可以使用e.getmessage()方法对异常进行描述.但是@afterThrowing是aop形式的异常描述,是在主类文件外部来
返回json数据时出现空指针异常_springboot 项目封装：统一结果，统一异常，统一日志...
weixin_39670246的博客
11-20 390
点击上方蓝色字体，选择“标星公众号”优质文章，第一时间送达 作者|iTachiLEe来源 | urlify.cn/q226Bb统一结果的一般形式是否响应成功；响应状态码；状态码描述；响应数据其他标识符结果类枚举importlombok.Getter;/***@authorleon*/@GetterpublicenumResultCodeEnum{SUCC...
Spring 入门到实战
03-29
     Spring是一个轻量级的Java 开发框架 ，  它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。    主要包括：      IOC&DI、在Spring中配置Bean、自动装配、Bean之间的关系（依赖、继承）、Bean的作用域、使用外部属性文件、SpEL、管理Bean的生命周期、通过工厂方法配置Bean、通过注解配置Bean、注解方式AOP基础、前置通知、后置通知、返回通知、异常通知、环绕通知、切面的优先级、切点表达式、使用XML文件的方式配置AOP使用JdbcTemplate和JdbcDaoSupport、Spring的声明式事务、事务的属性、使用XML文件的方式配置事务整合应用
Java项目构建基础：统一结果，统一异常，统一日志（好文推荐）
Java知音
03-19 588
作者：永动的图灵机juejin.im/post/5e073980f265da33f8653f2e统一结果返回目前的前后端开发大部分数据的传输格式都是js...
spring AOP @AfterThrowing没有返回值的原因
LzwGlory的专栏
12-15 7357
import java.util.Map; import javax.servlet.http.HttpServletRequest; import org.apache.log4j.Logger; import org.apache.shiro.web.servlet.ShiroHttpServletRequest; import org.aspectj.lang.JoinPoint; im
afterthrowing注解无法捕获异常_简单分享一下手写注解事务的小demo
weixin_28668743的博客
12-05 937
本次创建的工程师maven工程1、加入依赖，有些依赖是之前其他知识的，可以忽略 org.javassist javassist 3.26.0-GA org.springframework spring-core 3.0.6.RELEASE org.springframework spring-context 3.0.6.RELEASE org.springframework spr...
Spring（11）_AOP
魏宇轩
01-30 416
本系列博客汇总在这里：Spring 汇总 AOPAOP1、JDK 动态代理2、CGLIB 动态代理3、Spring 的注解形式 AOP第一步：引入 Spring 的 aop 的包第二步：引入头信息第三步：基于注解方式的切面声明第四步：切面定义4、使用配置文件做 AOP配置切面 源码工程文件为：spring3.2_07 & spring3.2_08 AOP AOP（Aspect Ori...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值