How Spring's Cacheable Annotation can work for class initailized through new Keyword. (In a Class Constructor, initialized through Bean)

In our service, we are initializing a bean (say "A") and that internally constructing a CacheableService Object by using - new CacheableService(). And as I know spring's @Cacheable annotations won't work on class method if the class is initialized using "new" Keyword.

Then what is an alternative or a way to cache method response?

Scenario :

<bean class="com.package.src.A"/>

public class A {
    
    Map<String, CacheableService> map;
    public CacheableService2() {
        map = new HashedMap();
        map.put("a", new CacheableService());
    }
}

import org.springframework.cache.annotation.Cacheable;
    
public class CacheableService {
    
    
    @Cacheable(value = "entityCount", key = "#criteria.toString()")
    public int someEntityCount(final String criteria) {
        System.out.println("Inside function : " + criteria);
        return 5;
    }
}

Here is a minimum example which demonstrates caching using Spring Boot. The code for the examples below can be found here.

Go to https://start.spring.io/ and create a new Spring Boot project. Make sure to include "Spring cache abstraction" which results in this entry being added to your pom:

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-cache</artifactId>
</dependency>

Add the @EnableCaching annotation to your application:

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

@EnableCaching
@SpringBootApplication
public class CacheableApplication {
	public static void main(String[] args) {
		SpringApplication.run(CacheableApplication.class, args);
	}
}

Your service:

package com.example;

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class CacheableService {
    @Cacheable(value = "entityCount")
    public int someEntityCount(final String criteria) {
        System.out.print(String.format("Inside function: %s", criteria));
        return 5;
    }
}

Class A:

package com.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class A {
    private CacheableService cacheableService;

    public A(@Autowired CacheableService cacheableService) {
        this.cacheableService = cacheableService;
    }

    public int getEntityCount(String criteria) {
        return cacheableService.someEntityCount(criteria);
    }
}

And then here is a test that demonstrates that the caching is working. As you can see in the test a.getEntityCount("foo") is being called twice, but in standard out we only see "Inside function: foo" being printed once. Therefore we have verified that the second call resulted in the cache being used to produce the result.

package com.example;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.ByteArrayOutputStream;
import java.io.PrintStream;

import static org.junit.jupiter.api.Assertions.assertEquals;

@SpringBootTest
class CacheableTest {
	private final ByteArrayOutputStream outContent = new ByteArrayOutputStream();

	@Autowired
	private A a;

	@BeforeEach
	public void init() {
		System.setOut(new PrintStream(outContent));
	}

	@Test
	public void testCaching() {
		a.getEntityCount("foo");
		a.getEntityCount("foo");

		assertEquals("Inside function: foo", outContent.toString());
	}
}

EDIT:
If you want to move the cache outside of the Spring lifecycle and manually manage it then I would recommend using Caffeine. Here is the same example but now without any Spring involved.

Your service:

package com.example.withoutspring;

import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;

import java.util.concurrent.TimeUnit;

public class CaffeineCachingService {
    private LoadingCache<String, Integer> entityCountCache = Caffeine.newBuilder()
            .expireAfterAccess(5, TimeUnit.MINUTES)
            .build(key -> someEntityCount(key));

    public int cachedEntityCount(final String criteria) {
        return entityCountCache.get(criteria);
    }

    private int someEntityCount(final String criteria) {
        System.out.print(String.format("Inside function: %s", criteria));
        return 5;
    }
}

Class B:

package com.example.withoutspring;

public class B {
    private CaffeineCachingService cacheableService;

    public B() {
        cacheableService = new CaffeineCachingService();
    }

    public int getEntityCount(String criteria) {
        return cacheableService.cachedEntityCount(criteria);
    }
}

And the same test but without Spring:

package com.example.withoutspring;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.io.ByteArrayOutputStream;
import java.io.PrintStream;

import static org.junit.jupiter.api.Assertions.assertEquals;

public class CaffeineCacheableTest {
    private final ByteArrayOutputStream outContent = new ByteArrayOutputStream();

    private B b = new B();

    @BeforeEach
    public void init() {
        System.setOut(new PrintStream(outContent));
    }

    @Test
    public void testCaching() {
        b.getEntityCount("foo");
        b.getEntityCount("foo");

        assertEquals("Inside function: foo", outContent.toString());
    }
}

Obviously you need to tune the cache to perform how you want it so probably evicting the cached values after 5 minutes is not what you want but if you visit the Caffeine Github page you will see a lot of detailed examples how to configure the cache to meet your use-case.

Hope this helps!