Spring 基础教程 (第 14 章) - Spring 集成 AspectJ

最新推荐文章于 2024-08-03 07:30:00 发布
最新推荐文章于 2024-08-03 07:30:00 发布
阅读量476 收藏
点赞数 1
分类专栏： Spring 基础教程系列 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/songlu/article/details/131107116
版权

我们知道，Spring AOP 是一个简化版的 AOP 实现，并没有提供完整版的 AOP 功能。通常情况下，Spring AOP 是能够满足我们日常开发过程中的大多数场景的，但在某些情况下，我们可能需要使用 Spring AOP 范围外的某些 AOP 功能。

例如 Spring AOP 仅支持执行公共（public）非静态方法的调用作为连接点，如果我们需要向受保护的（protected）或私有的（private）的方法进行增强，此时就需要使用功能更加全面的 AOP 框架来实现，其中使用最多的就是 AspectJ。

AspectJ 是一个基于 Java 语言的全功能的 AOP 框架，它并不是 Spring 组成部分，是一款独立的 AOP 框架。

但由于 AspectJ 支持通过 Spring 配置 AspectJ 切面，因此它是 Spring AOP 的完美补充，通常情况下，我们都是将 AspectJ 和 Spirng 框架一起使用，简化 AOP 操作。

使用 AspectJ 需要在 Spring 项目中导入 Spring AOP 和 AspectJ 相关 Jar 包：

  • spring-aop-xxx.jar
  • spring-aspects-xxx.jar
  • aspectjweaver-xxxx.jar

在以上 3 个 Jar 包中，spring-aop-xxx.jar 和 spring-aspects-xxx.jar 为 Spring 框架提供的 Jar 包，而 aspectjweaver-xxxx.jar 则是 AspectJ 提供的。

基于 AspectJ 实现 AOP 操作

  • 基于 xml 配置实现 AspectJ 的 AOP 开发
  • 基于注解方式实现 AspectJ 的 AOP 开发

14.1 AspectJ Jar 包下载

AspectJ Jar 包的下载步骤如下：

1）使用浏览器访问 AspectJ 包下载页面：https://www.eclipse.org/aspectj/downloads.php，选择相应的版本，这里我们以 1.9.6 稳定版本为例进行介绍。

在这里插入图片描述

2）点击 aspectj-1.9.6.jar 进入下载页面，选择 Select another mirror，如下图：

在这里插入图片描述

3）根据自己所处地区选择下载，这里我们选择的是中国科学技术大学的下载地址：

在这里插入图片描述

4）下载完成后解压该 Jar 文件，需要导入的 jar 包在 files 文件夹的 lib 目录下：

在这里插入图片描述

14.2 基于 XML 使用 AspectJ

我们可以在 Spring 项目中通过 XML 配置，对切面（Aspect 或 Advisor）、切点（PointCut）以及通知（Advice）进行定义和管理，以实现基于 AspectJ 的 AOP 开发。

Spring 提供了基于 XML 的 AOP 支持，并提供了一个名为 aop 的命名空间，该命名空间提供了一个 <aop:config> 元素。

  • 在 Spring 配置中，所有的切面信息（切面、切点、通知）都必须定义在 <aop:config> 元素中；
  • 在 Spring 配置中，可以使用多个 <aop:config> 。
  • 每一个 <aop:config> 元素内可以包含 3 个子元素： pointcut、advisor 和 aspect ，这些子元素必须按照这个顺序进行声明。

1. 引入 aop 命名空间

首先，我们需要在 XML 配置文件中导入 Spring aop 命名空间的约束，如下所示：

<?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"
       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">
			 ...
</beans>

2. 定义切面 <aop:aspect>

在 Spring 配置文件中，使用 <aop:aspect> 元素定义切面。该元素可以将定义好的 Bean 转换为切面 Bean，所以使用 <aop:aspect> 之前需要先定义一个普通的 Spring Bean。

<aop:config>
    <aop:aspect id="myAspect" ref="aBean">
        ...
    </aop:aspect>
</aop:config>

其中，id 用来定义该切面的唯一标识名称，ref 用于引用普通的 Spring Bean。

3. 定义切入点 <aop:pointcut>

<aop:pointcut> 用来定义一个切入点，用来表示对哪个类中的那个方法进行增强。它既可以在 <aop:pointcut> 元素中使用，也可以在 <aop:aspect> 元素下使用。

  • 当 <aop:pointcut> 元素作为 <aop:config> 元素的子元素定义时，表示该切入点是全局切入点，它可被多个切面所共享；
  • 当 <aop:pointcut> 元素作为 <aop:aspect> 元素的子元素时，表示该切入点只对当前切面有效。
<aop:config>
    <aop:pointcut id="myPointCut"
        expression="execution(* section1.demo1.dao.*.*(..))"/>
</aop:config>

其中，id 用于指定切入点的唯一标识名称，execution 用于指定切入点关联的切入点表达式。

execution 的语法格式为：

 execution([权限修饰符][返回值类型][类的完全限定名][方法名称]([参数列表]))

其中：

  • 返回值类型、方法名、参数列表是必须配置的选项，而其它参数则为可选配置项。
  • 返回值类型：* 表示可以为任何返回值。如果返回值为对象，则需指定全路径的类名。
  • 类的完全限定名：指定包名 + 类名。
  • 方法名：* 代表所有方法，set* 代表以 set 开头的所有方法。
  • 参数列表：(..) 代表所有参数；(*) 代表只有一个参数，参数类型为任意类型；(*, String) 代表有两个参数，第一个参数可以为任何值，第二个为 String 类型的值。

举例 1：对 section1.demo1.dao.impl 包下 UserDaoImpl 类中的 add() 方法进行增强，配置如下：

execution(* section1.demo1.dao.impl.UserDaoImpl.add(..))

举例 2：对 section1.demo1.dao.impl 包下 UserDaoImpl 类中的所有方法进行增强，配置如下：

execution(* section1.demo1.dao.impl.UserDaoImpl.*(..))

举例 3：对 section1.demo1.dao.impl 包下所有类中的所有方法进行增强，配置如下：

execution(* section1.demo1.dao.impl.*.*(..))

4. 定义通知

AspectJ 支持 5 种类型的 advice，如下：

<aop:aspect id="myAspect" ref="aBean">
    <!-- 前置通知 -->
    <aop:before pointcut-ref="myPointCut" method="..."/>
    <!-- 后置通知 -->
    <aop:after-returning pointcut-ref="myPointCut" method="..."/>
    <!-- 环绕通知 -->
    <aop:around pointcut-ref="myPointCut" method="..."/>
    <!-- 异常通知 -->
    <aop:after-throwing pointcut-ref="myPointCut" method="..."/>
    <!-- 最终通知 -->
    <aop:after pointcut-ref="myPointCut" method="..."/>
    .... 
</aop:aspect>
例 1

下面我们通过一个示例来演示下 Spring 集成 AspectJ 基于 XML 实现 AOP 开发。

创建命名为 UserDao 的接口，代码如下：

package section2.demo1.dao;

/**
 * ClassName: UserDao
 * Description: TODO
 *
 * @author chuanlu
 * @version 1.0.0
 */
public interface UserDao {
    void add();

    void delete();

    void modify();

    void get();
}

创建 UserDao 的实现类 UserDaoImpl，代码如下：

package section2.demo1.dao.impl;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.stereotype.Repository;
import section2.demo1.dao.UserDao;

/**
 * ClassName: UserDaoImpl
 * Description: TODO
 *
 * @author chuanlu
 * @version 1.0.0
 */
@Repository("userDao")
public class UserDaoImpl implements UserDao {
    private static final Log LOGGER = LogFactory.getLog(UserDaoImpl.class);

    @Override
    public void add() {
        LOGGER.info("正在执行 UserDao 的 add() 方法……");
    }

    @Override
    public void delete() {
        LOGGER.info("正在执行 UserDao 的 delete() 方法……");
    }

    @Override
    public void modify() {
        LOGGER.info("正在执行 UserDao 的 modify() 方法……");
    }

    @Override
    public void get() {
        LOGGER.info("正在执行 UserDao 的 get() 方法……");
    }
}

创建命名为 MyUserAspect 的类，代码如下：

package section2.demo1.aspect;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.aspectj.lang.ProceedingJoinPoint;

/**
 * ClassName: MyUserAspect
 * Description: TODO
 *
 * @author chuanlu
 * @version 1.0.0
 */
