cachemanage.java

Speedframework--基于类型元数据的羽量级ORM.完全基于Java类型元数据和反射机制同时不需要任何对象关系映射配置文件的轻量级ORM框架,它充分利用了类型本身的信息,使用Metadata

package org.speedframework.cache;

import java.util.*;

import org.apache.log4j.*;
import org.speedframework.entity.*;

/**
 * <p>
 * Title: SpeedFrameworkWork持久层框架
 * </p>
 * 
 * <p>
 * Description: Cache控制对象
 * </p>
 * 
 * <p>
 * Copyright: Copyright (c) 2006
 * </p>
 * 
 * <p>
 * Company: SpeedFrameworkWork team
 * </p>
 * 
 * @author 李志峰 电话：[phone] 程伟杰 电话：
 * @version 1.0
 */
public class CacheManage {
	private static String CachePoolName = "speedCache";

	private static final String SQLCacheName = "sqlCache";

	private static final String ParamCacheName = "paramCache";

	private static final Logger log = Logger.getLogger(CacheManage.class);

	private static final CachePool cp = CachePoolFactory.getProviderCache();

	public CacheManage() {

	}

	/**
	 * 寻找Cache存放对象
	 * 
	 * @param parmvalue
	 *            Object[]
	 * @param SQL
	 *            String
	 * @throws Exception
	 * @return List
	 */
public static synchronized List FindCache(Object[] parmvalue, String SQL)
			throws Exception {
		List relist = null;
		cp.newInstance(CachePoolName);
		CacheSQLBean sqlBean = new CacheSQLBean();
		sqlBean.setSql(SQL.toLowerCase());
		sqlBean.setCodeid(sqlBean.hashCode());		

		// cbone.setParmvalue(parmvalue);
		// cbone.setSql(SQL);
		List list = (List) cp.get(SQLCacheName);
		List paramList = (List) cp.get(ParamCacheName);
		if (list != null && list.size() > 0) {			
			Iterator it = list.iterator();
			while (it.hasNext()) {
				boolean found = true;
				// CacheBean cbtemp = (CacheBean) it.next();
				CacheSQLBean tempBean = (CacheSQLBean) it.next();
				int codeid = tempBean.getCodeid();
				int paramid = 0;
				if (tempBean.getSql().equals(SQL.toLowerCase())) { // check sql
																	// is match
					log.debug("SQL found : id = " + codeid);
					// String[] cache_paramvalue = cbtemp.getParmvalue();
					if (paramList != null && paramList.size() > 0) {						
						Iterator paramIt = paramList.iterator();
						while (paramIt.hasNext()) {
							CacheParamBean paramTemp = (CacheParamBean) paramIt
									.next();
							if (paramTemp.getCodeid() == codeid) {
								paramid = paramTemp.getParamid();
								log.debug("found the param object: id = "
										+ paramTemp.getParamid());
								Object[] cache_paramvalue = paramTemp
										.getParmvalue();
								if (cache_paramvalue.length == parmvalue.length) { // check
																					// param
																					// value
																					// is
																					// match
									log.debug("param's length match");
									for (int param_length = 0; param_length < cache_paramvalue.length; param_length++) {
										if (!cache_paramvalue[param_length]
												.toString().equals(
														parmvalue[param_length]
																.toString())) {
											log.debug("param'value not match");
											found = false;
											break;
										}
									}

									if (found) {
										relist = (List) cp.get(codeid + "_"
												+ paramid);
										log
												.debug("Fount the ResultList : id = "
														+ codeid
														+ "_"
														+ paramid);
										break;
									}
								} else {
									log.debug("param's length not match ");
									// found = false;
									break;
								}

							} else {
								continue;
							}
						}
					}
				} else {
					continue;
				}
			}
		}

		/*
		 * Object[] cache_paramvalue = cbtemp.getParmvalue(); if
		 * (cache_paramvalue.length != 0 && parmvalue.length != 0) { if
		 * (cache_paramvalue.length == parmvalue.length) { log.debug("parm
		 * length 参数长度匹配::"); for (int param_length = 0; param_length <
		 * cache_paramvalue.length; param_length++) { if
		 * (!cache_paramvalue[param_length].toString().equals(parmvalue[
		 * param_length].toString())) { log.debug("参数值不匹配::"); found = false;
		 * break; } } } else { log.debug("参数长度不匹配::"); found = false; } } if
		 * (found == true) { log.debug("Cache搜索命中::" + cbtemp.hashCode());
		 * relist = (List) CachePool.get(Integer.toString(cbtemp.hashCode()));
		 * break; } } else { continue; } } }
		 */

		return relist;
	}
	/**
	 * 存放Cache对象
	 * 
	 * @param parmvalue
	 *            Object[]
	 * @param SQL
	 *            String
	 * @param putlist
	 *            List
	 * @throws Exception
	 */
	public static synchronized void put(Object[] parmvalue, String SQL, List putlist)
			throws Exception {
		cp.newInstance(CachePoolName);
		boolean found = false;
		int codeid = 0;

		int paramid = 0;

		List sqlList = (List) cp.get(SQLCacheName);
		List paramList = (List) cp.get(ParamCacheName);

		if (sqlList == null) {
			sqlList = new ArrayList();

			CacheSQLBean sqlTemp = new CacheSQLBean();
			codeid = sqlTemp.hashCode();
			sqlTemp.setCodeid(codeid);
			sqlTemp.setSql(SQL);

			sqlList.add(sqlTemp);
			log.debug("Put SQLBean in Cache: id = " + codeid);

			cp.put(SQLCacheName, sqlList);
		} else {
			Iterator it = sqlList.iterator();
			while (it.hasNext()) {
				CacheSQLBean sqlBean = (CacheSQLBean) it.next();
				if (sqlBean.getSql().toLowerCase().equals(SQL.toLowerCase())) {
					codeid = sqlBean.getCodeid();
					log.debug("found the repeat sql in SQlBean : id = "
							+ codeid);
					found = true;
					break;
				}
			}
			if (!found) {
				CacheSQLBean sqlBean = new CacheSQLBean();
				codeid = sqlBean.hashCode();
				sqlBean.setCodeid(codeid);
				sqlBean.setSql(SQL);
				sqlList.add(sqlBean);
			}
		}

		CacheParamBean cb = new CacheParamBean();
		paramid = cb.hashCode();
		cb.setParmvalue(parmvalue);
		cb.setCodeid(codeid);
		cb.setParamid(paramid);

		if (paramList == null) {
			paramList = new ArrayList();

		}

		paramList.add(cb);
		log.debug("Put ParamBean in Cache: id = " + paramid);
		cp.put(ParamCacheName, paramList);
		// log.debug("Load in Cache Object::" + sqlTemp.hashCode());

		cp.put(codeid + "_" + paramid, putlist);
		log.debug("Put result in cache: id = " + codeid + "_" + paramid);
	}

