Question

必须删除其中的一些细节，但基本上我正在尝试缓存返回一组对象的昂贵操作的结果，但这些单个对象的类型在编译时是未知的（仅一个基类）。

public class SomeClass
{
    private static final Map<Integer,Collection<? extends SomeBaseClass>> theCache = new HashMap<Integer,Collection<? extends SomeBaseClass>>();

    public <T extends SomeBaseClass> Collection<T> theMethod(Class<T> theClass, int index)
    {
        if (theCache.containsKey(index))
        {
            return (Collection<T>) theCache.get(index);
        }
        else
        {
            Collection<T> result = someExpensiveOperation(theClass, index);
            theCache.put(index, result);
            return result;
        }
    }

    // ...

}

这里缓存检索是一个未经检查的强制转换，因为代码只是信任它，调用者传递给方法的类参数与创建对象的早期调用传递的类参数兼容（应该是相同的）首先在缓存中。

是否有某种方式或某种设计模式可以将实际类与对象本身一起缓存，以便可以避免这种未经检查的强制转换？

Answer 1

此行为没有直接支持。

如果缓存包含单个元素，则可以使用Class.cast()，如果不匹配，则会引发ClassCastException：

private Map<Integer, ?> cache = ...;

public <T> T get(Integer id, Class<T> c) {
    return c.cast(cache.get(id));
}

对于缓存集合，它会更复杂。如果您确实想要避免未经检查的强制转换，则可以创建一个新集合并通过Class.cast()填充它：

Collection<T> result = ...;
for (Object o: theCache.get(index)) 
    result.add(theClass.cast(o));
return result;

其他方法包括，例如，使用Guava Collections2.transform()创建“已检查”的集合视图：

public class Cast<T> implements Function<Object, T> {
    private Class<T> type;
    public Cast(Class<T> type) {
        this.type = type;
    }

    public T apply(Object in) {
        return type.cast(in);
    }
}

return Collections2.transform(theCache.get(index), new Cast<T>(theClass));

Answer 2

有许多方法可以解决这个问题。这是我要做的 - 创建一个存储其元素类型的Collection类：

class TypedList<T> extends ArrayList<T> {

    private Class<T> type;

    TypedList(Class<T> type) {
        super();
        this.type = type;
    }

    Class<T> getType() {
        return type;
    }
}

并确保someExpensiveOperation（）使用此类返回其结果。这样，您就可以在检索缓存项时查询类型。

如何在缓存中存储泛型类型以避免在检索时未经检查的强制转换？

2 个答案: