---初始化项目

itc-pcitc-dependencies/itc-pcitc-dependencies-service/src/main/java/com/pictc/cache/AbstractCache.java

@@ -0,0 +1,16 @@
+package com.pictc.cache;
+
+public abstract class AbstractCache<K,V> implements TanukiCache<K,V>{
+	
+	private final String cache_name;
+
+	public AbstractCache(String name) {
+		this.cache_name=name;
+	}
+	
+	@Override
+	public String getCacheName() {
+		return cache_name;
+	}
+
+}

itc-pcitc-dependencies/itc-pcitc-dependencies-service/src/main/java/com/pictc/cache/CacheFactory.java

@@ -0,0 +1,13 @@
+package com.pictc.cache;
+
+public class CacheFactory{
+
+	public static final String PROVIDER="provider-name";
+	
+	public static final String PROVIDER_CLASS="provider-classpath";
+	
+	public static <K, V> TanukiCache<K, V> factory(String cacheName) {
+		return new DefaultCacheProvider<K, V>(cacheName);
+	}
+
+}

itc-pcitc-dependencies/itc-pcitc-dependencies-service/src/main/java/com/pictc/cache/DefaultCacheProvider.java

@@ -0,0 +1,109 @@
+package com.pictc.cache;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+public class DefaultCacheProvider<K,V>  extends AbstractCache<K,V> implements TanukiCache<K,V>{
+	
+    private final HashMap<K, V> cache;
+    
+    private final ReadWriteLock lock = new ReentrantReadWriteLock();
+    
+    private final Lock readLock = lock.readLock();
+    
+    private final Lock writeLock = lock.writeLock();
+    
+	public DefaultCacheProvider(String cache_name) {
+		super(cache_name);
+		cache = new HashMap<K, V>();
+	}
+
+
+	@Override
+	public void save(K key, V value) {
+        writeLock.lock();
+        try {
+        	if(cache.containsKey(key)) cache.remove(key);
+            cache.put(key, value);
+        } finally {
+            writeLock.unlock();
+        }
+	}
+
+
+	@Override
+	public void remove(K key) {
+        writeLock.lock();
+        try {
+            cache.remove(key);
+        } finally {
+            writeLock.unlock();
+        }
+	}
+
+
+	@Override
+	public V get(K key) {
+		readLock.lock();
+        try {
+            return cache.get(key);
+        } finally {
+            readLock.unlock();
+        }
+	}
+
+
+	@Override
+	public boolean containsKey(K key) {
+        readLock.lock();
+        try {
+            return cache.containsKey(key);
+        } finally {
+            readLock.unlock();
+        }
+	}
+
+
+	@Override
+	public void clear() {
+        writeLock.lock();
+        try {
+            cache.clear();
+        } finally {
+            writeLock.unlock();
+        }
+	}
+
+	@Override
+	public List<V> values() {
+		return new ArrayList<V>(cache.values());
+	}
+
+	@Override
+	public void save(K key, V value, long time, TimeUnit unit) {
+        writeLock.lock();
+        try {
+            cache.put(key, value);
+            setExpire(key, time, unit);
+        } finally {
+            writeLock.unlock();
+        }
+	}
+
+	@Override
+	public Set<K> keys() {
+		return cache.keySet();
+	}
+
+	@Override
+	public boolean setExpire(K key, long time, TimeUnit unit) {
+		// TODO Auto-generated method stub
+		return false;
+	}
+}

itc-pcitc-dependencies/itc-pcitc-dependencies-service/src/main/java/com/pictc/cache/TanukiCache.java

@@ -0,0 +1,29 @@
+package com.pictc.cache;
+
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+
+public  interface TanukiCache<K,V>{
+	
+	String getCacheName();
+
+	void save(K key,V value);
+	
+	void save(K key,V value,long time,TimeUnit unit);
+	
+	boolean setExpire(K key,long time,TimeUnit unit);
+	
+	void remove(K key);
+	
+	V get(K key);
+
+	boolean containsKey(K key);
+	
+	List<V> values();
+	
+	Set<K> keys();
+	
+	void clear();
+
+}