public class MyUserAspect {
    private static final Log LOGGER = LogFactory.getLog(MyUserAspect.class);

    public void before() {
        LOGGER.info("前置增强……");
    }

    public void after() {
        LOGGER.info("最终增强……");
    }

    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        LOGGER.info("环绕增强---前……");
        proceedingJoinPoint.proceed();
        LOGGER.info("环绕增强---后……");
    }

    public void afterThrow(Throwable exception) {
        LOGGER.info("异常增强…… 异常信息为：" + exception.getMessage());
    }

    public void afterReturning(Object returnValue) {
        LOGGER.info("后置返回增强…… 方法返回值为：" + returnValue);
    }
}

修改 Spring 配置文件 spring-config.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"
       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-->
    <bean id="userDao" class="section2.demo1.dao.impl.UserDaoImpl"/>
    <!--定义切面-->
    <bean id="myUserAspect" class="section2.demo1.aspect.MyUserAspect"/>
    <aop:config>
        <aop:pointcut id="beforePointCut"
                      expression="execution(* section2.demo1.dao.impl.UserDaoImpl.add(..))"/>
        <aop:pointcut id="throwPointCut"
                      expression="execution(* section2.demo1.dao.impl.UserDaoImpl.get(..))"/>
        <aop:pointcut id="afterReturnPointCut"
                      expression="execution(* section2.demo1.dao.impl.UserDaoImpl.modify(..))"/>
        <aop:pointcut id="afterPointCut"
                      expression="execution(* section2.demo1.dao.impl.UserDaoImpl.*(..))"/>
        <aop:aspect ref="myUserAspect">
            <!--前置增强-->
            <aop:before method="before" pointcut-ref="beforePointCut"/>
            <!--后置返回增强-->
            <aop:after-returning method="afterReturning"
                                 pointcut-ref="afterReturnPointCut"
                                 returning="returnValue"/>
            <!--异常通知-->
            <aop:after-throwing method="afterThrow" pointcut-ref="throwPointCut"
                                throwing="exception"/>
            <!--最终通知-->
            <aop:after method="after" pointcut-ref="afterPointCut"/>
            <!--环绕通知-->
            <aop:around method="around" pointcut-ref="beforePointCut"/>
        </aop:aspect>
    </aop:config>
</beans>

创建命名为 MainApp 的类，代码如下：

package section2.demo1;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import section2.demo1.dao.UserDao;

/**
 * ClassName: MainApp
 * Description: TODO
 *
 * @author chuanlu
 * @version 1.0.0
 */
public class MainApp {
    private static final Log LOGGER = LogFactory.getLog(MainApp.class);

    public static void main(String[] args) {
        // 获取 ApplicationContext 容器
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        // 获取名为 employee 的 Bean
        UserDao userDao = context.getBean("userDao", UserDao.class);
        LOGGER.info("调用 UserDao 中的方法");
        userDao.add();
        userDao.delete();
        userDao.get();
        userDao.modify();
    }
}

执行 MainApp 中的 main 方法，控制台输出如下：

4月 09, 2022 8:35:34 下午 section2.demo1.MainApp main
信息: 调用 UserDao 中的方法
4月 09, 2022 8:35:34 下午 section2.demo1.aspect.MyUserAspect before
信息: 前置增强……
4月 09, 2022 8:35:34 下午 section2.demo1.aspect.MyUserAspect around
信息: 环绕增强---前……
4月 09, 2022 8:35:34 下午 section2.demo1.dao.impl.UserDaoImpl add
信息: 正在执行 UserDao 的 add() 方法……
4月 09, 2022 8:35:34 下午 section2.demo1.aspect.MyUserAspect around
信息: 环绕增强---后……
4月 09, 2022 8:35:34 下午 section2.demo1.aspect.MyUserAspect after
信息: 最终增强……
4月 09, 2022 8:35:34 下午 section2.demo1.dao.impl.UserDaoImpl delete
信息: 正在执行 UserDao 的 delete() 方法……
4月 09, 2022 8:35:34 下午 section2.demo1.aspect.MyUserAspect after
信息: 最终增强……
4月 09, 2022 8:35:34 下午 section2.demo1.dao.impl.UserDaoImpl get
信息: 正在执行 UserDao 的 get() 方法……
4月 09, 2022 8:35:34 下午 section2.demo1.aspect.MyUserAspect after
信息: 最终增强……
4月 09, 2022 8:35:34 下午 section2.demo1.dao.impl.UserDaoImpl modify
信息: 正在执行 UserDao 的 modify() 方法……
4月 09, 2022 8:35:34 下午 section2.demo1.aspect.MyUserAspect after
信息: 最终增强……
4月 09, 2022 8:35:34 下午 section2.demo1.aspect.MyUserAspect afterReturning
信息: 后置返回增强…… 方法返回值为：null

