Java IRmCacheListener类代码示例

import org.quickbundle.itf.cache.IRmCacheListener; //导入依赖的package包/类
/**
 * 从页面表单获取信息注入vo，并插入单条记录
 * 
 * @param mapping
 * @param form
 * @param request
 * @param response 
 * @return
 * @throws Exception
 */
public ActionForward insert(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
    RmCodeDataVo vo = new RmCodeDataVo();
    RmPopulateHelper.populate(vo, request);  //从request中注值进去vo
    RmVoHelper.markCreateStamp(request,vo);  //打创建时间,IP戳
    String id = getService().insert(vo);  //插入单条记录
    request.setAttribute(IGlobalConstants.WF_FORM_ID, id);
    RmSqlCountCache.clearCount(TABLE_NAME);  //清除count记录数缓存
    { //刷缓存的时机，选择在用户界面操作后
		//刷新本地缓存
		RmGlobalReference.getSingleton().initDataTotal();
        //通知兄弟集群节点
        RmCacheHandler.getSingleton().flushOtherNodes(RmGlobalReference.class, IRmCacheListener.RefreshType.COMMON.value());
    }
    return mapping.findForward(FORWARD_TO_QUERY_ALL);
}
 

import org.quickbundle.itf.cache.IRmCacheListener; //导入依赖的package包/类
/**
    * 批量更新修改多条记录
    * 
    * @param vos 更新的VO对象数组
    * @return 成功更新的记录最终数量
    */
public int update(RmLogTypeVo[] vos) {
	int[] sum = getDao().update(vos);
	int finalSum = 0;
	for (int i = 0; i < sum.length; i++) {
		finalSum += sum[i];
	}
	//RmProjectHelper.log(TABLE_LOG_TYPE_NAME, "批量更新了" + finalSum + "条记录);
       RmSqlCountCache.clearCount(TABLE_NAME);  //清除count记录数缓存
       { //刷缓存的时机，选择在调用Service的更新类方法后
   		//刷新本地缓存
   		RmLogTypeCache.getSingleton().flushCache(IRmCacheListener.RefreshType.COMMON.value());
           //通知兄弟集群节点
   		RmCacheHandler.getSingleton().flushOtherNodes(RmLogTypeCache.class, IRmCacheListener.RefreshType.COMMON.value());
       }
	return finalSum;
}
 

import org.quickbundle.itf.cache.IRmCacheListener; //导入依赖的package包/类
/**
 * 从页面的表单获取多条记录id，并删除多条记录
 * 
 * @param mapping
 * @param form
 * @param request
 * @param response 
 * @return
 * @throws Exception
 */
public ActionForward deleteMulti(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
    String[] id = RmJspHelper.getArrayFromRequest(request, REQUEST_IDS);  //从request获取多条记录id
    int deleteCount = 0;  //定义成功删除的记录数
    if (id != null && id.length != 0) {
        deleteCount = getService().delete(id);  //删除多条记录
    }
    RmSqlCountCache.clearCount(TABLE_NAME);  //清除count记录数缓存
    request.setAttribute(EXECUTE_ROW_COUNT, deleteCount);  //sql影响的行数放入request属性
    { //刷缓存的时机，选择在用户界面操作后
		//刷新本地缓存
		RmGlobalReference.getSingleton().initDataTotal();
        //通知兄弟集群节点
        RmCacheHandler.getSingleton().flushOtherNodes(RmGlobalReference.class, IRmCacheListener.RefreshType.COMMON.value());
    }
    return mapping.findForward(FORWARD_TO_QUERY_ALL);
}
 

import org.quickbundle.itf.cache.IRmCacheListener; //导入依赖的package包/类
/**
 * 从页面表单获取信息注入vo，并修改单条记录
 * 
 * @param mapping
 * @param form
 * @param request
 * @param response 
 * @return
 * @throws Exception
 */
public ActionForward update(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
    RmCodeDataVo vo = new RmCodeDataVo();
    RmPopulateHelper.populate(vo, request);  //从request中注值进去vo
    RmVoHelper.markModifyStamp(request,vo);  //打修改时间,IP戳
    int count = getService().update(vo);  //更新单条记录
    RmSqlCountCache.clearCount(TABLE_NAME);  //清除count记录数缓存
    request.setAttribute(EXECUTE_ROW_COUNT, count);  //sql影响的行数放入request属性
    { //刷缓存的时机，选择在用户界面操作后
		//刷新本地缓存
		RmGlobalReference.getSingleton().initDataTotal();
        //通知兄弟集群节点
        RmCacheHandler.getSingleton().flushOtherNodes(RmGlobalReference.class, IRmCacheListener.RefreshType.COMMON.value());
    }
    return mapping.findForward(FORWARD_TO_QUERY_ALL);
}
 

import org.quickbundle.itf.cache.IRmCacheListener; //导入依赖的package包/类
/**
    * 批量更新修改多条记录
    * 
    * @param vos 更新的VO对象数组
    * @return 成功更新的记录最终数量
    */
public int update(RmPartyViewVo[] vos) {
	int[] sum = getDao().update(vos);
	int finalSum = 0;
	for (int i = 0; i < sum.length; i++) {
		finalSum += sum[i];
	}
	//RmProjectHelper.log(TABLE_LOG_TYPE_NAME, "批量更新了" + finalSum + "条记录);
       RmSqlCountCache.clearCount(TABLE_NAME);  //清除count记录数缓存
       { //刷缓存的时机，选择在调用Service的更新类方法后
   		//刷新本地缓存
   		RmPartyViewCache.getSingleton().flushCache(IRmCacheListener.RefreshType.COMMON.value());
           //通知兄弟集群节点
   		RmCacheHandler.getSingleton().flushOtherNodes(RmPartyViewCache.class, IRmCacheListener.RefreshType.COMMON.value());
       }
	return finalSum;
}
 

import org.quickbundle.itf.cache.IRmCacheListener; //导入依赖的package包/类
/**
    * 批量更新修改多条记录
    * 
    * @param vos 更新的VO对象数组
    * @return 成功更新的记录最终数量
    */
public int update(RmFunctionNodeVo[] vos) {
	int[] sum = getDao().update(vos);
	int finalSum = 0;
	for (int i = 0; i < sum.length; i++) {
		finalSum += sum[i];
	}
	//RmProjectHelper.log(TABLE_LOG_TYPE_NAME, "批量更新了" + finalSum + "条记录);
       RmSqlCountCache.clearCount(TABLE_NAME);  //清除count记录数缓存
       { //刷缓存的时机，选择在调用Service的更新类方法后
   		//刷新本地缓存
   		RmFunctionNodeCache.getSingleton().flushCache(IRmCacheListener.RefreshType.COMMON.value());
           //通知兄弟集群节点
   		RmCacheHandler.getSingleton().flushOtherNodes(RmFunctionNodeCache.class, IRmCacheListener.RefreshType.COMMON.value());
       }
	return finalSum;
}
 

import org.quickbundle.itf.cache.IRmCacheListener; //导入依赖的package包/类
/**
    * 批量更新修改多条记录
    * 
    * @param vos 更新的VO对象数组
    * @return 成功更新的记录最终数量
    */
public int update(RmPartyTypeRelationRuleVo[] vos) {
	int[] sum = getDao().update(vos);
	int finalSum = 0;
	for (int i = 0; i < sum.length; i++) {
		finalSum += sum[i];
	}
	//RmProjectHelper.log(TABLE_LOG_TYPE_NAME, "批量更新了" + finalSum + "条记录);
       RmSqlCountCache.clearCount(TABLE_NAME);  //清除count记录数缓存
       { //刷缓存的时机，选择在调用Service的更新类方法后
   		//刷新本地缓存
   		RmPartyTypeRelationRuleCache.getSingleton().flushCache(IRmCacheListener.RefreshType.COMMON.value());
           //通知兄弟集群节点
   		RmCacheHandler.getSingleton().flushOtherNodes(RmPartyTypeRelationRuleCache.class, IRmCacheListener.RefreshType.COMMON.value());
       }
	return finalSum;
}
 

