通用工厂模式-如何处理返回类型

Question

I am trying to implement a generic cache factory with a method that return a cache of the nested type. I am facing problem about configuring cache in the factory depending on generic type parameter used to get the cache instance.

I think my model is not good to handle specific configuration in the factory but I would like to manage my different cache in a single place. What do you advise to do this ?

My implementation :

public class GuavaCacheFactory {

    public static final String STRING_CACHE = "STRING_CACHE";
    public static final String SERVICES_LIST_CACHE = "SERVICES_LIST_CACHE";

    private volatile Map<String, Cache<String, ? extends Object>> cacheMap = Maps.newHashMap();

    public final <I extends Object> Cache<String, I> getCache(String name) {

        Cache<String, I> cache = (Cache<String, I>) cacheMap.get(name); // Unchecked cast :(

        if (cache == null) {
            if(STRING_CACHE.equals(name)) {
                cache = CacheBuilder.newBuilder()
                        .maximumSize(300)
                        .expireAfterWrite(12, TimeUnit.HOURS)                       
                        .removalListener(new RemovalListener<String, I>() {
                            @Override
                            public void onRemoval(RemovalNotification<String, I> notification) { // I -> String here
                                System.out.println("Remove parameter '" + notification + "' from cache with cause " + notification.getCause()));
                            }
                        })
                        .build();
            } else if(SERVICES_LIST_CACHE.equals(name)) {
                // I need to do an unchecked cast if I want to manipulate "List<Service>" instead of I
                cache = (Cache<String, I>) CacheBuilder.newBuilder()
                        .maximumWeight(1000L)
                        .weigher(new Weigher<String, List<Service>>() {
                            @Override
                            public int weigh(String key, List<Service> services) { // I -> List<Service>
                                return services != null ? services.size() : 0;
                            }
                        })
                        .expireAfterWrite(1, TimeUnit.HOURS)
                        .build();
                /*cache = CacheBuilder.newBuilder()
                        .maximumWeight(1000L)
                        .weigher(new Weigher<String, I>() {
                            @Override
                            public int weigh(String key, I services) { // I -> List<Service> here
                                return services != null ? services.size() : 0; // Error -> Here I want manipulate "List"
                            }
                        })
                        .expireAfterWrite(1, TimeUnit.HOURS)
                        .build();*/
            } else {
                throw new IllegalStateException("Cache with name '"+ name + "' cannot be created by GuavaCacheFactory");
            }
            cacheMap.put(name, cache);
        }

        return cache;
    }   
    // singleton
}

How I need to use it :

Cache<String, String> stringCache = GuavaCacheFactory.getInstance().getCache(GuavaCacheFactory.STRING_CACHE);
String value = stringCache.get("str1", ...);
// or
Cache<String, List<Service>> listCache = GuavaCacheFactory.getInstance().getCache(GuavaCacheFactory.SERVICES_LIST_CACHE);
List<Service> services = listCache.get("serv1", ...);

I know what type I want to use depending on name. There is no better solution to resolve my problem ?

Answer 1

You can replace the string constant that identifies your cache type by the actual type of the expected cache. This works fine for untyped classes like String . For the service list, you would have to define your own class to make it work:

public class ServiceList extends List<Service> { }

public class GuavaCacheFactory {

    public final <I> Cache<String, I> getCache(Class<I> cacheType) {
        if cacheType.equals(String.class) {
            // ...
        } else if cacheType.equals(ServiceList.class) {
            // ...
        }
}

Then use it like this:

GuavaCacheFactory f = GuavaCacheFactory.getInstance()

// String-Cache
Cache<String, String> stringCache = f.getCache(String.class);
String value = stringCache.get("str1", ...);

// ServiceList-Cache
Cache<String, ServiceList> listCache = f.getCache(ServiceList.class);
ServiceList services = listCache.get("serv1", ...);

Answer 2

Mind the racy code:

private volatile Map<String, Cache<String, ? extends Object>> cacheMap = Maps.newHashMap();

The volatile does not help here, it only affects modifications to the field cacheMap, not the map itself. Take a look at Collections.synchronizedMap(...) or make the getCache method sychronized.

centralized configuration or god object anti-pattern : How many different caches will your application need finally? You have probably bidirectional dependencies: Cache users depend on the factory to construct the cache, the cache factory depends on the users to define needed value types, maybe additional needed listeners, etc. At the end everything depends on each other, that is not a layered architecture.

exposal of the mighty cache interface : Who is using the cache factory? Is everybody allowed to request the service cache and delete a service? Maybe the service cache is only needed by the service factory. Why make the service cache a public and general offering then?

error prone reconfiguration : Probably you like to have the configuration in a central place. However, some configuration options inside your factory are not meant to be changed, or, the cache users need to change also. Here is cohesion, but the code is separated.

So the better solution is to instantiate the caches where you need them.

You are also coding something what is there already in more advanced caches. Take a look at EHCache or cache2k which have a CacheManager or at any JCache compliant cache implementation.

Sorry for the slightly off-topic answer.