Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

1. Introduction

Spring provides an annotation-based approach to enable caching on a Spring-managed bean. Based on the AOP technology, it’s easy to make a method cacheable by adding the annotation @Cacheable on it. However, the cache will be ignored when called from within the same class.

In this tutorial, we’ll explain why it happens and how to solve it.

2. Reproducing the Problem

First, we create a Spring Boot application with cache enabled. In this article, we created a MathService with a @Cacheable annotated square method:

@Service
@CacheConfig(cacheNames = "square")
public class MathService {
    private final AtomicInteger counter = new AtomicInteger();

    @CacheEvict(allEntries = true)
    public AtomicInteger resetCounter() {
        counter.set(0);
        return counter;
    }

    @Cacheable(key = "#n")
    public double square(double n) {
        counter.incrementAndGet();
        return n * n;
    }
}

Second, we create a method sumOfSquareOf2 in MathService that invokes the square method twice:

public double sumOfSquareOf2() {
    return this.square(2) + this.square(2);
}

Third, we create a test for the method sumOfSquareOf2 to check how many times the square method is invoked:

@SpringBootTest(classes = Application.class)
class MathServiceIntegrationTest {

    @Resource
    private MathService mathService;

    @Test
    void givenCacheableMethod_whenInvokingByInternalCall_thenCacheIsNotTriggered() {
        AtomicInteger counter = mathService.resetCounter();

        assertThat(mathService.sumOfSquareOf2()).isEqualTo(8);
        assertThat(counter.get()).isEqualTo(2);
    }

}

Since the invocation from the same class doesn’t trigger the cache, the number of the counter is equal to 2, which indicates the method square with argument 2 is called twice and the cache is ignored. It isn’t our expectation, so we need to determine the reason for this behavior.

3. Analyzing the Problem

The caching behavior for the @Cacheable method is supported by Spring AOP. We’ll find some clues if we use an IDE to debug this code. The variable mathService in MathServiceIntegrationTest points to an instance of MathService$$EnhancerBySpringCGLIB$$5cdf8ec8, whereas this in MathService points to an instance of MathService.

MathService$$EnhancerBySpringCGLIB$$5cdf8ec8 is a proxy class generated by Spring. It intercepts all requests on the @Cacheable method for MathService and responds with the cached value.

On the other hand, MathService itself doesn’t have the ability to cache, so internal calls within the same class won’t get the cached value.

Now that we understand the mechanism, let’s look for the solutions to this problem. Apparently, the simplest way is to move the @Cacheable method to another bean. But, if we have to keep the methods in the same bean for some reason, we have three possible solutions:

  • Self-injection
  • Compile-time weaving
  • Load-time weaving

In our Intro to  AspectJ article introduces aspect-oriented programming (AOP) and different weaving approaches in detail. Weaving is a way to insert the code that will occur when we compile the source code into .class files. It includes compile-time weaving, post-compile weaving, and load-time weaving in AspectJ. Since post-compile weaving is used to weave for third-party libraries, which isn’t our case, we just focus on compile-time weaving and load-time weaving.

4. Solution 1: Self-Injection

Self-injection is a commonly used solution for bypassing Spring AOP limitations. It allows us to get a reference to the Spring-enhanced bean and call the method through that bean. In our case, we can autowire the mathService bean to a member variable called self, and call the square method by self instead of using the this reference:

@Service
@CacheConfig(cacheNames = "square")
@Scope(proxyMode = ScopedProxyMode.TARGET_CLASS)
public class MathService {

    @Autowired
    private MathService self;

    // other code

    public double sumOfSquareOf3() {
        return self.square(3) + self.square(3);
    }
}

The @Scope annotation helps create and inject a stub proxy to self due to the circular reference. It will later be filled with the same MathService instance. The test shows that the square method is only executed once:

