春季AOP和Aspect“ perthis”

Question

Is it possible to have aspect instance per pointcut?

I want to implement simple Spring AOP proxy-based aspect. If method marked in separate classes, both perthis and pertarget works fine. But what can I do when multiple methods should be cached in one class?

Sample project: https://github.com/mezlogo/spring-aop-sample

For instance, I have:

build.gradle

buildscript {
    repositories { jcenter() }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:1.3.5.RELEASE")
    }
}
apply plugin: 'spring-boot'
apply plugin: 'groovy'

repositories { jcenter() }

dependencies {
    compile group: 'org.codehaus.groovy', name: 'groovy-all', version: '2.4.6'
    compile 'org.springframework.boot:spring-boot-starter-aop'
    testCompile 'org.springframework.boot:spring-boot-starter-test'
    testCompile group: 'org.spockframework', name: 'spock-spring', version: '1.0-groovy-2.4'
}

CacheAspect.groovy

package mezlogo

import groovy.transform.CompileStatic
import org.aspectj.lang.ProceedingJoinPoint
import org.aspectj.lang.annotation.Around
import org.aspectj.lang.annotation.Aspect

@CompileStatic
@Aspect("perthis(@annotation(mezlogo.CacheIt))")
class CacheAspect {
    int cachedValue = -1

    @Around('@annotation(mezlogo.CacheIt)')
    int cacheRemoteService(ProceedingJoinPoint pjp) {
        if (-1 == cachedValue) {
            def result = pjp.proceed()
            cachedValue = (int) result
        }
        cachedValue
    }
}

Custom CacheIt.java annotation

package mezlogo;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface CacheIt{}

Config.groovy

package mezlogo

import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.context.annotation.EnableAspectJAutoProxy
import org.springframework.context.annotation.Scope

@Configuration
@EnableAspectJAutoProxy
class Config {
    @Bean
    RemoteService remoteService() { new RemoteService() }

    @Bean
    @Scope("prototype")
    CacheAspect cacheAspect() { new CacheAspect() }
}

RemoteService.groovy

package mezlogo

import groovy.transform.CompileStatic

@CompileStatic
class RemoteService {
    static final int RESULT = 1
    static final int ANOTHER_RESULT = 2
    static final RuntimeException exception = new RuntimeException('Prevent it by caching')
    boolean isFirstAccessed = true
    boolean isSecondAccessed = true

    @CacheIt
    int firstMethod() {
        if (!isFirstAccessed) { throw exception }
        isFirstAccessed = false
        RESULT
    }

    @CacheIt
    int secondMethod() {
        if (!isSecondAccessed) { throw exception }
        isSecondAccessed = false
        ANOTHER_RESULT
    }
}

Finally, CacheAspectSpec.groovy

package mezlogo

import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.SpringApplicationConfiguration
import spock.lang.Specification
import spock.lang.Stepwise

@SpringApplicationConfiguration(Config)
@Stepwise
class CacheAspectSpec extends Specification {
    @Autowired
    RemoteService sut

    def "should cache firstMethod result"() {
        expect: "firstMethod return correct result"
        sut.firstMethod() == RemoteService.RESULT

        when: "firstMethod fired again"
        sut.firstMethod()
        then: "no RTE has been thrown"
        noExceptionThrown()
    }

    def "should cache secondMethod result"() {
        expect: "secondMethod return correct result"
        //Cache return RemoteService.RESULT value
        sut.secondMethod() == RemoteService.ANOTHER_RESULT

        when: "secondMethod fired again"
        sut.secondMethod()
        then: "no RTE has been thrown"
        noExceptionThrown()
    }
}

Answer 1

M. Deinum is right. As documented in the Spring AOP manual , instantiation models percflow() and percflowbelow() which might have helped you are not supported in Spring AOP.

But one aspect instance per object or even per joinpoint would be expensive anyway. Why not use a caching approach similar to the one mentioned here ? In that answer I just re-use the original poster's approach, answering another type of question about unit-testing aspects, and I think it could be implemented in a smarter way, but basically it works and you will easily understand how it is done.

PS: I also love to use Spock for testing. Cool! :-) I have completely stopped using JUnit except for cases in which I am answering questions like the one I just pointed to.