memcached整合ibatis

ibatis自带的本地缓存有FIFO，LRU等，对于分布式缓存也有osCache支持，而最常用的memcached也可以整合到ibatis里滴，这样通过map关系配置，就省了很多硬编码。
首先写个实现CacheController接口的MemcachedIbatisController类
/**
 * ibatis管理memcache 使用LRU算法
 * @author langke93
 * @date 2011-01-17
 * @usage:
 *  <cacheModel id="cache-videoinfo" type="com.woyo.upload.kernel.util.MemcachedIbatisController">
      <flushInterval seconds="3600"/>
       <flushOnExecute statement="updateVideoInfo" />
     <flushOnExecute statement="insertVideoInfo" />
     <flushOnExecute statement="deleteVideoInfo" />
      <property name="size" value="1000" />
    </cacheModel>
    @modify:
     cacheSize默认为0 ，表示由memcache管理缓存大小，推荐在集群中使用
 */
package com.woyo.upload.kernel.util;
import java.util.Collections;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.Properties;
import org.apache.log4j.Logger;
import com.ibatis.sqlmap.engine.cache.CacheController;
import com.ibatis.sqlmap.engine.cache.CacheModel;
public class MemcachedIbatisController implements CacheController {
    protected final Logger log = Logger.getLogger(this.getClass());
    private MemCachedManager cache;    
    private List<String> keyList;//keyList 管理key
    private int cacheSize;   
  
