【详解】AspectJAOP完整示例

pingmian/2025/9/28 2:25:27/文章来源:href="https://blog.51cto.com/u_15702012/14128692" target="_blank"

AspectJ AOP 完整示例

在面向对象编程中，横切关注点（如日志记录、事务管理等）通常会分散到多个方法或类中，导致代码重复和维护困难。面向切面编程（AOP，Aspect-Oriented Programming）提供了一种将这些横切关注点从业务逻辑中分离出来的方法，使得代码更加模块化和易于维护。

AspectJ 是 Java 平台上的一个成熟且强大的 AOP 框架，它允许开发者定义切面（Aspects），并在编译时或运行时将这些切面织入（Weave）到应用程序的其他部分。本文将通过一个简单的例子来展示如何使用 AspectJ 实现 AOP。

环境准备

1. 安装 AspectJ 插件

如果你使用的是 Eclipse IDE，可以通过安装 AJDT (AspectJ Development Tools) 插件来支持 AspectJ 开发。对于 IntelliJ IDEA，可以安装相应的 AspectJ 插件。

2. 添加依赖

如果你的项目是 Maven 或 Gradle 项目，需要添加 AspectJ 的依赖。以下是 Maven 的 pom.xml 配置示例：

<dependencies><dependency><groupId>org.aspectj</groupId><artifactId>aspectjrt</artifactId><version>1.9.7</version></dependency><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.7</version></dependency>
</dependencies><build><plugins><plugin><groupId>org.codehaus.mojo</groupId><artifactId>aspectj-maven-plugin</artifactId><version>1.14.0</version><configuration><complianceLevel>1.8</complianceLevel><source>1.8</source><target>1.8</target></configuration><executions><execution><goals><goal>compile</goal><goal>test-compile</goal></goals></execution></executions></plugin></plugins>
</build>

示例代码

1. 创建业务逻辑类

首先，我们创建一个简单的业务逻辑类 BusinessService，该类包含一个 doSomething() 方法。

public class BusinessService {public void doSomething() {System.out.println("执行业务逻辑");}
}

2. 创建切面类

接下来，我们创建一个切面类 LoggingAspect，用于在 doSomething() 方法调用前后打印日志信息。

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.After;@Aspect
public class LoggingAspect {@Before("execution(* com.example.BusinessService.doSomething(..))")public void logBefore() {System.out.println("日志 - 在方法执行前");}@After("execution(* com.example.BusinessService.doSomething(..))")public void logAfter() {System.out.println("日志 - 在方法执行后");}
}

3. 测试切面

最后，我们编写一个测试类 App 来验证切面是否按预期工作。

public class App {public static void main(String[] args) {BusinessService service = new BusinessService();service.doSomething();}
}

运行结果

运行 App 类，你应该会看到如下输出：

日志 - 在方法执行前
执行业务逻辑
日志 - 在方法执行后

通过上述示例，我们可以看到 AspectJ 如何帮助我们将日志记录这样的横切关注点与业务逻辑分离。这不仅提高了代码的可读性和可维护性，还使我们能够更专注于核心业务逻辑的开发。AspectJ 是一个流行的面向切面编程（AOP）框架，用于在 Java 应用程序中实现横切关注点（如日志记录、事务管理等）。下面是一个完整的 AspectJ 示例，展示如何在 Spring 框架中使用 AOP 来实现日志记录。

1. 添加依赖

首先，在你的 pom.xml 文件中添加 AspectJ 和 Spring AOP 的依赖：

<dependencies><!-- Spring Core --><dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>5.3.10</version></dependency><!-- Spring Context --><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.3.10</version></dependency><!-- Spring AOP --><dependency><groupId>org.springframework</groupId><artifactId>spring-aop</artifactId><version>5.3.10</version></dependency><!-- AspectJ --><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.7</version></dependency>
</dependencies>

2. 创建业务逻辑类

创建一个简单的业务逻辑类 BusinessService，该类包含一些方法，我们将在这些方法上应用切面。

package com.example.aop;public class BusinessService {public void doSomething() {System.out.println("Doing something important...");}public void doAnotherThing() {System.out.println("Doing another thing...");}
}

3. 创建切面类