	/**
	 * 删除Cache对象
	 * 
	 * @param TableName
	 *            String
	 * @throws Exception
	 */
	public static synchronized void RemoveCache(String TableName)
			throws Exception {
		cp.newInstance(CachePoolName);
		List list = (List) cp.get(SQLCacheName);
		List paramList = (List) cp.get(ParamCacheName);
		Map remove_ = new HashMap();
		if (list != null && list.size() > 0) {
			for (int i = 0; i < list.size(); i++) {
				CacheSQLBean cbtemp = (CacheSQLBean) list.get(i);
				if (cbtemp.getSql().indexOf(TableName.toLowerCase()) != -1) {
					log.debug("Update/Delete Cache Object::"
							+ cbtemp.getCodeid());
					// list.remove(cbtemp);
					remove_.put(Integer.toString(cbtemp.getCodeid()), cbtemp);
					// CachePool.remove(Integer.toString(cbtemp.hashCode()));
				}
			}
		}
		if (remove_.size() > 0) {
			Iterator it = remove_.keySet().iterator();
			while (it.hasNext()) {
				String key = it.next().toString();
				int paramid = 0;
				log.debug("Delete SQlBean : id = " + key);
				CacheSQLBean sqlBean = (CacheSQLBean) remove_.get(key);
				int codeid = sqlBean.getCodeid();
				for (int j = 0; j < paramList.size(); j++) {
					CacheParamBean paramBean = (CacheParamBean) paramList
							.get(j);
					if (paramBean.getCodeid() == codeid) {
						paramid = paramBean.getParamid();
						log.debug("Delete ParamBean : id = " + paramid);
						paramList.remove(paramBean);
					}
				}
				list.remove(sqlBean);
				cp.remove(key + "_" + paramid);
				log.debug("Remove result in cache : id = " + key + "_"
						+ paramid);
			}
		}
		// log.debug(CachePool.get("SQLBean"));
	}

}