NC65根据sql读取缓存数据

NC65根据sql读取缓存数据，相关类

//获取已经读出的参照数据
String sql = "select eps_code,eps_name,pk_eps,pk_org,pk_parent from pm_eps where ((pk_group = '0001E110000000001BVA') ) order by eps_code";
Vector v = getCacheValue(sql);//出自：nc.ui.bd.ref.AbstractRefTreeModel.getClassData()


// 出自：nc.ui.bd.ref.RefModelHandlerForClient.getCacheValue(String sql)
public Vector getCacheValue(String sql) {
		SQLCache cache = SQLCache.getSQLCache();
		if (cache != null) {
			return cache.getValue(sql);
		}
		return null;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13

package nc.ui.bd.ref;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Vector;

import nc.bs.logging.Logger;
import nc.ui.dbcache.DBCacheEnv;
import nc.ui.dbcache.DBCacheFacade;
import nc.ui.dbcache.util.SqlTableParser;
import nc.vo.bd.ref.RefColumnDispConvertVO;
import nc.vo.bd.ref.RefQueryResultVO;
import nc.vo.bd.ref.RefQueryVO;
import nc.vo.bd.ref.RefcolumnVO;
import nc.vo.bd.ref.ReftableVO;
import nc.vo.logging.Debug;
import nc.vo.org.GroupVO;
import nc.vo.pub.BusinessException;
import nc.vo.pub.lang.UFBoolean;
import nc.vo.sm.UserVO;

public class RefModelHandlerForClient implements IRefModelHandler {

	private AbstractRefModel targetModel;

	/**
	 * AbstractRefModel 构造子注解。
	 */
	public RefModelHandlerForClient(AbstractRefModel targetModel) {
		super();
		this.targetModel = targetModel;
	}
	
	public RefModelHandlerForClient(){
		super();
	}

	/**
	 * 删除参照缓存数据
	 */
	public void clearCacheData() {
		RefCache.clearRefDataCache(targetModel.getRefDataCacheKey());
	}

	public void clearDataPowerCache() {
		SQLCache cache = SQLCache.getSQLCache();
		if (cache != null) {
			cache.remove(targetModel.getDataPowerSqlKey(targetModel
					.getTableName(), targetModel.getDataPowerColumn()));
		}
	}

	/**
	 * 获取缓存或数据库表中的参照数据－－二维Vector。
	 * 

	 * 最后修改人：sxj
	 * 

	 * 最后修改日期：2006-7-12
	 * 

	 * 
	 * @param
	 * @return Vector
	 * @exception BusinessException
	 * @since NC5.0
	 */
	public final Vector getRefData() {

		String sqlKey = targetModel.getRefCacheSqlKey();

		Vector v = null;
		boolean isDataFromCache = false;
		boolean isNeedPutToCache = false;
		if (targetModel.isCacheEnabled()) {
			/** 从缓存读数据 */
			v = RefCache.getFromCache(targetModel.getRefDataCacheKey(), sqlKey);
			/** 从数据库中读 */
			if (v == null) {

				v = targetModel.getData();
				if (v != null) {
					isNeedPutToCache = true;
				}

			} else {

				isDataFromCache = true;

			}

		} else {
			v = targetModel.getData();
			isDataFromCache = false;

		}
		if (v != null) {
			v = targetModel.getConvertedData1(isDataFromCache, v, true);
			// 放入缓存，因为转换数据时 v 会发生变化，所以要转换完数据格式后再加入缓存。
			if (targetModel.isCacheEnabled() && isNeedPutToCache) {
				RefCache
						.putToCache(targetModel.getRefDataCacheKey(), sqlKey, v);
			}
		}
		
		//按传入Pks过滤
		Vector filteredVecData = RefPubUtil.getFilterPKsVector(v, targetModel);
		
		return filteredVecData;
	}

	public Vector queryRefDataFromTemplateTable(String sql) {
		Vector v = null;
		// try {
		//
		// if (OrgnizeTypeVO.ZHUZHANG_TYPE
		// .equals(targetModel.getOrgTypeCode())) {
		// v = RefBO_Client.queryMainByTempTable(targetModel
		// .getDataSource(), sql, targetModel.getRefNodeName(),
		// targetModel.getPk_GlOrgBook(), targetModel.getPara());
		// } else {
		// v = RefBO_Client.queryMainByTempTable(targetModel
		// .getDataSource(), sql, targetModel.getRefNodeName(),
		// getPk_corp(), targetModel.getPara());
		// }
		//
		// } catch (Exception e) {
		// Debug.debug(e.getMessage(), e);
		// }

		return v;
	}

	/**
	 * 得到公司主键－－默认参照使用。 创建日期：(2001-8-17 11:17:03)
	 * 
	 * @return java.lang.String
	 */
	public String getPk_corp() {
		if (targetModel.m_strPk_corp != null) {
			return targetModel.m_strPk_corp;
		}
//		String pk_corp = RefContext.getInstance().getPk_corp();
		
		String pk_corp = getPk_group();
		// 登陆界面pk_corp会为null,给个默认值,用以保存栏目信息
		return pk_corp == null ? IRefConst.GROUPCORP : pk_corp;
	}

	// 通知前台缓存
	public void fireDBCache() {
		List<String> tables = null;
		try {
			//tables = SqlTableParser.getTables(targetModel.getRefSql());
			tables = getTables();
			if (tables != null) {
				for (String table : tables) {
					Logger.debug("参照开始刷新表:" + table);
					DBCacheFacade.refreshTable(table);
					Logger.debug("参照刷新表结束:" + table);
				}
			}
		} catch (Exception e) {
			Logger.debug("树、表参照刷新数据库表" + tables + "失败");
		}
	}
	
	private List<String> getTables() {
		List<String> tables = new ArrayList<String>();
		if (targetModel.getRefSql() != null
				&& SqlTableParser.getTables(targetModel.getRefSql()) != null)
			tables.addAll(SqlTableParser.getTables(targetModel.getRefSql()));
		if (targetModel instanceof AbstractRefTreeModel) {
			List<String> classTables = getClassTables();
			if (classTables != null && tables != null) {
				for (int i = 0; i < classTables.size(); i++) {
					if (!tables.contains(classTables.get(i))) {
						tables.add(classTables.get(i));
					}
				}
			}
		}
		return tables;
	}
	
	private List<String> getClassTables() {
		String classSql = ((AbstractRefTreeModel) targetModel).getClassRefSql();
		if (classSql == null)
			return null;
		return SqlTableParser.getTables(classSql);
	}

	/**
	 * 此处插入方法说明。 创建日期：(01-4-3 20:08:40)
	 * 
	 * @return java.util.Hashtable
	 * @param tableName
	 *            java.lang.String
	 */
	public Map getFieldCNName() {
		return BasDocFieldsRes.getInstance().getMap();
	}

	/**
	 * 添加列条件
	 * 
	 * @param iSelectFieldCount
	 * @param strSql
	 * @param strFieldCode
	 * @param hiddenFields
	 */
	public void addQueryColumn(int iSelectFieldCount, StringBuffer strSql,
			String[] strFieldCode, String[] hiddenFields) {
		for (int i = 0; i < iSelectFieldCount; i++) {
			strSql.append(strFieldCode[i]);
			if (i < iSelectFieldCount - 1)
				strSql.append(",");
		}
		// 加入隐藏字段
		if (hiddenFields != null && hiddenFields.length > 0) {
			for (int k = 0; k < hiddenFields.length; k++) {
				if (hiddenFields[k] != null
						&& hiddenFields[k].trim().length() > 0) {
					strSql.append(",");
					strSql.append(hiddenFields[k]);
				}
			}
		}
	}

	/**
	 * 过滤表名
	 * 
	 * @param column
	 * @return
	 */
	public String filterColumn(String column) {
		return column.substring(column.indexOf(".") + 1, column.length());
	}

	/**
	 * @param sqlBuffer
	 */
	public String addBlurWherePart() {
		// 处理模糊---但是不加入WherePart
		StringBuffer sqlBuffer = new StringBuffer();
		String[] toLowCasefieldNames = new String[targetModel.getBlurFields().length];
		for (int i = 0; i < toLowCasefieldNames.length; i++) {
			toLowCasefieldNames[i] = RefPubUtil.toLowerDBFunctionWrapper(
					targetModel, targetModel.getBlurFields()[i]);
		}

		if (RefPubUtil.isIncludeBlurChar(targetModel.getBlurValue())) {

			String value = targetModel.getBlurValue().replace('*', '%')
					.replace('?', '_');
			String blurSql = RefPubUtil.getCompositeSql(toLowCasefieldNames,
					RefPubUtil.toLowerCaseStr(targetModel, value), " like ",
					null, null, " or ");
			sqlBuffer.append(" and (");
			sqlBuffer.append(blurSql);

			sqlBuffer.append(")");
		} else { // 处理助记码检索为多条
			if (targetModel.isMnecodeInput()) {
				String blurSql = RefPubUtil.getCompositeSql(
						toLowCasefieldNames, RefPubUtil.toLowerCaseStr(
								targetModel, targetModel.getBlurValue()), "=",
						null, null, " or ");
				sqlBuffer.append(" and ( ").append(blurSql).append(" )");

			}
		}
		String blurSql = sqlBuffer.toString();
		return blurSql;
	}

	/*
	 * 
	 */
	public ReftableVO getRefTableVO(String pk_corp) {

		ReftableVO vo = null;
		String key = getReftableVOCacheKey(pk_corp);
		// 从缓存读
		Object obj = SQLCache.getSQLCache().getColumn(key);
		if (obj == null) {
			String refNodeName = targetModel.getRefNodeName();

			if (pk_corp == null) {
				pk_corp = getPk_corp();
			}
			try {
				obj = ReftableBO_Client.findByNode(refNodeName, pk_corp);
			} catch (Exception e) {
				Logger.debug(e);
				obj = SQLCache.NULLFLAG;
			}
		}
		if (obj instanceof ReftableVO) {
			vo = (ReftableVO) obj;
		}

		setReftableVO2Cache(vo, pk_corp);
		return vo;
	}

	/*
	 * 栏目信息数据放到缓存.
	 */
	public void setReftableVO2Cache(ReftableVO vo, String pk_org) {

		String key = getReftableVOCacheKey(pk_org);
		// 放到缓存中。
		if (vo != null) {
			SQLCache.getSQLCache().putColumns(key, vo);
		} else {
			SQLCache.getSQLCache().putColumns(key, SQLCache.NULLFLAG);
		}
	}

	public boolean isReftableVOCached(String pk_org) {

		// 从缓存读
		Object obj = SQLCache.getSQLCache().getColumn(
				getReftableVOCacheKey(pk_org));

		return obj != null;
	}

	public String getReftableVOCacheKey(String pk_org) {
		String refNodeName = targetModel.getRefNodeName();

		// if (OrgnizeTypeVO.ZHUZHANG_TYPE.equals(getOrgTypeCode())){
		// pk_org = getPk_GlOrgBook();
		// }else{
		// pk_org = getPk_corp();
		// }
		// 目前还是按当前登录公司来保存栏目信息,以后有需求可以加入对主体账簿的支持

		String key = refNodeName + pk_org;
		return key;
	}

	/**
	 * 

	 * 最后修改人：sxj
	 * 

	 * 最后修改日期：2006-5-18
	 * 

	 * 
	 * @param
	 * @return String
	 * @exception BusinessException
	 * @since NC5.0
	 */
	public String getFieldCodeWithTableName(String fieldCode) {
		if (fieldCode.indexOf(".") < 0) {
			fieldCode = RefPubUtil
					.getFirstTableName(targetModel.getTableName())
					+ "." + fieldCode;
		}
		return fieldCode;
	}

	public String getResID(String fieldCode) {
		String resid = null;
		fieldCode = getFieldCodeWithTableName(fieldCode);
		if (getFieldCNName() != null) {
			resid = (String) getFieldCNName().get(fieldCode);
		}

		return resid;
	}

	/**
	 * 

	 * 最后修改人：sxj
	 * 

	 * 最后修改日期：2006-5-17
	 * 

	 * 
	 * @param
	 * @return void
	 * @exception BusinessException
	 * @since NC5.0
	 */
	private RefValueVO getRefValueVO(Object originValue, Object newValue) {
		RefValueVO valueVO = new RefValueVO();
		valueVO.setOriginValue(originValue);
		valueVO.setNewValue(newValue);
		return valueVO;
	}

	/**
	 * @return 返回 m_pk_user。
	 */
	public String getPk_user() {
		try {
			Class c = Class.forName("nc.desktop.ui.WorkbenchEnvironment");

			Method m = c.getMethod("getInstance", null);
			Object o = m.invoke(null, null);
			Method m1 = c.getMethod("getLoginUser", null);
			UserVO userVO = (UserVO) m1.invoke(o, null);
			return userVO.getPrimaryKey();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			Logger.debug(e);
		}

		return null;

	}

	public boolean canUseDB() {
		return DBCacheEnv.isCacheEnabled();
	}

	public Vector getCacheValue(String sql) {
		SQLCache cache = SQLCache.getSQLCache();
		if (cache != null) {
			return cache.getValue(sql);
		}
		return null;
	}

	public Vector queryMain(String dsName, String sql) {
		try {
			return RefBO_Client.queryMain(dsName, sql,targetModel.isQueryFromServer());
		} catch (BusinessException e) {
			Logger.error(e);
		}
		return null;
	}

	public void removeCache(String sql) {
		SQLCache cache = SQLCache.getSQLCache();
		if (cache != null) {
			cache.remove(sql);
		}
	}

	public void setCacheValue(String sql, Vector value) {
		SQLCache cache = SQLCache.getSQLCache();
		if (cache != null) {
			cache.putValue(sql, value);
		}
	}

	public String getCodeRuleFromPara(String orgTypeCode, String pk_GlOrgBook,
			String codingRule, UFBoolean boolean1) {
		return RefPubUtil.getCodeRuleFromPara(orgTypeCode, pk_GlOrgBook,
				codingRule, boolean1);
	}

	public String getCodeRuleFromPara(String codingRule) {
		return RefPubUtil.getCodeRuleFromPara(codingRule, getPk_corp());
	}

	public String getNumberCodingRule(String codingRule) {
		return RefPubUtil.getNumberCodingRule(codingRule);
	}

	public String[] getDefFields(String[] fieldCode) {
		return RefPubUtil.getDefFields(fieldCode);
	}

	public String getWherePartByFieldsAndValues(String[] fields, String[] values) {
		String wherePart = "";
		StringBuffer sb = new StringBuffer();
		if (fields != null) {
			int length = fields.length;
			for (int i = 0; i < length; i++) {
				if (values.length == 1) {
					// =
					sb.append(fields[i]).append("='").append(values[0]).append(
							"' ");

				} else {
					// in

					sb.append(fields[i]).append(" in ").append(
							RefPubUtil.getInSubSql(values));

				}

				if (i == length - 1) {
					continue;
				}
				sb.append(" or ");

			}
		} else {
			return null;
		}

		wherePart = sb.toString();
		return wherePart;
	}

	public boolean isNonSqlMatch(String matchsql) {
		String refNodeName = targetModel.getRefNodeName();
		return matchsql == null || refNodeName != null
				&& RefPubUtil.isNonSqlMatchRef(refNodeName);
	}

	public Map<String, RefcolumnVO> getRefColumnVOsMap() {
		RefcolumnVO[] columnVOs = RefPubUtil
				.getColumnSequences(this.targetModel);
		Map<String, RefcolumnVO> map = new HashMap<String, RefcolumnVO>();

		for (int i = 0; i < columnVOs.length; i++) {

			map.put(columnVOs[i].getFieldname(), columnVOs[i]);
		}
		return map;
	}

	public String getRefNodeName_mLang(String refNodeName) {
		return RefPubUtil.getRefNodeName_mLang(refNodeName);
	}

	public String getRefMultiLangStr(String resid, String fieldCode) {
		return RefPubUtil.getRefMultiLangStr(resid, fieldCode);
	}

	public void putToCache(String refDataCacheKey, String sql, Vector data) {
		RefCache.putToCache(refDataCacheKey, sql, data);
	}

	public RefQueryResultVO queryRefdataByQueryVO(RefQueryVO queryVO) {
		RefQueryResultVO resultVO = null;

		try {
			resultVO = RefBO_Client.queryRefdataByQueryVO(queryVO,targetModel.isQueryFromServer());
		} catch (Exception e) {
			Logger.info(e);
		}
		return resultVO;
	}

	public RefQueryResultVO queryBlurRefdataByQueryVO(RefQueryVO queryVO) {
		RefQueryResultVO resultVO = null;

		try {
			resultVO = RefBO_Client.queryBlurRefdataByQueryVO(queryVO);
		} catch (Exception e) {
			Logger.info(e);
		}
		return resultVO;
	}

	public Vector matchPK(String dataSource, String matchsql) {
		try {
			return  RefPubUtil.getFilterPKsVector(RefBO_Client.matchPK(dataSource, matchsql,targetModel.isQueryFromServer()), targetModel);
		} catch (BusinessException e) {
			Debug.error(e.getMessage(), e);
		}
		return null;
	}

	public boolean equals(String m_fun_code, String m_fun_code2) {
		return RefPubUtil.equals(m_fun_code, m_fun_code2);
	}

	public Vector getFromCache(String refDataCacheKey, String sql) {
		return RefCache.getFromCache(refDataCacheKey, sql);
	}

	public String getDataPowerSubSql(String tableName, String dataPowerField,
			AbstractRefModel model, String resourceID) {
		return RefDataPowerHelper.getDataPowerSubSql(tableName,
				dataPowerField, model, resourceID);
	}

	public Vector setColDispValue(Vector vecData,
			RefColumnDispConvertVO convertVO, String className) {
		IRefColDispConverter converter = (IRefColDispConverter) getClassInstance(className);
		return converter.getDispConvertResult(convertVO);
	}

	private Object getClassInstance(String className) {
		Object clsInstance = null;
		try {
			Class cls = Class.forName(className);
			clsInstance = cls.newInstance();

		} catch (Exception e) {
			Logger.debug(e);

		}
		return clsInstance;
	}

	public String getPk_group() {

		try {
			Class c = Class.forName("nc.desktop.ui.WorkbenchEnvironment");

			Method m = c.getMethod("getInstance", null);
			Object o = m.invoke(null, null);
			Method m1 = c.getMethod("getGroupVO", null);
			GroupVO groupVO = (GroupVO) m1.invoke(o, null);
			if (groupVO != null)
				return groupVO.getPrimaryKey();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			Logger.debug(e);
		}
		return null;

	}

	public LRUMap<String, Vector> getLRUMap() {
		// TODO Auto-generated method stub
		return SQLCache.getSQLCache().getLRUMap();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621

package nc.ui.bd.ref;

import java.util.HashMap;
import java.util.Hashtable;
import java.util.LinkedList;
import java.util.Vector;
import nc.bs.logging.Logger;


/**
 * 此处插入类型说明。 创建日期：(01-6-18 17:32:58)
 * 
 * @author：童志杰 修改：张扬 1.新增clear方法 2.新增remove(String)方法
 */
public class SQLCache {
	private java.util.Hashtable ht;
	
	private java.util.HashMap recentRecordht;

	public static final String REFSQLCACHE_STRING = "ref223234";

	LinkedList mrulist = new LinkedList();

	public static final int DEFAULT_SIZE = 8003;

	int cacheSize = DEFAULT_SIZE;

	public static final String NULLFLAG = "null";

	private static SQLCache cache = new SQLCache();

	private LRUMap<String, Vector> lruMap = new LRUMap<String, Vector>(20);

	/**
	 * SQLCache 构造子注解。
	 */
	private SQLCache() {
		super();
	}

	/**
	 * 此处插入方法说明。 创建日期：(2001-7-25 17:02:55)
	 */
	public void clear() {
		//getRecentRecordht().clear();
		getHt().clear();
		getLRUMap().clear();
		if (mrulist != null)
			mrulist.clear();
		else
			mrulist = new LinkedList();
	}

	/**
	 * 此处插入方法说明。 创建日期：(01-6-18 17:41:48)
	 */
	public String get(String sql) {
		if (sql == null || sql.trim().length() == 0)
			return null;
		if (getSQLCache().getHt().containsKey(sql.trim())) {
			if (mrulist == null) {
				mrulist = new LinkedList();
			} else {
				try {
					mrulist.remove(sql.trim());
				} catch (Exception e) {
					Logger.debug(e);
				}
			}
			mrulist.addFirst(sql.trim());
			return (String) getSQLCache().getHt().get(sql.trim());
		} else
			return null;
	}

	public Object getObjectValue(String sql) {
		if (sql == null || sql.trim().length() == 0)
			return null;
		if (getSQLCache().getHt().containsKey(sql.trim())) {
			if (mrulist == null) {
				mrulist = new LinkedList();
			} else {
				mrulist.remove(sql.trim());
			}
			mrulist.addFirst(sql.trim());
			return getSQLCache().getHt().get(sql.trim());
		} else
			return null;
	}

	/**
	 * 此处插入方法说明。 创建日期：(01-6-18 17:41:48)
	 */
	public Object getColumn(String nodeCorpName) {
		if (nodeCorpName == null || nodeCorpName.trim().length() == 0)
			return null;
		if (getSQLCache().getHt().containsKey(nodeCorpName.trim())) {
			if (mrulist == null) {
				mrulist = new LinkedList();
			} else {
				mrulist.remove(nodeCorpName.trim());
			}
			mrulist.addFirst(nodeCorpName.trim());
			Object obj = getSQLCache().getHt().get(nodeCorpName.trim());
			return obj;
			// nc.vo.bd.ref.ReftableVO VO=null
			// return (nc.vo.bd.ref.ReftableVO)
			// getSQLCache().getHt().get(nodeCorpName.trim());
		} else
			return null;
	}

	/**
	 * 此处插入方法说明。 创建日期：(01-6-18 17:41:31)
	 * 
	 * @return java.util.Hashtable
	 */
	private java.util.Hashtable getHt() {
		if (ht == null)
			ht = new Hashtable();
		return ht;
	}

	/**
	 * 从环境变量获得SQLCache。 创建日期：(01-6-18 17:38:55)
	 */
	public static SQLCache getSQLCache() {
		// DesktopEnvironment ce = DesktopEnvironment.getInstance();
		// if (ce.getClientCache(REFSQLCACHE_STRING) == null) {
		// SQLCache cache = new SQLCache();
		// ce.putClientCache(REFSQLCACHE_STRING, cache);
		// }
		// return (SQLCache) ce.getClientCache(REFSQLCACHE_STRING);
		return cache;
	}

	/**
	 * 此处插入方法说明。 创建日期：(01-6-18 17:41:48)
	 */
	public Vector getValue(String sql) {
		if (sql == null || sql.trim().length() == 0)
			return null;
		if (getSQLCache().getHt().containsKey(sql.trim())) {
			if (mrulist == null) {
				mrulist = new LinkedList();
			} else {
				mrulist.remove(sql.trim());
			}
			mrulist.addFirst(sql.trim());
			return (Vector) getSQLCache().getHt().get(sql.trim());
		} else
			return null;
	}

	/**
	 * 把用户保存的参照栏目的信息缓存，区分公司
	 */
	public void putColumns(String nodeCorpName, Object obj) {
		if (nodeCorpName == null || obj == null)
			return;
		// synchronized (getSQLCache().getHt()) {
		if (nodeCorpName != null && obj != null) {
			if (mrulist == null) {
				mrulist = new LinkedList();
			} else if (mrulist.size() >= cacheSize) {
				getSQLCache().getHt().remove(mrulist.getLast());
				mrulist.removeLast();
			}
			getSQLCache().getHt().put(nodeCorpName.trim(), obj);
			mrulist.addFirst(nodeCorpName.trim());
		}
		// }
		return;
	}

	/**
	 * 把数据权限的Sql 语句缓存，解决参照取得数据时，每次都要都要调用数据权限接口。
	 */
	public void putValue(String sql, Object dataPowerSql) {
		if (sql == null || sql.trim().length() == 0 || dataPowerSql == null)
			return;
		// synchronized (getSQLCache().getHt()) {
		if (sql != null && dataPowerSql != null) {
			if (mrulist == null) {
				mrulist = new LinkedList();
			} else if (mrulist.size() >= cacheSize) {
				getSQLCache().getHt().remove(mrulist.getLast());
				mrulist.removeLast();
			}
			getSQLCache().getHt().put(sql.trim(), dataPowerSql);
			mrulist.addFirst(sql.trim());
		}
		// }
		return;
	}

	/**
	 * 此处插入方法说明。 创建日期：(01-6-18 17:41:48)
	 */
	public void putValue(String sql, Vector v) {
		if (sql == null || sql.trim().length() == 0 || v == null)
			return;
		// synchronized (getSQLCache().getHt()) {
		if (sql != null && v != null) {
			if (mrulist == null) {
				mrulist = new LinkedList();
			} else if (mrulist.size() >= cacheSize) {
				getSQLCache().getHt().remove(mrulist.getLast());
				mrulist.removeLast();
			}
			getSQLCache().getHt().put(sql.trim(), v);
			mrulist.addFirst(sql.trim());
		}
		// }
		return;
	}

	/**
	 * 此处插入方法说明。 创建日期：(2001-7-25 17:01:00)
	 * 
	 * @param sql
	 *            java.lang.String
	 */
	public void remove(String sql) {
		if (sql != null) {
			getSQLCache().getHt().remove(sql.trim());
			if (mrulist == null) {
				mrulist = new LinkedList();
			} else {
				try {
					mrulist.remove(sql.trim());
				} catch (Exception e) {
					Logger.debug(e);
				}

			}
		}
	}

	public HashMap getRefDataValue(String key) {
		if (key == null || key.trim().length() == 0)
			return null;
		if (getSQLCache().getHt().containsKey(key.trim())) {
			if (mrulist == null) {
				mrulist = new LinkedList();
			} else {
				mrulist.remove(key.trim());
			}
			mrulist.addFirst(key.trim());
			return (HashMap) getSQLCache().getHt().get(key.trim());
		} else
			return null;
	}

	/**
	 * 
	 */
	public void putValue(String key, HashMap hm) {
		if (key == null || key.trim().length() == 0 || hm == null)
			return;

		if (mrulist == null) {
			mrulist = new LinkedList();
		} else if (mrulist.size() >= cacheSize) {
			getSQLCache().getHt().remove(mrulist.getLast());
			mrulist.removeLast();
		}
		getSQLCache().getHt().put(key, hm);
		mrulist.addFirst(key);

		return;
	}

	public LRUMap<String, Vector> getLRUMap() {
		return lruMap;
	}



	public java.util.HashMap getRecentRecordht() {
		if (recentRecordht == null)
			recentRecordht = new HashMap();
		return recentRecordht;
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287

package nc.ui.bd.ref;

import java.io.Serializable;
import java.util.LinkedHashMap;
import java.util.Map;

public class LRUMap<K, V> extends LinkedHashMap<K, V> implements Cloneable,
		Serializable {
	private static final long serialVersionUID = 1L;

	private int lruSize = 500;

	public LRUMap(int initSize) {
		super(initSize, 1f, true);
		this.lruSize = initSize;
	}

	@Override
	protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
		if (size() > lruSize)
			return true;
		else
			return false;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26