import org.quickbundle.itf.cache.IRmCacheListener; //导入依赖的package包/类
/**
    * 批量更新修改多条记录
    * 
    * @param vos 更新的VO对象数组
    * @return 成功更新的记录最终数量
    */
public int update(RmAuthorizeVo[] vos) {
	int[] sum = getDao().update(vos);
	int finalSum = 0;
	for (int i = 0; i < sum.length; i++) {
		finalSum += sum[i];
	}
	//RmProjectHelper.log(TABLE_LOG_TYPE_NAME, "批量更新了" + finalSum + "条记录);
       RmSqlCountCache.clearCount(TABLE_NAME);  //清除count记录数缓存
       { //刷缓存的时机，选择在调用Service的更新类方法后
   		//刷新本地缓存
   		RmAuthorizeCache.getSingleton().flushCache(IRmCacheListener.RefreshType.COMMON.value());
           //通知兄弟集群节点
   		RmCacheHandler.getSingleton().flushOtherNodes(RmAuthorizeCache.class, IRmCacheListener.RefreshType.COMMON.value());
       }
	return finalSum;
}
 

import org.quickbundle.itf.cache.IRmCacheListener; //导入依赖的package包/类
/**
    * 批量更新修改多条记录
    * 
    * @param vos 更新的VO对象数组
    * @return 成功更新的记录最终数量
    */
public int update(RmPartyTypeVo[] vos) {
	int[] sum = getDao().update(vos);
	int finalSum = 0;
	for (int i = 0; i < sum.length; i++) {
		finalSum += sum[i];
	}
	//RmProjectHelper.log(TABLE_LOG_TYPE_NAME, "批量更新了" + finalSum + "条记录);
       RmSqlCountCache.clearCount(TABLE_NAME);  //清除count记录数缓存
       { //刷缓存的时机，选择在调用Service的更新类方法后
   		//刷新本地缓存
   		RmPartyTypeCache.getSingleton().flushCache(IRmCacheListener.RefreshType.COMMON.value());
           //通知兄弟集群节点
   		RmCacheHandler.getSingleton().flushOtherNodes(RmPartyTypeCache.class, IRmCacheListener.RefreshType.COMMON.value());
       }
	return finalSum;
}
 

import org.quickbundle.itf.cache.IRmCacheListener; //导入依赖的package包/类
/**
 * 从页面的表单获取多条记录id，并删除多条记录
 * 
 * @param mapping
 * @param form
 * @param request
 * @param response 
 * @return
 * @throws Exception
 */
public ActionForward deleteMulti(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
    String[] id = RmJspHelper.getArrayFromRequest(request, REQUEST_IDS);  //从request获取多条记录id
    int deleteCount = 0;  //定义成功删除的记录数
    if (id != null && id.length != 0) {
        deleteCount = getService().delete(id);  //删除多条记录
    }
    request.setAttribute(EXECUTE_ROW_COUNT, deleteCount);  //sql影响的行数放入request属性
    { //刷缓存的时机，选择在用户界面操作后
		//刷新本地缓存
		RmGlobalReference.getSingleton().initDataTotal();
        //通知兄弟集群节点
        RmCacheHandler.getSingleton().flushOtherNodes(RmGlobalReference.class, IRmCacheListener.RefreshType.COMMON.value());
    }
    return mapping.findForward(FORWARD_TO_QUERY_ALL);
}
 

