标签: aspectj

我有一个由Spring Roo生成的maven项目,并使用几个工具(checkstyle,pmd等)来收集有关我的项目的信息.(即我正在使用codehaus'声纳)

Roo大量使用AspectJ Inter Type声明(ITD)来分离诸如持久性,javabeans-getter/setter等问题.

这些ITD在编译时编织,因此checkstyle和pmd(在源级别工作)等工具有很多误报.

我目前看到的唯一解决方案是停用对使用ITD的类的检查.

有更好的想法吗？

我使用aspectj来拦截带注释的方法 @Profile(description="something")

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Profile {
    public String description() default "";
}

@Around("com.merc.aop.ctw.aspect.PointcutDefinitions.logAnnotatedMethods(profile)")
public Object profile(ProceedingJoinPoint pjp, Profile profile) throws Throwable {
    ....
}

@Pointcut("@annotation(com.merc.annotations.Profile)")
protected void logAnnotatedMethods(Profile profile) {
}

但是在使用AJC编译时我得到以下错误消息

formal unbound in pointcut 

我能够从建议的方法调用中获取签名和参数,但我无法弄清楚如何获取返回值或异常.我有点假设它可以以某种方式使用并继续.

我正在尝试使用aspectj-maven-pluginmaven项目.在编译时,我得到:

Syntax error, annotations are only available if source level is 5.0
Syntax error, annotations are only available if source level is 5.0
Syntax error, annotations are only available if source level is 5.0

但是,我在我的pom.xml中设置了以下内容:

<project.build.source>1.6</project.build.source>
<project.build.target>1.6</project.build.target>

我有一些依赖:

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>1.6.11</version>
    </dependency>

    <dependency>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>aspectj-maven-plugin</artifactId>
        <version>1.4</version>
    </dependency>

我该如何解决这个问题？谢谢.

解

我在我的pom.xml中添加了以下内容,现在它可以工作:

        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>aspectj-maven-plugin</artifactId>
            <version>1.4</version>
            <executions>
                <execution>
                    <goals>
                        <goal>compile</goal>
                        <goal>test-compile</goal>
                    </goals>
                    <configuration>
                        <source>${project.build.source}</source>  <- Addition
                        <target>${project.build.target}</target>  <- Addition
                    </configuration>
                </execution>
           </executions>
       </plugin>

我想知道使用AspectJ是否存在任何重大性能问题,如果它被用于拦截应用程序中的每个(或最多)方法.当然,性能也会受到每次拦截执行的建议的影响.

为了这个例子,让我们说它非常简单的建议,运行速度非常快,开销最小/没有内存泄漏.每种方法都被截获,是否还有重要的性能杀手？

我有一个多模块项目.该方面目前已添加到"核心"项目中.在mvn clean install这里做它有效.但是,mvn clean install在编译父项目时,在编译其他项目时,它会因此错误而失败:

无法解析org.hibernate.annotations.CacheConcurrencyStrategy类型.它是从所需的.class文件间接引用的

如果我在该项目中添加Hibernate核心依赖项也可以,但是将依赖项添加到不应该具有依赖项的项目中是没有意义的 - 所以它不是一个解决方案.用javac它编译时工作正常.

是什么原因？我如何解决它,以便我可以使用AspectJ编译器而不会泄漏依赖项到不应该有的项目？

我在父POM中有这个配置:

 <build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>aspectj-maven-plugin</artifactId>
            <version>1.5</version>
            <configuration>
                <source>1.6</source>
                <target>1.6</target>
                <complianceLevel>1.6</complianceLevel>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>compile</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

更新

我刚刚发现.mvn clean install每次都运行失败.但是,运行mvn [clean] install一次失败.然后mvn install没有clean工作运行.我看到builddef.lst目标文件夹中的原因是它运行的原因并根据您是否运行干净而失败.所以现在我的问题是:你如何自动生成这个文件？

父POM文件:

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

    <modelVersion>4.0.0</modelVersion>
    <groupId>com.mycompany</groupId>
    <artifactId>core-lib</artifactId>
    <name>core-lib</name>
    <packaging>pom</packaging>

    <build>
        <plugins>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>aspectj-maven-plugin</artifactId>
                <version>1.5</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                    <complianceLevel>1.6</complianceLevel>
                </configuration> …

我正在尝试为测量方法运行时创建一个计时器方面.

我创建了一个名为的注释@Timer:

@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.METHOD, ElementType.TYPE})
public @interface Timer {
    String value();
}

然后我创建了如下方面:

@Aspect
public class MetricAspect {

    @Autowired
    private MetricsFactory metricsFactory;

    @Pointcut("@annotation(my.package.Timer)")
    public void timerPointcut() {}

    @Around("timerPointcut() ")
    public Object measure(ProceedingJoinPoint joinPoint) throws Throwable {
       /* Aspect logic here */
    }

    private Timer getClassAnnotation(MethodSignature methodSignature) {
        Timer annotation;
        Class<?> clazz = methodSignature.getDeclaringType();
        annotation = clazz.getAnnotation(Timer.class);
        return annotation;
    }

我有一个配置类如下:

@Configuration
@EnableAspectJAutoProxy
public class MetricsConfiguration {