创建一个切面类 LoggingAspect，该类将包含日志记录的逻辑。

package com.example.aop;import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;@Aspect
@Component
public class LoggingAspect {@Before("execution(* com.example.aop.BusinessService.*(..))")public void logBefore(JoinPoint joinPoint) {System.out.println("Before method: " + joinPoint.getSignature().getName());}@After("execution(* com.example.aop.BusinessService.*(..))")public void logAfter(JoinPoint joinPoint) {System.out.println("After method: " + joinPoint.getSignature().getName());}
}

4. 配置 Spring 应用上下文

创建一个 Spring 配置类 AppConfig，启用 AOP 支持并配置业务逻辑类和切面类。

package com.example.aop;import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;@Configuration
@EnableAspectJAutoProxy
public class AppConfig {@Beanpublic BusinessService businessService() {return new BusinessService();}@Beanpublic LoggingAspect loggingAspect() {return new LoggingAspect();}
}

5. 测试类

创建一个测试类 MainApp，用于启动 Spring 应用上下文并调用业务逻辑方法。

package com.example.aop;import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;public class MainApp {public static void main(String[] args) {ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);BusinessService businessService = context.getBean(BusinessService.class);businessService.doSomething();businessService.doAnotherThing();}
}

6. 运行应用程序

运行 MainApp 类，你将看到以下输出：

Before method: doSomething
Doing something important...
After method: doSomething
Before method: doAnotherThing
Doing another thing...
After method: doAnotherThing

这个示例展示了如何使用 AspectJ 和 Spring AOP 在业务逻辑方法调用前后插入日志记录。你可以根据需要扩展切面类，添加更多的横切关注点，如性能监控、安全检查等AspectJ 是一种流行的 AOP（面向切面编程）框架，它允许开发者在应用程序中定义横切关注点（如日志记录、事务管理等），并通过编织过程将这些关注点插入到主业务逻辑中。下面我将通过一个完整的 AspectJ 示例来详细介绍其使用方法。

1. 环境准备

首先，确保你的开发环境已经配置好 Java 和 AspectJ。你可以使用 Maven 或 Gradle 来管理依赖项。这里以 Maven 为例：

<dependencies><dependency><groupId>org.aspectj</groupId><artifactId>aspectjrt</artifactId><version>1.9.7</version></dependency><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.7</version></dependency>
</dependencies><build><plugins><plugin><groupId>org.codehaus.mojo</groupId><artifactId>aspectj-maven-plugin</artifactId><version>1.14.0</version><configuration><complianceLevel>1.8</complianceLevel><source>1.8</source><target>1.8</target><showWeaveInfo>true</showWeaveInfo><verbose>true</verbose><Xlint>ignore</Xlint></configuration><executions><execution><goals><goal>compile</goal><goal>test-compile</goal></goals></execution></executions></plugin></plugins>
</build>

2. 创建业务逻辑类

假设我们有一个简单的业务逻辑类 BusinessService，它有一个方法 doSomething 需要被监控。

public class BusinessService {public void doSomething() {System.out.println("Doing something...");}
}

3. 创建切面类

接下来，创建一个切面类 LoggingAspect，用于在 doSomething 方法执行前后添加日志记录。

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.After;@Aspect
public class LoggingAspect {@Before("execution(* com.example.BusinessService.doSomething(..))")public void logBefore() {System.out.println("Before method: doSomething");}@After("execution(* com.example.BusinessService.doSomething(..))")public void logAfter() {System.out.println("After method: doSomething");}
}

4. 主程序

最后，编写一个主程序来测试 BusinessService 的行为。

public class Main {public static void main(String[] args) {BusinessService service = new BusinessService();service.doSomething();}
}

5. 运行程序

编译并运行主程序，你应该会看到如下输出：

Before method: doSomething
Doing something...
After method: doSomething

解释

@Aspect: 标记 LoggingAspect 类为一个切面。
@Before: 定义一个前置通知，在 doSomething 方法执行前执行。
@After: 定义一个后置通知，在 doSomething 方法执行后执行。
execution( com.example.BusinessService.doSomething(..))*: 这是一个切入点表达式，指定了哪些方法会被通知拦截。这里的表达式表示 BusinessService 类中的 doSomething 方法。