Cache Management

/**
 * An implementation of JSR-107 CacheManager that manages Caffeine-based caches.
 * Handles cache creation, retrieval, lifecycle, and management operations.
 */
public final class CacheManagerImpl implements CacheManager {
    
    /**
     * Create a new cache with the specified configuration
     * @param cacheName the name of the cache
     * @param configuration the cache configuration
     * @return newly created Cache instance
     * @throws CacheException if cache already exists or is externally configured
     * @throws IllegalArgumentException if arguments are null
     * @throws IllegalStateException if CacheManager is closed
     */
    public <K, V, C extends Configuration<K, V>> Cache<K, V> createCache(String cacheName, C configuration) throws IllegalArgumentException, CacheException, IllegalStateException;
    
    /**
     * Get an existing cache with type safety
     * @param cacheName the name of the cache
     * @param keyType the expected key type
     * @param valueType the expected value type
     * @return Cache instance or null if not found
     * @throws ClassCastException if types don't match
     * @throws IllegalArgumentException if arguments are null
     * @throws IllegalStateException if CacheManager is closed
     */
    public <K, V> @Nullable Cache<K, V> getCache(String cacheName, Class<K> keyType, Class<V> valueType) throws IllegalArgumentException, ClassCastException, IllegalStateException;
    
    /**
     * Get an existing cache without type checking
     * @param cacheName the name of the cache
     * @return CacheProxy instance or null if not found
     * @throws IllegalArgumentException if cacheName is null
     * @throws IllegalStateException if CacheManager is closed
     */
    public <K, V> CacheProxy<K, V> getCache(String cacheName) throws IllegalArgumentException, IllegalStateException;
    
    /**
     * Get all cache names managed by this CacheManager
     * @return unmodifiable collection of cache names
     * @throws IllegalStateException if CacheManager is closed
     */
    public Collection<String> getCacheNames() throws IllegalStateException;
    
    /**
     * Destroy and remove a cache by name
     * @param cacheName the name of the cache to destroy
     * @throws IllegalStateException if CacheManager is closed
     */
    public void destroyCache(String cacheName) throws IllegalStateException;
    
    /**
     * Enable or disable JMX management for a cache
     * @param cacheName the name of the cache
     * @param enabled true to enable management
     * @throws IllegalStateException if CacheManager is closed
     */
    public void enableManagement(String cacheName, boolean enabled) throws IllegalStateException;
    
    /**
     * Enable or disable statistics collection for a cache
     * @param cacheName the name of the cache
     * @param enabled true to enable statistics
     * @throws IllegalStateException if CacheManager is closed
     */
    public void enableStatistics(String cacheName, boolean enabled) throws IllegalStateException;
    
    /**
     * Get the CachingProvider that created this CacheManager
     * @return the associated CachingProvider
     */
    public CachingProvider getCachingProvider();
    
    /**
     * Get the URI that identifies this CacheManager
     * @return the CacheManager URI
     */
    public URI getURI();
    
    /**
     * Get the ClassLoader associated with this CacheManager
     * @return the ClassLoader (may be null if garbage collected)
     */
    public @Nullable ClassLoader getClassLoader();
    
    /**
     * Get the properties used to configure this CacheManager
     * @return the configuration properties
     */
    public Properties getProperties();
    
    /**
     * Close this CacheManager and all associated caches
     */
    public void close();
    
    /**
     * Check if this CacheManager is closed
     * @return true if closed
     */
    public boolean isClosed();
    
    /**
     * Unwrap this CacheManager to the specified type
     * @param clazz the class to unwrap to
     * @return unwrapped instance
     * @throws IllegalArgumentException if unwrapping is not supported
     */
    public <T> T unwrap(Class<T> clazz) throws IllegalArgumentException;
}

import javax.cache.Caching;
import javax.cache.CacheManager;
import javax.cache.Cache;
import javax.cache.configuration.MutableConfiguration;
import com.github.benmanes.caffeine.jcache.configuration.CaffeineConfiguration;

// Get CacheManager
CacheManager cacheManager = Caching.getCachingProvider().getCacheManager();

// Create cache with standard configuration
Cache<String, String> basicCache = cacheManager.createCache("basic", 
    new MutableConfiguration<String, String>()
        .setTypes(String.class, String.class));

// Create cache with Caffeine-specific configuration
Cache<String, Integer> advancedCache = cacheManager.createCache("advanced",
    new CaffeineConfiguration<String, Integer>()
        .setTypes(String.class, Integer.class)
        .setMaximumSize(OptionalLong.of(1000))
        .setExpireAfterWrite(OptionalLong.of(Duration.ofMinutes(30).toNanos()))
        .setStatisticsEnabled(true));

// Retrieve existing caches
Cache<String, String> retrieved = cacheManager.getCache("basic", String.class, String.class);
Cache<Object, Object> untyped = cacheManager.getCache("basic");

// Manage cache lifecycle
Collection<String> cacheNames = cacheManager.getCacheNames();
cacheManager.enableStatistics("advanced", true);
cacheManager.enableManagement("advanced", true);

// Cleanup
cacheManager.destroyCache("basic");
cacheManager.close();

// Internal factory methods (package-private)
static CacheProxy<?, ?> createCache(CacheManager cacheManager, String cacheName, Configuration<?, ?> configuration);
static CacheProxy<?, ?> tryToCreateFromExternalSettings(CacheManager cacheManager, String cacheName);
static boolean isDefinedExternally(CacheManager cacheManager, String cacheName);

// Example with external configuration
Properties props = new Properties();
props.setProperty("cache.myCache.maximumSize", "1000");
props.setProperty("cache.myCache.expireAfterWrite", "PT30M");

CacheManager manager = Caching.getCachingProvider()
    .getCacheManager(URI.create("custom://config"), 
                    getClass().getClassLoader(), 
                    props);

// OSGi-aware cache creation (internal handling)
// Automatically detects OSGi environment and adjusts ClassLoader behavior
Cache<String, String> osgiCache = cacheManager.createCache("osgi-cache", configuration);