14.3 基于注解使用 AspectJ

在 Spring 中，虽然我们可以使用 XML 配置文件可以实现 AOP 开发，但如果所有的配置都集中在 XML 配置文件中，就势必会造成 XML 配置文件过于臃肿，从而给维护和升级带来一定困难。

为此，AspectJ 框架为 AOP 开发提供了一套 @AspectJ 注解。它允许我们直接在 Java 类中通过注解的方式对切面（Aspect）、切入点（Pointcut）和增强（Advice）进行定义，Spring 框架可以根据这些注解生成 AOP 代理。

关于注解的介绍如表 1 所示：

名称说明
@Aspect用于定义一个切面。
@Pointcut用于定义一个切入点。
@Before用于定义前置通知，相当于 BeforeAdvice。
@AfterReturning用于定义后置通知，相当于 AfterReturningAdvice。
@Around用于定义环绕通知，相当于 MethodInterceptor。
@AfterThrowing用于定义抛出通知，相当于 ThrowAdvice。
@After用于定义最终通知，不管是否异常，该通知都会执行。
@DeclareParents用于定义引介通知，相当于 IntroductionInterceptor（不要求掌握）。

1. 启用 @AspectJ 注解支持

在使用 @AspectJ 注解进行 AOP 开发前，首先我们要先启用 @AspectJ 注解支持。

我们可以通过以下 2 种方式来启用 @AspectJ 注解：

1）基于 XML 配置启用

在 Spring 的 XML 配置文件中，添加以下内容启用 @AspectJ 注解支持。

<!-- 开启注解扫描 -->
<context:component-scan base-package="section2.demo2"/>
<!-- 开启AspectJ 自动代理 -->
<aop:aspectj-autoproxy/>
2）基于注解配置启用

我们可以在 Java 配置类（标注了 @Configuration 注解的类）中，使用 @EnableAspectJAutoProxy 和 @ComponentScan 注解启用 @AspectJ 注解支持。

@Configuration
@ComponentScan(basePackages = "section2.demo2") // 注解扫描
@EnableAspectJAutoProxy // 开启 AspectJ 的自动代理
public class AppConfig {
  ...
}

2. 定义切面 @Aspect

我们可以通过 @AspectJ 注解将一个 Bean 定义为切面。

在启用了 @AspectJ 注解支持的情况下，Spring 会自动将 IoC 容器（ApplicationContext）中的所有使用了 @AspectJ 注解的 Bean 识别为一个切面。

1）基于 XML 定义

我们可以在 XML 配置中通过一些配置将这个类定义为一个 Bean，如下：

<bean id="myAspect" class="section2.demo2.aspect.MyAspect"/>
   ...
</bean>
2）基于注解定义

在定义完 Bean 后，我们只需要在Bean 对应的 Java 类中使用一个 @AspectJ 注解，将这个 Bean 定义为一个切面，代码如下：

package section2.demo2.aspect;

import org.aspectj.lang.annotation.*;

@Aspect // 定义为切面
public class MyAspect {
  ...
}
3）全注解方式定义

我们也可以在 Java 类上使用以下 2 个注解，使用全注解方式定义切面，示例代码如下：

package section2.demo2.aspect;

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

@Component // 定义成 Bean
@Aspect // 定义为切面
public class MyAspect {
  ...
}

在以上代码中共使用两个注解：

  • @Component 注解：将这个类的对象定义为一个 Bean；
  • @Aspect 注解：则是将这个 Bean 定义为一个切面。

3. 定义切点 @Pointcut

在 AspectJ 中，我们可以使用 @Pointcut 注解用来定义一个切点。需要注意的是，定义为切点的方法，它的返回值类型必须为 void，示例代码如下：

