【详解】AspectJAOP完整示例

举报
皮牙子抓饭 发表于 2025/08/14 18:20:43 2025/08/14
【摘要】 AspectJ AOP 完整示例在面向对象编程中，横切关注点（如日志记录、事务管理等）通常会分散到多个方法或类中，导致代码重复和维护困难。面向切面编程（AOP，Aspect-Oriented Programming）提供了一种将这些横切关注点从业务逻辑中分离出来的方法，使得代码更加模块化和易于维护。AspectJ 是 Java 平台上的一个成熟且强大的 AOP 框架，它允许开发者定义切面（A...

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 {

    @Bean
    public BusinessService businessService() {
        return new BusinessService();
    }

    @Bean
    public 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​​ 方法。

总结

通过这个示例，你可以看到如何使用 AspectJ 在不修改业务逻辑代码的情况下，添加额外的功能（如日志记录）。这使得代码更加模块化和可维护。希望这个示例对你理解 AspectJ 有所帮助！如果有任何问题或需要进一步的解释，请随时告诉我。

【声明】本内容来自华为云开发者社区博主，不代表华为云及华为云开发者社区的观点和立场。转载时必须标注文章的来源（华为云社区）、文章链接、文章作者等基本信息，否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
Java Spring
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入