import org.quickbundle.itf.cache.IRmCacheListener; //导入依赖的package包/类
/**
 * 刷新缓存的值，将keys对应的数据设置为已过期（或未初始化）状态
 * 
 * @param refreshType 缓存的刷新类型
 * @param keys 缓存的key值
 * @return 返回执行结果: -1表示错误, 0表示没找到删除的对象, 大于0的值表示影响的行数
 */
public String flushCache(String flushType, Object... keys) {
	String result = null;
	if(IRmCacheListener.RefreshType.DELETE.value().equals(flushType)) {
		if(keys.length > 0) {
			clearCountInner(keys[0].toString());
			result = "1";
		}
	} else {
		result = "0";
	}
	logCache.info(this.getClass().getName() + ".flushCache(" + flushType + ", " + Arrays.deepToString(keys) + "): result=" + result);
	return result;
}
 

import org.quickbundle.itf.cache.IRmCacheListener; //导入依赖的package包/类
public String flushCache(String flushType, Object... keys) {
String result = null;
if(IRmCacheListener.RefreshType.COMMON.value().equals(flushType)) {
	isInit = false;
	result = "0";
}
logCache.info(this.getClass().getName() + ".flushCache(" + flushType + ", " + Arrays.deepToString(keys) + "): isInit=false");
return result;
  }
 

import org.quickbundle.itf.cache.IRmCacheListener; //导入依赖的package包/类
/**
 * 集群模式下的缓存刷新实现，被其他节点调用
 * 
 * @param cacheClassName
 * @param flushType
 * @param keys
 */
public String reflectFlush(Class<T> cacheClassName, String flushType, Object... keys) {
	String result = null;
	try {
		Method methodGs = cacheClassName.getMethod("getSingleton");
		IRmCacheListener cl = (IRmCacheListener)methodGs.invoke(cacheClassName);
		result = cl.flushCache(flushType, keys);
		logCache.info(RmCacheHandler.class.getName() + ".reflectFlush(" + cacheClassName.getName() + ", " + flushType + ", " + Arrays.deepToString(keys) + "): " + result);
	} catch (Exception e) {
		logCache.error(RmCacheHandler.class.getName() + ".reflectFlush(" + cacheClassName.getName() + ", " + flushType + ", " + Arrays.deepToString(keys) + "): " + e.toString());
		result = IRmCacheListener.Result.FAIL.pattern();
	}
	return result;
}
 

import org.quickbundle.itf.cache.IRmCacheListener; //导入依赖的package包/类
/**
 * 刷新缓存的值，将keys对应的数据设置为已过期（或未初始化）状态
 * 
 * @param refreshType 缓存的刷新类型
 * @param keys 缓存的key值，所有参数应可能使用String(如Java基本类型)
 * @return 返回执行结果: -1表示错误, 0表示没找到删除的对象, 大于0的值表示影响的行数
 */
public String flushCache(String flushType, Object... keys) {
	String result = null;
	if(IRmCacheListener.RefreshType.COMMON.value().equals(flushType)) {
		isInit = false;
		result = "0";
	}
	return result;
}
 

import org.quickbundle.itf.cache.IRmCacheListener; //导入依赖的package包/类
/**
   * 插入单条记录
   * 
   * @param vo 用于添加的VO对象
   * @return 若添加成功，返回新生成的Oid
   */
  public String insert(RmLogTypeVo vo) {
      String id = getDao().insert(vo);
      //RmProjectHelper.log(TABLE_LOG_TYPE_NAME, "插入了1条记录,id=" + String.valueOf(id));
      RmSqlCountCache.clearCount(TABLE_NAME);  //清除count记录数缓存
      { //刷缓存的时机，选择在调用Service的更新类方法后
  		//刷新本地缓存
  		RmLogTypeCache.getSingleton().flushCache(IRmCacheListener.RefreshType.COMMON.value());
          //通知兄弟集群节点
  		RmCacheHandler.getSingleton().flushOtherNodes(RmLogTypeCache.class, IRmCacheListener.RefreshType.COMMON.value());
      }
return id;
  }