// 要求：方法必须是private，返回值类型为 void，名称自定义，没有参数
@Pointcut("execution(* section2.demo2..*.*(..))")
private void myPointCut() {
  ...
}

@Pointcut 注解中有一个 value 属性，这个属性的值就是切入点表达式。有关切入点表达式的具体介绍请参考本章第二小节 “基于 XML 使用 AspectJ 进行 AOP 开发” 中的 execution 语法格式介绍。

值得注意的是，我除了可以通过切入点表达式（execution）直接对切点进行定义外，还可以通过切入点方法的名称来引用其他的切入点。在使用方法名引用其他切入点时，还可以使用 &&、|| 和 ! 等表示 与、或、非 的含义，示例代码如下：

/**
* 将 section2.demo2.dao.impl 包下 UserDaoImpl 类中的 get() 方法定义为一个切点
*/
@Pointcut(value ="execution(* section2.demo2.dao.impl.UserDaoImpl.get(..))")
public void pointCut1(){
  ...
}
/**
* 将 section2.demo2.dao.impl 包下 UserDaoImpl 类中的 delete() 方法定义为一个切点
*/
@Pointcut(value ="execution(* section2.demo2.dao.impl.UserDaoImpl.delete(..))")
public void pointCut2(){
  ...
}
/**
* 除了 section2.demo2.dao.impl 包下 UserDaoImpl 类中 get() 方法和 delete() 方法外，其他方法都定义为切点
*
* ! 表示 非 ，即 "不是"，求补集
* && 表示 与，即 "并且"，求交集
* || 表示 或，即 "或者"，求并集
*/
@Pointcut(value ="!pointCut1() && !pointCut2()")
public void pointCut3(){
  ...
}

4. 定义通知 Advice

AspectJ 为我们提供了以下 6 个注解，来定义 6 种不同类型的通知（Advice），如下表所示：

注解说明
@Before用于定义前置通知，相当于 BeforeAdvice。
@AfterReturning用于定义后置通知，相当于 AfterReturningAdvice。
@Around用于定义环绕通知，相当于 MethodInterceptor。
@AfterThrowing用于定义抛出通知，相当于 ThrowAdvice。
@After用于定义最终通知，不管是否异常，该通知都会执行。
@DeclareParents用于定义引介通知，相当于 IntroductionInterceptor（不要求掌握）。

以上这些通知注解中都有一个 value 属性，这个 value 属性的取值就是这些通知（Advice）作用的切点（PointCut），它既可以是切入点表达式，也可以是切入点的引用（切入点对应的方法名称），示例代码如下：

@Pointcut(value ="execution(* section2.demo2.dao.impl.UserDaoImpl.get(..))")
public void pointCut1(){
}

@Pointcut(value ="execution(* section2.demo2.dao.impl.UserDaoImpl.delete(..))")
public void pointCut2(){
}

@Pointcut(value ="!pointCut1() && !pointCut2()")
public void pointCut3(){
}

//使用切入点引用
@Before("MyAspect.pointCut3()")
public void around() throws Throwable {
    System.out.println("环绕增强……");
}
//使用切入点表达式
@AfterReturning(value = "execution(* section2.demo2.dao.impl.UserDaoImpl.get(..))" ,returning = "returnValue")
public void afterReturning(Object returnValue){
    System.out.println("方法返回值为：" + returnValue);
}
例 1

下面，我们就通过一个完整的实例，来演示下如何通过注解的方式实现 AspectJ AOP 开发。

创建命名为 UserDao 的接口，代码如下：

package section3.demo1.dao;

import java.util.Date;

/**
 * ClassName: UserDao
 * Description: TODO
 *
 * @author chuanlu
 * @version 1.0.0
 */
public interface UserDao {
    void add();

    void delete();

    Integer modify();

    String get();
}

创建 UserDao 的实现类 UserDaoImpl，代码如下：

package section3.demo1.dao.impl;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.stereotype.Repository;
import section3.demo1.dao.UserDao;

import java.util.Date;

/**
 * ClassName: UserDaoImpl
 * Description: TODO
 *
 * @author chuanlu
 * @version 1.0.0
 */
@Repository("userDao")
public class UserDaoImpl implements UserDao {
    private static final Log LOGGER = LogFactory.getLog(UserDaoImpl.class);

