创建 MutableGuiceKeyToInstanceMap 的最简单方法？

Question

我想找到或实现一个 MutableGuiceKeyToInstanceMap，其工作方式与 Guava 中的 com.google.common.collect.MutableClassToInstanceMap 类似，但使用 Guice 中的 com.google.inject.Key<T> 代替 Class<T>。

我在 Guice 中找不到它，也无法像 MutableClassToInstanceMap 那样实现它，因为它的超类 ConstrainedMap 是包私有的。我也不能使用MapConstraint.constrainedMap，因为我没有机会添加getInstance 和putInstance 方法（没有它们，这一切都毫无意义）。

制作自己的 ConstrainedMap 类副本会迫使我复制很多额外的类，所以这不是要走的路。通过MapConstraint.constrainedMap 制作助手地图并制作将所有内容委托给助手的MutableGuiceKeyToInstanceMap extends ForwardingMap 可以工作，但仍然很麻烦。有更好的主意吗？

你认为将ConstrainedMap公开是个好主意吗？

Answer 1

一些想法：

1. 我很好奇你为什么要这样做。
2. ForwardingMap 对此似乎很好。有什么麻烦？
3. 公开ConstrainedMap 不是一个好主意。

Answer 2

我不明白你为什么不喜欢ForwardingMap 和MapConstraint.constrainedMap 的组合。代码非常简单，看起来几乎与直接扩展 ConstrainedMap 所得到的完全一样：

import com.google.common.collect.ForwardingMap;
import com.google.common.collect.MapConstraint;
import com.google.common.collect.MapConstraints;
import com.google.inject.Key;
import org.apache.commons.lang.NotImplementedException;

import java.util.HashMap;
import java.util.Map;


public final class MutableGuiceKeyToInstanceMap<B>
        extends ForwardingMap<Key<? extends B>, B> {

    /**
     * Returns a new {@code MutableGuiceKeyToInstanceMap} instance backed by a {@link
     * java.util.HashMap} using the default initial capacity and load factor.
     */
    public static <B> MutableGuiceKeyToInstanceMap<B> create() {
        return new MutableGuiceKeyToInstanceMap<B>(new HashMap<Key<? extends B>, B>());
    }

    /**
     * Returns a new {@code MutableGuiceKeyToInstanceMap} instance backed by a given
     * empty {@code backingMap}. The caller surrenders control of the backing map,
     * and thus should not allow any direct references to it to remain accessible.
     */
    public static <B> MutableGuiceKeyToInstanceMap<B> create(Map<Key<? extends B>, B> backingMap) {
        return new MutableGuiceKeyToInstanceMap<B>(backingMap);
    }


    private final Map<Key<? extends B>, B> delegate;

    private MutableGuiceKeyToInstanceMap(Map<Key<? extends B>, B> delegate) {
        this.delegate = MapConstraints.constrainedMap(delegate, VALUE_MATCHES_GUICE_KEY);
    }

    @Override
    protected Map<Key<? extends B>, B> delegate() {
        return delegate;
    }

    private static final MapConstraint<Key<?>, Object> VALUE_MATCHES_GUICE_KEY = new MapConstraint<Key<?>, Object>() {
        @Override
        public void checkKeyValue(Key<?> key, Object value) {
            matchesGuiceKey(key, value);
        }
    };

    public <T extends B> T putInstance(Key<T> key, T value) {
        return matchesGuiceKey(key, put(key, value));
    }

    public <T extends B> T getInstance(Key<T> key) {
        return matchesGuiceKey(key, get(key));
    }

    private static <B, T extends B> T matchesGuiceKey(Key<T> key, B value) {
        throw new NotImplementedException("TODO");
    }

    private static final long serialVersionUID = 0;
}

代码与MutableClassToInstanceMap非常相似，无需扩展ForwardingMap...当然，您需要添加delegate()方法及其随附字段，但其余部分相同。

我省略了matchesGuiceKey() 实现作为读者练习。祝你好运！你mightneedit。