nms-nmsserver/src/com/nms/server/thread/detecData/NewDetecDataResoveThread.java

package com.nms.server.thread.detecData;

import java.io.File;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.ConcurrentModificationException;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.Callable;

import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;

import com.nms.server.bean.DetectInfo;
import com.nms.server.bean.EmailInfo;
import com.nms.server.bean.TableColumnsModel;
import com.nms.server.common.Common;
import com.nms.server.common.Constants;
import com.nms.server.common.EmailTypeConstants;
import com.nms.server.dao.CommonDao;
import com.nms.server.service.CommonService;
import com.nms.server.thread.socket.SSLClient;
import com.nms.server.util.CSVUtils;
import com.nms.server.util.FileUtils;
import com.nms.server.util.StringUtil;

/**
 * CSV解析线程
 * @author ZGGG3
 * 
 */ 
public class NewDetecDataResoveThread implements Callable<Object> {
	Logger logger = Logger.getLogger(NewDetecDataResoveThread.class);
	volatile boolean stop = false;//线程是否被取消标志
	private String name; // 自定义Thread Name
	private LinkedList<byte []> dsbList;
	private SimpleDateFormat format2 = new SimpleDateFormat(Constants.COMMON_DATE_FORMAT);		//Java Date 类型数据格式化格式
	
	private long infoId = -1;
	private long currentId = -1;
	private long interval = -1;
	private int warnResumeNum = 0;
	private PreparedStatement infoNewInsertStmt;
	private PreparedStatement infoNewUpdateStmt;
	private List<Object[]> insertDataTonew;
	private List<Object[]> updateDataTonew;
	private PreparedStatement warnUpdateStmt;
	public NewDetecDataResoveThread(String name,LinkedList<byte []> dsbList) {
		this.name = name;
		this.dsbList = dsbList;
	}

