一个基于Cache+Repository+DAO的实现

public interface CacheEngine {
/** 默认的空的完全限定名 */
public final static String DEFAULT_EMPTY_FQN = "empty_fqn";
/**
* 初始化缓存
*/
public void init();
/**
* 停止缓存
*/
public void stop();
/**
* 添加一个新的对象到缓存中去
*
* @param key
*            键
* @param value
*            值
*/
public void add(String key, Object value);
/**
* 添加一个新的对象到缓存中去
*
* @param fqn
*            缓存的完全限定名(full qualified name)
* @param key
*            键
* @param value
*            值
*/
public void add(String fqn, String key, Object value);
/**
* 从缓存中删除一个值
*
* @param key
*            要删除值的键
*/
public void remove(String key);
/**
* 从缓存中删除一个值
*
* @param fqn
*            缓存的完全限定名(full qualified name)
* @param key
*            要删除值的键
*/
public void remove(String fqn, String key);
/**
* 从缓存中获得一个值
*
* @param fqn
*            缓存的完全限定名(full qualified name)
* @return 如果不存在,返回<code>null</code> ,否则返回<code>Object</code>
*/
public Object getValue(String fqn);
/**
* 从缓存中获得一个值
*
* @param fqn
*            缓存的完全限定名(full qualified name)
* @param key
*            获得值的键
* @return 如果不存在,返回<code>null</code> ,否则返回<code>Object</code>
*/
public Object getValue(String fqn, String key);
/**
* 获得缓存中所有的值
*
* @param fqn
*            缓存的完全限定名(full qualified name)
* @return 如果不存在,返回<code>null</code> ,否则返回<code>Collection</code>
*/
@SuppressWarnings("unchecked")
public Collection getValues(String fqn);
}

public class DefaultCacheEngine implements CacheEngine {
private volatile Map<String, Object> cache;

@Override
public void add(String key, Object value) {
cache.put(key, value);
}

@SuppressWarnings("unchecked")
@Override
public void add(String fqn, String key, Object value) {
Map fqnMap = (Map) cache.get(fqn);
if (fqnMap == null) {
fqnMap = new HashMap();
}
fqnMap.put(key, value);
cache.put(fqn, fqnMap);
}

@Override
public Object getValue(String fqn) {
return cache.get(fqn);
}

@SuppressWarnings("unchecked")
@Override
public Object getValue(String fqn, String key) {
Map fqnMap = (Map) cache.get(fqn);
if (fqnMap == null) {
return null;
}
return fqnMap.get(key);
}

@SuppressWarnings("unchecked")
@Override
public Collection getValues(String fqn) {
Map fqnMap = (Map) cache.get(fqn);
if (fqnMap == null) {
return null;
}
return fqnMap.values();
}

@Override
public void init() {
cache = new ConcurrentHashMap<String, Object>();
}

@Override
public void remove(String key) {
cache.remove(key);
}

@SuppressWarnings("unchecked")
@Override
public void remove(String fqn, String key) {
Map fqnMap = (Map) cache.get(fqn);
if (fqnMap != null) {
fqnMap.remove(key);
}
}

@Override
public void stop() {
}
}

public class JBossCacheEngine implements CacheEngine {
private volatile Cache<String, Object> cache;
private volatile Node<String, Object> rootNode;

@Override
public void add(String key, Object value) {
this.add(DEFAULT_EMPTY_FQN, key, value);
}

@Override
public void add(String fqn, String key, Object value) {
Fqn<String> cacheFqn = Fqn.fromString(fqn);
Node<String, Object> childNode = rootNode.addChild(cacheFqn);
childNode.put(key, value);
}

@Override
public Object getValue(String key) {
return this.getValue(DEFAULT_EMPTY_FQN, key);
}

@Override
public Object getValue(String fqn, String key) {
if (rootNode == null) {
return null;
}
Node<String, Object> childNode = rootNode.getChild(Fqn.fromString(fqn));
if (childNode == null) {
return null;
}
return childNode.get(key);
}

@SuppressWarnings("unchecked")
@Override
public Collection getValues(String fqn) {
if (rootNode == null) {
return null;
}
return rootNode.getChild(Fqn.fromString(fqn)).getData().values();
}

@Override
public void init() {
CacheFactory<String, Object> cacheFactory = new DefaultCacheFactory<String, Object>();
cache = cacheFactory.createCache("config/cache/jboss_cache_config.xml");
//cache.addCacheListener(new JBossCacheListener());
cache.create();
cache.start();
rootNode = cache.getRoot();
}

@Override
public void remove(String key) {
this.remove(DEFAULT_EMPTY_FQN, key);
}

@Override
public void remove(String fqn, String key) {
Node<String, Object> childNode = rootNode.getChild(Fqn.fromString(fqn));
if (childNode != null) {
childNode.remove(key);
}
}

@Override
public void stop() {
}
}

public interface Cacheable {
public void setCacheEngine(CacheEngine cacheEngine);
public void refreshCache(String key) ;
public void refreshCache(String fqn,String key) ;
}

public class MyRepository implements Cacheable{

private CacheEngine cacheEngine  ;
@Override
public void refreshCache(String key) {

cacheEngine.remove(key) ;
}
@Override
public synchronized  void refreshCache(String fqn, String key) {

cacheEngine.remove(fqn, key) ;
}
@Override
public synchronized  void setCacheEngine(CacheEngine cacheEngine) {
this.cacheEngine = cacheEngine ;

}

public List getStoredApple(){
List results = (List) cacheEngine.getValue("/fruit", "apple") ;
if(results==null){
//From DAO
results = dao.query() ;
cacheEngine.add("/fruit", "apple", results) ;

}
return results ;
}
}