java基于AspectJ(面向切面编程)编码示例分享

下面我将简要介绍一下关于“Java基于AspectJ编码示例分享”的完整攻略。

了解AspectJ

AspectJ是一种基于Java语言的AOP（面向切面编程）框架，它提供了完整的Java编程语言中AOP的支持，可以独立使用，也可以与Spring框架相结合使用。

AspectJ有自己的语法规则和关键字，其中最重要的关键字就是@Aspect。用@Aspect注解来标注一个类，表示这是一个切面。除此之外，AspectJ还有很多其他关键字和概念，需要通过实际使用逐渐了解和熟悉。

示例一：使用AspectJ实现日志记录功能

本示例中，我们将使用AspectJ实现一个简单的日志记录功能，也就是当程序执行某些方法时自动输出日志信息。

1.添加依赖和插件

在项目的pom文件中，加入以下依赖和插件：

<!-- AspectJ依赖 -->
<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>

<!-- AspectJ插件 -->
<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>aspectj-maven-plugin</artifactId>
    <version>1.14.0</version>
    <executions>
        <execution>
            <goals>
                <goal>compile</goal>
                <goal>test-compile</goal>
            </goals>
        </execution>
    </executions>
    <configuration>
        <complianceLevel>1.8</complianceLevel>
        <source>1.8</source>
        <target>1.8</target>
        <Xlint>ignore</Xlint>
        <encoding>UTF-8</encoding>
        <verbose>true</verbose>
        <showWeaveInfo>true</showWeaveInfo>
    </configuration>
</plugin>

2.编写切面类

package com.example.demo.aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Aspect // 切面注解
@Component // Spring组件注解
public class LogAspect {

    // 创建日志记录器
    private Logger logger = LoggerFactory.getLogger(getClass());

    // 定义切点，表示我们需要拦截哪些方法
    @Before("execution(* com.example.demo.controller.*.*(..))")
    public void beforeMethod(JoinPoint joinPoint) {
        // 记录日志信息
        logger.info("调用了" + joinPoint.getSignature().getName() + "方法");
    }

}

3.启用AspectJ

在启动类上加上@EnableAspectJAutoProxy注解，启用AspectJ自动代理：

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@SpringBootApplication
@EnableAspectJAutoProxy // 启用AspectJ自动代理
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

4.测试代码

在com.example.demo.controller包下创建一个测试控制器：

package com.example.demo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello, AspectJ!";
    }

    @GetMapping("/world")
    public String world() {
        return "Hello, World!";
    }

}

然后我们可以启动应用，并访问http://localhost:8080/hello和http://localhost:8080/world，可以看到控制台输出了对应的日志信息。

示例二：使用AspectJ实现缓存访问功能

本示例中，我们将使用AspectJ实现一个简单的缓存访问功能，也就是当程序访问某些方法时，如果缓存中已经存在对应的结果，则直接返回缓存中的结果。

1.添加依赖和插件

同示例一，添加AspectJ的依赖和插件。

2.编写切面类

package com.example.demo.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

@Aspect // 切面注解
@Component // Spring组件注解
public class CacheAspect {

    // 创建日志记录器
    private Logger logger = LoggerFactory.getLogger(getClass());

    // 创建缓存对象
    private Map<String, Object> cache = new HashMap<>();

    // 定义切点，表示我们需要拦截哪些方法
    @Around("execution(* com.example.demo.controller.*.*(..))")
    public Object aroundMethod(ProceedingJoinPoint joinPoint) throws Throwable {
        // 获取方法名
        String methodName = joinPoint.getSignature().getName();
        logger.info("处理缓存访问：" + methodName);
        // 返回缓存中的结果
        if (cache.containsKey(methodName)) {
            logger.info("缓存中已经存在结果：" + methodName);
            return cache.get(methodName);
        }
        // 没有缓存，执行方法
        logger.info("缓存中没有结果，执行方法：" + methodName);
        Object result = joinPoint.proceed();
        // 将结果加入缓存
        cache.put(methodName, result);
        logger.info("将结果加入缓存：" + methodName);
        return result;
    }

}

3.启用AspectJ

同示例一，在启动类上加上@EnableAspectJAutoProxy注解，启用AspectJ自动代理。

4.测试代码

同示例一，我们可以创建一个测试控制器，然后多次访问这个控制器的方法，观察控制台输出的日志，可以看到当有缓存结果时直接返回，没有缓存结果时执行方法，并将结果加入缓存。

以上就是通过AspectJ实现日志记录和缓存访问功能的示例。