Spring @Cachable method within the same class (self-invocation, proxy issue) - What is the best way to solve it?

Question

I'm trying to call a @Cacheable method from within the same class.

And it didn't work. Because of:

In proxy mode (the default), only external method calls coming in through the proxy are intercepted. This means that self-invocation (in effect, a method within the target object that calls another method of the target object) does not lead to actual caching at runtime even if the invoked method is marked with @Cacheable. Consider using the aspectj mode in this case. Also, the proxy must be fully initialized to provide the expected behavior, so you should not rely on this feature in your initialization code (that is, @PostConstruct).

It means, @Cachable(also @Transactional) works by proxy classes which is Spring AOP in. a internal call in the same class make call by 'this' instead of proxy classes.

To solve the problem, I should call a method by proxy or using AspectJ(another AOP). So, I found 4 solutions.

What is your choice? and why others are not recommended?

Please, share your opinion!

1. using AspectJ (another AOP)
2. get the Bean from ApplicationContext and use it

@Service
public class UserService implements Service {

    @Autowired
    private ApplicationContext applicationContext;

    private Service self;

    @PostConstruct
    private void init() {
        self = applicationContext.getBean(UserService.class);
    }
}

3. self-autowiring using @Resource //since Spring 4.3

@Component
@CacheConfig(cacheNames = "SphereClientFactoryCache")
public class CacheableSphereClientFactoryImpl implements SphereClientFactory {

    /**
     * 1. Self-autowired reference to proxified bean of this class.
     */
    @Resource
    private SphereClientFactory self;

    @Override
    @Cacheable(sync = true)
    public SphereClient createSphereClient(@Nonnull TenantConfig tenantConfig) {
        // 2. call cached method using self-bean
        return self.createSphereClient(tenantConfig.getSphereClientConfig());
    }

    @Override
    @Cacheable(sync = true)
    public SphereClient createSphereClient(@Nonnull SphereClientConfig clientConfig) {
        return CtpClientConfigurationUtils.createSphereClient(clientConfig);
    }
}

4. make the Bean scope of the class as 'prototype' instead of 'singleton'

@Service
@Scope(proxyMode = ScopedProxyMode.TARGET_CLASS)
class AService {

    private final AService _aService;

    @Autowired
    public AService(AService aService) {
        _aService = aService;
    }

    @Cacheable("employeeData")
    public List<EmployeeData> getEmployeeData(Date date){
        ..println("Cache is not being used");
        ...
    }

    public List<EmployeeEnrichedData> getEmployeeEnrichedData(Date date){
        List<EmployeeData> employeeData = _aService.getEmployeeData(date);
        ...
    }
}

I'm a newbie in spring :)

Actually, I choose the 4th solution, but I felt it isn't a good way. because I just need to call the caching method by proxy, and it make several beans to achieve it.

After reading articles, I think AspectJ is the best choice. It looks cool, Spring recommends it, and many people also recommend too.

But I don't understand how to AspectJ works (I will study) and I also don't know why others is not recommended.

references

• Spring Cache @Cacheable - not working while calling from another method of the same bean
• Spring cache @Cacheable method ignored when called from within the same class
• https://spring.io/blog/2012/05/23/transactions-caching-and-aop-understanding-proxy-usage-in-spring
• https://docs.spring.io/spring/docs/current/spring-framework-reference/integration.html#cache