XML-based configuration is indeed becoming less common, with Java-based configuration being preferred in modern Spring Boot applications. Let's update the approach for Spring Boot 3.3.3 using Java configuration.

Here's how to set up EhCache without XML, configure multiple caches, and follow industry standards:

1. First, ensure you have the correct dependencies:

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

1. Create a Java configuration class for EhCache:

import org.ehcache.config.builders.*;
import org.ehcache.jsr107.Eh107Configuration;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.jcache.JCacheCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.cache.Caching;
import javax.cache.spi.CachingProvider;
import java.util.concurrent.TimeUnit;

@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    public JCacheCacheManager cacheManager() {
        CachingProvider cachingProvider = Caching.getCachingProvider();
        javax.cache.CacheManager cacheManager = cachingProvider.getCacheManager();

        // Configure multiple caches
        createCache(cacheManager, "userCache", String.class, Object.class, 100, 10, 3600);
        createCache(cacheManager, "productCache", Long.class, Object.class, 500, 50, 7200);

        return new JCacheCacheManager(cacheManager);
    }

    private void createCache(javax.cache.CacheManager cacheManager, String name, 
                             Class<?> keyType, Class<?> valueType, 
                             long heapEntries, long offHeapMB, long ttlSeconds) {
        cacheManager.createCache(name, 
            Eh107Configuration.fromEhcacheCacheConfiguration(
                CacheConfigurationBuilder.newCacheConfigurationBuilder(keyType, valueType,
                        ResourcePoolsBuilder.newResourcePoolsBuilder()
                            .heap(heapEntries)
                            .offheap(offHeapMB, MemoryUnit.MB))
                    .withExpiry(ExpiryPolicyBuilder.timeToLiveExpiration(
                            Duration.ofSeconds(ttlSeconds)))
                    .build()));
    }
}

Note:

• Instead we can create a helper bean, That holds the instance of CacheConfiguration.
• Later autowire the list of CacheConfiguration beans into CacheConfig class, and then we can iterate over them and use each of the cache configuration to create Cache dynamically.
• Also, we can create a Factory method to create an instance of CacheConfiguration, which can be used for each cache declaration.

This configuration does the following:

• Sets up a JCacheCacheManager bean.
• Configures multiple caches (userCache and productCache) with different settings.
• Uses a helper method createCache to reduce code duplication.

1. Use caching annotations in your service classes:

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

@Service
public class UserService {

    @Cacheable(value = "userCache", key = "#id")
    public User getUserById(String id) {
        // Your logic to fetch the user
    }
}

@Service
public class ProductService {

    @Cacheable(value = "productCache", key = "#id")
    public Product getProductById(Long id) {
        // Your logic to fetch the product
    }
}

Industry Standard Practices for Implementing Cache:

1. Use abstraction: Spring's caching abstraction allows you to switch between caching providers easily.
2. Configure caches based on your use case:
   • For frequently accessed, rarely changing data: Longer TTL, larger heap size.
   • For frequently changing data: Shorter TTL or use @CacheEvict to manually invalidate.