AspectJ使用详解

一、需要哪些包

AspectJ作为一个流行的AOP框架，需要一些包来正确运行。以下是在使用AspectJ时需要导入的包：

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>${aspectj.version}</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>${aspectj.version}</version>
    </dependency>

在使用AspectJ前确保导入了以上两个包即可正常运行。

二、AspectJ实现AOP

AspectJ是一个基于Java的面向切面编程框架。通过使用AspectJ，可以以声明式的方法建立一个切面，并将其织入到程序的不同部分中。下面是一个最基本的AspectJ切面实例：

    public aspect LoggingAspect {
        pointcut logging() : execution(* com.example.*.*(..));
        before() : logging() {
            System.out.println("Method is executed: " + thisJoinPoint.getSignature().getName());
        }
    }

在上述实例中，我们声明了一个切面LoggingAspect，用于织入应用程序。该切面拦截所有 com.example 包下的所有方法，并在其执行前打印出方法名。

三、@AspectJWeaver使用

@AspectJWeaver是AspectJ提供的一个注解，用于启用AspectJ编译器和织入器。在需要使用AspectJ时，将该注解添加到主类的定义中：

    @AspectJWeaver(loadTimeWeaver = org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver.class)
    public class MainClass {
        public static void main(String[] args) {
            // ...
        }
    }

由于该注解启用了AspectJ编译器和织入器，因此AspectJ就可以拦截和修改应用程序的行为。

四、@Aspect使用

@Aspect是AspectJ中另一个重要的注解，用于定义一个切面。下面是一个例子：

    @Aspect
    public class LoggingAspect {
        @Pointcut("execution(* com.example.*.*(..))")
        public void logging() {}
 
        @Before("logging()")
        public void beforeAdvice() {
            System.out.println("Method is executed: " + thisJoinPoint.getSignature().getName());
        }
    }

该例子同样用于在方法执行前打印出方法名，但与前面的例子不同的是，它使用了@Aspect注解来定义切面。

五、Aspect使用与常用搭配

在开发中，AspectJ与其他框架常常被搭配使用，以下是常用的搭配方式：

1. Spring AOP

Spring框架提供了自己的AOP实现，但是在某些情况下，使用AspectJ可以更加方便。如果需要在Spring中使用AspectJ，需要在配置文件中增加如下npm依赖：

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>${spring.version}</version>
    </dependency>

其中spring.version需自行指定。

2. Hibernate

Hibernate是一个流行的ORM框架，它也支持使用AspectJ实现AOP。在pom.xml文件中，需要添加如下npm依赖：

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.2</version>
    </dependency>

然后在hibernate.cfg.xml文件中增加如下内容：

    <session-factory>
        <property name="hibernate.transaction.factory_class">
            org.hibernate.transaction.JTATransactionFactory
        </property>
        <property name="hibernate.transaction.manager_lookup_class">
            org.hibernate.transaction.JBossTransactionManagerLookup
        </property>
        <property name="hibernate.transaction.aspectj.matching">
            com.example.app.aspectj.TransactionalAspect
        </property>
    </session-factory>

3. JUnit

当需要使用AspectJ对JUnit测试进行AOP时，可以使用JUnit-AspectJ扩展库。

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>1.6.6</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${spring.version}</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>junit-addons</groupId>
        <artifactId>junit-addons</artifactId>
        <version>${junit-addons.version}</version>
        <scope>test</scope>
    </dependency>

然后在测试类中使用@UsingDataSet和@ShouldMatchDataSet注解即可。

六、inaspectof用法

在AspectJ中，inaspectof用于在切面中获取一个特定的目标对象。下面是一个例子：

    public aspect LoggingAspect {
        private MyBean myBean;

        public void MyAspect(MyBean myBean) {
            this.myBean = myBean;
        }

        pointcut logging() : execution(* com.example.*.*(..));
        before() : logging() && inaspectof(myBean) {
            myBean.doSomething();
        }
    }

在这个例子中，我们声明了一个LoggingAspect切面，并在其构造函数中传入了一个MyBean实例。在@Before通知中，我们可以使用inaspectof(myBean)获取该实例，并调用其doSomething()方法。

小结

AspectJ是一个流行的AOP框架，可以方便地将切面织入到Java应用程序中。使用AspectJ需要导入一些包，在注解中使用@AspectJWeaver启用编译器和织入器。常用的搭配方式包括Spring AOP、Hibernate和JUnit。在切面中，使用inaspectof可以获取特定的目标对象。