    @Override
    public void add() {
        LOGGER.info("正在执行 UserDao 的 add() 方法……");
    }

    @Override
    public void delete() {
        LOGGER.info("正在执行 UserDao 的 delete() 方法……");
    }

    @Override
    public Integer modify() {
        LOGGER.info("正在执行 UserDao 的 modify() 方法……");
        return 1;
    }

    @Override
    public String get() {
        LOGGER.info("正在执行 UserDao 的 get() 方法……");
        return "传陆编程";
    }
}

创建命名为 MyUserAspect 的类，代码如下：

package section3.demo1.aspect;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * ClassName: MyUserAspect
 * Description: TODO
 *
 * @author chuanlu
 * @version 1.0.0
 */
@Component // 定义成 Bean
@Aspect // 定义为切面
public class MyUserAspect {
    private static final Log LOGGER = LogFactory.getLog(MyUserAspect.class);

    @Before("execution(* section3.demo1.dao.UserDao.add(..))")
    public void before(JoinPoint joinPoint) {
        LOGGER.info("前置增强……" + joinPoint);
    }

    @After("execution(* section3.demo1.dao.UserDao.get(..))")
    public void after(JoinPoint joinPoint) {
        LOGGER.info("最终增强……" + joinPoint);
    }

    /**
     * 将 section3.demo1.dao 包下的 UserDao 类中的 get() 方法 定义为一个切点
     */
    @Pointcut(value = "execution(* section3.demo1.dao.UserDao.get(..))")
    public void pointCut1() {
    }

    /**
     * 将 section3.demo1.dao 包下的 UserDao 类中的 delete() 方法 定义为一个切点
     */
    @Pointcut(value = "execution(* section3.demo1.dao.UserDao.delete(..))")
    public void pointCut2() {
    }

    //使用切入点引用
    @Around("MyUserAspect.pointCut1()")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        LOGGER.info("环绕增强……1");
        Object object = proceedingJoinPoint.proceed();
        LOGGER.info("环绕增强……2>>>" + (object == null ? "无返回值" : object.toString()));
        return object;
    }

    //使用切入点表达式
    @AfterReturning(value = "execution(* section3.demo1.dao.UserDao.modify(..))", returning = "returnValue")
    public void afterReturning(Object returnValue) {
        LOGGER.info("后置返回增强……,方法返回值为：" + returnValue);
    }
}

创建命名为 AppConfig 的类，代码如下：

package section3.demo1.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * ClassName: AppConfig
 * Description: TODO
 *
 * @author chuanlu
 * @version 1.0.0
 */
@Configuration
@ComponentScan(basePackages = "section3.demo1") //注解扫描
@EnableAspectJAutoProxy //开启 AspectJ 的自动代理
public class AppConfig {
}

创建命名为 MainApp 的类，代码如下：

package section3.demo1;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import section3.demo1.config.AppConfig;
import section3.demo1.dao.UserDao;

/**
 * ClassName: MainApp
 * Description: TODO
 *
 * @author chuanlu
 * @version 1.0.0
 */
public class MainApp {
    private static final Log LOGGER = LogFactory.getLog(MainApp.class);

    public static void main(String[] args) {
        // 获取 ApplicationContext 容器
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        // 获取名为 employee 的 Bean
        UserDao userDao = context.getBean("userDao", UserDao.class);
        LOGGER.info("调用 UserDao 中的方法");
        userDao.add();
        userDao.delete();
        userDao.get();
        userDao.modify();
    }
}

执行 MainApp 中的 main 方法，控制台输出如下：

