java缓存系统

第一版

package cache;

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

public class Cache1 {
	private Map map=new HashMap();
	
	private static Cache1 cache1=new Cache1();
	private Cache1(){
		
	}
	public static  Cache1 getInstanceCache1(){
		return cache1;
	}
	
	public void setObject(String key,Object value){
		map.put(key, value);
	}
	
	public Object getObject(String key){
		Object value=null;
		value=map.get(key);
		if (value==null) {
			value=getFromDB(key); // 从远程数据库获得
			map.put(key, value);
		}
		return value;
	}
	/**
	*仅仅只是模拟
	*/
	private Object getFromDB(String key) {
		return null;
	}
}

所谓的缓存,就是把经常用的数据存储到内存中,下次用的时候能很快的拿到。因而,上面的核心代码其实就是getObject。但是,得承认,上面的代码实在是太过简陋了。上面的测试程序很简单我就不写了。

第二版

之前第一版的缓存只是个实例代码,还算不上工具,因为它并没有对某一个"计算"操作做包装。我知道我说的很模糊,咱们看代码。

package cache;


public interface GetResutl {
	public Object get(Object o);
}




package cache;


public class ComputeSum implements GetResutl {


	@Override
	public Object get(Object o) {
		if (      !(o instanceof Integer)   ){
			throw new IllegalArgumentException (o+"is not Integer");
			
		}
		int n=(int) o;
		int result=0;
		for (int i = 1; i <= n; i++) {
			result+=i;
		}
		return result;
	}


}


package cache;


public class ComputeMultiply implements GetResutl {


	@Override
	public Object get(Object o) {
		if (      !(o instanceof Integer)   ){
			throw new IllegalArgumentException (o+"is not Integer");
			
		}
		int n=(int) o;
		int result=1;
		for (int i = 1; i <= n; i++) {
			result*=i;
		}
		return result;
	}


}

第一版的缓存系统,不能缓存某种操作的结果。
看了上面的连加,与连乘。
我们就大概知道新的缓存该是个什么样了。

package cache;


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


public  class Cache2 {
	private Map map=new HashMap();
	private GetResutl getResutl=null;
	
	public Cache2(GetResutl r){
		this.getResutl=r;
	}


	
	public void setObject(String key,Object value){
		map.put(key, value);
	}
	
	public Object getObject(String key){
		Object value=null;
		value=map.get(key);
		if (value==null) {
			value=getResutl.get(key);
			map.put(key, value);
		}
		return value;
	}
}

另外多嘴一句,Cahe2中有一个接口GetResut,之后再调用GetResult的某一个方法,这种设计似乎叫做策略模式。

第三版

如果ComputeMultiply中的get方法的运行需要花很长时间,同时我们也不着急要它计算的结果,第二版的计算是放在一个线程里的,这样效率不高。
我们试试CallAble。 

package cache;


import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;


public class ComputeSum implements GetResutl {


	@Override
	public Object get(Object o) {
		
		final Long n=Long.valueOf((String) o);
		
		Callable c=new Callable() {
			@Override
			public Long call(){
				Long result=0L;
				for (int i = 1; i <= n; i++) {
					result+=i;
				}
				return result;
			}
		};


		return new FutureTask<>(c);
	}
}

连乘的写法与之类似,不再赘述。
再看cache的写法。

package cache;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public  class Cache3 {
	private Map> map=new HashMap >();
	private GetResutl getResutl=null;
	
	public Cache3(GetResutl r){
		this.getResutl=r;
	}

	@SuppressWarnings("unchecked")
	public Object getObject(String key){
		FutureTask