    @Bean
    public MetricAspect notifyAspect() {
        return new MetricAspect();
    }
} …

在我的项目中,我目前在编译时使用AspectJ(由于某些限制而不仅仅是Spring AOP).为了加速Eclipse的开发,我想在加载时进行编织.我成功地做到了这一点,但有一个主要的约束:为我的服务使用包含一些事务方法的接口.如果我使用其实现而不是其接口声明服务,则在调用者类中,没有编织,因此不支持任何事务.

因此,如果AspectJ支持它,如何在没有接口的情况下使用加载时编织配置AspectJ？

我创建了一个重现问题的小项目:

以下测试失败.

以下测试成功:

• 注入的服务是通过其接口而不是其实现来声明的(即通过"@Inject MyService service"替换"@Inject MyServiceImpl服务"),测试成功.

• 在编译期间执行编织(在这种情况下,配置,POM和Spring应用程序上下文明显不同).但我的目标是在加载时进行编织,以避免每次保存Java文件时的编织阶段.

• Spring AOP(tx:annotation-driven mode ="proxy"),即基于代理的解决方案,用于代替AspectJ.但在这种情况下,我们遇到了自调用问题,即目标对象中调用目标对象的其他方法的方法,即使被调用的方法用@Transactional标记,也不会在运行时导致实际的事务.

AspectJ的LTW/SRC /测试/ JAVA/myCompany的/ aspectj_ltw/MyServiceImplTest.java

package mycompany.aspectj_ltw;

import static junit.framework.Assert.assertTrue;

import javax.inject.Inject;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:/META-INF/spring/applicationContext.xml" })
public class MyServiceImplTest {

    @Inject
    MyServiceImpl service;

    @Test
    public void shouldBeExecutedInTransaction() {
        assertTrue(this.service.isExecutedInTransaction());
    }
}

AspectJ的LTW/SRC /主/爪哇/ myCompany的/ aspectj_ltw/MyService.java

package mycompany.aspectj_ltw;

public interface MyService {

    boolean isExecutedInTransaction();

}

AspectJ的LTW/SRC /主/爪哇/ myCompany的/ aspectj_ltw/MyServiceImpl.java

package mycompany.aspectj_ltw;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional; …

在我基于Maven的项目中,我使用Lombok来保存一些样板代码.此外,我正在使用一个Spring数据库,它使用AspectJ来完成工作.遗憾的是,由于AspectJ编译器重新编译Java文件,因此Lombok和AspectJ不能很好地一起开箱即用.因此,实施的龙目岛的Getter和Setters将丢失.

我决定使用Lombok Maven插件来删除我的代码.然后将此代码传递给AspectJ.这是基本流程:

Sources in /src/main/java or /src/test/java
=> [Delombok] 
=> Delomboked sources in /target/generated-sources/delombok or /target/generated-test-sources/delombok
=> [AspectJ]
=> Compiled results in /target/classes or /target/test-classes

但是,这种方法的一个缺点是:我似乎已经失去了使用IntelliJ的调试支持.在/ src/main/java或/ target/generated-sources/delombok Java文件中设置的断点永远不会被命中.我使用IntelliJ Maven插件运行项目,选择生命周期项(例如"test"),调试钩子.可悲的是,断点永远不会受到打击.

可以做些什么来获得调试支持？

我正在使用AspectJ来监视字段访问和字段修改.我有一个gradle项目,它编译了两个方面,并使用gradle shadow插件将jar与aspectjrt和aspectjweaver打包在一个带阴影的jar中.代理仍然是org.aspectj.weaver.loadtime.Agent.一切正常,但当我尝试重新定位aspectj包时,我得到一个错误.

shadow插件配置是:

shadowJar {
    relocate 'org.aspectj', 'shadow.org.aspectj'
    relocate 'aj.org.objectweb.asm', 'shadow.aj.org.objectweb.asm'
}

清单:

jar {
    manifest {
        attributes("Premain-Class": "shadow.org.aspectj.weaver.loadtime.Agent",
                "Can-Redefine-Classes": true,
                "Can-Retransform-Classes":true)
    }
}

这是反编译的方面类,所以看起来是正确的:

package com.vfunction.singletonanalysis;

import shadow.org.aspectj.lang.JoinPoint;
import shadow.org.aspectj.lang.NoAspectBoundException;
import shadow.org.aspectj.lang.annotation.Aspect;
import shadow.org.aspectj.lang.annotation.Before;

@Aspect
public class StaticFieldBeforeAccessAspect extends AbstractFieldAccessAspect {
    public StaticFieldBeforeAccessAspect() {
    }

    @Before("callAt()")
    public void before(JoinPoint joinPoint) throws Throwable {
        this.printJoinPoint(joinPoint);
    }

    public static StaticFieldBeforeAccessAspect aspectOf() {
        if (ajc$perSingletonInstance == null) {
            throw new NoAspectBoundException("com.vfunction.singletonanalysis.StaticFieldBeforeAccessAspect", ajc$initFailureCause);
        } else {
            return ajc$perSingletonInstance;
        }
    }

    public static boolean …