Why triggered only one cache? (RedisCacheManager and CacheOperationInvocationContext issue)

Question

I configure first_cache and it works fine. But when I want add second_cache in FirstCasheResolver CacheOperationInvocationContext has only one cache while RedisCacheManager has two caches. Also SecondCacheResolver even not triggered. Please help me.

Here is my CacheConfiguration class

@EnableCaching
@Configuration
public class CacheConfiguration {
    public static final String FIRST_CACHE_NAME = "first_cache";
    public static final String SECOND_CACHE_NAME = "second_cache";
    private int defaultTokenExpirationTime = 1000;

    @Bean
    public RedisCacheManager redisCacheManager(RedisConnectionFactory redisConnectionFactory) {
        return RedisCacheManager.builder(redisConnectionFactory)
                .cacheDefaults(getDefaultRedisCacheConfiguration())
                .withCacheConfiguration(FIRST_CACHE_NAME, getCustomRedisCacheConfiguration())
                .withCacheConfiguration(SECOND_CACHE_NAME, getCustomRedisCacheConfiguration())
                .build();
    }

    private RedisCacheConfiguration getDefaultRedisCacheConfiguration() {
        return RedisCacheConfiguration.defaultCacheConfig().disableCachingNullValues();
    }

    private RedisCacheConfiguration getCustomRedisCacheConfiguration() {
        return RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofSeconds(defaultTokenExpirationTime));
    }

    @Bean("firstCacheResolver")
    public CacheResolver firstCacheResolver(RedisCacheManager redisCacheManager) {
        return new FirstCacheResolver(redisCacheManager);
    }

    @Bean("secondCacheResolver")
    public CacheResolver secondCacheResolver(RedisCacheManager redisCacheManager) {
        return new SecondCacheResolver(redisCacheManager);
    }
}

Here is my FirstCacheResolver class

public class FirstCacheResolver extends SimpleCacheResolver {

    public FirstCacheResolver(CacheManager cacheManager) {
        super(cacheManager);
    }

    @Override
    public Collection<? extends Cache> resolveCaches(CacheOperationInvocationContext<?> context) {
        return super.resolveCaches(context).stream().toList();
    }
}

here super.resolveCaches(context) returns list only one first_cache but CacheManager has first_cache and second_cache

Here is my SecondCacheResolver class

public class SecondCacheResolver extends SimpleCacheResolver {

    public SecondCacheResolver(CacheManager cacheManager) {
        super(cacheManager);
    }

    @Override
    public Collection<? extends Cache> resolveCaches(CacheOperationInvocationContext<?> context) {
        return super.resolveCaches(context).stream().toList();
    }
}

this resolveCaches() method even not triggered

here is usage of both caches. They

public class FirstClass {
    @Cacheable(
            cacheNames = {CacheConfiguration.FIRST_CACHE_NAME},
            key = "#params.get('first').get(0)",
            cacheResolver = "firstCacheResolver"
    )
    public int getFirst(MultiValueMap<String, Object> params) {
        // some logic
    }
}



public class SecondClass {
    @Cacheable(
            cacheNames = {CacheConfiguration.SECOND_CACHE_NAME},
            key = "#params.get('second').get(0)",
            cacheResolver = "secondCacheResolver"
    )
    public int getSecond(MultiValueMap<String, Object> params) {
        // some logic
    }
}

cacheManager in debug

I try implement two caches with custom CacheResolvers.