    public MemcachedIbatisController(){
        this.cacheSize = 0; //默认为0表示不限制缓存大小，不使用LRU
        this.cache = MemCachedManager.getInstance();
        this.keyList = getKeyListInstance();
        log.info("       Enable MemcachedIbatisController !");
    }   
    public synchronized List<String> getKeyListInstance(){
     if(keyList == null){
      keyList =  Collections.synchronizedList(new LinkedList<String>());
     }
     return keyList;
    }
    public void flush(CacheModel cacheModel) {
     String key = null;   
        try {
         if(keyList.isEmpty()){
          //cache.flush(); 目前清除缓存仅依赖于缓存过期，分表/条件清除缓存还需要做扩展
         }else
            for (int i=0;i<keyList.size();i++) {
             key = keyList.get(i);
          cache.delete(key);
          keyList.remove(key); 
            }
        } catch (Exception e) {   
            e.printStackTrace();   
        }
        //keyList.clear();
        log.info("       flush memcache!"); 
    }
    /**
     * 实现LRU算法
     * 把最近取过的数据放到栈顶
     */
    public Object getObject(CacheModel cacheModel, Object key) {
     Object result ;
        String ckey = getKey(cacheModel, key);
        try {
            result = cache.get(ckey);
            if(cacheSize>0){//如果缓存大小有限制，则使用LRU算法
                keyList.remove(ckey);
                if (result != null) {
                  keyList.add(ckey);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();   
            return null;   
        }
        log.info("       getObject memcache!!");
        return result ;
    }   
  
    /**
     * 如果超过缓存大小限制，移出栈底数据
     */
    public void putObject(CacheModel cacheModel, Object key, Object object) {   
        String ckey = getKey(cacheModel, key);   
        keyList.add(ckey);
        try {
         Date expiry = new Date();//过期时间
         expiry.setTime(expiry.getTime()+cacheModel.getFlushInterval());
            cache.add(ckey,object,expiry);
            log.debug("       putObject memcache!"); 
            log.info("cacheSize:"+cacheSize+",keyListSize:"+keyList.size());
            if (cacheSize>0 && keyList.size() > cacheSize) {   
                String oldestKey = keyList.remove(0);   
                cache.delete(oldestKey);   
                log.debug("       keyList.oldestKey memcache!"); 
            }   
        } catch (Exception e) {   
            e.printStackTrace();   
        }   
  
    }   
  
    public Object removeObject(CacheModel cacheModel, Object key) {
        log.info("       removeObject memcache!"); 
        String ckey = getKey(cacheModel, key);   
        try {   
            if (keyList.contains(ckey)) {
             keyList.remove(ckey);
                log.info("       removeObject memcache!"); 
                return cache.delete(ckey);   
            }   
        } catch (Exception e) {   
            e.printStackTrace();   
        }   
        return null;   
    }   
    public void setProperties(Properties props){ 
        String size = props.getProperty("size");   
        if (size == null) {
            size = props.getProperty("cache-size");   
        }   
        if (size != null) {
            cacheSize = Integer.parseInt(size);   
        }
        if(cache!=null)
         cache =  MemCachedManager.getInstance();
    }
    
    public int getCacheSize() {
        return cacheSize;
      }
      public void setCacheSize(int cacheSize) {
        this.cacheSize = cacheSize;
      }
      
    private String getKey(CacheModel cacheModel, Object cacheKey) {   
        String key = cacheKey.toString();   
        int keyhash = key.hashCode();   
        String cacheId = cacheModel.getId();
        key = Config.MEMCACHED_PRE + cacheId + "_" + keyhash; 
        return key;
    }
}
对于分布式/集群环境下，每个实例的key会不一至，也就是说A机器存入的一条SQL的KEY在B机器里算出来的KEY会不一至。原因是ibatis在key的算法里，把statement id的hash码做为key的一部分，所以需要重写CachingStatement类，修改baseCacheKey(下文高亮色的地方)：
/*
 *  Copyright 2004 Clinton Begin
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package com.ibatis.sqlmap.engine.mapping.statement;
import com.ibatis.sqlmap.client.event.RowHandler;
import com.ibatis.sqlmap.engine.cache.CacheKey;
import com.ibatis.sqlmap.engine.cache.CacheModel;
import com.ibatis.sqlmap.engine.mapping.parameter.ParameterMap;
import com.ibatis.sqlmap.engine.mapping.result.ResultMap;
import com.ibatis.sqlmap.engine.mapping.sql.Sql;
import com.ibatis.sqlmap.engine.scope.StatementScope;
import com.ibatis.sqlmap.engine.transaction.Transaction;
import java.sql.SQLException;
import java.util.List;
/**
 * 
 * @modify langnke93
 * statement.setBaseCacheKey(0);
 * baseCacheKey使用固定值，保证每个实例的CacheKey一至
 *
 */
public class CachingStatement extends MappedStatement {
  private MappedStatement statement;
  private CacheModel cacheModel;
  public CachingStatement(MappedStatement statement, CacheModel cacheModel) {
    this.statement = statement;
    this.cacheModel = cacheModel;
  }
  public String getId() {
    return statement.getId();
  }
  public StatementType getStatementType() {
    return statement.getStatementType();
  }
  public Integer getResultSetType() {
    return statement.getResultSetType();
  }
  public Integer getFetchSize() {
    return statement.getFetchSize();
  }
  public ParameterMap getParameterMap() {
    return statement.getParameterMap();
  }
  public ResultMap getResultMap() {
    return statement.getResultMap();
  }
  public int executeUpdate(StatementScope statementScope, Transaction trans, Object parameterObject)
      throws SQLException {
    int n = statement.executeUpdate(statementScope, trans, parameterObject);
    return n;
  }
  public Object executeQueryForObject(StatementScope statementScope, Transaction trans, Object parameterObject, Object resultObject)
      throws SQLException {
    CacheKey cacheKey = getCacheKey(statementScope, parameterObject);
    cacheKey.update("executeQueryForObject");
    Object object = cacheModel.getObject(cacheKey);
    if (object == CacheModel.NULL_OBJECT){
     // This was cached, but null
     object = null;
    }else if (object == null) {
       object = statement.executeQueryForObject(statementScope, trans, parameterObject, resultObject);
       cacheModel.putObject(cacheKey, object);
    }
    return object;
  }
  public List executeQueryForList(StatementScope statementScope, Transaction trans, Object parameterObject, int skipResults, int maxResults)
      throws SQLException {
    CacheKey cacheKey = getCacheKey(statementScope, parameterObject);
    cacheKey.update("executeQueryForList");
    cacheKey.update(skipResults);
    cacheKey.update(maxResults);
    Object listAsObject = cacheModel.getObject(cacheKey);
    List list;
    if(listAsObject == CacheModel.NULL_OBJECT){
      // The cached object was null
      list = null;
    }else if (listAsObject == null) {
      list = statement.executeQueryForList(statementScope, trans, parameterObject, skipResults, maxResults);
      cacheModel.putObject(cacheKey, list);
    }else{
      list = (List) listAsObject;
    }
    return list;
  }
  public void executeQueryWithRowHandler(StatementScope statementScope, Transaction trans, Object parameterObject, RowHandler rowHandler)
      throws SQLException {
    statement.executeQueryWithRowHandler(statementScope, trans, parameterObject, rowHandler);
  }
  public CacheKey getCacheKey(StatementScope statementScope, Object parameterObject) {
 statement.setBaseCacheKey(0);//去掉取于statement id 动态的baseCacheKey使用固定值，保证每个实例的CacheKey一至，用于集群环境
    CacheKey key = statement.getCacheKey(statementScope, parameterObject);
    if (!cacheModel.isReadOnly() && !cacheModel.isSerialize()) {
      key.update(statementScope.getSession());
    }
    return key;
  }
  public void setBaseCacheKey(int base) {
    statement.setBaseCacheKey(base);
  }
  public void addExecuteListener(ExecuteListener listener) {
    statement.addExecuteListener(listener);
  }
  public void notifyListeners() {
    statement.notifyListeners();
  }
  public void initRequest(StatementScope statementScope) {
    statement.initRequest(statementScope);
  }
  public Sql getSql() {
    return statement.getSql();
  }
  public Class getParameterClass() {
    return statement.getParameterClass();
  }
  public Integer getTimeout() {
    return statement.getTimeout();
  }
  public boolean hasMultipleResultMaps() {
    return statement.hasMultipleResultMaps();
  }
  public ResultMap[] getAdditionalResultMaps() {
    return statement.getAdditionalResultMaps();
  }
}
好了，这样就可以在map配置里引用刚才的cache实现类
 <cacheModel id="CacheVideoInfo"  readOnly="false" serialize="true" type="com.woyo.upload.kernel.util.MemcachedIbatisController">
      <flushInterval seconds="3600"/>
      <property name="size" value="1000" />
    </cacheModel>
 <statement id="updateVideoInfo" parameterClass="com.woyo.upload.kernel.entity.VideoInfo" cacheModel="CacheVideoInfo">  ....
目前清除缓存仅依赖于缓存过期，分实例/条件清除缓存还需要做扩展