4月 09, 2022 10:25:10 下午 section3.demo1.MainApp main
信息: 调用 UserDao 中的方法
4月 09, 2022 10:25:10 下午 section3.demo1.aspect.MyUserAspect before
信息: 前置增强……execution(void section3.demo1.dao.UserDao.add())
4月 09, 2022 10:25:10 下午 section3.demo1.dao.impl.UserDaoImpl add
信息: 正在执行 UserDao 的 add() 方法……
4月 09, 2022 10:25:10 下午 section3.demo1.dao.impl.UserDaoImpl delete
信息: 正在执行 UserDao 的 delete() 方法……
4月 09, 2022 10:25:10 下午 section3.demo1.aspect.MyUserAspect around
信息: 环绕增强……1
4月 09, 2022 10:25:10 下午 section3.demo1.dao.impl.UserDaoImpl get
信息: 正在执行 UserDao 的 get() 方法……
4月 09, 2022 10:25:10 下午 section3.demo1.aspect.MyUserAspect after
信息: 最终增强……execution(String section3.demo1.dao.UserDao.get())
4月 09, 2022 10:25:10 下午 section3.demo1.aspect.MyUserAspect around
信息: 环绕增强……2>>>传陆编程
4月 09, 2022 10:25:10 下午 section3.demo1.dao.impl.UserDaoImpl modify
信息: 正在执行 UserDao 的 modify() 方法……
4月 09, 2022 10:25:10 下午 section3.demo1.aspect.MyUserAspect afterReturning
信息: 后置返回增强……,方法返回值为：1
传陆编程
关注
专栏目录
spring——Aspectj
qq_43650773的博客
12-15 1114
spring——Aspectj 1.1 介绍 AspectJ是一个基于Java语言的AOP框架 Spring2.0以后新增了对AspectJ切点表达式支持 @AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面 新版本Spring框架，建议使用AspectJ方式来开发AOP 主要用途：自定义开发 1.2 切入点表达式【掌握】 1.executio...
Spring框架入门学习教程---从无到有，一次学明白！
assdfgdfgjhtdo的博客
08-31 356
Spring通过PlatformTransactionManager平台事务管理器接口对事务的管理进行高度抽象，但是该接口下具体的实现是由各个平台自己实现，Spring并不直接管理事务，而是提供了多种事务管理器，也就是对各个平台的事务管理进行封装，最终将事务管理的职责委托给JDBC、Hibernate、JPA、JMS、MongoDB等持久化平台框架的事务来实现。 一、认识Spring Spring 是于 2003 年兴起的一个轻量级的 Java 开发框架，它是为了解决企业应用开发 的复杂性而创建的。.
spring学习笔记（十九）Spring集成AspectJ
Ufridy的博客
10-21 248
在《Spring JDK动态代理》和《Spring CGLlB动态代理》一节我们学习了基于代理类的 AOP 实现，Spring 2.0 以后，Spring 新增了对 AspectJ 的支持。在新版本的 Spring 框架中，建议使用 AspectJ 方式开发 AOP。 AspectJ 是一个基于 Java 语言的 AOP 框架，它扩展了 Java 语言，提供了强大的 AOP 功能。 使用 AspectJ 需要导入以下 jar 包： Aspectjrt.jar Aspectjweaver.jar Aspec
Java中的AOP技术：AspectJ与Spring AOP
最新发布
微赚开发者技术分享博客
08-03 465
大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！这两者是Java领域中实现AOP的主要工具，通过它们可以实现代码的横切关注点（如日志记录、安全检查等）分离，从而提高代码的可维护性和重用性。AOP是一种强大的技术，能够帮助开发者将日志记录、安全检查等横切关注点从业务逻辑中分离出来，简化代码，提升系统的可维护性和扩展性。AspectJ是一个功能强大的AOP框架，它是对Java语言的扩展，允许你定义切面（Aspect）以声明性地指定横切关注点。
AspectJ在Spring中的使用
weixin_33912638的博客
11-18 329
在上一篇AspectJ的入门中，简单的介绍了下AspectJ的使用，主要是以AspectJ的example作为例子。介绍完后也留下了几个问题：1）我们在spring中并没有看到需要aspectj之类的关键词，而是使用java代码就可以了，这是如何做到的2）Spring中如何做到不使用特殊的编译器实现aop的（AspectJ如何在运行期使用）3）Sprin...
Spring Framework 开发参考手册 之六 集成AspectJ
pioneer's blog
04-28 1785
6.1. 概述Spring基于代理的AOP框架很适合处理一般的中间件和特定应用的问题。 然而，有时，更强大的AOP方案也是需要的，例如，如果我们需要给一个类增加 额外的字段， 或者通知（Advise）一个不是由Spring IoC容器创建的细粒度的对象。 We recommend the use of AspectJ in such cases. Accordingly, as of versio
spring中的aspectJ表达式
linchunhua的专栏
01-15 3475
Spring AOP supports the following AspectJ pointcut designators (PCD) for use in pointcut expressions:   表　达　式 说明 execution 匹配方法执行连接点。我们可以指定包、类或者方法名，以及方法的可见性、返回值和参数类型。这是应
spring-aop-aspectj-case
08-06
标题“spring-aop-aspectj-case”涉及到的是Spring框架中的AOP（面向切面编程）与AspectJ的集成使用案例。在Spring框架中，AOP用于处理系统中的横切关注点，如日志、事务管理等，而AspectJ则是一个强大的、独立的...
cj.software.aspectj.aspectj-in-action-parent
03-13
- 使用IDE集成AspectJ，如Spring Tool Suite或IntelliJ IDEA，它们提供了强大的AOP支持。 - 编写并运行测试，确保切面正确无误地应用到目标代码。 6. **挑战与注意事项** - 避免过度使用AOP，过多的切面可能导致...
Spring基础教程.pdf
03-06
5. **Aspects**：对AspectJ的集成，增强了AOP功能。 6. **Messaging**：提供对消息传递系统的支持，如JMS。 7. **工具**：Spring的工具支持，包括Spring上下文的测试和暴露。 **Spring MVC** Spring MVC是Spring...
一文学会Spring,Spring最简单的入门教程（万字好文）
毕业势必进大厂的博客
08-01 9178
spring教程
Spring AspectJ
黄文孝同学的博客
12-28 2792
Hello，这里来简单的说一下AspectJ的使用 概述： AspectJ是一个基于Java语言的AOP框架，在Spring2.0以后添加了对AspectJ切入点表达式的支持 @AspectJ允许在Bean类定义切面 Spring配置文件 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.sprin...
Spring - AspectJ基础
sususz的博客
11-16 117
AOP的基本组成主要有以下几个对于程序员来说，需要配置的只有。
spring集成aspectj
qiangcz
01-30 147
[code="xml"] [/code] [code="java"] @Aspect @Component public class TickLogInterceptorWithAspectJ { public void pointCut() { } @Around("execution(* xx...
Spring集成AspectJ
洛卡JAVA架构师每日分享Java架构师知识
05-18 407
我们知道，Spring AOP 是一个简化版的 AOP 实现，并没有提供完整版的 AOP 功能。通常情况下，Spring AOP 是能够满足我们日常开发过程中的大多数场景的，但在某些情况下，我们可能需要使用 Spring AOP 范围外的某些 AOP 功能。 例如 Spring AOP 仅支持执行公共（public）非静态方法的调用作为连接点，如果我们需要向受保护的（protected）或私有的（private）的方法进行增强，此时就需要使用功能更加全面的 AOP 框架来实现，其中使用最多的就是 Aspec
spring整合AspectJ
Dug_Zhang的博客
12-20 643
AOP的基本概念 @Aspect(切面): 通常是一个类，里面可以定义切入点和通知 JointPoint(连接点): 程序执行过程中明确的点，一般是方法的调用 Advice(通知): AOP在特定的切入点上执行的增强处理: @Before: 标识一个前置增强方法，相当于BeforeAdvice的功能 @After: fi...
【归纳总结】Spring之AspectJ
Octavius_的博客
03-31 274
AspectJ实际上是对AOP编程思想的一个实践 有三种实践方式： 切入点表达式 advisor aspect 需要导包： <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.6</version&gt
Spring+AspectJ集成
killer0128的专栏
07-04 936
最近遇到个问题，服务端框架被重新构建后，发现spring里配置的@Transaction失效了，报了hibernate session未绑定的错误：具体流程是：1.注册函数：2.反射调用这个注册的方法这个invoke的 _this就是上面注册时候的this其中_onLogin方法是有@transaction的，但是从debug的结果可以看出来，这个方法并没有被AOP代理，所以自然没有处理trans...
（Spring笔记）Spring的AspectJ基本概念
张松的博客
06-17 290
Spring的AspectJ基本概念
Spring 3.0.5 MVC部署：IoC容器与Spring JDBC集成教程
本文档详细介绍了如何在Spring MVC 3.0.5版本中部署Spring IoC...通过这个教程，开发者可以了解到Spring IoC容器在项目中的部署步骤，以及各个组件的具体作用，有助于提升在Spring MVC框架下的开发效率和代码可维护性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

传陆编程

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值