Struts2中的缓存----以Injector为例

构成缓存的类

 com.opensymphony.xwork2.inject.util.ReferenceCache<K, V>
 com.opensymphony.xwork2.inject.util.ReferenceMap<K, V>

public class ReferenceMap<K, V> implements Map<K, V>, Serializable {

  private static final long serialVersionUID = 0;

  transient ConcurrentMap<Object, Object> delegate;

  final ReferenceType keyReferenceType;
  final ReferenceType valueReferenceType;
}

public abstract class ReferenceCache<K, V> extends ReferenceMap<K, V> {

  private static final long serialVersionUID = 0;

  transient ConcurrentMap<Object, Future<V>> futures =
      new ConcurrentHashMap<Object, Future<V>>();

  transient ThreadLocal<Future<V>> localFuture = new ThreadLocal<Future<V>>();
}

缓存的操作接口

  public V get(final Object key) {
    ensureNotNull(key);
    return internalGet((K) key);  
  }
ensureNotNull看名字就知道是干什么的了。
  V internalGet(K key) {
    Object valueReference = delegate.get(makeKeyReferenceAware(key));//标识1
    return valueReference == null
        ? null
        : (V) dereferenceValue(valueReference);
  }

  @Override public V get(final Object key) {
    V value = super.get(key);  //标识2
    return (value == null)
      ? internalCreate((K) key) //标识9
      : value;
  }

V internalCreate(K key) {
    try {
      FutureTask<V> futureTask = new FutureTask<V>(
          new CallableCreate(key));

      // use a reference so we get the same equality semantics.
      Object keyReference = referenceKey(key);  //referenceKey方法大家就当没看见
      Future<V> future = futures.putIfAbsent(keyReference, futureTask); //标识4
      if (future == null) {
        // winning thread.
        try {
    //localFuture在这里到底扮演什么角色
    //到现在我也没有看明白
          if (localFuture.get() != null) {   
            throw new IllegalStateException(
                "Nested creations within the same cache are not allowed.");
          }
          localFuture.set(futureTask);
          futureTask.run();       //标识3
          V value = futureTask.get();  //标识5
          putStrategy().execute(this,   //标识7
              keyReference, referenceValue(keyReference, value));
          return value;
        } finally {
          localFuture.remove();
          futures.remove(keyReference);
        }
      } else {
        // wait for winning thread.
        return future.get();
      }//省略catch
    }
  }

另外多说一句废话

对于线程来说,直接调用run方法就没有线程的效果,就相当于函数调用,而对futureTask而言,调用run方法就是启动线程并调用call方法。

   if (!map.containsKey(key))
       return map.put(key, value);
   else
       return map.get(key);

public class ConcurrentHashMapTest {
    public static void main(String[] args) {
        ConcurrentHashMap<People, String> chm=new ConcurrentHashMap<People, String>();
        People p=new People();
        System.out.println(chm.putIfAbsent(p, "1"));
        System.out.println(chm.putIfAbsent(p, "2"));
        System.out.println(chm.get(p));
    }

}
class People{
    String name;
    String age;
}

class CallableCreate implements Callable<V> {

    K key;

    public CallableCreate(K key) {
      this.key = key;
    }

    public V call() {
      // try one more time (a previous future could have come and gone.)
      V value = internalGet(key);  //在父类的delegate里面找
      if (value != null) {
        return value;
      }

      // create value.
      value = create(key);  //标识6
      if (value == null) {
        throw new NullPointerException(
            "create(K) returned null for: " + key);
      }
      return value;
    }
  }

ok,到现在我们就得引入本文标题中的Injector了。

final Map<Class<?>, List<Injector>> injectors =
    new ReferenceCache<Class<?>, List<Injector>>() {
        @Override
        protected List<Injector> create( Class<?> key ) {
            List<Injector> injectors = new ArrayList<Injector>();
            addInjectors(key, injectors);
            return injectors;
        }
    };

void inject( Object o, InternalContext context ) {  
    List<Injector> injectors = this.injectors.get(o.getClass());
    for ( Injector injector : injectors ) {
        injector.inject(context, o);
    }
}

 putStrategy().execute(this,keyReference, referenceValue(keyReference, value));

缓存中的策略模式

protected interface Strategy {
    public Object execute(ReferenceMap map, Object keyReference,
        Object valueReference);
  }

  protected Strategy putStrategy() {
    return PutStrategy.PUT;  //直接放
  }

  protected Strategy putIfAbsentStrategy() {
    return PutStrategy.PUT_IF_ABSENT;  //不存在时才放
  }

  protected Strategy replaceStrategy() {
    return PutStrategy.REPLACE;     //替换
  }

  //枚举类 存放数据有三种方式 PUT PUT_IF_ABSENT REPLACE
  private enum PutStrategy implements Strategy {
    PUT {
      public Object execute(ReferenceMap map, Object keyReference,
          Object valueReference) {
        return map.delegate.put(keyReference, valueReference);
      }
    },

    REPLACE {
      public Object execute(ReferenceMap map, Object keyReference,
          Object valueReference) {
        return map.delegate.replace(keyReference, valueReference);
      }
    },

    PUT_IF_ABSENT {
      public Object execute(ReferenceMap map, Object keyReference,
          Object valueReference) {
        return map.delegate.putIfAbsent(keyReference, valueReference);
      }
    };
  };

map.delegate.put(keyReference, valueReference);

第二次查找

Future<V> future = futures.putIfAbsent(keyReference, futureTask);

这篇文章,只能说是引大家入门而已。

感谢glt

参考资料:

Struts2中的缓存----以Injector为例

原文：http://blog.csdn.net/dlf123321/article/details/43088937