	/*
	 * 线程操作
	 * 
	 * 依次解析urlList中仍存在的Files
	 * 
	 * 实现了依次解析Files，由于后期实现多线程解析操作
	 */
	public Object call() {
		// 为当前线程命名 ，用与开发阶段友好输出。
		Thread.currentThread().setName(name +"-"+System.currentTimeMillis());
		logger.info("配置文件设置批量入库监测数据条数："+ Constants.DETECTION_INFO_DATA_MAX_ROWS);
		CommonDao dao = null;
		try {
			dao = new CommonDao();
			CommonService service = new CommonService(dao);
			 
			//-- 空数据集合 结束操作
			if(dsbList == null || dsbList.size() == 0 ){
				logger.debug("缓存监测数据 为空，无需解析");
				return null;
			}
			
			//用于判断网络端口			
			long eNewTime = System.currentTimeMillis();
			Map<String,List<String>> allPortName= service.getAllPortName();//之后如果数据大了，影响性能了，可以改成获取一个seqid的数据和一个端口的list，查询seqid，得到下标，再从list中获取信息，目前先暂时不改
			long portTime = System.currentTimeMillis()-eNewTime;
			int portTimeM=(int)portTime/1000/60;
			int portTimeS=(int)((long)(portTime/1000)%60);
			int portTimeMS=(int)portTime%1000;
			logger.info("第零步：获取端口表的所有数据，总耗时："+(portTimeM)+"分 "+(portTimeS)+"秒 "+(portTimeMS)+"毫秒");
			
			
			logger.debug("缓存监测数据 " + (dsbList.size())+ "条，解析开始");
			
			//-- 遍历解析
			Iterator<byte []> dsbIte = dsbList.iterator();
			int totalCount = dsbList.size();
			int successCount=0;
			int falseCount = 0;
			int zeroByteCount = 0;
			
			int count = 1;
			int resoveCount=1;
			int allResove = 0;
			int allSuccess = 0;
			int allFail = 0;
			int allZero = 0;
			/*
			 * 第一步：解析所有数据
			 * 	新格式数据，旧格式同一放入	newDataMap 集合
			 */
			//存放解析之后的数据：[["systemdate",["5",["1602",[{detectInfo1,detectInfo2,...}]],...],...],...]
			List<List<Object>> dataList = new LinkedList<List<Object>>();
			long sTime = System.currentTimeMillis();				
			while (dsbIte.hasNext()&& !stop) {//线程未被中断
				/* 单条解析异常捕捉处理 */
				byte [] dsb = null;
				try {
					dsb = dsbIte.next();
					/* 零字节文件记录和过滤 */
					if (dsb != null && dsb.length > 0) {
						/* 解析非0字节文件内容 */
						List<String []> strsList = CSVUtils.csvBytesParser(dsb,Constants.COMMON_TEXT_CODING);
						/* 新旧解析格式判断 */
						/**
						 * 新旧解析格式区别：
						 * 区别：第一行基本信息数据 新格式12列固定比旧格式至少15列
						 *  */
						if(strsList!=null && strsList.size()>0){	//多行数据判断
							Object[] detecInfo = null;
							String [] detailsStr = strsList.get(0);	//取第一行数据

							if(detailsStr != null){
								if(detailsStr.length > 12){//旧格式 解析
									logger.debug("旧格式数据");
									detecInfo = service.resoveOldData(strsList,allPortName);//解析数据，不判断状态变更
								}else if(detailsStr.length<12){
									logger.debug( "基本数据解析长度："+detailsStr.length+" 小于最小解析标准，不予解析；");
								}else{//新格式 解析
									logger.debug("新格式数据");
									detecInfo = service.resoveNewData(strsList,allPortName);//解析数据，不判断状态变更
								}
							}
							
							//将解析之后的数据放入集合,不为空说明解析成功
							if(detecInfo != null){
								successCount++;//成功解析
								detecAddToList(dataList, detecInfo);
							}else{
								falseCount ++;//解析失败								
								String filePath = getFilePath();//Constants.ERROR_DETEC_FILE_DIR+"/"+Common.getDateDirName()+"/"+Calendar.getInstance().getTimeInMillis()+".csv";
								logger.error("Abnormal monitoring data format，file has been saved to "+filePath);
								FileUtils.wirteBytesToFile(dsb, filePath);
							}
						}
					}else{
						zeroByteCount++;
					}
					
					//解析入库一条数据，从list中remove一条数据
					dsbIte.remove();
					//判断当前线程是否被中断
					if (Thread.currentThread().isInterrupted()) {
						// 线程中断状态，不会改变中断状态的值
						logger.info("监测数据解析线程 被中断");
						stop = true;//如果中断执行（重启、或者升级），就停止解析数据，之后将数据入库
					}
				}catch (InterruptedException e) {
					logger.error("Monitoring data parsing threads are interrupted",e);
					stop = true;
					
				}catch (ConcurrentModificationException e) {
					logger.debug("获取下一条监测数据 异常 停止本轮解析!",e);
					stop = true;//由于获取next的时候出错，之后的都出错了就，所以此处stop=true，停止循环
				}catch (Exception e) {
					logger.debug("一条监测数据解析失败!",e);
				}
				
				if(count%Constants.BATCH_RESOVE_COUNT==0||stop||count==totalCount){
					long resoveCurTime = System.currentTimeMillis();
					long resoveTime = resoveCurTime-sTime;
					int resoveTimeM=(int)resoveTime/1000/60;
					int resoveTimeS=(int)((long)(resoveTime/1000)%60);
					int resoveTimeMS=(int)resoveTime%1000;
					logger.info("第一步：解析完毕，共:"+(resoveCount)+"条[成功:"+successCount+"条,失败:"+falseCount+"条,空数据:"+zeroByteCount+"条]"
						     +" 总耗时："+(resoveTimeM)+"分 "+(resoveTimeS)+"秒 "+(resoveTimeMS)+"毫秒");
					insertDataTonew=new ArrayList<Object[]>();
					updateDataTonew=new ArrayList<Object[]>();
					warnUpdateStmt=dao.getConn().prepareStatement(DetectInfo.getChangeWarningInfoSql());
					judgeStateAndSave(dataList,sTime,resoveCount,successCount,falseCount,zeroByteCount,service, dao);
					dataList.clear();
					allResove = allResove + resoveCount;
					allSuccess = allSuccess+ successCount;
					allFail = allFail + falseCount;
					allZero = allZero + zeroByteCount;
					warnResumeNum = 0;
					resoveCount=0;
					successCount=0;
					falseCount=0;
					zeroByteCount=0;
				}
				resoveCount++;
				count++;
			}
			dsbList.clear();		
			
			//将监测数据入库后，需要检查新入库的数据是否为无效（处理监测数据的有效性标志）
			long startUpdateTime = System.currentTimeMillis();
			updateDetectDataValid(dao);
			long updateCurTime = System.currentTimeMillis()-startUpdateTime;
			int updateCurTimeM=(int)updateCurTime/1000/60;
			int updateCurTimeS=(int)((long)(updateCurTime/1000)%60);
			int updateCurTimeMS=(int)updateCurTime%1000;
			logger.info("第四步：更新监测数据有效性完毕，总耗时："+(updateCurTimeM)+"分 "+(updateCurTimeS)+"秒 "+(updateCurTimeMS)+"毫秒");
			
			
			long eTime = System.currentTimeMillis();
			long curTime = eTime-sTime;
			int m=(int)curTime/1000/60;
			int s=(int)((long)(curTime/1000)%60);
			int ms=(int)curTime%1000;
			logger.info("第一到四步，整体解析批量入库监测数据全过程执行完毕，共:"+(allResove)+"条[成功:"+allSuccess+"条,失败:"+allFail+"条,空数据:"+allZero+"条]"
				     +" 总耗时："+(m)+"分 "+(s)+"秒 "+(ms)+"毫秒");

		} catch (Exception e) {
			logger.error("Running exception",e);
		}finally{
			dao.closeCommonBatchStatement();
			dao.closeDetailBatchStatement();
			if(dao!=null){
				dao.close();
				dao=null;
			}
			//1：由web 主控控制入库
			if(Constants.DETECT_INSERT_MODE == 1 ||Constants.DETECT_INSERT_MODE == 3){
				//入库完成，通知web 主控释放锁
				SSLClient.sengReleaseDetect();
			}
			logger.debug("数据清理 解析完成");
		}		
		return null;
	}
	
	
	public void judgeStateAndSave(List<List<Object>> dataList,long sTime, int resoveCount, int successCount, int falseCount, int zeroByteCount, CommonService service,CommonDao dao) throws Exception{
		/**
		 * 第二步：判断监测状态变更
		 */
		long resoveCurTime = System.currentTimeMillis();
		if(dataList != null && dataList.size() >0){
			for(List<Object> checkTypeList : dataList){
				int checkTypeSize =  checkTypeList.size();
				for(int i = 1,j =checkTypeSize; i < j; i ++){
					List<Object> setIdList = (List<Object>) checkTypeList.get(i);
					String setId = (String) setIdList.get(0);//监测设置id
					
					List<Object[]> detectionInfoNewData = null;
					List<String> seqList = new ArrayList<String>();
					int setIdSize = setIdList.size();
					/**
					 * 2017年1月9日11:15:21 新增 添加过滤条件查询new表数据（只查询当前解析数据seqid的new表数据）
					 */
					for(int h = 1;h<setIdSize;h++){
						List<Object> seqIdList = (List<Object>) setIdList.get(h);
 						String seqId = (String) seqIdList.get(0);//seqId
						seqList.add(seqId);
					}
					/**以上*/
					
					//获取new表中对应监测设置的监测数据
					detectionInfoNewData = service.getDetectionInfoNewListBySet(setId,seqList);
					for(int ii = 1; ii < setIdSize ; ii ++){
						List<Object> seqIdList = (List<Object>) setIdList.get(ii);
						String seqId = (String) seqIdList.get(0);//seqId
						List<Object[]> allDeteInfo = (List<Object[]>) seqIdList.get(1);
						if(allDeteInfo != null && allDeteInfo.size() > 0){
							//detection_info_new中的 最新监测数据
							Object[] oldDetecInfo = null;
							if(detectionInfoNewData != null){//detectionInfoNewData:监测设置--节点--监测信息
								oldDetecInfo = service.getIndexObj(seqList, seqId,detectionInfoNewData);
							}else{
								oldDetecInfo = null;
							}
							//数据库中没有当前监测类别对应的seqid节点的监测信息，不需要判断状态变更
							if(oldDetecInfo != null){
								if(allDeteInfo.size() <2 ){//只有一条数据直接比较数据库中的数据
									//只有一条最新监测
									Object[] newDetecInfo = allDeteInfo.get(0);
									
									int state = (Integer) newDetecInfo[DetectInfo.STATE];
									/*
									 * 入库数据不是延时数据时，与数据库中的最新数据比对判断状态变更
									 * 数据库中的监测时间小于当前需要入库的监测时间
									 */
									if((Long)oldDetecInfo[DetectInfo.CHECKTIME] < (Long)newDetecInfo[DetectInfo.CHECKTIME]){
										/*判断状态变更*/
										stateChange(newDetecInfo, oldDetecInfo);
									}else{//监测时间小于数据库中监测数据的时间，说明当前需要入库的监测为延迟数据
										if(state != 1){//延迟数据监测状态没有成功，数据库入库的是正常数据，补录一条报警信息
											if((Integer) newDetecInfo[DetectInfo.STATE] == 1 && (Integer)oldDetecInfo[DetectInfo.PLEVEL] == 99){
												newDetecInfo[DetectInfo.APPENDWARNINGINFO]= oldDetecInfo;
												warnResumeNum++;
											}
										}
									}
								}else{//大于两条数据时，排序之后判断数据库的数据是否为最接近的时间数据
									//未入库的数据排序
									Collections.sort(allDeteInfo, new Comparator<Object[]>() {
										@Override
										public int compare(Object[] o1,
												Object[] o2) {
											Long time1 = (Long) o1[DetectInfo.CHECKTIME];
											Long time2 = (Long) o2[DetectInfo.CHECKTIME];
											return time1 < time2 ? -1 : 1;
										}
									});
									/*判断状态变更*/
									judgeState(allDeteInfo, oldDetecInfo);	
								}
								judgeAndCollect(allDeteInfo, oldDetecInfo, updateDataTonew,service);
							}else{//如果new表中没有数据，应为detection_info status_change_time设置初始值-->data_check_time
								if(allDeteInfo!=null&&allDeteInfo.size()>0){
									for (Object[] newInfo : allDeteInfo) {
										if(newInfo[DetectInfo.STATUSCHANGTIME]==null||(Long)newInfo[DetectInfo.STATUSCHANGTIME]==-1){
											newInfo[DetectInfo.STATUSCHANGTIME]=
													newInfo[DetectInfo.CHECKTIME]==null?newInfo[DetectInfo.STARTTIME]:newInfo[DetectInfo.CHECKTIME];
										}
									}
									insertDataTonew.addAll(allDeteInfo);
									
								}
							}
						}
					}
					//清理内存
					detectionInfoNewData.clear();
					detectionInfoNewData = null;
				}
			}
		}
		long stateCurTime = System.currentTimeMillis();
		long stateCheckTime = stateCurTime-resoveCurTime;
		int stateCheckM=(int)stateCheckTime/1000/60;
		int stateCheckS=(int)((long)(stateCheckTime/1000)%60);
		int stateCheck=(int)stateCheckTime%1000;
		logger.info("第二步：判断监测状态变更完毕（只针对解析成功的），共:"+resoveCount+"条  总耗时："+(stateCheckM)+"分 "+(stateCheckS)+"秒 "+(stateCheck)+"毫秒");
		logger.info("          第二步-1： 补录告警恢复告警信息："+warnResumeNum+"条");
		
		/**
		 * 第三步：批量入库
		 */
		//判断入库标示
		if(Constants.FLAG_RESOVE_COMMIT_DB != 1){
			String s = "file.resove.commitDB.flag 不为1,数据不可保存，请检查配置文件";
			logger.warn(s);
	//		return null;
			return ;
		}
		int failBatchInsert=0;
		String failBatchInsertCheckType = "";//批量入库失败的监测类别信息
		if(dataList != null && dataList.size() >0){
			int infoCount = 0;
			int detailCount = 0;
			int sysinfoCount = 0;
			int warnningCount = 0;
			int statusChange = 0;
			int emailCount = 0;
			//监测设置对应的联系人email地址
			Map<String,List<String>> setInfoEmail = null;
			//未指定的监测设置通过seqid找到对应的联系人
			Map<String,List<String>> seqIdEmail = null;
//			List<String> logList = new ArrayList<String>();
			dao.setAutoCommit(false);
			LinkedList<byte []> dsbBatchList = new LinkedList<byte[]>();//用于批量入库后是否将监测数据存入硬盘的overrun	:每次入库，或者存硬盘都需要清空此列表	
			
			//迭代器遍历，方便删除数据
			Iterator<List<Object>> iteDataList =  dataList.iterator();
			while(iteDataList.hasNext()){
				List<Object> checkTypeList = iteDataList.next();//["cpu",["1",["1602",[{detecAllInfo}]]]],
				String checkType = (String) checkTypeList.get(0);//监测类型
				
				int checkTypeRecordNum=0;//每种监测类别入库的记录数
				String insertDetailSql = null;//插入详细参数
				List<String> fieldNames = new ArrayList<String>();//detail表的字段名
				//详细信息对应的表名
				String detailTableName = Common.getInsertTable().get(checkType) == null ? null : Common.getInsertTable().get(checkType).getTableName();
				if(detailTableName == null){
					logger.error(checkType + " the corresponding detailed table was not found and the data could not be stored");
					continue;
				}
				String seqId = null;
				
				Iterator<Object> checkIte = checkTypeList.iterator();
				boolean firstKey1 = true;
				while(checkIte.hasNext()){
					if(firstKey1){
						checkIte.next();
						firstKey1 = false;
					}else{
						List<Object> setIdList = (List<Object>) checkIte.next();//["1",["1602",[{detecAllInfo}]]]
						String setInfoId = (String) setIdList.get(0);//监测设置id
						Iterator<Object> setIte = setIdList.iterator();
						boolean firstKey2 = true;
						while(setIte.hasNext()){
							if(firstKey2){
								firstKey2 = false;
								setIte.next();
							}else{
								List<Object> seqIdList = (List<Object>) setIte.next();//["1602",[{detecAllInfo,detecAllInfo}]]
								seqId = (String) seqIdList.get(0);//seqid
								List<Object[]> detecDatas = (List<Object[]>) seqIdList.get(1);//{detecAllInfo,detecAllInfo}
								Iterator<Object[]> detecIte =  detecDatas.iterator();
								
								long statusChangeTime = -1;//状态变更时间
								while(detecIte.hasNext()){
									Object[] temInfo = detecIte.next();
									//将解析之后的数据还原
									byte[] dsb = objectToString(temInfo);
									//将还原之后的数据缓存，出现异常时保存到文件
									dsbBatchList.add(dsb);
									if(temInfo != null){
										// 计算 详细表的 外键 时间戳（10） + seqId（5）+ setId (3)，主要是为了使用 java 中long 类型
										String checkTime = temInfo[DetectInfo.CHECKTIME].toString();
										String setId = temInfo[DetectInfo.SETINFOID].toString();
										String seqid = temInfo[DetectInfo.SEQID].toString();
										String id = DetectInfo.computeId(checkTime, seqId, setId);
//										currentId = getSequenceId(service);
										currentId = Long.parseLong(id);
										//addbatch
										service.addInfoStmt(currentId,temInfo);
										
										infoCount ++;
										logger.debug(" detection_info表id:" + currentId + ",监测类别：" + checkType +",监测设置id：" + setInfoId + ",seqId：" + seqId);
										//添加详细信息
										if((Boolean) temInfo[DetectInfo.DELYFLAG]){
											//当delyFlag 为false时 不插入详细信息
											List<Map<String,String>> details = (List<Map<String, String>>) temInfo[DetectInfo.DETAILS];
											if(details!= null && details.size()>0 ){
												for(Map<String,String> tempMap :details){
													//首先组织sql语句
													if(insertDetailSql == null || "".equals(insertDetailSql)){
														//组织detail表的insert语句
														insertDetailSql = createDetailSql(fieldNames,detailTableName,tempMap);
														logger.debug("监测设置id: " + setInfoId +" ,detail表插入语句:" + insertDetailSql);
													}
													dao.setDetailVals(insertDetailSql,fieldNames,tempMap,currentId,detailTableName);
													checkTypeRecordNum++;
													detailCount ++;
												}
											}
										}
										//特殊格式追加信息
										if(Constants.DETEC_SYSTEMINFO_STR.equalsIgnoreCase(checkType) ){
											List<String[]> diskInfoList = (List<String[]>) temInfo[DetectInfo.DISKINFOLIST];
											List<String[]> netInfoList = (List<String[]>) temInfo[DetectInfo.NETINFOLIST];
											if(diskInfoList != null && diskInfoList.size() > 0){//disk
												for(String[] temDiskInfo : diskInfoList){
													if(temDiskInfo != null && temDiskInfo.length >7){
														service.addDiskStmt(currentId,temDiskInfo);
														sysinfoCount ++;
													}
												}
											}
											if(netInfoList != null && netInfoList.size() > 0){//net
												for(String[] temNetInfo : netInfoList){
													if(temNetInfo != null && temNetInfo.length >7){
														service.addNetStmt(currentId,temNetInfo);
														sysinfoCount ++;
													}
												}
											}
										}
										
										//添加告警信息:告警信息=状态异常+状态改变+推迟入库的
										if((Integer)temInfo[DetectInfo.STATE] != 1 || (Boolean)temInfo[DetectInfo.STATECHANGEFLAG]){
											service.addWarningStmt(currentId +"",temInfo);
//											logList.addAll(generateLog(dsb,"          第三步-1： 添加一条告警信息,状态发生变更或者数据异常!state="+temInfo[DetectInfo.STATE]+",isChange="+(Boolean)temInfo[DetectInfo.STATECHANGEFLAG]));
											warnningCount ++;
										}
										//延迟监测数据追加告警信息
										if(temInfo[DetectInfo.APPENDWARNINGINFO] != null){
											Object[] warningInfo = (Object[]) temInfo[DetectInfo.APPENDWARNINGINFO];
											service.addWarningStmt((String)warningInfo[DetectInfo.DETECTIONINFOID],warningInfo);
//											logList.addAll(generateLog(dsb,"          第三步-1： 追加一条延迟数据的告警信息!"));
											warnningCount ++;
										}
										//添加邮件信息
										if(Constants.flag_email != 1){
											logger.info("邮件功能已关闭");
										}else{
											if((Boolean) temInfo[DetectInfo.SENDEMAILFLAG]){
												EmailInfo emailInfo = (EmailInfo) temInfo[DetectInfo.EMAILINFO];
												if(emailInfo != null){
													if(setInfoEmail == null){
														setInfoEmail = service.getDetecSetEmailListOf123();
													}
													if(seqIdEmail == null){
														seqIdEmail = service.getDetecEmailListOf4();
													}
													if((setInfoEmail == null || setInfoEmail.size() == 0) && (seqIdEmail == null || seqIdEmail.size() == 0)){
														logger.debug("未找到邮件地址！");
													}else{
														List<String> emailAddress = null;
														//1.首先通过监测设置的map中查找
														if(setInfoEmail != null){
															emailAddress = setInfoEmail.get(setInfoId);
														}
														if(emailAddress == null){
															emailAddress = seqIdEmail.get(seqId);
														}
														if(emailAddress != null && emailAddress.size() >0){
															for(String tempAddress : emailAddress){
																if(StringUtils.isNotEmpty(tempAddress)){
																    emailCount ++;
																	//addbatch
																	service.addEmailStmt(emailInfo,tempAddress);
																}
															}
														}
													}
												}
											}
										}
										
										/*判断状态变更时间的最大时间，用于更新new表
											当监测类型为 nmsclient 时，比较多条相同监测节点数据的状态变更时间，取最大的一个
										*/
										if(checkType.equalsIgnoreCase(Constants.DETEC_NMSC_STR)){
											long temChangeTime = (Long) temInfo[DetectInfo.STATUSCHANGTIME];
											if(temChangeTime > 0 ){
												if(temChangeTime > statusChangeTime){
													statusChangeTime = temChangeTime;
												}
											}
										}
									}
									//dsbBatchList.add((byte[]) temInfo[27]);
									//判断infoStmt的数量是否达到最大入库条数
									/*if(infoCount != 0 && infoCount % Constants.DETECTION_INFO_DATA_MAX_ROWS == 0){
										int dataLen = dsbBatchList.size();
										try {
											//执行批处理
											dao.executeBatchAllStmt(false);
											//提交事务
											dao.commit();
										} catch (SQLException e){
											dao.rollback();
											handleException(dsbBatchList, e);
											failBatchInsert = failBatchInsert + dataLen;
											failBatchInsertCheckType = failBatchInsertCheckType + checkType+"  ";
										}catch (Exception e) {
											logger.error("批处理保存失败,数据库错误，共"+dataLen+"条",e);
											dao.rollback();
											
											//批量入库失败以后，要将失败的监测数据存到硬盘的overrun里，以备下次进行再次入库
											Common.saveByteToFile(dsbBatchList);
											failBatchInsert = failBatchInsert + dataLen;
											failBatchInsertCheckType = failBatchInsertCheckType + checkType+"  ";
										}
										dsbBatchList.clear();
									}*/
									detecIte.remove();//删除，内存优化
								}
								/*
								 * 更新状态变更时间
								 * 只有当监测类型：nmsclient 时，statusChangeTime才会大于0
								 */
								if(statusChangeTime > 0){
									service.addStateChangeStmt(statusChangeTime,seqId);
									statusChange++;
									logger.info("状态变更详细信息：seqId="+seqId+" changeTime="+statusChangeTime);
								}
							}
							setIte.remove();//删除监测设置	
						}
					}
					checkIte.remove();//删除监测设置，内存优化
				}
				iteDataList.remove();//删除监测类型，内存优化
				
				int dataLastLen = dsbBatchList.size();
				try{
					//执行批处理
					dao.executeBatchAllStmt(true);
					service.saveToNew(insertDataTonew, 0, infoNewInsertStmt);
					service.saveToNew(updateDataTonew, 1, infoNewUpdateStmt);
					warnUpdateStmt.executeBatch();
					//提交事务
					dao.commit();							
				}catch (SQLException e){
					logger.error("",e);
					dao.rollback();
					handleException(dsbBatchList, e);
					failBatchInsert = failBatchInsert + dataLastLen;
					failBatchInsertCheckType = failBatchInsertCheckType + checkType+"  ";
				}catch(Exception e){
					logger.error("Batch save failed, database error, total"+dsbBatchList.size(),e);
					dao.rollback();
					//批量入库失败以后，要将失败的监测数据存到硬盘的overrun里，以备下次进行再次入库
					logger.error("Monitoring data batch storage, database error, the file has been saved to the hard disk.");
					Common.saveByteToFile(dsbBatchList);
					failBatchInsert = failBatchInsert + dataLastLen;
					failBatchInsertCheckType = failBatchInsertCheckType + checkType+"  ";
				}finally{
					//关闭stmt：此处逻辑不太顺，最后会有一个对dao的整体的关闭，但是本线程中使用的都是自己定义的preparedstatement，不够统一
					dao.closeDetailBatchStatement();
					dsbBatchList.clear();
				}
//				logList.add("          第三步-1： 监测类型：" + checkType +" ，批量入库结束，记录数： "+checkTypeRecordNum);
				
			}
			long endTime = System.currentTimeMillis();
			long curTime = endTime-stateCurTime;
			int m=(int)curTime/1000/60;
			int s=(int)((long)(curTime/1000)%60);
			int ms=(int)curTime%1000;
//			logList.add("          第三步-1： 共"+dataList.size()+" 种详细信息 " );
//			logList.add("          第三步-1： new表状态变更 共"+statusChange+" 条 " );
			logger.info("第三步：批量保存入库完毕（只针对解析成功的），共:"+(dataList.size())+"条[共插入detection_info表： " + infoCount +" 条，detail表： " + detailCount +" 条，特殊追加信息： " +  sysinfoCount +" 条，warning 表： " +warnningCount +" 条。]"
				      +" 总耗时："+(m)+"分 "+(s)+"秒 "+(ms)+"毫秒,批量入库失败记录数："+failBatchInsert+"  具体"+failBatchInsertCheckType);
//			printLogs(logList);
		}
		
	}

	public void handleException(LinkedList<byte[]> dsbBatchList,
			SQLException e) {
		try
		{
			//如果数据过错误是：1、ORA-01861：文字与格式字符串不匹配  
			//	（一般情况下）     2、ORA-01400：不能将空值插入 3、ORA-01722：无效数字 
			//				   4、ORA-00351：时间无效
			//				   5、ORA-01401: 插入的值过大
			//	 属于文件内容的错误所以保存到 错误文件夹中
			
			int size = dsbBatchList.size();
			if(e.getMessage().indexOf("ORA-01722")>=0 
					|| e.getMessage().indexOf("ORA-01400")>=0 
					|| e.getMessage().indexOf("ORA-01401")>=0 
					|| e.getMessage().indexOf("ORA-01861")>=0
					|| e.getMessage().indexOf("ORA-00351")>=0){
				logger.error("Monitoring data batch storage：Monitor data format exception，a total of"+size+"，the file has been saved to "+getParentDirPath(),e);
				for(int j=0;j<size;j++) {
					byte[] data= dsbBatchList.get(0);//因为每次循环都会dataList.remove(0);所以每次操作的都是第0条记录
					FileUtils.wirteBytesToFile(data, getFilePath());
				}
			}else{									
				//批量入库失败以后，要将失败的监测数据存到硬盘的overrun里，以备下次进行再次入库
				logger.error("Monitoring data batch storage, database error,a total of "+size+",the file has been saved to the hard disk.",e);
				Common.saveByteToFile(dsbBatchList);
			}
			
		} catch (Exception e2)
		{
			logger.error("Batch storage of hard disk abnormal after batch storage of abnormal monitoring data",e2);
		}
	}


	/**
	 * 1.将解析之后的对象放进list
	 * 2.设置默认值
	 * @param dataList
	 * @param detecInfo
	 */
	public void detecAddToList(List<List<Object>> dataList,Object[] detecInfo){
		String checkType = (String) detecInfo[DetectInfo.CHECKTYPE];
		String setInfoId = (String) detecInfo[DetectInfo.SETINFOID];
		String seqId = (String) detecInfo[DetectInfo.SEQID];
		/**
		 * 设置默认值
		 */
		if(detecInfo[DetectInfo.STATE] == null){
			detecInfo[DetectInfo.STATE] = -1;//state
		}
		if(detecInfo[DetectInfo.PLEVEL] == null){
			detecInfo[DetectInfo.PLEVEL] = 99;//pLevel
		}
		if(detecInfo[DetectInfo.DELYFLAG] == null){
			detecInfo[DetectInfo.DELYFLAG] = false;//delyFlag
		}
		if(detecInfo[DetectInfo.URGENTLEVEL] == null){
			detecInfo[DetectInfo.URGENTLEVEL] = 0;//urgentLevel
		}
		if(detecInfo[DetectInfo.SENDEMAILFLAG] == null){
			detecInfo[DetectInfo.SENDEMAILFLAG] = false;//sendEmailFlag
		}
		if(detecInfo[DetectInfo.STATECHANGEFLAG] == null){
			detecInfo[DetectInfo.STATECHANGEFLAG] = false;//stateChangeFlag
		}
		if(detecInfo[DetectInfo.STATUSCHANGTIME] == null){
			detecInfo[DetectInfo.STATUSCHANGTIME] = -1L;//statusChangeTime
		}
		
		if(dataList.size() == 0){
			List<Object[]> detecList = new LinkedList<Object[]>();
			detecList.add(detecInfo);
			List<Object> seqList = new LinkedList<Object>();//seqid list
			seqList.add(seqId);
			seqList.add(detecList);
			List<Object> setIdList = new LinkedList<Object>();//监测设置 id list
			setIdList.add(detecInfo[DetectInfo.SETINFOID]);
			setIdList.add(seqList);
			List<Object> checkTypeList = new LinkedList<Object>();
			checkTypeList.add(checkType);
			checkTypeList.add(setIdList);
			dataList.add(checkTypeList);
		}else{
			//第一层 checkType 
			for(int i = 0 , j = dataList.size(); i < j ; i ++){
				List<Object> tempObj = dataList.get(i);
				String key = (String)tempObj.get(0);//第一个为key
				if(checkType.equals(key)){//监测类型已存在
					for(int ii = 1 , jj = tempObj.size(); ii < jj ; ii ++){
						List<Object> tempSet = (LinkedList<Object>) tempObj.get(ii);
						String setKey = (String) tempSet.get(0);//监测设置id
						if(setInfoId.equals(setKey)){
							for(int iii = 1 ,jjj = tempSet.size(); iii < jjj; iii ++){
								List<Object> tempSeq = (LinkedList<Object>) tempSet.get(iii);
								String seqKey = (String) tempSeq.get(0);//监测设置id
								if(seqId.equals(seqKey)){//seqId 存在
									List<Object[]> detecList = (List<Object[]>) tempSeq.get(1);
									detecList.add(detecInfo);
									break;
								}else if(iii == jjj -1){//seqid 不存在
									List<Object[]> detecList = new LinkedList<Object[]>();
									detecList.add(detecInfo);
									List<Object> seqList = new LinkedList<Object>();//seqid list
									seqList.add(seqId);
									seqList.add(detecList);
									tempSet.add(seqList);
								}
							}
							break;
						}else if(ii == jj-1){//监测设置id不存在
							List<Object[]> detecList = new LinkedList<Object[]>();
							detecList.add(detecInfo);
							List<Object> seqList = new LinkedList<Object>();//seqid list
							seqList.add(seqId);
							seqList.add(detecList);
							List<Object> setIdList = new LinkedList<Object>();//监测设置 id list
							setIdList.add(detecInfo[DetectInfo.SETINFOID]);
							setIdList.add(seqList);
							tempObj.add(setIdList);
						}
					}
					break;//跳出循环
				}else if(i == j-1){//不存在
					List<Object[]> detecList = new LinkedList<Object[]>();
					detecList.add(detecInfo);
					List<Object> seqList = new LinkedList<Object>();//seqid list
					seqList.add(seqId);
					seqList.add(detecList);
					List<Object> setIdList = new LinkedList<Object>();//监测设置 id list
					setIdList.add(detecInfo[DetectInfo.SETINFOID]);
					setIdList.add(seqList);
					List<Object> checkTypeList = new LinkedList<Object>();
					checkTypeList.add(checkType);
					checkTypeList.add(setIdList);
					dataList.add(checkTypeList);	
				}
			}
		}
	}
	
	
	/**
	 * 组织detail表的insert语句
	 * @param fieldNames
	 * @param detailTableName
	 * @param tempMap
	 * @return
	 */
	public String createDetailSql(List<String> fieldNames,
			String detailTableName, Map<String, String> tempMap) {
		String insertDetailSql;
		StringBuffer preSql = new StringBuffer();
		StringBuffer sufSql = new StringBuffer();
		preSql.append(",detection_info_id");
		sufSql.append(",?");
		fieldNames.add("detection_info_id");
		for(String tempField : tempMap.keySet()){
			fieldNames.add(tempField);
			preSql.append("," + tempField);
			String value = tempMap.get(tempField);
			sufSql.append(",?");
		}
		insertDetailSql = "insert into "+detailTableName +" ( "+ preSql.substring(1) +" ) values (" + sufSql.substring(1) +" )";
		return insertDetailSql;
	}
	
	/**
	 * 状态变更判断:只对大于等于new表监测时间的监测数据进行是否告警的判断
	 * @param allDetectInfo
	 * @param inDbInfo
	 */
	public void judgeState(List<Object[]> allDetectInfo , Object[] inDbInfo){
		/*判断每一个的状态变更
		 * 1.监测时间小于已经入库的监测数据时间不做判断
		 * */
		int startIndex = 0;
		for(int i = 0, j = allDetectInfo.size(); i < j ; i++){
			Object[] newDetecInfo = allDetectInfo.get(i);
			Object[] oldDetecInfo = null;//前一条监测数据
			//监测时间小于已经入库的监测数据时间不做判断，只在最后一条数据判断插入告警信息
			if( newDetecInfo== null || (Long) newDetecInfo[DetectInfo.CHECKTIME] < (Long)inDbInfo[DetectInfo.CHECKTIME]){
				startIndex++;
				if(i < j -1){
					continue;
				}else{
					//集合中的最后一条数据监测时间也小于数据库中的时间时，最后一条数据判断是否插入一条告警信息
					if((Integer)newDetecInfo[DetectInfo.STATE] != 1){//延迟数据监测状态没有成功，数据库入库的是正常数据，补录一条报警信息
						if((Integer)inDbInfo[DetectInfo.STATE] == 1 && (Integer)inDbInfo[DetectInfo.PLEVEL] == 99){
							newDetecInfo[DetectInfo.APPENDWARNINGINFO] = oldDetecInfo;
							warnResumeNum++;
						}
					}
				}
			}
			//判断最新的监测数据
			if(i== startIndex){
				oldDetecInfo = inDbInfo;
			}else{
				oldDetecInfo = allDetectInfo.get(i-1);
			}
			/*判断状态变更*/
			stateChange(newDetecInfo, oldDetecInfo);
		}
		
	}
	/**
	 * 判断状态变更具体实现
	 * @param newDetecInfo
	 * @param oldDetecInfo
	 */
	public void stateChange(Object[] newDetecInfo,Object[] oldDetecInfo ){
		/**
		 * 判断状态变更
		 */
		
		if(newDetecInfo == null || oldDetecInfo == null 
				|| ((Long)newDetecInfo[DetectInfo.CHECKTIME] < (Long)oldDetecInfo[DetectInfo.CHECKTIME])){
			return;
		}
		if(((Integer)oldDetecInfo[DetectInfo.STATE] != (Integer)newDetecInfo[DetectInfo.STATE]) || //状态改变
				(((Integer)oldDetecInfo[DetectInfo.STATE] == (Integer)newDetecInfo[DetectInfo.STATE] 
				&& (Integer)oldDetecInfo[DetectInfo.PLEVEL]!= (Integer)newDetecInfo[DetectInfo.PLEVEL] ))){//状态未变，告警级别改变

			int state = (Integer)newDetecInfo[DetectInfo.STATE];
			//邮件告警信息
			StringBuffer alarmInfo = new StringBuffer((String)newDetecInfo[DetectInfo.ALARMINFO]);//告警信息
			String dsinfo = (String) newDetecInfo[DetectInfo.DSINFO];//状态信息
			String checkType = (String) newDetecInfo[DetectInfo.CHECKTYPE];//监测类别
			long checkTime = (Long) newDetecInfo[DetectInfo.CHECKTIME];
			int actionType = 11;
			int urgentLevel = EmailTypeConstants.URGENT_LATER;
			//整理告警数据,拼写邮件信息
			if(state == -1){	//执行失败
//				alarmInfo.append("监测执行失败\n  ");
//				alarmInfo.append("Failure to monitor execution\n  ");
				alarmInfo.append("i18n_server.DetecDataResoveThread.alarmInfo1_n81i\n  ");
				alarmInfo.append(dsinfo+"\n");
				actionType= EmailTypeConstants.TYPE_DETECTION_INFO_EXCEPTION;
				if(Constants.DETEC_NMSC_STR.equalsIgnoreCase(checkType)) {
					urgentLevel = EmailTypeConstants.URGENT_IMMEDIATELY;
					
				}
			}else if(state == 0){	//一般异常
				alarmInfo.append("  "+dsinfo+"\n");
				//如果是握手监测，不添加告警设置字段相关信息
				if(!Constants.DETEC_NMSC_STR.equalsIgnoreCase(checkType)) {
					alarmInfo.append(dsinfo+" \n");
				}else {
					alarmInfo.delete(0,alarmInfo.length());//如果是握手监测，则不添加告警设置字段相关信息
					alarmInfo.append(dsinfo+" \n");
					urgentLevel = EmailTypeConstants.URGENT_IMMEDIATELY;
				}
				actionType= EmailTypeConstants.TYPE_DETECTION_INFO_EXCEPTION;
			}else if(state == 1){	//恢复正常
//				alarmInfo.append("监测恢复正常");
//				alarmInfo.append("Monitoring back to normal");
				alarmInfo.append("i18n_server.DetecDataResoveThread.alarmInfo1_n81i");
				actionType= EmailTypeConstants.TYPE_DETECTION_INFO_RECOVER;
				urgentLevel = EmailTypeConstants.URGENT_LATER;
				//更新该节点所有监测时间为当前监测时间
				if(checkType.equalsIgnoreCase(Constants.DETEC_NMSC_STR)){
					newDetecInfo[DetectInfo.STATUSCHANGTIME] = (checkTime);
				}
			}
			// 报警通知
			
			newDetecInfo[DetectInfo.STATECHANGEFLAG] = (true);
			newDetecInfo[DetectInfo.ALARMINFO] = (alarmInfo.toString());
			newDetecInfo[DetectInfo.SENDEMAILFLAG] = (true);
			newDetecInfo[DetectInfo.URGENTLEVEL] = (urgentLevel);
			//目前代码中是否紧急和紧急级别不对应，有的是紧急，但是级别是2，所以此处进行修改，如果是紧急，则级别修改为0级
			if(EmailTypeConstants.URGENT_IMMEDIATELY==urgentLevel){
				newDetecInfo[DetectInfo.PLEVEL] = Constants.LEVEL_OF_EMERGENCY;
			}
			//如果是0级，则设置为紧急，使得紧急状态和级别一致
			if(newDetecInfo[DetectInfo.PLEVEL].equals(Constants.LEVEL_OF_EMERGENCY)){
				newDetecInfo[DetectInfo.URGENTLEVEL] = EmailTypeConstants.URGENT_IMMEDIATELY;
			}
			long seqIdLong = Long.parseLong((String)newDetecInfo[DetectInfo.SEQID]);
			long setInfoIdLong = Long.parseLong((String)newDetecInfo[DetectInfo.SETINFOID]);
				
			String emailContent = alarmInfo.toString();
			if(emailContent.getBytes().length>290){
					emailContent = StringUtil.substring(emailContent,290);
			}
				
			EmailInfo emailInfo = new EmailInfo(actionType,Common.getSetInfoNameMape().get(setInfoIdLong)+"("+Common.getCheckTypeNameMape().get(checkType)+")",Common.getNodeIpByUUID(seqIdLong), format2.format(new Date(checkTime)),emailContent,EmailTypeConstants.FLAG_SEND_LATER,urgentLevel);

			newDetecInfo[DetectInfo.EMAILINFO] = (emailInfo);
			//如果新入数据和new表中的监测状态不同，或者监测状态相同，告警级别不同   ，修改  状态改变时间 为获取新入数据的时间（data_check_time）
			newDetecInfo[DetectInfo.STATUSCHANGTIME]=newDetecInfo[DetectInfo.CHECKTIME];
		}
		else{//如果新入数据和new表中的监测状态相同，且告警级别相同  ，则状态改变时间更新为new表中的时间
			newDetecInfo[DetectInfo.STATUSCHANGTIME]=oldDetecInfo[DetectInfo.STATUSCHANGTIME];
		}
	}
	/**
	 *  id 和 currentId 同时 = -1时，为第一次获取sequence id
	 *  result[0] 为currentID
	 *  result[1] 为基准id，获取的sequence id
	 * @param id
	 * @param currentId
	 * @return
	 */
	public long getSequenceId(CommonService service){
		
		long result = -1L;
		if( infoId != -1 && currentId != -1 &&  currentId < (infoId + interval -1) && interval != -1){
			currentId ++;
			result = currentId;
		}else{
			//-- 申请sequences for detection_info
			long[] temp = service.getDetectionInfoSequenceID();
			if(temp[0] > 0){
				result = infoId = currentId = temp[0];//获取的id
				interval = temp[1];//步进
			}
		}
		return result;
	}
	
	
	/**
	 * 
	 * 获取文件路径，判断当天目录下的文件如果>=500个，则新创建父目录，
	 * 创建父目录的原则是"日期_1"、"日期_2"、"日期_3"累加的形式
	 * 
	 * @author jsj Apr 28, 2013
	 * @version 1.0 
	 * @return
	 */
	private String getFilePath()
	{
		String filePath = "";
		try
		{
			String parentDirPath = getParentDirPath();
			filePath = parentDirPath + "/" + Calendar.getInstance().getTimeInMillis() + ".csv";
			
		} catch (Exception e)
		{
			logger.error("Getting the error file path exception", e);
		}
		return filePath;
	}
	
	/**
	 * 
	 *获取文件的父目录
	 * 获取当天的父母目录，如果父目录不存在，则为第一次写入文件，直接返回当天的目录，
		存在则判断目录下的文件是否>-500,>=500则新建日期目录，否则取当前目录
	 * @author jsj Apr 28, 2013
	 * @version 1.0 
	 * @return
	 */
	private String getParentDirPath()
	{
		String parentDirPath = Constants.ERROR_DETEC_FILE_DIR;
		String currentDirName = Common.getDateDirName();
		String dirPath = parentDirPath + "/" + currentDirName;
		File parentDirFile = new File(parentDirPath);
		List<File> existDir = new ArrayList<File>();
		
		if (parentDirFile.exists())
		{
			File[] dirFiles = parentDirFile.listFiles();
			if (dirFiles.length > 0)
			{
				for (File dirFile: dirFiles)
				{
					if (dirFile.getName().contains(Common.getDateDirName()))
					{
						existDir.add(dirFile);
					}
				}
			}
			
		} else
		{
			return dirPath;
		}
		
		boolean isGetFile = false;
		
		for (File dirFile: existDir)
		{
			File[] files = dirFile.listFiles();
			if (currentDirName.compareTo(dirFile.getName()) < 0)
			{
				currentDirName = dirFile.getName();
			}
			if (files.length < Constants.ERROR_DETEC_FILE_DIR_FILE_SIZES)
			{
				dirPath = dirFile.getAbsolutePath();
				isGetFile = true;
				break;
			}
		}
		
		if (!isGetFile)
		{
			String[] currentDirNames = currentDirName.split("_");
			if (currentDirNames.length == 1)
			{
				currentDirName += "_1";
			} else
			{
				currentDirName = currentDirNames[0] + "_"
						+ +(Integer.parseInt(currentDirNames[1]) + 1);
			}
			dirPath = parentDirPath + "/" + currentDirName;
		}
		return dirPath;
	}
	
	
	//检查入库的监测数据中是否有无效的数据,有则置为无效
	public void updateDetectDataValid(CommonDao dao) throws Exception{
		CommonService service = new CommonService(dao);		
		Map<String,String> detectSetSeqIdMap = service.getDetectSetInfo();//查询有效监测数值对应的seqid
		Map<String,String[]> detectDataSeqIdMap = service.getDetectSeq(Constants.DETECTION_INFO_TABLE_NAME);//统计 监测数据 表: 监测设置<->已有有效数据的seqid
		Iterator detectDateSeqIte = detectDataSeqIdMap.entrySet().iterator();
		String invalidSeqIds = "";
		List<String> sqls = new ArrayList<String>();
		while(detectDateSeqIte.hasNext()) {
			invalidSeqIds = "";
			Entry en = (Entry)detectDateSeqIte.next();
			String setId = (String)en.getKey();
			String seqIdsValid = detectSetSeqIdMap.get(setId);//得到监测设置当前有效的seqids：1,2,3
			if(seqIdsValid!=null) {//如果有效的监测设置内没有此监测设置，则不予处理
				seqIdsValid = "," + seqIdsValid + ",";
				String[] seqIds = (String[])en.getValue();
				for(String seqIdTmp:seqIds) {
					if(seqIdTmp!=null && !"".equals(seqIdTmp)) {					
						if(!seqIdsValid.contains(","+seqIdTmp+",")) {//不在有效范围内，则更新为无效
							invalidSeqIds = invalidSeqIds + seqIdTmp + ",";
						}
					}
				}
				if(invalidSeqIds.endsWith(",")) {
					invalidSeqIds = invalidSeqIds.substring(0,invalidSeqIds.length()-1);				
					sqls.add("update "+Constants.DETECTION_INFO_TABLE_NAME+" t set valid=0 where t.valid=1  and t.detection_set_info_id="+setId+" and t.seq_id in ("+invalidSeqIds+")");
				}
			}
		}	
		if(sqls.size()>0){//一般情况下不需要更新，所以，如果不加if判断，则每次都会浪费时间去创建statement
			dao.dbUpdateByBatch(sqls);
		}
		
	}
	
	
	
	/**
	 *打印统计的监测数据:监测类别--监测设置--节点--监测信息
	 */
	private void printDetectDataInfo(Map<String, Map<String,Map<String,List<Object[]>>>> newDataMap) {
		/**
		 *打印统计的监测数据:监测类别--监测设置--节点--监测信息
		 */
		if(newDataMap != null && newDataMap.size()>0){
			logger.debug("解析完毕：共" +newDataMap.size()+ "个监测类型");
			for(Map.Entry<String, Map<String,Map<String,List<Object[]>>>> setInfoIdMap :newDataMap.entrySet()){
				logger.debug("监测类型： " + setInfoIdMap.getKey()  + " 共有：" + setInfoIdMap.getValue().size() +" 个监测设置项");
				if(setInfoIdMap.getValue() != null){
					for(Map.Entry<String, Map<String,List<Object[]>>> me : setInfoIdMap.getValue().entrySet() ){
						if(me.getValue() != null){
							logger.debug("监测设置id: " + me.getKey() + " 共包含：" + me.getValue().size() +" 节点");
							for(Map.Entry<String, List<Object[]>> seqMe : me.getValue().entrySet()){
								if(seqMe.getValue() != null){
									logger.debug("seqId : " + seqMe.getKey() + " 共包含：" + seqMe.getValue().size() +" 条监测数据");
								}
							}
						}
					}
				}
			}
		}
	}
	
	/**
	 * 将解析之后的监测数据写入到文件
	 * @param temInfo
	 * @param file
	 * @return
	 */
	private byte[] objectToString(Object[] temInfo){
		byte[] dsb = null;
		try {
			// ------- 总监测数据组织
			int index = 0;
			String[] totalData = new String[12];
			totalData[index++] = (String) temInfo[DetectInfo.SEQID];// UUID
			totalData[index++] = (String) temInfo[DetectInfo.SETINFOID];// 监测设置ID
			String checkType = totalData[index++] = (String) temInfo[DetectInfo.CHECKTYPE];// 监测类别
			totalData[index++] = (String) temInfo[DetectInfo.PROCESS];// 进程名称
			totalData[index++] = temInfo[DetectInfo.STARTTIME] +"";// 监测服务启动时间
			totalData[index++] = temInfo[DetectInfo.DELAYTIME] +"";// 检测时延（秒）
			totalData[index++] = temInfo[DetectInfo.CHECKTIME]+ "";// 本次检测时间
			totalData[index++] = temInfo[DetectInfo.CURRENTTIMES] + "";// 尝试次数
			totalData[index++] = temInfo[DetectInfo.NEXTCHECKTIME]+"";// 下次计划监测时间
			totalData[index++] = temInfo[DetectInfo.STATE] + "";// 执行状态是否成功是否正常
			totalData[index++] = temInfo[DetectInfo.DSINFO] +"";// 状态信息（描述信息）
			totalData[index++] = temInfo[DetectInfo.PDATA] +"";// 性能数据

			/**
			 * 详细数据前三个告警相关信息
			 */
			List<String> showNumList = (List<String>) temInfo[DetectInfo.SHOWNUMLIST]; 
			List<String> plevelList = (List<String>) temInfo[DetectInfo.PLEVELLIST];
			List<String> alarmList = (List<String>) temInfo[DetectInfo.ALARMLIST];

			List<String[]> dataList = new LinkedList<String[]>();
			// 总数据
			dataList.add(totalData);
			
			//详细信息
			List<Map<String,String>> details = (List<Map<String, String>>) temInfo[DetectInfo.DETAILS];
			if(details != null && details.size() > 0){
				Map<Integer, TableColumnsModel> tableMap = Common.getTableMap().get(checkType);
				Map<String,Integer> fieldMap = fieldNameToLower(tableMap);//将表字段名称转换成小写
				// 详细信息
				dataList.add(new String[]{"details", details.size()+ ""});// details(解析标识),详细信息条数
				List<String[]> detailDataList = new LinkedList<String[]>();
				int listIndex = 0;
				for(Map<String,String> temp : details){
					//单条详细信息
					String[] tempDetail = new String[tableMap.size() + 4];
					tempDetail[0] = showNumList.get(listIndex);
					tempDetail[1] = plevelList.get(listIndex);
					tempDetail[2] = alarmList.get(listIndex);
					for(Map.Entry<String, String> tempEntry : temp.entrySet()){
						String fieldName = tempEntry.getKey().toLowerCase();
						if("seq_id".equals(fieldName) || //解析时添加的数据跳过
								"detectioned_state".equals(fieldName) ||
								"detection_set_info_id".equals(fieldName) ||
								"data_check_time_digital".equals(fieldName) ||
								"data_check_time".equals(fieldName) ||
								"data_arrive_time_digital".equals(fieldName) ||
								"data_arrive_time".equals(fieldName) ){
							continue;
						}
						String value = tempEntry.getValue();
						int arrIndex = fieldMap.get(fieldName) + 2;
						tempDetail[arrIndex] = value;
					}
					detailDataList.add(tempDetail);
					listIndex ++;
				}
				
				dataList.addAll(detailDataList);// 具体的详细数据
				
				// 特殊数据定制(目前是针对系统信息监测systeminfo)
				if ("systeminfo".equalsIgnoreCase(checkType)) {
					List<String[]> netList = (List<String[]>) temInfo[DetectInfo.NETINFOLIST];
					if(netList != null && netList.size() > 0){
						dataList.add(new String[]{"net", netList.size() + ""});// 解析标识, 行数（当前解析标识指定的类型有多少条数据）
						dataList.addAll(netList);// 多条数据
					}
					List<String[]> diskList = (List<String[]>) temInfo[DetectInfo.DISKINFOLIST];
					if(netList != null && diskList.size() > 0){
						dataList.add(new String[]{"disk", netList.size() + ""});// 解析标识, 行数（当前解析标识指定的类型有多少条数据）
						dataList.addAll(diskList);// 多条数据
					}
				}
			}
			dsb = CSVUtils.csvBytesPrinter1(dataList, Constants.COMMON_TEXT_CODING);
		} catch (Exception e) {
			e.printStackTrace();
			logger.error("Conversion from Object[] to byte[] failure",e);
		}
		return dsb;
	}
	/**
	 * 表字段名称全部转换成小写,并fieldName做key
	 * @param tableMap
	 * @return
	 */
	private Map<String,Integer> fieldNameToLower(Map<Integer, TableColumnsModel> tableMap){
		Map<String,Integer> result = new HashMap<String,Integer>();
		if(tableMap != null && tableMap.size()>0){
			for(Map.Entry<Integer, TableColumnsModel> temp : tableMap.entrySet()){
				TableColumnsModel column = temp.getValue();
				if(column != null){
					result.put(column.getFiledName().toLowerCase(), temp.getKey());
				}
			}
		}
		return result;
	}
	
	
	private List<String> generateLog(byte[] info,String head) {
		List<String> warnInfoList = new ArrayList<String>();
		try
		{
			//byte[] info = (byte[]) temInfo[27];
			List<String []> strsList = CSVUtils.csvBytesParser(info,Constants.COMMON_TEXT_CODING);
			String time = System.currentTimeMillis()+"";
			for(String[] strArr:strsList) {
//			logger.info(head+"  "+time +"  "+StringUtils.join(strArr,","));
				warnInfoList.add(head+"  "+time +"  "+StringUtils.join(strArr,","));
			}
			
		} catch (Exception e){
		}
		return warnInfoList;
	}
	
	private void printLogs(List<String> logList) {
		for(String log:logList){
			logger.info(log);
		}
	}
	private void judgeAndCollect(List<Object[]> allDeteInfo, Object[] oldDetecInfo,List<Object[]> newDataList,CommonService service){
		Object[] newDeteInfo = allDeteInfo.get(0);
		if((Long)newDeteInfo[DetectInfo.CHECKTIME]>(Long)oldDetecInfo[DetectInfo.CHECKTIME]){
				newDataList.add(newDeteInfo);
		}
		if((Integer)newDeteInfo[DetectInfo.STATE]==1){
				Object[] params={newDeteInfo[DetectInfo.SEQID],newDeteInfo[DetectInfo.SETINFOID]};
				try {
					service.addRecordToStatement(warnUpdateStmt, params);
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
		}
	}
	
	public static void main(String[] args) {
		
	}
	
	
}