java ExecutorService线程池技术实现批量导入数据

Java利用线程池技术批量导入数据到数据库

 ***1. 第一个类WifiAndImsiImportTask.java定时任务中组装集合数据并提交多线程池执行：***

/**
 * wifiImsi数据入库
 * @author xjl
 * 2018-11-6 13:34:27
 * */
@Component
public class WifiAndImsiImportTask {
	private final int INSERNUM = 50000;//每次添加的条数
	private  final String FILE_SEPARATOR = System.getProperty("file.separator");
	private Logger logger = LoggerFactory.getLogger(getClass());
	private String policeStationid;
	private String policeAreaid;
	private String policeProvinceid;
	ExecutorService threadPool = null;//线程池
	Map<String, Object> mapImsiLocation=null;
	@Resource
	WifiAndImsiImportService wifiAndImsiImportService;

	//@Scheduled(cron = "0 0/5 * * * ?")
	public synchronized void runTask() {
		if (threadPool == null) {//初始化线程池
			threadPool = Executors.newFixedThreadPool(10);
		}
		policeStationid = SysDictUtils.getDictByCode("policeStationid", "policeStationid");
		policeAreaid = SysDictUtils.getDictByCode("policeAreaid", "policeAreaid");
		policeProvinceid = SysDictUtils.getDictByCode("provinceid", "provinceid");
		
		logger.info("============================================数据导入开始===================================================");
		importData();
		logger.info("============================================数据导入结束====================================================");
	}
	public void importData() {
		List<WifiImportEntity> wifiList = new ArrayList<WifiImportEntity>();//存放wifi数据
		List<IMSIImportEntity> imsiList = new ArrayList<IMSIImportEntity>();//存放IMSI数据
		StringBuffer wifiIds = new StringBuffer();
		StringBuffer imsiIds = new StringBuffer();
		
		List<Map<String,Object>> dataList = wifiAndImsiImportService.getWaitImportData();//待导入数据
		for (Map<String,Object> map : dataList) {
			String ID = "";
			try {
				ID = map.get("id").toString();
				String fileName = map.get("filename").toString();
				String filePath = map.get("filepath").toString();
				List<String> fileList = FileUtils.readLines(new File(filePath+FILE_SEPARATOR+fileName), "UTF-8");
				wifiAndImsiImportService.updateStatus(ID, "1");
				if (map.get("filetype")!= null && "1".equals(map.get("filetype"))) {
					wifiIds.append(ID).append(",");
					wifiImportData(wifiList, fileList, fileName,wifiIds);		
				} else {
					if(mapImsiLocation == null && "3".equals(map.get("filetype"))){
						logger.info("==================开始获取归属地============================");
						long starttime = System.currentTimeMillis();
						mapImsiLocation= wifiAndImsiImportService.getImsiLocation();
						logger.info("===耗时："+(System.currentTimeMillis()-starttime)+"毫秒====");
					}
					imsiIds.append(ID).append(",");
					iMSIImportData(imsiList, fileList, fileName,imsiIds,map.get("filetype").toString());
				}
			} catch(Exception e) {
				logger.error("数据导入》》》"+e.toString());
				wifiAndImsiImportService.updateStatus(ID, "-1");
			}
		}
		insertSurplusData(wifiList, imsiList, wifiIds, imsiIds);//处理数量不满足的数据
	}
	/**
	 * wifi入库
	 * */
	public void wifiImportData(List<WifiImportEntity> list,List<String> fileList,String fileName,StringBuffer IDS) {
		for (String wifi : fileList) {
			try {
				WifiImportEntity wifiImportEntity = new WifiImportEntity();
				String[] wifis = wifi.split("\\|");
				wifiImportEntity.setMac(wifis[0].replace("\"", ""));
				wifiImportEntity.setWsiteid(wifis[1].replace("\"", ""));
				wifiImportEntity.setWagentid(wifis[4].replace("\"", ""));
				wifiImportEntity.setStarttime(wifis[3].replace("\"", ""));
				wifiImportEntity.setFilename(fileName);
				wifiImportEntity.setImporttime(DateUtils.getNow());
				wifiImportEntity.setPoliceStationid(policeStationid);
				wifiImportEntity.setPoliceAreaid(policeAreaid);
				wifiImportEntity.setPoliceProvinceid(policeProvinceid);
				list.add(wifiImportEntity);
			} catch(Exception e) {
				logger.error(e.toString());
			}
		}
		if (list.size() >= INSERNUM) {
			try{
				logger.info("============================================WIFI入库开始===================================================");
				Future<Boolean> hotWifi = threadPool.submit(new HotWifiImport(list,wifiAndImsiImportService));
				Future<Boolean> hotWifihis = threadPool.submit(new HotWifiHisImport(list,wifiAndImsiImportService));
				boolean b = hotWifi.get();
				boolean b1 = hotWifihis.get();
				list.clear();
				wifiAndImsiImportService.updateStatus(IDS.toString(), "2");
				IDS.setLength(0);//清空Stringbuffer
				logger.info("============================================WIFI入库结束=================================");
			} catch(Exception e) {
				list.clear();
				wifiAndImsiImportService.updateStatus(IDS.toString(), "-1");
				IDS.setLength(0);//清空Stringbuffer
				logger.error(e.toString());
			}
		}
	}
	/**
	 * imsi入库
	 * */
	public void iMSIImportData(List<IMSIImportEntity> list,List<String> fileList,String fileName,StringBuffer IDS,String type) {
		if ("2".equals(type)){
			IMSIdata(list,fileList,fileName);
		} else if ("3".equals(type)) {
			IMSITextdata(list,fileList,fileName);
		}
		if (list.size() >= INSERNUM) {
			try{
				logger.info("============================================IMSI入库开始===================================================");
				//int insertNum = wifiAndImsiImportService.insertIMSIData(list);
				Future<Boolean> imsiWifi = threadPool.submit(new HotImsiImport(list, wifiAndImsiImportService));
				Future<Boolean> imsiWifihis = threadPool.submit(new HotImsiHisImport(list, wifiAndImsiImportService));
				boolean b = imsiWifi.get();
				boolean b1 = imsiWifihis.get();
				list.clear();
				wifiAndImsiImportService.updateStatus(IDS.toString(), "2");
				IDS.setLength(0);//清空Stringbuffer
				logger.info("============================================IMSI入库结束条数据=================================");
			} catch(Exception e) {
				list.clear();
				wifiAndImsiImportService.updateStatus(IDS.toString(), "-1");
				IDS.setLength(0);//清空Stringbuffer
				logger.error(e.toString());
			}
		}
	}
	//处理imsi数据用于导入
	public void IMSIdata(List<IMSIImportEntity> list,List<String> fileList,String fileName) {
		for (String IMSI : fileList) {
			try {
				
				String[] IMSIS = IMSI.split("\\|");
				IMSIImportEntity imsiImportEntity = new IMSIImportEntity();
				imsiImportEntity.setImei(IMSIS[6].replace("\"", ""));
				imsiImportEntity.setImsi(IMSIS[5].replace("\"", ""));
				imsiImportEntity.setWsiteid(IMSIS[0].replace("\"", ""));
				imsiImportEntity.setWagentid(IMSIS[1].replace("\"", ""));
				imsiImportEntity.setStarttime(IMSIS[4].replace("\"", ""));
				imsiImportEntity.setImporttime(DateUtils.getNow());
				imsiImportEntity.setLocation(IMSIS[8].replace("\"", ""));
				imsiImportEntity.setModel(IMSIS[9].replace("\"", ""));
				imsiImportEntity.setFilename(fileName);
				imsiImportEntity.setPoliceStationid(policeStationid);
				imsiImportEntity.setPoliceAreaid(policeAreaid);
				imsiImportEntity.setPoliceProvinceid(policeProvinceid);
				list.add(imsiImportEntity);
			} catch(Exception e) {
				logger.error(e.toString());
			}
		}
	}
	public void IMSITextdata(List<IMSIImportEntity> list,List<String> fileList,String fileName) {
		String siteId = fileName.split("_")[0];
		for (String IMSI : fileList) {
			try {
				String[] IMSIS = IMSI.split("\t");
				IMSIImportEntity imsiImportEntity = new IMSIImportEntity();
				imsiImportEntity.setImsi(IMSIS[0].replace("\"", ""));
				imsiImportEntity.setWsiteid(siteId);
				imsiImportEntity.setWagentid(siteId);
				imsiImportEntity.setStarttime(IMSIS[3].replace("\"", ""));
				imsiImportEntity.setImporttime(DateUtils.getNow());
				if(mapImsiLocation.get(IMSIS[0].substring(0, 10))!=null){
					String City=mapImsiLocation.get(IMSIS[0].substring(0, 10)).toString();//得到imsi的归属地
					imsiImportEntity.setLocation(City);
				}
				imsiImportEntity.setFilename(fileName);
				imsiImportEntity.setPoliceStationid(policeStationid);
				imsiImportEntity.setPoliceAreaid(policeAreaid);
				imsiImportEntity.setPoliceProvinceid(policeProvinceid);
				list.add(imsiImportEntity);
			} catch(Exception e) {
				logger.error(e.toString());
			}
		}
	}
	/**
	 * 入库剩余文件
	 * */
	public void insertSurplusData(List<WifiImportEntity> wifiList,List<IMSIImportEntity> imsiList,StringBuffer wifiIds,StringBuffer imsiIds) {
		if (wifiList != null && wifiList.size()>0) {
			try{
				logger.info("============================================WIFI入库开始===================================================");
				Future<Boolean> hotWifi = threadPool.submit(new HotWifiImport(wifiList,wifiAndImsiImportService));
				Future<Boolean> hotWifihis = threadPool.submit(new HotWifiHisImport(wifiList,wifiAndImsiImportService));
				boolean b = hotWifi.get();
				boolean b1 = hotWifihis.get();
				wifiList.clear();
				wifiAndImsiImportService.updateStatus(wifiIds.toString(), "2");
				wifiIds.setLength(0);//清空Stringbuffer
				logger.info("============================================WIFI入库结束=================================");
			} catch(Exception e) {
				wifiList.clear();
				wifiAndImsiImportService.updateStatus(wifiIds.toString(), "-1");
				wifiIds.setLength(0);//清空Stringbuffer
				logger.error(e.toString());
			}
		}
		if (imsiList != null && imsiList.size()>0) {
			try{
				logger.info("============================================IMSI入库开始===================================================");
				Future<Boolean> imsiWifi = threadPool.submit(new HotImsiImport(imsiList, wifiAndImsiImportService));
				Future<Boolean> imsiWifihis = threadPool.submit(new HotImsiHisImport(imsiList, wifiAndImsiImportService));
				boolean b = imsiWifi.get();
				boolean b1 = imsiWifihis.get();
				imsiList.clear();
				wifiAndImsiImportService.updateStatus(imsiIds.toString(), "2");
				imsiIds.setLength(0);//清空Stringbuffer
				logger.info("============================================IMSI入库结束条数据=================================");
			} catch(Exception e) {
				imsiList.clear();
				wifiAndImsiImportService.updateStatus(imsiIds.toString(), "-1");
				imsiIds.setLength(0);//清空Stringbuffer
				logger.error(e.toString());
			}
		}
	}
}

/*****************************************************************************************************************************************/
//wifi分析后数据入库
class HotWifiImport implements Callable<Boolean>{
	private Logger logger = LoggerFactory.getLogger(getClass());
	List<WifiImportEntity> list = null;
	WifiAndImsiImportService wifiAndImsiImportService;
	
	public HotWifiImport(List<WifiImportEntity> list,WifiAndImsiImportService wifiAndImsiImportService) {
		this.list = list;
		this.wifiAndImsiImportService = wifiAndImsiImportService;
	}
	@Override
	public Boolean call() {
		try {
			logger.info("============================================执行数据分析入库线程=================================");
			List<WifiImportEntity> anasisList = new ArrayList<WifiImportEntity>();
			List<String> wifiRedList = HotRedListTask.getWifiRedList();
			for (WifiImportEntity wifiImportEntity : list) {//去除红名单数据
				try{
					if (!(wifiRedList.contains(wifiImportEntity.getMac()))) {
						String starttime = wifiImportEntity.getStarttime();
						starttime = starttime.replace("\"", "");
						String[] starttimes = starttime.split("\\s+");
						String time = starttimes[0];
						String hour = starttimes[1].split(":")[0];
						wifiImportEntity.setGroupBySiteStatic(wifiImportEntity.getWsiteid()+"|"+wifiImportEntity.getWagentid()+"|"+time);
						wifiImportEntity.setGroupBySiteTime(wifiImportEntity.getWsiteid()+"|"+time+"|"+hour);
						anasisList.add(wifiImportEntity);
					}
				} catch(Exception e) {
					e.printStackTrace();
				}
			}
			anasisData(anasisList);//数据分析结果入库
			warmResult(anasisList);//预警结果分析
			int insertNum = wifiAndImsiImportService.insertWifiData(anasisList,"social_hot_wifilog");
			logger.info("============================================执行数据分析入库线结束=================================");
			if (insertNum < 0) {
				return false;
			}
		}catch(Exception e) {
			return false;
		}
		return true;
	}
	/**
	 * 数据统计分析
	 * */
	public boolean anasisData(List<WifiImportEntity> anasisList) {
		try {
			String policeAreaid = SysDictUtils.getDictByCode("policeAreaid", "policeAreaid");
			String policeProvinceid = SysDictUtils.getDictByCode("provinceid", "provinceid");
			List<Map<String,Object>> updateHotSiteStaticList = new ArrayList<>();//站点时间数量统计-修改
			List<Map<String,Object>> updateHotSiteTimeList = new ArrayList<>();//站点时间小时数量统计-修改
			List<Map<String,Object>> insertHotSiteStaticList = new ArrayList<>();//站点时间数量统计-增加
			List<Map<String,Object>> insertHotSiteTimeList = new ArrayList<>();//站点时间小时数量统计-增加
			List<Map<String,Object>> hotSiteStaticList = wifiAndImsiImportService.getSiteStatic();//已存在站点时间
			List<Map<String,Object>> hotSiteTimeList = wifiAndImsiImportService.getSiteStaticTime();//已存在站点时间小时

			Map<String, List<WifiImportEntity>> hotSiteStaticMap = anasisList.stream().collect(Collectors.groupingBy(WifiImportEntity::getGroupBySiteStatic));
			Map<String, List<WifiImportEntity>> hotSiteTimeMap = anasisList.stream().collect(Collectors.groupingBy(WifiImportEntity::getGroupBySiteTime));
			//遍历map中的键 
			for (String key : hotSiteStaticMap.keySet()) {
				try {
					  Map<String, Object> resultMap = new HashMap<String, Object>();
					  String[] keys = key.split("\\|");
					  resultMap.put("SITEID", keys[0]);
					  resultMap.put("AGENTID", keys[1]);
					  resultMap.put("STATICTIME", keys[2]);
					  resultMap.put("PROVINCEID", policeProvinceid);
					  resultMap.put("AREAID", policeAreaid);
					  resultMap.put("TYPE", "1");//类型：1：热点wifi,2:嗅探wifi,3:imsi
					  if (hotSiteStaticList.contains(resultMap)) {
						  resultMap.put("TOTAL", hotSiteStaticMap.get(key).size());//不能放在if外边否则会影响判断
						  updateHotSiteStaticList.add(resultMap);
					  }else {
						  resultMap.put("TOTAL", hotSiteStaticMap.get(key).size());//不能放在if外边否则会影响判断
						  insertHotSiteStaticList.add(resultMap);
					  }
				} catch(Exception e) {
					e.printStackTrace();
				}
			  //hotSiteStaticList.add(resultMap);
			}	
			//遍历map中的键 
			for (String key : hotSiteTimeMap.keySet()) {
				try {
					  Map<String, Object> resulTimetMap = new HashMap<String, Object>();
					  String[] keys = key.split("\\|");
					  resulTimetMap.put("SITEID", keys[0]);
					  resulTimetMap.put("STATICTIME", keys[1]);
					  resulTimetMap.put("STATICHOUR", keys[2]);
					  
					  resulTimetMap.put("PROVINCEID", policeProvinceid);
					  resulTimetMap.put("AREAID", policeAreaid);
					  resulTimetMap.put("TYPE", "1");//类型：1：热点wifi,2:嗅探wifi,3:imsi
					  if (hotSiteTimeList.contains(resulTimetMap)) {
						  resulTimetMap.put("TOTAL", hotSiteTimeMap.get(key).size());//不能放在if外边否则会影响判断
						  updateHotSiteTimeList.add(resulTimetMap);
					  } else {
						  resulTimetMap.put("TOTAL", hotSiteTimeMap.get(key).size());//不能放在if外边否则会影响判断
						  insertHotSiteTimeList.add(resulTimetMap);
					  }
				} catch(Exception e) {
					e.printStackTrace();
				}
			  //hotSiteTimeList.add(resulTimetMap);
			}
			wifiAndImsiImportService.updateSiteStatic(updateHotSiteStaticList);
			wifiAndImsiImportService.updateSiteStaticTime(updateHotSiteTimeList);
			wifiAndImsiImportService.insertSiteStatic(insertHotSiteStaticList);
			wifiAndImsiImportService.insertSiteStaticTime(insertHotSiteTimeList);
		} catch(Exception e) {
			e.printStackTrace();
			return false;
		}
		return true;
	}
	 /**
	  * 获取符合预警值得结果
	  * */
	 public void warmResult(List<WifiImportEntity> anasisList) {
		 try {
			 List<HotWarmImportEntity> warmList = wifiAndImsiImportService.getWarmInfo("4");//3:imsi实时预警，4：wifi实时预警5:imei实时预警
			 List<Map<String,Object>> resultList = new ArrayList<Map<String,Object>>();
			 for (WifiImportEntity wifiImportEntity : anasisList) {
				 try{
					 for (HotWarmImportEntity hotWarmEntity : warmList) {
						 if (hotWarmEntity.getWarmvalue().equals(wifiImportEntity.getMac())) {
							 Map<String,Object> map = new HashMap<String,Object>();
							 map.put("id", hotWarmEntity.getId());
							 map.put("warmTime", wifiImportEntity.getStarttime());
							 map.put("siteId", wifiImportEntity.getWsiteid());
							 resultList.add(map);
							 break;
						 }
					 } 
				 } catch(Exception e) {
					 
				 }
			 }
			 wifiAndImsiImportService.insertWarmResult(resultList); 
		 } catch(Exception e) {
			 e.printStackTrace();
		 }
	 }
}

//wifi完整数据入库
class HotWifiHisImport implements Callable<Boolean>{
	List<WifiImportEntity> list = null;
	WifiAndImsiImportService wifiAndImsiImportService;
	
	public HotWifiHisImport(List<WifiImportEntity> list,WifiAndImsiImportService wifiAndImsiImportService) {
		this.list = list;
		this.wifiAndImsiImportService = wifiAndImsiImportService;
	}
	@Override
	public Boolean call(){
		try {
			int insertNum = wifiAndImsiImportService.insertWifiData(list,"social_hot_wifilog_his");
			if (insertNum < 0) {
				return false;
			}
		}catch(Exception e) {
			return false;
		}
		return true;
	}
}

/*****************************************************************************************************************************************/
//IMSI数据入库
class HotImsiImport implements Callable<Boolean>{
	private Logger logger = LoggerFactory.getLogger(getClass());
	List<IMSIImportEntity> list = null;
	WifiAndImsiImportService wifiAndImsiImportService;
	private String hotArea;
	public HotImsiImport(List<IMSIImportEntity> list,WifiAndImsiImportService wifiAndImsiImportService) {
		this.list = list;
		this.wifiAndImsiImportService = wifiAndImsiImportService;
		hotArea = SysDictUtils.getDictByCode("hot", "hotaera");//热点区域
	}
	@Override
	public Boolean call() {
		try {
			List<IMSIImportEntity> anasisList = new ArrayList<IMSIImportEntity>();
			List<String> imsiRedList = HotRedListTask.getImsiRedList();
			for (IMSIImportEntity importEntity : list) {
				if (!(imsiRedList.contains(importEntity.getImsi()))) {
					String starttime = importEntity.getStarttime();
					starttime = starttime.replace("\"", "");
					String[] starttimes = starttime.split("\\s+");
					String time = starttimes[0];
					String hour = starttimes[1].split(":")[0];
					String location = importEntity.getLocation();
					if (location == null || "".equals(location)) {
						location = "其他";
					}
					importEntity.setGroupBySiteStatic(importEntity.getWsiteid()+"|"+importEntity.getWagentid()+"|"+time);
					importEntity.setGroupBySiteTime(importEntity.getWsiteid()+"|"+time+"|"+hour);
					importEntity.setGroupBySiteLocation(importEntity.getWsiteid()+"|"+importEntity.getWagentid()+"|"+time+"|"+location);
					importEntity.setGroupBySiteTimeIMSI(importEntity.getImsi()+"|"+importEntity.getWsiteid()+"|"+time);
					anasisList.add(importEntity);
				}
			}
			anasisData(anasisList);//数据分析
			warmResult(anasisList);//预警结果分析
			int insertNum  = wifiAndImsiImportService.insertIMSIData(anasisList,"social_hot_imeilog");//数据入库
			if (insertNum < 0) {
				return false;
			}
		}catch(Exception e) {
			return false;
		}
		return true;
	}
	//统计IMEI个数
	public int getIMEITotal(List<IMSIImportEntity> list) {
		int count = 0;
		for(IMSIImportEntity iMSIImportEntity:list) {
			try {
				if (iMSIImportEntity.getImei() != null && !"".equals(iMSIImportEntity.getImei()) && !"000000000000000".equals(iMSIImportEntity.getImei())) {
					count++;
				}
			} catch(Exception e) {
				
			}
		}
		return count;
	}
	/**
	 * 数据分析
	 * */
	 public boolean anasisData(List<IMSIImportEntity> anasisList) {
		 try{
				String policeAreaid = SysDictUtils.getDictByCode("policeAreaid", "policeAreaid");
				String policeProvinceid = SysDictUtils.getDictByCode("provinceid", "provinceid");
				
				List<Map<String,Object>> updateHotSiteStaticList = new ArrayList<>();//站点时间数量统计-修改
				List<Map<String,Object>> updateHotSiteTimeList = new ArrayList<>();//站点时间小时数量统计-修改
				List<Map<String,Object>> updateHotSiteLocationList = new ArrayList<>();//站点时间归属地数量统计-修改
				List<Map<String,Object>> updateHotSiteIMSITimeList = new ArrayList<>();//IMSI站点时间-修改
				
				List<Map<String,Object>> insertHotSiteStaticList = new ArrayList<>();//站点时间数量统计-添加
				List<Map<String,Object>> insertHotSiteTimeList = new ArrayList<>();//站点时间小时数量统计-添加
				List<Map<String,Object>> insertHotSiteLocationList = new ArrayList<>();//站点时间归属地数量统计-添加
				List<Map<String,Object>> insertHotSiteIMSITimeList = new ArrayList<>();//IMSI站点时间-添加
				
				List<Map<String,Object>> hotSiteStaticList = wifiAndImsiImportService.getSiteStatic();//已存在站点时间
				List<Map<String,Object>> hotSiteTimeList = wifiAndImsiImportService.getSiteStaticTime();//已存在站点时间小时
				List<Map<String,Object>> hotSiteLocationList = wifiAndImsiImportService.getSiteStaticLocation();//已存在站点时间归属地
				List<Map<String,Object>> hotSiteIMSITimeList = wifiAndImsiImportService.getIMSISite();//已存在IMSI站点时间
				
				Map<String, List<IMSIImportEntity>> hotSiteStaticMap = anasisList.stream().collect(Collectors.groupingBy(IMSIImportEntity::getGroupBySiteStatic));
				Map<String, List<IMSIImportEntity>> hotSiteTimeMap = anasisList.stream().collect(Collectors.groupingBy(IMSIImportEntity::getGroupBySiteTime));
				Map<String, List<IMSIImportEntity>> hotSiteLocationMap = anasisList.stream().collect(Collectors.groupingBy(IMSIImportEntity::getGroupBySiteLocation));
				Map<String, List<IMSIImportEntity>> hotSiteIMSITimeMap = anasisList.stream().collect(Collectors.groupingBy(IMSIImportEntity::getGroupBySiteTimeIMSI));
				for (String key : hotSiteStaticMap.keySet()) {
					try {
						  Map<String, Object> resultMap = new HashMap<String, Object>();
						  String[] keys = key.split("\\|");
						  resultMap.put("SITEID", keys[0]);
						  resultMap.put("AGENTID", keys[1]);
						  resultMap.put("STATICTIME", keys[2]);
						  resultMap.put("PROVINCEID", policeProvinceid);
						  resultMap.put("AREAID", policeAreaid);
						  resultMap.put("TYPE", "3");//类型：1：热点wifi,2:嗅探wifi,3:imsi
						  if (hotSiteStaticList.contains(resultMap)) {//表示数据已存在则修改总数
							  resultMap.put("TOTAL", hotSiteStaticMap.get(key).size());//不能放在if外边否则会影响判断
							  updateHotSiteStaticList.add(resultMap);
						  } else {
							  resultMap.put("TOTAL", hotSiteStaticMap.get(key).size());
							  insertHotSiteStaticList.add(resultMap);
						  }
						  
						  Map<String, Object> resultIMEIMap = new HashMap<String, Object>();
						  resultIMEIMap.put("SITEID", keys[0]);
						  resultIMEIMap.put("AGENTID", keys[1]);
						  resultIMEIMap.put("STATICTIME", keys[2]);
						  resultIMEIMap.put("PROVINCEID", policeProvinceid);
						  resultIMEIMap.put("AREAID", policeAreaid);
						  resultIMEIMap.put("TYPE", "4");//类型：1：热点wifi,2:嗅探wifi,3:imsi
						  if (hotSiteStaticList.contains(resultIMEIMap)) {//表示数据已存在则修改总数
							  resultIMEIMap.put("TOTAL", getIMEITotal(hotSiteStaticMap.get(key)));//不能放在if外边否则会影响判断
							  updateHotSiteStaticList.add(resultIMEIMap);
						  } else {
							  resultIMEIMap.put("TOTAL", getIMEITotal(hotSiteStaticMap.get(key)));
							  insertHotSiteStaticList.add(resultIMEIMap);
						  }
					} catch(Exception e) {
						e.printStackTrace();
					}
				}
				for (String key : hotSiteTimeMap.keySet()) {
					try {
						  Map<String, Object> resulTimetMap = new HashMap<String, Object>();
						  String[] keys = key.split("\\|");
						  resulTimetMap.put("SITEID", keys[0]);
						  resulTimetMap.put("STATICTIME", keys[1]);
						  resulTimetMap.put("STATICHOUR", keys[2]);
						  resulTimetMap.put("PROVINCEID", policeProvinceid);
						  resulTimetMap.put("AREAID", policeAreaid);
						  resulTimetMap.put("TYPE", "3");//类型：1：热点wifi,2:嗅探wifi,3:imsi
						  if (hotSiteTimeList.contains(resulTimetMap)) {//表示数据已存在则修改总数
							  resulTimetMap.put("TOTAL", hotSiteTimeMap.get(key).size());//不能放在if外边否则会影响判断
							  updateHotSiteTimeList.add(resulTimetMap);
						  }else {
							  resulTimetMap.put("TOTAL", hotSiteTimeMap.get(key).size());//不能放在if外边否则会影响判断
							  insertHotSiteTimeList.add(resulTimetMap);
						  }
					} catch(Exception e) {
						e.printStackTrace();
					}
				}
				//importEntity.setGroupBySiteLocation(importEntity.getWsiteid()+"|"+importEntity.getWagentid()+"|"+time+"|"+location);
				for (String key : hotSiteLocationMap.keySet()) {
					try {
						Map<String,Object> resultLocationMap = new HashMap<String,Object>();
						String[] keys = key.split("\\|");
						resultLocationMap.put("SITEID",keys[0]);
						resultLocationMap.put("AGENTID",keys[1]);
						resultLocationMap.put("STATICTIME",keys[2]);
						String location = keys[3];
						String[] locations = locationPattren(location);
						resultLocationMap.put("LOCATIONPROVINCENAME", locations[0]);
						resultLocationMap.put("LOCATIONAREANAME", locations[1]);
						//resultLocationMap.put("TOTAL", hotSiteLocationMap.get(key).size());
						resultLocationMap.put("PROVINCEID", policeProvinceid);
						resultLocationMap.put("AREAID", policeAreaid);
						  if (hotSiteLocationList.contains(resultLocationMap)) {//表示数据已存在则修改总数
							  resultLocationMap.put("TOTAL", hotSiteLocationMap.get(key).size());//不能放在if外边否则会影响判断
							  updateHotSiteLocationList.add(resultLocationMap);
						  }else {
							  resultLocationMap.put("TOTAL", hotSiteLocationMap.get(key).size());//不能放在if外边否则会影响判断
							  insertHotSiteLocationList.add(resultLocationMap);
						  }
					} catch(Exception e) {
						e.printStackTrace();
					}
				}
				if (hotArea.equals("1")) {
					logger.info("============================开始遍历IMSI异常站点数据=======================================================================");
					long starttime = System.currentTimeMillis();
					insertHotSiteIMSITimeList = compareForIMSISite(hotSiteIMSITimeList,hotSiteIMSITimeMap);
					logger.info("============================耗时："+(System.currentTimeMillis()-starttime)+"毫秒==========================================");
				}
				wifiAndImsiImportService.updateSiteStatic(updateHotSiteStaticList);
				wifiAndImsiImportService.updateSiteStaticTime(updateHotSiteTimeList);
				wifiAndImsiImportService.updateSiteStaticLocation(updateHotSiteLocationList);
				wifiAndImsiImportService.updateIMSISite(updateHotSiteIMSITimeList);

				wifiAndImsiImportService.insertSiteStatic(insertHotSiteStaticList);
				wifiAndImsiImportService.insertSiteStaticTime(insertHotSiteTimeList);
				wifiAndImsiImportService.insertSiteStaticLocation(insertHotSiteLocationList);
				wifiAndImsiImportService.insertIMSISite(insertHotSiteIMSITimeList);
		 } catch(Exception e) {
			 e.printStackTrace();
			 return false;
		 }
		 return true;
	 }
	 /**
	  * 轨迹分析入库比较方法
	  * */
	 public List<Map<String,Object>> compareForIMSISite(List<Map<String,Object>> sourceList,Map<String, List<IMSIImportEntity>> hotSiteIMSITimeMap) {
		 Set<String> dataByFileSet = new HashSet<String>();//文件中获取的数据
		 Set<String> dataByDataSet = new HashSet<String>();//数据库中获取的数据
		 Set<String> tempSet = new HashSet<String>();//临时集合
		 for (String key : hotSiteIMSITimeMap.keySet()) {//Map数据转为set集合
				try {
					  String[] keys = key.split("\\|");
					  String IMSI = keys[0];
					  String SITEID = keys[1];
					  String STATICDAY = keys[2];
					  String compareValue = IMSI+"|"+SITEID+"|"+STATICDAY;
					  dataByFileSet.add(compareValue);
				} catch(Exception e) {
					logger.error(e.toString());
				}
			}
		 for (Map<String,Object> map : sourceList) {
			 String compareValue = map.get("COMPAREVALUE").toString();
			 dataByDataSet.add(compareValue);
		 }
		 tempSet.addAll(dataByFileSet);
		 tempSet.removeAll(dataByDataSet);
		 List<Map<String,Object>> list = new ArrayList<>();//IMSI站点时间-修改
		 for (String s : tempSet) {//转为list集合
			 try{
				 String[] ss = s.split("\\|");
				 Map<String,Object> params = new HashMap<String,Object>();
				 params.put("IMSI", ss[0]);
				 params.put("SITEID", ss[1]);
				 params.put("STATICDAY", ss[2]);
				 list.add(params);
			 }catch(Exception e) {
				 logger.error(e.toString());
			 }
		 }
		 return list;
	 }
	 public String[] locationPattren(String location) {
		 String[] result = new String[2];
		 if (location == null || "".equals(location)) {
			 result[0] = "其他";
			 result[1] = "其他";
		 } else if(Pattern.matches(".*-.*", location)){
			 result[0] = location.split("-")[0];
			 result[1] = location.split("-")[1];
		 } else if(Pattern.matches(".*省.*市", location)){
			 result[0] = location.split("省")[0];
			 String s = location.split("省")[1];
			 result[1] = s.substring(0, s.length()-1);
		 } else if(Pattern.matches(".*省.*", location)){
			 result[0] = location.split("省")[0];
			 result[1] = location.split("省")[1];
		 } else if(Pattern.matches(".*市.*", location)){
			 if (location.split("市").length > 1) {
				 result[0] = location.split("市")[0];
				 result[1] = location.split("市")[1]; 
			 } else {
				 result[0] = location.split("市")[0];
				 result[1] = "其他";
			 }
		 } else {
			 List<String> plist = new ArrayList<String>();
			 plist.add("内蒙古");
			 plist.add("广西");
			 plist.add("西藏");
			 plist.add("宁夏");
			 plist.add("新疆");
			 boolean isempty = true;
			 for (String p : plist) {
				 if (location.contains(p)) {
					 result[0] = p;
					 result[1] = location.substring(p.length(), location.length());
					 isempty = false;
				 }
			 }
			 if (isempty) {
				 result[0] = location;
				 result[1] = "其他";
			 }
		 }
		 return result;
	 }
	 /**
	  * 获取符合预警值得结果
	  * */
	 public void warmResult(List<IMSIImportEntity> anasisList) {
		 try {
			 List<HotWarmImportEntity> warmList = wifiAndImsiImportService.getWarmInfo("3");//3:imsi实时预警，4：wifi实时预警5:imei实时预警
			 List<Map<String,Object>> resultList = new ArrayList<Map<String,Object>>();
			 for (IMSIImportEntity imsiImportEntity : anasisList) {
				 try{
					 for (HotWarmImportEntity hotWarmEntity : warmList) {
						 if (hotWarmEntity.getWarmvalue().equals(imsiImportEntity.getImsi()) || hotWarmEntity.getWarmvalue().equals(imsiImportEntity.getImei())) {
							 Map<String,Object> map = new HashMap<String,Object>();
							 map.put("id", hotWarmEntity.getId());
							 map.put("warmTime", imsiImportEntity.getStarttime());
							 map.put("siteId", imsiImportEntity.getWsiteid());
							 resultList.add(map);
						 }
					 } 
				 } catch(Exception e) {
					 e.printStackTrace();
				 }
			 }
			 wifiAndImsiImportService.insertWarmResult(resultList); 
		 } catch(Exception e) {
			 e.printStackTrace();
		 }
	 }
}

//IMSI完整数据入库
class HotImsiHisImport implements Callable<Boolean>{
	List<IMSIImportEntity> list = null;
	WifiAndImsiImportService wifiAndImsiImportService;
	
	public HotImsiHisImport(List<IMSIImportEntity> list,WifiAndImsiImportService wifiAndImsiImportService) {
		this.list = list;
		this.wifiAndImsiImportService = wifiAndImsiImportService;
	}
	@Override
	public Boolean call() {
		try {
			int insertNum = wifiAndImsiImportService.insertIMSIData(list,"social_hot_imeilog_his");
			if (insertNum < 0) {
				return false;
			}
		}catch(Exception e) {
			return false;
		}
		return true;
	}
	
}

***第二个类WifiAndImsiImportServiceImpl.java定时任务线程池接口中，调用service插入数据库：***

@Service
public class WifiAndImsiImportServiceImpl extends BaseService<WifiAndImsiImportVO> implements WifiAndImsiImportService {
	@Resource
	WifiAndImsiImportMapper wifiAndImsiImportMapper;
	@Autowired
    DataSource dataSource;
	int batchSize = 1000;//每次导入条数
	/**
	 * 获取待导入数据
	 * */
	@Override
	public List<Map<String, Object>> getWaitImportData() {
		return wifiAndImsiImportMapper.getWaitImportData();
	}
	/**
	 * 修改待导入数据
	 * */
	@Override
	public void updateStatus(String ID, String status) {
		Map<String,Object> params = new HashMap<String,Object>();
		ID = StringUtil.addSemicolon(ID);
		params.put("id", ID);
		params.put("filestatus", status);
		wifiAndImsiImportMapper.updateStatus(params);
	}
	/**
	 * 导入WIFI数据
	 * */
	@Override
	public int insertWifiData(List<WifiImportEntity> wifiList, String tableName) {
		int insertNum = 0;//成功添加数量
		try{
			Connection con = dataSource.getConnection();
			StringBuffer suffix = new StringBuffer();
			PreparedStatement ps = con.prepareStatement("");
		   	try {
		        String prefix  =  "INSERT INTO shzy."+tableName+"("
				        		+ "mac,"
				        		+ "wsiteid,"
				        		+ "wagentid,"
				        		+ "starttime,"
				        		+ "filename,"
				        		+ "importtime,"
				        		+ "longitude,"
				        		+ "latitude,"
				        		+ "police_stationid,"
				        		+ "police_areaid,"
				        		+ "police_provinceid"
				        		+ ") values ";
				int i= 0;
		        con.setAutoCommit(false);
		        //保存sql后缀     
		        int j = 0;
		        for (WifiImportEntity wifiImportEntity : wifiList) {
		        	i++;
		        	suffix.append("("
		        			+"'"+ escapeSqlUtil.escapeSql(wifiImportEntity.getMac())+"', "
		        			+"'"+escapeSqlUtil.escapeSql(wifiImportEntity.getWsiteid())+"', "  
		        			+"'"+escapeSqlUtil.escapeSql(wifiImportEntity.getWagentid())+"', "  
		        			+"'"+escapeSqlUtil.escapeSql(wifiImportEntity.getStarttime())+"', "  
		        			+"'"+escapeSqlUtil.escapeSql(wifiImportEntity.getFilename())+"', "  
		        			+"'"+escapeSqlUtil.escapeSql(wifiImportEntity.getImporttime())+"', "  
		        			+"'"+escapeSqlUtil.escapeSql(wifiImportEntity.getLongitude())+"', "  
		        			+"'"+escapeSqlUtil.escapeSql(wifiImportEntity.getLatitude())+"', "  
		        			+"'"+escapeSqlUtil.escapeSql(wifiImportEntity.getPoliceStationid())+"', "  
		        			+"'"+escapeSqlUtil.escapeSql(wifiImportEntity.getPoliceAreaid())+"', "  
		        			+"'"+escapeSqlUtil.escapeSql(wifiImportEntity.getPoliceProvinceid())+"'"  
		        			+ "),");
	            	  if ( i % batchSize == 0 || i == batchSize) {
	            		  try{            		  
		                      String sql = prefix + suffix.substring(0, suffix.length() - 1);// 构建完整sql     
		                      ps.addBatch(sql);  // 添加执行sql    
		                      int[] size = ps.executeBatch(); // 执行操作
		                      con.commit();  // 提交事务    
		                      suffix = new StringBuffer();// 清空上一次添加的数据
		                      if (size != null && size.length>0) {
		                    	  insertNum = insertNum+size[0];
		                      }
	            		  }catch(Exception ex){
	            			  ex.printStackTrace();
	            			  System.out.println(""+suffix);
	            			  suffix = new StringBuffer();    
	            		  }
	                 }
		          }
		        if (suffix != null && suffix.length() > 0) {
		              String sql = prefix + suffix.substring(0, suffix.length() - 1);    
		              ps.addBatch(sql);//添加执行sql      
		              int[] num = ps.executeBatch();//执行操作     
		              con.commit();//提交事务
	                  if (num != null && num.length>0) {
	                	  insertNum = insertNum+num[0];
	                  }
		        }
			  }catch (Exception e) {
	        	System.out.println(""+suffix);
	        	return -1;
			  } finally{
	              try {
		              ps.close();
		              con.close();
	              } catch(Exception e) {
	            	 e.printStackTrace();
	            	 return -1;
	              }
			  }
		}catch(Exception ex){
			ex.printStackTrace();
			return -1;
		} 
		return insertNum;
	}
	/**
	 * 导入IMSI数据
	 * */
	@Override
	public int insertIMSIData(List<IMSIImportEntity> imsiList, String tableName) {
		int insertNum = 0;//成功添加数量
		try{
			Connection con = dataSource.getConnection();
			StringBuffer suffix = new StringBuffer();
			PreparedStatement ps = con.prepareStatement("");
		   	try {
		        String prefix  =  "INSERT INTO shzy."+tableName+"("
				        		+ "imei,"
				        		+ "imsi,"
				        		+ "wsiteid,"
				        		+ "wagentid,"
				        		+ "starttime,"
				        		+ "location,"
				        		+ "model,"
				        		+ "filename,"
				        		+ "importtime,"
				        		+ "police_stationid,"
				        		+ "police_areaid,"
				        		+ "police_provinceid"
				        		+ ") values ";
				int i= 0;
		        con.setAutoCommit(false);
		        //保存sql后缀     
		        int j = 0;
		        for (IMSIImportEntity imsiImportEntity : imsiList) {
		        	i++;
		        	suffix.append("("
		        			+"'"+escapeSqlUtil.escapeSql(imsiImportEntity.getImei())+"', "
		        			+"'"+escapeSqlUtil.escapeSql(imsiImportEntity.getImsi())+"', "  
		        			+"'"+escapeSqlUtil.escapeSql(imsiImportEntity.getWsiteid())+"', "  
		        			+"'"+escapeSqlUtil.escapeSql(imsiImportEntity.getWagentid())+"', "  
		        			+"'"+escapeSqlUtil.escapeSql(imsiImportEntity.getStarttime())+"', "    
		        			+"'"+escapeSqlUtil.escapeSql(imsiImportEntity.getLocation())+"', "  
		        			+"'"+escapeSqlUtil.escapeSql(imsiImportEntity.getModel())+"', " 
				        	+"'"+escapeSqlUtil.escapeSql(imsiImportEntity.getFilename())+"', "  
				        	+"'"+escapeSqlUtil.escapeSql(imsiImportEntity.getImporttime())+"', " 
		        			+"'"+escapeSqlUtil.escapeSql(imsiImportEntity.getPoliceStationid())+"', "  
		        			+"'"+escapeSqlUtil.escapeSql(imsiImportEntity.getPoliceAreaid())+"', "  
		        			+"'"+escapeSqlUtil.escapeSql(imsiImportEntity.getPoliceProvinceid())+"'"  
		        			+ "),");
	            	  if ( i % batchSize == 0 || i == batchSize) {
	            		  try{            		  
		                      String sql = prefix + suffix.substring(0, suffix.length() - 1);// 构建完整sql     
		                      ps.addBatch(sql);  // 添加执行sql    
		                      int[] size = ps.executeBatch(); // 执行操作
		                      con.commit();  // 提交事务    
		                      suffix = new StringBuffer();// 清空上一次添加的数据
		                      if (size != null && size.length>0) {
		                    	  insertNum = insertNum+size[0];
		                      }
	            		  }catch(Exception ex){
	            			  ex.printStackTrace();
	            			  System.out.println(""+suffix);
	            			  suffix = new StringBuffer();    
	            		  }
	                 }
		          }
		        if (suffix != null && suffix.length() > 0) {
		              String sql = prefix + suffix.substring(0, suffix.length() - 1);    
		              ps.addBatch(sql);//添加执行sql      
		              int[] num = ps.executeBatch();//执行操作     
		              con.commit();//提交事务
	                  if (num != null && num.length>0) {
	                	  insertNum = insertNum+num[0];
	                  }
		        }
			  }catch (Exception e) {
	        	System.out.println(""+suffix);
	        	return -1;
			  } finally{
	              try {
		              ps.close();
		              con.close();
	              } catch(Exception e) {
	            	 e.printStackTrace(); 
	              }
			  }
		}catch(Exception ex){
			ex.printStackTrace();
			return -1;
		} 
		return insertNum;
	}
	/**
	 * 导入IMSI数据txt
	 * */
	@Override
	public int insertIMSIDataTxt(List<IMSIImportEntity> imsiList,String tableName) {
		int insertNum = 0;//成功添加数量
		try{
			Connection con = dataSource.getConnection();
			StringBuffer suffix = new StringBuffer();
			PreparedStatement ps = con.prepareStatement("");
		   	try {
		        String prefix  =  "INSERT INTO shzy."+tableName+"("
				        		+ "imsi,"
				        		+ "starttime,"
				        		+ "filename,"
				        		+ "importtime,"
				        		+ "police_stationid,"
				        		+ "police_areaid,"
				        		+ "police_provinceid"
				        		+ ") values ";
				int i= 0;
		        con.setAutoCommit(false);
		        //保存sql后缀     
		        int j = 0;
		        for (IMSIImportEntity imsiImportEntity : imsiList) {
		        	i++;
		        	suffix.append("("
		        			+"'"+escapeSqlUtil.escapeSql(imsiImportEntity.getImsi())+"', "   
		        			+"'"+escapeSqlUtil.escapeSql(imsiImportEntity.getStarttime())+"', " 
				        	+"'"+escapeSqlUtil.escapeSql(imsiImportEntity.getFilename())+"', "  
				        	+"'"+escapeSqlUtil.escapeSql(imsiImportEntity.getImporttime())+"', " 
		        			+"'"+escapeSqlUtil.escapeSql(imsiImportEntity.getPoliceStationid())+"', "  
		        			+"'"+escapeSqlUtil.escapeSql(imsiImportEntity.getPoliceAreaid())+"', "  
		        			+"'"+escapeSqlUtil.escapeSql(imsiImportEntity.getPoliceProvinceid())+"'"  
		        			+ "),");
	            	  if ( i % batchSize == 0 || i == batchSize) {
	            		  try{            		  
		                      String sql = prefix + suffix.substring(0, suffix.length() - 1);// 构建完整sql     
		                      ps.addBatch(sql);  // 添加执行sql    
		                      int[] size = ps.executeBatch(); // 执行操作
		                      con.commit();  // 提交事务    
		                      suffix = new StringBuffer();// 清空上一次添加的数据
		                      if (size != null && size.length>0) {
		                    	  insertNum = insertNum+size[0];
		                      }
	            		  }catch(Exception ex){
	            			  ex.printStackTrace();
	            			  System.out.println(""+suffix);
	            			  suffix = new StringBuffer();    
	            		  }
	                 }
		          }
		        if (suffix != null && suffix.length() > 0) {
		              String sql = prefix + suffix.substring(0, suffix.length() - 1);    
		              ps.addBatch(sql);//添加执行sql      
		              int[] num = ps.executeBatch();//执行操作     
		              con.commit();//提交事务
	                  if (num != null && num.length>0) {
	                	  insertNum = insertNum+num[0];
	                  }
		        }
			  }catch (Exception e) {
	        	System.out.println(""+suffix);
	        	return -1;
			  } finally{
	              try {
		              ps.close();
		              con.close();
	              } catch(Exception e) {
	            	 e.printStackTrace(); 
	              }
			  }
		}catch(Exception ex){
			ex.printStackTrace();
			return -1;
		} 
		return insertNum;
	}
	/**
	 * 修改站点采集统计表（不含小时统计）
	 * */
	@Override
	public void updateSiteStatic(List<Map<String, Object>> list) {
		if (list != null && list.size()>0) {
			wifiAndImsiImportMapper.updateSiteStatic(list);
		}
	}
	/**
	 * 修改站点采集统计表（含小时统计）
	 * */
	@Override
	public void updateSiteStaticTime(List<Map<String, Object>> list) {
		if (list != null && list.size()>0) {
			wifiAndImsiImportMapper.updateSiteStaticTime(list);
		}
	}
	/**
	 * 修改站点归属地采集统计表
	 * */
	@Override
	public void updateSiteStaticLocation(List<Map<String, Object>> list) {
		if (list != null && list.size()>0) {
			wifiAndImsiImportMapper.updateSiteStaticLocation(list);
		}
	}
	/**
	 * 获取站点采集统计表（不含小时统计）
	 * */
	@Override
	public List<Map<String, Object>> getSiteStatic() {
		return wifiAndImsiImportMapper.getSiteStatic();
	}
	/**
	 * 获取站点采集统计表（含小时统计）
	 * */
	@Override
	public List<Map<String, Object>> getSiteStaticTime() {
		return wifiAndImsiImportMapper.getSiteStaticTime();
	}
	/**
	 * 获取站点归属地采集统计表
	 * */
	@Override
	public List<Map<String, Object>> getSiteStaticLocation() {
		return wifiAndImsiImportMapper.getSiteStaticLocation();
	}
	/**
	 * 添加站点采集统计表（不含小时统计）
	 * */
	@Override
	public void insertSiteStatic(List<Map<String, Object>> list) {
		if (list != null && list.size()>0) {
			wifiAndImsiImportMapper.insertSiteStatic(list);
		}
	}
	/**
	 * 添加站点采集统计表（含小时统计）
	 * */
	@Override
	public void insertSiteStaticTime(List<Map<String, Object>> list) {
		if (list != null && list.size()>0) {
			wifiAndImsiImportMapper.insertSiteStaticTime(list);
		}
	}
	/**
	 * 添加站点归属地采集统计表
	 * */
	@Override
	public void insertSiteStaticLocation(List<Map<String, Object>> list) {
		if (list != null && list.size()>0) {
			wifiAndImsiImportMapper.insertSiteStaticLocation(list);
		}	
	}
	/**
	 * 获取实时预警信息
	 * */
	@Override
	public List<HotWarmImportEntity> getWarmInfo(String type) {
		if (type.equals("3")) {//类型为3时同时查询IMSI和IMEI
			type = "3,5";
			type = StringUtil.addSemicolon(type);
		}
		return wifiAndImsiImportMapper.getWarmInfo(type);
	}
	/**
	 * 添加预警结果信息
	 * */
	@Override
	public void insertWarmResult(List<Map<String, Object>> list) {
		if (list != null && list.size()>0) {
			wifiAndImsiImportMapper.insertWarmResult(list);
		}
	}
	/**
	 * 获取imsi归属地信息
	 */
	@Override
	public Map<String, Object> getImsiLocation() {
		// TODO Auto-generated method stub
		List<Map<String, Object>> listLocation=wifiAndImsiImportMapper.getImsiLocation();
		Map<String, Object> mapLocation=new HashMap<String, Object>();
		for (Map<String, Object> map : listLocation) {
			
			try {
				mapLocation.put(map.get("IMSI").toString(), map.get("city").toString());
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}
		}
		return  mapLocation;
	}
	/**
	 * 获取IMSI站点统计信息
	 * */
	@Override
	public List<Map<String, Object>> getIMSISite() {
		return wifiAndImsiImportMapper.getIMSISite();
	}
	/**
	 * 修改IMSI站点统计信息
	 * */
	@Override
	public void updateIMSISite(List<Map<String, Object>> list) {
		if (list != null && list.size()>0) {
			List<List<Map<String,Object>>> importList = CollectionUtils.fixedGrouping(list, 100);
			for (List<Map<String,Object>> l : importList) {
				if (l != null && l.size()>0) {
					wifiAndImsiImportMapper.updateIMSISite(l);
				}
			}
			
		}
	}
	/**
	 * 添加IMSI站点统计信息
	 * */
	@Override
	public void insertIMSISite(List<Map<String, Object>> list) {
		if (list != null && list.size()>0) {
			List<List<Map<String,Object>>> importList = CollectionUtils.fixedGrouping(list, 100);
			for (List<Map<String,Object>> l : importList) {
				if (l != null && l.size()>0) {
					wifiAndImsiImportMapper.insertIMSISite(l);
				}
			}
		}
	}
}