@Test
void givenCacheableMethod_whenInvokingByExternalCall_thenCacheIsTriggered() {
    AtomicInteger counter = mathService.resetCounter();

    assertThat(mathService.sumOfSquareOf3()).isEqualTo(18);
    assertThat(counter.get()).isEqualTo(1);
}

5. Solution 2: Compile-Time Weaving

The weaving process in compile-time weaving, as the name suggests, happens at compile-time. It’s the simplest approach to weaving. When we have both the source code of the aspect and the code that we’re using aspects in, the AspectJ compiler will compile from the source and produce a woven class file as output.
In a Maven project, we can use Mojo’s AspectJ Maven Plugin to weave AspectJ aspects into our classes using the AspectJ compiler. For the @Cacheable annotation, the source code of the aspect is provided by the library spring-aspects, so we need to add it as the Maven dependency and the aspect library for the AspectJ Maven Plugin.

There are three steps to enable compile-time wavring. First, let’s enable caching with AspectJ mode by adding @EnableCaching annotation on any configuration class:

@EnableCaching(mode = AdviceMode.ASPECTJ)

Second, we need to add the spring-aspects dependency:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
</dependency>

Third, let’s define the aspectj-maven-plugin for the compile goal:

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>aspectj-maven-plugin</artifactId>
    <version>${aspectj-plugin.version}</version>
    <configuration>
        <source>${java.version}</source>
        <target>${java.version}</target>
        <complianceLevel>${java.version}</complianceLevel>
        <Xlint>ignore</Xlint>
        <encoding>UTF-8</encoding>
        <aspectLibraries>
            <aspectLibrary>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</artifactId>
            </aspectLibrary>
        </aspectLibraries>
    </configuration>
    <executions>
        <execution>
            <goals>
                <goal>compile</goal>
            </goals>
        </execution>
    </executions>
</plugin>

The AspectJ Maven plugin shown above will weave the aspects when we execute mvn clean compile. With compile-time weaving, we don’t need to change the code, and the square method would be executed only once:

@Test
void givenCacheableMethod_whenInvokingByInternalCall_thenCacheIsTriggered() {
    AtomicInteger counter = mathService.resetCounter();

    assertThat(mathService.sumOfSquareOf2()).isEqualTo(8);
    assertThat(counter.get()).isEqualTo(1);
}

6. Solution 3: Load-Time Weaving

Load-time weaving is simply binary weaving deferred until the point that a classloader loads a class file and defines the class to the JVM. AspectJ load-time weaving can be enabled using an AspectJ agent to get involved in the class-loading process and weave any types before they’re defined in the VM.

There are also three steps to enable load-time weaving. First, enable caching with AspectJ mode and load-time weaver by adding two annotations on any configuration class:

@EnableCaching(mode = AdviceMode.ASPECTJ)
@EnableLoadTimeWeaving

Second, let’s add the spring-aspects dependency:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
</dependency>

Finally, we specify the javaagent option to the JVM -javaagent:path/to/aspectjweaver.jar or use the Maven plugin to configure the javaagent:

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>${maven-surefire-plugin.version}</version>
            <configuration>
                <argLine>
                    --add-opens java.base/java.lang=ALL-UNNAMED
                    --add-opens java.base/java.util=ALL-UNNAMED
                    -javaagent:"${settings.localRepository}"/org/aspectj/aspectjweaver/${aspectjweaver.version}/aspectjweaver-${aspectjweaver.version}.jar
                    -javaagent:"${settings.localRepository}"/org/springframework/spring-instrument/${spring.version}/spring-instrument-${spring.version}.jar
                </argLine>
                <useSystemClassLoader>true</useSystemClassLoader>
                <forkMode>always</forkMode>
                <includes>
                    <include>com.baeldung.selfinvocation.LoadTimeWeavingIntegrationTest</include>
                </includes>
            </configuration>
        </plugin>
    </plugins>
</build>

The test givenCacheableMethod_whenInvokingByInternalCall_thenCacheIsTriggered will also pass for load-time weaving.

7. Conclusion

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW