1703 lines
64 KiB
Java
1703 lines
64 KiB
Java
package com.nis.web.service.restful;
|
||
|
||
import java.text.ParseException;
|
||
import java.text.SimpleDateFormat;
|
||
import java.util.ArrayList;
|
||
import java.util.Calendar;
|
||
import java.util.Collections;
|
||
import java.util.Comparator;
|
||
import java.util.Date;
|
||
import java.util.HashMap;
|
||
import java.util.HashSet;
|
||
import java.util.Iterator;
|
||
import java.util.LinkedHashMap;
|
||
import java.util.List;
|
||
import java.util.Map;
|
||
import java.util.Map.Entry;
|
||
import java.util.Set;
|
||
|
||
import org.springframework.beans.factory.annotation.Autowired;
|
||
import org.springframework.stereotype.Service;
|
||
|
||
import com.beust.jcommander.internal.Maps;
|
||
import com.nis.domain.restful.NtcConnNumReport;
|
||
import com.nis.domain.restful.NtcEntranceReport;
|
||
import com.nis.domain.restful.dashboard.AppConnRecordStatistic;
|
||
import com.nis.domain.restful.dashboard.NtcTotalReport;
|
||
import com.nis.domain.restful.dashboard.TrafficAppFocusStatistic;
|
||
import com.nis.domain.restful.dashboard.TrafficAppStatistic;
|
||
import com.nis.domain.restful.dashboard.TrafficHttpFocusStatistic;
|
||
import com.nis.domain.restful.dashboard.TrafficIpActiveStatistic;
|
||
import com.nis.domain.restful.dashboard.TrafficPortActiveStatistic;
|
||
import com.nis.domain.restful.dashboard.TrafficProtocolStatistic;
|
||
import com.nis.domain.restful.dashboard.TrafficTransStatistic;
|
||
import com.nis.domain.restful.dashboard.TrafficUaStatistic;
|
||
import com.nis.restful.RestBusinessCode;
|
||
import com.nis.restful.RestServiceException;
|
||
import com.nis.util.Constants;
|
||
import com.nis.util.DateUtils;
|
||
import com.nis.util.StringUtils;
|
||
import com.nis.web.dao.dashboard.NtcTotalReportDao;
|
||
import com.nis.web.dao.dashboard.TrafficAppStatisticDao;
|
||
import com.nis.web.dao.dashboard.TrafficHttpStatisticDao;
|
||
import com.nis.web.dao.dashboard.TrafficIpActiveStatisticDao;
|
||
import com.nis.web.dao.dashboard.TrafficPortActiveStatisticDao;
|
||
import com.nis.web.dao.dashboard.TrafficProtocolStatisticDao;
|
||
import com.nis.web.dao.dashboard.TrafficUaStatisticDao;
|
||
import com.nis.web.service.BaseService;
|
||
import com.zdjizhi.utils.StringUtil;
|
||
|
||
@Service
|
||
public class DashboardService extends BaseService {
|
||
|
||
@Autowired
|
||
public TrafficIpActiveStatisticDao trafficIpActiveStatisticDao;
|
||
@Autowired
|
||
public TrafficProtocolStatisticDao trafficProtocolStatisticDao;
|
||
@Autowired
|
||
public TrafficAppStatisticDao trafficAppStatisticDao;
|
||
@Autowired
|
||
public TrafficUaStatisticDao trafficUaStatisticDao;
|
||
@Autowired
|
||
public TrafficHttpStatisticDao trafficHttpStatisticDao;
|
||
@Autowired
|
||
public NtcTotalReportDao ntcTotalReportDao;
|
||
@Autowired
|
||
public TrafficPortActiveStatisticDao trafficPortActiveStatisticDao;
|
||
|
||
/**
|
||
* 流量统计 数据显示 info：先查询最近时间，根据时间条件查询数据 效率提高
|
||
*/
|
||
public List<Map> getTotalReportList() {
|
||
List<Map> totalReportList = new ArrayList<Map>();
|
||
List<Map> newData = new ArrayList<Map>();
|
||
// 流量统计阻断丢弃回流等数据显示最近时间
|
||
NtcTotalReport maxReportTime = ntcTotalReportDao.getMaxReportTime();
|
||
if (maxReportTime != null && maxReportTime.getReportTime() != null) {
|
||
Date reportTime = maxReportTime.getReportTime();
|
||
totalReportList = ntcTotalReportDao.getTotalReportList(reportTime);// 返回阻断，监测等結果
|
||
}
|
||
Map maxRecvtTime = ntcTotalReportDao.getMaxStatTime();
|
||
if (maxRecvtTime != null && maxRecvtTime.get("statTime") != null) {
|
||
Date recvTime = (Date) maxRecvtTime.get("statTime");
|
||
newData = ntcTotalReportDao.getNetFlowPortInfoNew(recvTime);
|
||
}
|
||
// 统计带宽的流入流出 单位 五分钟 的 byte
|
||
if (StringUtil.isNotEmpty(newData)) {
|
||
Double inoctets = Double.parseDouble(newData.get(0).get("inoctets").toString());
|
||
Double outoctets = Double.parseDouble(newData.get(0).get("outoctets").toString());
|
||
|
||
if (StringUtil.isEmpty(totalReportList)) {
|
||
Map valueMap = Maps.newHashMap();
|
||
valueMap.put("inoctets", inoctets);
|
||
valueMap.put("outoctets", outoctets);
|
||
totalReportList.add(valueMap);
|
||
} else {
|
||
totalReportList.get(0).put("inoctets", inoctets);
|
||
totalReportList.get(0).put("outoctets", outoctets);
|
||
}
|
||
}
|
||
return totalReportList;
|
||
}
|
||
|
||
/**
|
||
* 根据ip46,协议tcp，udp查询带宽
|
||
*
|
||
* @param addrType
|
||
* @param transType
|
||
* @return
|
||
*/
|
||
/*
|
||
* public List<HashMap> getBandwidthTrans(String addrType, Integer
|
||
* transType,String beginDate,String endDate) { ArrayList<HashMap> listMap = new
|
||
* ArrayList<HashMap>(); List<TrafficTransStatistic> bandwidthList = new
|
||
* ArrayList<TrafficTransStatistic>(); Map maxStatTime =
|
||
* ntcTotalReportDao.getMaxStatTime(); if (maxStatTime != null &&
|
||
* maxStatTime.get("statTime") != null) { Date stat = (Date)
|
||
* maxStatTime.get("statTime"); HashMap m = new HashMap(); bandwidthList =
|
||
* ntcTotalReportDao.getBandwidthTrans(stat, addrType, transType); List timeList
|
||
* = new ArrayList(); List linkList = new ArrayList(); List gbpsList = new
|
||
* ArrayList(); List ppsList = new ArrayList(); if (bandwidthList != null &&
|
||
* bandwidthList.size() > 0) { for (TrafficTransStatistic tt : bandwidthList) {
|
||
* if (tt.getTime() != null) { timeList.add(tt.getTime()); if (tt.getLinkNum()
|
||
* != null) { linkList.add(tt.getLinkNum()); } if (tt.getPps() != null) {
|
||
* ppsList.add(tt.getPps()); } if (tt.getGbps() != null) {
|
||
* gbpsList.add(tt.getGbps()); } } } } m.put("linkNum", linkList); m.put("gbps",
|
||
* gbpsList); m.put("pps", ppsList); m.put("statTime", timeList);
|
||
* listMap.add(m); } return listMap; }
|
||
*/
|
||
/**
|
||
* 根据ip46,协议tcp，udp查询带宽
|
||
*
|
||
* @param addrType
|
||
* @param transType
|
||
* @return
|
||
*/
|
||
@Deprecated
|
||
public List<HashMap> getBandwidthTrans(String addrType, Integer transType, String beginDate, String endDate) {
|
||
ArrayList<HashMap> listMap = new ArrayList<HashMap>();
|
||
|
||
HashMap m1 = getBandwidthTransEntrance(addrType, transType, beginDate, endDate, 1);
|
||
if (m1 != null && m1.size() > 0) {
|
||
m1.put("entranceId", 1);// 局点1.2 不同来源
|
||
listMap.add(m1);
|
||
}
|
||
return listMap;
|
||
|
||
}
|
||
|
||
/**
|
||
* 根据ip46,协议tcp，udp查询带宽
|
||
*
|
||
* @param addrType
|
||
* @param transType
|
||
* @return
|
||
*/
|
||
@Deprecated
|
||
public List<HashMap> getBandwidthTrans2(String addrType, Integer transType, String beginDate, String endDate) {
|
||
ArrayList<HashMap> listMap = new ArrayList<HashMap>();
|
||
|
||
HashMap m2 = getBandwidthTransEntrance(addrType, transType, beginDate, endDate, 2);
|
||
if (m2 != null && m2.size() > 0) {
|
||
m2.put("entranceId", 2);
|
||
listMap.add(m2);
|
||
}
|
||
return listMap;
|
||
|
||
}
|
||
|
||
/**
|
||
* 查询单个局点流量的数据信息
|
||
*
|
||
* @param addrType
|
||
* @param transType
|
||
* @param beginDate
|
||
* @param endDate
|
||
* @param entranceId
|
||
* @return
|
||
*/
|
||
@Deprecated
|
||
public HashMap getBandwidthTransEntrance(String addrType, Integer transType, String beginDate, String endDate,
|
||
Integer entranceId) {
|
||
long start = System.currentTimeMillis();
|
||
ArrayList<HashMap> listMap = new ArrayList<HashMap>();
|
||
List<TrafficTransStatistic> bandwidthList = new ArrayList<TrafficTransStatistic>();
|
||
HashMap resulMap = new HashMap();
|
||
bandwidthList = ntcTotalReportDao.getBandwidthTrans(entranceId, beginDate, endDate, addrType, transType);
|
||
List timeList = new ArrayList();
|
||
List linkList = new ArrayList();
|
||
List gbpsList = new ArrayList();
|
||
List ppsList = new ArrayList();
|
||
if (bandwidthList != null && bandwidthList.size() > 0) {
|
||
Map<String, Comparable> m = new HashMap<String, Comparable>();
|
||
int inter = 1000 * 60 * 5;// 间隔时间为五分钟
|
||
// 开始时间，结束时间 时间戳
|
||
Long b = dateToStamp(beginDate);
|
||
Long e = dateToStamp(endDate);
|
||
int num = 0;
|
||
Long pointTime = b;
|
||
while (pointTime < e) {
|
||
Map rm = new HashMap();
|
||
Long sumL = 0l;
|
||
Long sumP = 0l;
|
||
Long sumG = 0l;
|
||
if (pointTime >= e) {
|
||
break; // 停止
|
||
}
|
||
for (TrafficTransStatistic tt : bandwidthList) {
|
||
// 实际时间
|
||
String time = tt.getTime();
|
||
Long t = dateToStamp(time);
|
||
if (t >= pointTime && t < pointTime + inter) {
|
||
// 范围之内分到此pointTime组
|
||
sumL = sumL + tt.getLinkNum();
|
||
sumP = sumP + Long.parseLong(tt.getPps().substring(0, tt.getPps().lastIndexOf(".")));
|
||
sumG = sumG + Long.parseLong(tt.getGbps().substring(0, tt.getGbps().lastIndexOf(".")));
|
||
}
|
||
}
|
||
// 在结束时间只有当值大于0时才记录数据，防止折线降为0引起误会
|
||
if (pointTime >= e - inter && sumL > 0) {
|
||
linkList.add(sumL);
|
||
}
|
||
if (pointTime >= e - inter && sumP > 0) {
|
||
ppsList.add(sumP);
|
||
}
|
||
if (pointTime >= e - inter && sumG > 0) {
|
||
gbpsList.add(sumG);
|
||
}
|
||
if (pointTime >= e - inter && (sumL > 0 || sumG > 0 || sumP > 0)) {
|
||
timeList.add(stampToDate(pointTime));
|
||
}
|
||
if (pointTime < e - inter) {
|
||
timeList.add(stampToDate(pointTime));
|
||
linkList.add(sumL);
|
||
gbpsList.add(sumG);
|
||
ppsList.add(sumP);
|
||
}
|
||
|
||
num = num + 1;
|
||
pointTime = b + inter * num;
|
||
}
|
||
resulMap.put("linkNum", linkList);
|
||
resulMap.put("gbps", gbpsList);
|
||
resulMap.put("pps", ppsList);
|
||
resulMap.put("statTime", timeList);
|
||
}
|
||
return resulMap;
|
||
}
|
||
|
||
/**
|
||
* 将结果格式为时间间隔相同，数量补0数据
|
||
*
|
||
* @param begin
|
||
* @param end
|
||
* @param li
|
||
* @return
|
||
*/
|
||
@Deprecated
|
||
public static List<Map> formatDateData(String begin, String end, List<Map> li) {
|
||
List<Map> resList = new ArrayList<Map>();
|
||
Map<String, Comparable> m = new HashMap<String, Comparable>();
|
||
int inter = 1000 * 60 * 60;// 间隔时间为一小时
|
||
// 开始时间，结束时间 时间戳
|
||
Long b = dateToStamp(begin);
|
||
Long e = dateToStamp(end);
|
||
int num = 0;
|
||
Long pointTime = b;
|
||
while (pointTime < e) {
|
||
Map rm = new HashMap();
|
||
Long sum = 0l;
|
||
if (pointTime >= e) {
|
||
break; // 停止
|
||
}
|
||
for (Map<?, ?> map : li) {
|
||
// 实际时间
|
||
String time = (String) map.get("time");
|
||
Long t = dateToStamp(time);
|
||
if (t >= pointTime && t < pointTime + inter) {
|
||
// 范围之内分到此pointTime组
|
||
sum = sum + (Long) map.get("count");
|
||
}
|
||
}
|
||
rm.put("time", stampToDate(pointTime));
|
||
rm.put("sum", sum);
|
||
num = num + 1;
|
||
pointTime = b + inter * num;
|
||
resList.add(rm);
|
||
}
|
||
return resList;
|
||
}
|
||
|
||
/**
|
||
* 日期格式字符串转换成时间戳
|
||
*
|
||
* @param date 字符串日期
|
||
* @param format 如：yyyy-MM-dd HH:mm:ss
|
||
* @return
|
||
*/
|
||
@Deprecated
|
||
public static Long dateToStamp(String date_str) {
|
||
try {
|
||
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
||
return sdf.parse(date_str).getTime();
|
||
} catch (Exception e) {
|
||
e.printStackTrace();
|
||
}
|
||
return 0l;
|
||
}
|
||
|
||
/**
|
||
* 时间戳 换成日期格式字符串转
|
||
*
|
||
* @param 时间 1544602212000
|
||
* @param format 如：yyyy-MM-dd HH:mm:ss
|
||
* @return
|
||
*/
|
||
@Deprecated
|
||
public static String stampToDate(long timeStamp) {
|
||
SimpleDateFormat sdf = new SimpleDateFormat("MM-dd HH:mm");// 这个是你要转成后的时间的格式
|
||
String sd = sdf.format(new Date(timeStamp)); // 时间戳转换成时间
|
||
return sd;
|
||
}
|
||
|
||
/**
|
||
* 根据service 动作查询近五分钟变化趋势 entrance 默认为1,2
|
||
*/
|
||
/*
|
||
* public List<HashMap> getActionTrans(String begin, String end, String
|
||
* serviceType) { String sql = ""; String sqlBlock =
|
||
* "((service>=16 and service<=40) or (service>=258 and service<=273) or (service=576))"
|
||
* ; // 阻断 String sqlMonitor =
|
||
* "((service>=128 and service<=152) or (service>=384 and service<=513) or (service=592) or (service>=848 and service<=1030) or (service=1152))"
|
||
* ; // 监测 String sqlDrop =
|
||
* "((service>=1040 and service<=1042) or (service=3) or (service=5) or (service=25) or (service=28) or (service=274))"
|
||
* ; // 丢弃 String sqlLoop = "((service=4) or (service>=832 and service<=834))";
|
||
* // 回流 // 区分动作 if (StringUtils.isNotBlank(serviceType)) { if
|
||
* (serviceType.equalsIgnoreCase("block")) { sql = sqlBlock; } if
|
||
* (serviceType.equalsIgnoreCase("monitor")) { sql = sqlMonitor; } if
|
||
* (serviceType.equalsIgnoreCase("drop")) { sql = sqlDrop; } if
|
||
* (serviceType.equalsIgnoreCase("loop")) { sql = sqlLoop; } }
|
||
* ArrayList<HashMap> listMap = new ArrayList<HashMap>();
|
||
* List<NtcEntranceReport> entrance1 = new ArrayList<NtcEntranceReport>();
|
||
* List<NtcEntranceReport> entrance2 = new ArrayList<NtcEntranceReport>();
|
||
* HashMap m1 = new HashMap(); HashMap m2 = new HashMap(); entrance1 =
|
||
* ntcTotalReportDao.getActionTrans(begin, end, 1, sql); entrance2 =
|
||
* ntcTotalReportDao.getActionTrans(begin, end, 2, sql); List timeList = new
|
||
* ArrayList(); List sumList1 = new ArrayList(); List sumList2 = new
|
||
* ArrayList();
|
||
*
|
||
* Map<String, Comparable> m = new HashMap<String, Comparable>(); int inter =
|
||
* 1000 * 60 * 5;// 间隔时间为五分钟 // 开始时间，结束时间 时间戳 Long b = dateToStamp(begin); Long
|
||
* e = dateToStamp(end); int num = 0; Long pointTime = b; while (pointTime < e)
|
||
* { Map rm = new HashMap(); Long sum1 = 0l; Long sum2 = 0l; if (pointTime >= e)
|
||
* { break; // 停止 } for (NtcEntranceReport e1 : entrance1) { // 实际时间 String time
|
||
* = e1.getTime(); Long t = dateToStamp(time); if (t >= pointTime && t <
|
||
* pointTime + inter) { // 范围之内分到此pointTime组 sum1 = sum1 + e1.getSum(); } } for
|
||
* (NtcEntranceReport e2 : entrance2) { // 实际时间 String time = e2.getTime(); Long
|
||
* t = dateToStamp(time); if (t >= pointTime && t < pointTime + inter) { //
|
||
* 范围之内分到此pointTime组 sum2 = sum2 + e2.getSum(); } } //
|
||
* 在结束时间只有当值大于0时才记录数据，防止折线降为0引起误会 if (pointTime >= e - inter && sum1 > 0) {
|
||
* sumList1.add(sum1); } if (pointTime >= e - inter && sum2 > 0) {
|
||
* sumList2.add(sum2); } if (pointTime >= e - inter && (sum1 > 0 || sum2 > 0)) {
|
||
* timeList.add(stampToDate(pointTime)); } if (pointTime < e - inter) {
|
||
* sumList1.add(sum1); sumList2.add(sum2); timeList.add(stampToDate(pointTime));
|
||
* } num = num + 1; pointTime = b + inter * num; } m1.put("count", sumList1);
|
||
* m1.put("statTime", timeList); m1.put("entranceId", 1); m2.put("count",
|
||
* sumList2);// m2.put("statTime", timeList); m2.put("entranceId", 2);
|
||
* listMap.add(m1); listMap.add(m2); return listMap; }
|
||
*/
|
||
/**
|
||
* 根据service 动作查询近五分钟变化趋势 entrance 默认为1,2
|
||
*/
|
||
public List<HashMap> getActionTrans2(String begin, String end, String serviceType) {
|
||
String sql = "";
|
||
String sqlBlock = "((service>=16 and service<=40) or (service>=258 and service<=273) or (service=576))"; // 阻断
|
||
String sqlMonitor = "((service>=128 and service<=152) or (service>=384 and service<=513) or (service=592) or (service>=848 and service<=1030) or (service=1152))"; // 监测
|
||
String sqlDrop = "((service>=1040 and service<=1042) or (service=3) or (service=5) or (service=25) or (service=28) or (service=274))"; // 丢弃
|
||
String sqlLoop = "((service=4) or (service>=832 and service<=834))"; // 回流
|
||
// 区分动作
|
||
if (StringUtils.isNotBlank(serviceType)) {
|
||
if (serviceType.equalsIgnoreCase("action_reject")) {
|
||
sql = sqlBlock;
|
||
}
|
||
if (serviceType.equalsIgnoreCase("action_monit")) {
|
||
sql = sqlMonitor;
|
||
}
|
||
if (serviceType.equalsIgnoreCase("action_drop")) {
|
||
sql = sqlDrop;
|
||
}
|
||
if (serviceType.equalsIgnoreCase("action_loop")) {
|
||
sql = sqlLoop;
|
||
}
|
||
}
|
||
ArrayList<HashMap> listMap = new ArrayList<HashMap>();
|
||
List<NtcEntranceReport> entrance1 = new ArrayList<NtcEntranceReport>();
|
||
List<NtcEntranceReport> entrance2 = new ArrayList<NtcEntranceReport>();
|
||
HashMap m1 = new HashMap();
|
||
HashMap m2 = new HashMap();
|
||
entrance1 = ntcTotalReportDao.getActionTrans(begin, end, 1, sql);
|
||
entrance2 = ntcTotalReportDao.getActionTrans(begin, end, 2, sql);
|
||
|
||
if(!StringUtil.isEmpty(entrance1)||!StringUtil.isEmpty(entrance2)){
|
||
Map<String, Comparable> m = new HashMap<String, Comparable>();
|
||
Date beginDate = DateUtils.parseDate(begin);
|
||
Date endDate = DateUtils.parseDate(end);
|
||
|
||
List<Date> dateRangeList = new ArrayList<Date>();
|
||
Calendar calendar = Calendar.getInstance();
|
||
calendar.setTime(beginDate);
|
||
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
||
while (calendar.getTime().compareTo(endDate) < 0) {
|
||
dateRangeList.add(calendar.getTime());
|
||
calendar.add(Calendar.MINUTE, Constants.TREND_TIME_INTERVAL);
|
||
}
|
||
// 存放每个时间点的总数
|
||
Map<String, List<Long>> ipCountListMap = new HashMap<String, List<Long>>();
|
||
int index1 = 0;
|
||
int index2 = 0;
|
||
List sumList1 = new ArrayList();
|
||
List sumList2 = new ArrayList();
|
||
Long sumEnt1 = 0L;
|
||
Long sumEnt2 = 0L;
|
||
for (int i = 0; i < dateRangeList.size(); i++) {
|
||
// 存放一个时间点中总数
|
||
List listEnt1 = new ArrayList();
|
||
List listEnt2 = new ArrayList();
|
||
Map<String, Long> ipCountMap = new HashMap<String, Long>();
|
||
Date date = dateRangeList.get(i);
|
||
Long num1 = 0L;
|
||
Long num2 = 0L;
|
||
for (int j = index1; j < entrance1.size(); j++) {
|
||
NtcEntranceReport ipInfo = entrance1.get(j);
|
||
if (ipInfo.getReportTime() != null) {
|
||
if (ipInfo.getReportTime().compareTo(date) >= 0 && (i + 1 < dateRangeList.size()?ipInfo.getReportTime().compareTo(dateRangeList.get(i + 1)) < 0:true)) {
|
||
num1 = num1 + ipInfo.getSum();
|
||
} else {
|
||
index1 = j;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
sumEnt1+=num1;
|
||
listEnt1.add(date.getTime());
|
||
listEnt1.add(num1);
|
||
sumList1.add(listEnt1);
|
||
for (int j = index2; j < entrance2.size(); j++) {
|
||
NtcEntranceReport ipInfo = entrance2.get(j);
|
||
if (ipInfo.getReportTime() != null) {
|
||
if (ipInfo.getReportTime().compareTo(date) >= 0 && (i + 1 < dateRangeList.size()?ipInfo.getReportTime().compareTo(dateRangeList.get(i + 1)) < 0:true)) {
|
||
num2 = num2 + ipInfo.getSum();
|
||
} else {
|
||
index2 = j;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
sumEnt2+=num2;
|
||
listEnt2.add(date.getTime());
|
||
listEnt2.add(num2);
|
||
sumList2.add(listEnt2);
|
||
}
|
||
// 整合 count time
|
||
m1.put("sum", sumEnt1);
|
||
m1.put("result", sumList1);
|
||
m1.put("entranceId", 1);
|
||
m2.put("sum", sumEnt2);//
|
||
m2.put("result", sumList2);
|
||
m2.put("entranceId", 2);
|
||
listMap.add(m1);
|
||
listMap.add(m2);
|
||
}
|
||
return listMap;
|
||
}
|
||
|
||
/**
|
||
* 最近活跃端口时间五分钟数据
|
||
*
|
||
* @return List
|
||
*/
|
||
public List<Map> getPortActiveList() {
|
||
List<Map> list = new ArrayList<Map>();
|
||
TrafficPortActiveStatistic maxStatTime = trafficPortActiveStatisticDao.getMaxStatTime();
|
||
if (maxStatTime != null && maxStatTime.getStatTime() != null) {
|
||
Date statTime = maxStatTime.getStatTime();
|
||
List<TrafficPortActiveStatistic> portActiveList = trafficPortActiveStatisticDao.getPortActiveList(statTime);
|
||
// 上个时间五分钟数据
|
||
if (portActiveList != null && portActiveList.size() > 0) {
|
||
for (TrafficPortActiveStatistic port : portActiveList) {
|
||
if (port.getPort() != null) {
|
||
Map map = new HashMap();
|
||
map.put("port", port.getPort());
|
||
map.put("sum", port.getSum());
|
||
TrafficPortActiveStatistic portActiveOld = trafficPortActiveStatisticDao
|
||
.getPortActiveOld(port.getPort(), statTime);
|
||
if (portActiveOld != null && portActiveOld.getSum() != null) {
|
||
map.put("preSum", portActiveOld.getSum());
|
||
} else {
|
||
map.put("preSum", 0);
|
||
}
|
||
list.add(map);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return list;
|
||
}
|
||
|
||
/**
|
||
* 活跃IP最近五分钟数据TOP10
|
||
*
|
||
* @return
|
||
*/
|
||
/*
|
||
* public List<HashMap> ipActiveFiveMinute(Date beginDate,Date endDate) {
|
||
* TrafficIpActiveStatistic maxStatTime =
|
||
* trafficIpActiveStatisticDao.getMaxStatTime(); ArrayList<HashMap> listMap =
|
||
* new ArrayList<HashMap>(); if (maxStatTime != null &&
|
||
* maxStatTime.getStatTime() != null) { Date statTime =
|
||
* maxStatTime.getStatTime(); // 查询最近五分钟TOP10 ArrayList<LinkedHashMap>
|
||
* ipListTop10 = trafficIpActiveStatisticDao.ipActiveChart(beginDate,endDate);
|
||
* if (ipListTop10 != null && ipListTop10.size() > 0) { for (LinkedHashMap map :
|
||
* ipListTop10) { HashMap m = new HashMap(); if (map.get("ipAddr") != null) {
|
||
* String ipAddr = (String) map.get("ipAddr"); m.put("ipAddr", ipAddr); //
|
||
* 根据五分钟TOP10IP，查询TOP10中每个IP最近一小时的变化 long beforeTime = beginDate.getTime(); long
|
||
* afterTime = endDate.getTime(); Long inter=(afterTime - beforeTime) / (1000 *
|
||
* 60 * 5); ArrayList<TrafficIpActiveStatistic> ipList =
|
||
* trafficIpActiveStatisticDao.ipActiveFiveMinute(inter,ipAddr,
|
||
* beginDate,endDate); List linkList = new ArrayList(); List timeList = new
|
||
* ArrayList(); if (ipList != null && ipList.size() > 0) { for
|
||
* (TrafficIpActiveStatistic ip : ipList) { if (ip.getLinkNum() != null &&
|
||
* ip.getTime() != null) { linkList.add(ip.getLinkNum());
|
||
* timeList.add(ip.getTime()); } } } m.put("linkNum", linkList);
|
||
* m.put("statTime", timeList); listMap.add(m); } } } }
|
||
*
|
||
* return listMap; }
|
||
*/
|
||
/**
|
||
* 获取活跃IPtop10 的趋势图
|
||
*/
|
||
public List<Map> ipActiveFiveMinute(Date beginDate, Date endDate) {
|
||
List<Map> listMap = new ArrayList<Map>();
|
||
List<LinkedHashMap> ipListTop10 = trafficIpActiveStatisticDao.ipActiveChart(beginDate, endDate);
|
||
if (ipListTop10 != null && ipListTop10.size() > 0) {
|
||
StringBuilder ipStr = new StringBuilder();
|
||
for (LinkedHashMap map : ipListTop10) {
|
||
ipStr.append("'" + (String) map.get("ipAddr") + "',");
|
||
}
|
||
if (!StringUtil.isEmpty(ipStr) && ipStr.indexOf(",") > 0) {
|
||
ipStr.deleteCharAt(ipStr.lastIndexOf(","));
|
||
}
|
||
// 如果所有IP在最后一个时间点的count都为0，则移除最后一个点
|
||
// 开始划分时间段,间隔5分钟
|
||
List<Date> dateRangeList = new ArrayList<Date>();
|
||
Calendar calendar = Calendar.getInstance();
|
||
calendar.setTime(beginDate);
|
||
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
||
while (calendar.getTime().compareTo(endDate) < 0) {
|
||
dateRangeList.add(calendar.getTime());
|
||
calendar.add(Calendar.MINUTE, Constants.TREND_TIME_INTERVAL);
|
||
}
|
||
|
||
ArrayList<TrafficIpActiveStatistic> ipInfoList = trafficIpActiveStatisticDao
|
||
.ipActiveFiveMinute(ipStr.toString(), beginDate, endDate);
|
||
// 存放每个IP，每个时间点的总数
|
||
Map<String, List> ipCountListMap = new HashMap<String, List>();
|
||
int index = 0;
|
||
for (int i = 0; i < dateRangeList.size(); i++) {
|
||
// 存放一个时间点中每个IP的总数
|
||
Map<String, Long> ipCountMap = new HashMap<String, Long>();
|
||
Date date = dateRangeList.get(i);
|
||
for (int j = index; j < ipInfoList.size(); j++) {
|
||
TrafficIpActiveStatistic ipInfo = ipInfoList.get(j);
|
||
if (ipInfo.getStatTime() != null) {
|
||
if (ipInfo.getStatTime().compareTo(date) >= 0 && (i + 1 < dateRangeList.size()
|
||
&& ipInfo.getStatTime().compareTo(dateRangeList.get(i + 1)) < 0)) {
|
||
Long num = ipInfo.getCount();
|
||
if (ipCountMap.containsKey(ipInfo.getIpAddr())) {
|
||
num = num + ipCountMap.get(ipInfo.getIpAddr());
|
||
}
|
||
ipCountMap.put(ipInfo.getIpAddr(), num);
|
||
} else {
|
||
index = j;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
for (LinkedHashMap map : ipListTop10) {
|
||
String ip = (String) map.get("ipAddr");
|
||
List sumList= new ArrayList();
|
||
sumList.add(date.getTime());
|
||
|
||
Long sum = 0l;
|
||
if (ipCountMap.containsKey(ip)) {
|
||
sum = ipCountMap.get(ip);
|
||
}
|
||
sumList.add(sum);
|
||
if (ipCountListMap.containsKey(ip)) {
|
||
List ipList = ipCountListMap.get(ip);
|
||
ipList.add(sumList);
|
||
} else {
|
||
List iplist = new ArrayList();
|
||
iplist.add(sumList);
|
||
ipCountListMap.put(ip, iplist);
|
||
}
|
||
}
|
||
}
|
||
// 整合IP计算总数
|
||
Iterator iterator = ipCountListMap.keySet().iterator();
|
||
while (iterator.hasNext()) {
|
||
String ip = iterator.next() + "";
|
||
Map ipTrafficMap = new HashMap();
|
||
ipTrafficMap.put("ipAddr", ip);
|
||
Long total = 0L;
|
||
for (Object obj : ipCountListMap.get(ip)) {
|
||
List<Long> list = (List) obj;
|
||
total+=list.get(1);
|
||
}
|
||
ipTrafficMap.put("result", ipCountListMap.get(ip));
|
||
ipTrafficMap.put("sum", total);
|
||
listMap.add(ipTrafficMap);
|
||
}
|
||
}
|
||
return listMap;
|
||
}
|
||
|
||
/**
|
||
* 根据活跃IP最近五分钟TOP10，查询近1小时最大值
|
||
*
|
||
* @return
|
||
*/
|
||
public List<HashMap> ipActiveOneHour(Date beginDate, Date endDate) {
|
||
|
||
// TrafficIpActiveStatistic maxStatTime = trafficIpActiveStatisticDao.getMaxStatTime();
|
||
ArrayList<HashMap> listMap = new ArrayList<HashMap>();
|
||
// if (maxStatTime != null && maxStatTime.getStatTime() != null) {
|
||
// Date statTime = maxStatTime.getStatTime();
|
||
ArrayList<LinkedHashMap> list = trafficIpActiveStatisticDao.ipActiveChart(beginDate, endDate);
|
||
if (list != null && list.size() > 0) {
|
||
for (LinkedHashMap map : list) {
|
||
if (map.get("ipAddr") != null) {
|
||
String ipAddr = (String) map.get("ipAddr");
|
||
HashMap resMap = trafficIpActiveStatisticDao.ipActiveOneHour(ipAddr, beginDate, endDate);
|
||
if (resMap != null) {
|
||
listMap.add(resMap);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// }
|
||
|
||
return listMap;
|
||
|
||
}
|
||
|
||
/**
|
||
* 活跃IP首页top10
|
||
*
|
||
* @param beginDate
|
||
* @param endDate
|
||
* @return
|
||
*/
|
||
@SuppressWarnings("rawtypes")
|
||
public List<LinkedHashMap> ipActiveChart(Date beginDate, Date endDate) {
|
||
// TrafficIpActiveStatistic maxStatTime = trafficIpActiveStatisticDao.getMaxStatTime();
|
||
ArrayList<LinkedHashMap> list = new ArrayList<>();
|
||
// if (maxStatTime != null && maxStatTime.getStatTime() != null) {
|
||
// Date statTime = maxStatTime.getStatTime();
|
||
list = trafficIpActiveStatisticDao.ipActiveChart(beginDate, endDate);
|
||
if (list != null && list.size() > 0) {
|
||
for (LinkedHashMap map : list) {
|
||
if (map.get("ipAddr") != null) {
|
||
Map m = new LinkedHashMap();
|
||
map.put("pktNum", 0);
|
||
map.put("byteLen", 0);
|
||
}
|
||
}
|
||
}
|
||
// }
|
||
return list;
|
||
}
|
||
|
||
/**
|
||
* 协议统计
|
||
*
|
||
* @return
|
||
*/
|
||
public List<Map> protocolChart() {
|
||
TrafficProtocolStatistic maxStatTime = trafficProtocolStatisticDao.getMaxStatTime();
|
||
List<Map> list = new ArrayList<Map>();
|
||
if (maxStatTime != null && maxStatTime.getStatTime() != null) {
|
||
Date statTime = maxStatTime.getStatTime();
|
||
list = trafficProtocolStatisticDao.protocolChart(statTime);
|
||
// 当不查询包，字节时 设为0
|
||
if (list != null && list.size() > 0) {
|
||
Map map = new HashMap();
|
||
map.put("pktNum", 0);
|
||
map.put("byteLen", 0);
|
||
}
|
||
}
|
||
return list;
|
||
}
|
||
|
||
/**
|
||
* 协议统计报表
|
||
*
|
||
* @return
|
||
*/
|
||
public List<Map> getProtocolList(String startTime, String endTime, Integer[] protoType) {
|
||
// TrafficProtocolStatistic maxStatTime = trafficProtocolStatisticDao.getMaxStatTime();
|
||
List<Map> list = new ArrayList<Map>();
|
||
// if (maxStatTime != null && maxStatTime.getStatTime() != null) {
|
||
// Date statTime = maxStatTime.getStatTime();
|
||
list = trafficProtocolStatisticDao.getProtocolList(startTime, endTime, protoType);
|
||
// }
|
||
return list;
|
||
}
|
||
|
||
/**
|
||
* app应用top10 图
|
||
*
|
||
* @return
|
||
*/
|
||
public List<Map> appChart() {
|
||
List<Map> list = new ArrayList<Map>();
|
||
TrafficAppStatistic maxStatTime = trafficAppStatisticDao.getMaxStatTime();
|
||
if (maxStatTime != null && maxStatTime.getStatTime() != null) {
|
||
Date statTime = maxStatTime.getStatTime();
|
||
list = trafficAppStatisticDao.appChart(statTime);
|
||
// 当不查询包，字节时 设为0
|
||
if (list != null && list.size() > 0) {
|
||
Map map = new HashMap();
|
||
map.put("pktNum", 0);
|
||
map.put("byteLen", 0);
|
||
}
|
||
}
|
||
return list;
|
||
}
|
||
|
||
/**
|
||
* App统计报表
|
||
*
|
||
* @return
|
||
*/
|
||
public List<Map> getAppList(String startTime, String endTime, Integer[] appType) {
|
||
// TrafficAppStatistic maxStatTime = trafficAppStatisticDao.getMaxStatTime();
|
||
List<Map> list = new ArrayList<Map>();
|
||
// if (maxStatTime != null && maxStatTime.getStatTime() != null) {
|
||
// Date statTime = maxStatTime.getStatTime();
|
||
list = trafficAppStatisticDao.getAppList(startTime, endTime, appType);
|
||
// }
|
||
return list;
|
||
}
|
||
|
||
// 操作系统列表 排名TOP10
|
||
@SuppressWarnings({ "unchecked", "rawtypes" })
|
||
public List<Map> systemList() {
|
||
List<Map> result = new ArrayList<Map>();
|
||
TrafficUaStatistic maxStatTime = trafficUaStatisticDao.getMaxStatTime();
|
||
if (maxStatTime != null) {
|
||
Date statTime = maxStatTime.getStatTime();
|
||
List<TrafficUaStatistic> list = trafficUaStatisticDao.systemList(statTime);
|
||
Long preCount = 0l;
|
||
for (TrafficUaStatistic ua : list) {
|
||
Map map = new HashMap();
|
||
map.put("osType", ua.getOsType());
|
||
map.put("count", ua.getCount());
|
||
map.put("pktNum", 0);
|
||
map.put("byteLen", 0);
|
||
preCount = trafficUaStatisticDao.preSystemListCount(ua.getOsType(), statTime);// 上个时段的量 用于与现在对比
|
||
if (preCount != null) {
|
||
map.put("preCount", preCount);
|
||
} else {
|
||
map.put("preCount", 0);
|
||
}
|
||
result.add(map);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
public List<Map> getBrowserBySystem(Integer osType) {
|
||
List<Map> list = new ArrayList<Map>();
|
||
TrafficUaStatistic maxStatTime = trafficUaStatisticDao.getMaxStatTime();
|
||
if (maxStatTime != null) {
|
||
Date statTime = maxStatTime.getStatTime();
|
||
list = trafficUaStatisticDao.getBrowserBySystem(osType, statTime);
|
||
List bsType = new ArrayList();
|
||
// 查新固定操系统下的除了TOP10以外的others
|
||
if (list != null && list.size() > 0) {
|
||
for (Map map : list) {
|
||
bsType.add(map.get("bsType"));
|
||
}
|
||
if (list.size() > 10) {
|
||
Map others = new HashMap();
|
||
others = trafficUaStatisticDao.systemOthers(bsType, osType, statTime);
|
||
if (others != null && others.size() > 0) {
|
||
others.put("bsType", "-1");
|
||
list.add(others);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return list;
|
||
}
|
||
|
||
public List<Map> browserList() {
|
||
List<Map> result = new ArrayList<Map>();
|
||
TrafficUaStatistic maxStatTime = trafficUaStatisticDao.getMaxStatTime();
|
||
if (maxStatTime != null) {
|
||
Date statTime = maxStatTime.getStatTime();
|
||
List<TrafficUaStatistic> list = trafficUaStatisticDao.browserList(statTime);
|
||
Long preCount = 0l;
|
||
if (list != null && list.size() > 0) {
|
||
for (TrafficUaStatistic ua : list) {
|
||
Map map = new HashMap();
|
||
map.put("bsType", ua.getBsType());
|
||
map.put("count", ua.getCount());
|
||
map.put("pktNum", 0);
|
||
map.put("byteLen", 0);
|
||
preCount = trafficUaStatisticDao.preBrowserListCount(ua.getBsType(), statTime);// 上个时段的量 用于与现在对比
|
||
if (preCount != null) {
|
||
map.put("preCount", preCount);
|
||
} else {
|
||
map.put("preCount", 0);
|
||
}
|
||
result.add(map);
|
||
}
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
public List<Map> getSystemBybrowser(Integer bsType) {
|
||
List<Map> list = new ArrayList<Map>();
|
||
TrafficUaStatistic maxStatTime = trafficUaStatisticDao.getMaxStatTime();
|
||
if (maxStatTime != null) {
|
||
Date statTime = maxStatTime.getStatTime();
|
||
list = trafficUaStatisticDao.getSystemBybrowser(bsType, statTime);
|
||
List osType = new ArrayList();
|
||
// 查询固定操系统下的除了TOP10以外的others
|
||
if (list != null && list.size() > 0) {
|
||
for (Map map : list) {
|
||
osType.add(map.get("osType"));
|
||
}
|
||
if (list.size() > 10) {
|
||
Map others = new HashMap();
|
||
others = trafficUaStatisticDao.browserOthers(osType, bsType, statTime);
|
||
if (others != null && others.size() > 0) {
|
||
others.put("osType", "-1");
|
||
list.add(others);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return list;
|
||
}
|
||
|
||
/**
|
||
*
|
||
* 网站子域名详情
|
||
*
|
||
* @param beginDate
|
||
* @param endDate
|
||
* @return
|
||
*/
|
||
public List<Map> getWebsiteDetailsById(Integer websiteServiceId, Date beginDate, Date endDate) {
|
||
List<Map> list = null;
|
||
if (beginDate != null && endDate != null) {
|
||
list = getDomainByWebsiteServiceId(websiteServiceId, beginDate, endDate, null);
|
||
} else {
|
||
Date startTime = getBeforeByHourTime(1);// 获取上一个小时
|
||
list = getDomainByWebsiteServiceId(websiteServiceId, startTime, new Date(), "top");
|
||
}
|
||
return list;
|
||
}
|
||
|
||
/**
|
||
* 根据网站服务查询子域名
|
||
*
|
||
* @param websiteServiceId
|
||
* @return list
|
||
*/
|
||
public List<Map> getDomainByWebsiteServiceId(Integer websiteServiceId, Date beginDate, Date endDate, String top) {
|
||
|
||
// Date statTime = getBeforeByHourTime(1);// 获取上一个小时
|
||
|
||
List idList = trafficHttpStatisticDao.getIdByWebSiteId(websiteServiceId);
|
||
|
||
List<Map> matchList = trafficHttpStatisticDao.getDomainByWebsiteServiceId(idList, beginDate, endDate);// 获取webid和count的对应关系,key是webid,val是count
|
||
// 获取webid和count的对应关系,key是webid,val是count
|
||
Set<Long> set = new HashSet<>();
|
||
Map<Long, List<Map>> countMap = new HashMap();// 存储count和map的对应关系,后面根据count过滤,获取top10的count
|
||
for (Map map : matchList) {
|
||
String countStr = String.valueOf(map.get("count"));
|
||
long count = Long.parseLong(countStr);
|
||
set.add(count);
|
||
if (countMap.containsKey(count)) {// 将每个count和对应的viewmap放到map中,count可能相同所以value是list
|
||
countMap.get(count).add(map);
|
||
} else {
|
||
List<Map> listMap = new ArrayList<>();
|
||
listMap.add(map);
|
||
countMap.put(count, listMap);
|
||
}
|
||
}
|
||
List<Map> top10Data = new ArrayList();
|
||
if (top != null) {
|
||
top10Data = getTop10Data(set, countMap, 1);
|
||
} else {
|
||
top10Data = getTop10Data(set, countMap, 2);
|
||
}
|
||
List<String> notTop10List = new ArrayList<>();// 获取不在top10中的webid,用来查询标记为orther
|
||
for (Map map : matchList) {
|
||
String webIdStr = String.valueOf(map.get("webId"));
|
||
boolean exist = false;
|
||
for (Map map1 : top10Data) {
|
||
String webIdStr1 = String.valueOf(map1.get("webId"));
|
||
if (webIdStr1 != null && webIdStr != null && webIdStr1.equals(webIdStr)) {
|
||
exist = true;
|
||
}
|
||
if (!exist) {
|
||
notTop10List.add(webIdStr);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 查询固定网站下的域名除了TOP10以外的others域名
|
||
if (matchList != null && matchList.size() > 10) {
|
||
Map others = trafficHttpStatisticDao.websiteDomainOthers(notTop10List, beginDate, endDate);
|
||
if (others != null && others.size() > 0) {
|
||
others.put("webId", "-1");
|
||
top10Data.add(others);
|
||
}
|
||
}
|
||
return top10Data;
|
||
|
||
}
|
||
|
||
/**
|
||
*
|
||
* 网站详情
|
||
*
|
||
* @param beginDate
|
||
* @param endDate
|
||
* @return
|
||
*/
|
||
public List<Map> getWebsiteDetails(Date beginDate, Date endDate, Integer domain[], Integer entranceId) {
|
||
List<Map> list = trafficHttpStatisticDao.getTrafficHttpDomain(beginDate, endDate, domain, entranceId);
|
||
return list;
|
||
}
|
||
|
||
/**
|
||
*
|
||
* 网站TOP10 默认一小时
|
||
*
|
||
* @param beginDate
|
||
* @param endDate
|
||
* @return
|
||
*/
|
||
public List<Map> getWebsiteTop10() {
|
||
Date startTime = getBeforeByHourTime(1);// 获取上一个小时
|
||
List<Map> list = getDomainByWebsiteList(startTime, new Date(), "top");
|
||
return list;
|
||
}
|
||
|
||
/**
|
||
* 获取网站列表
|
||
*
|
||
* @return
|
||
*/
|
||
@SuppressWarnings("unchecked")
|
||
public List<Map> getDomainByWebsiteList(Date beginDate, Date endDate, String top) {
|
||
Map<String, List<String>> websiteIdAndIdMap = new HashMap<>();// 存储websiteServiceId和id的对应关系,一个websiteServiceId有多个id
|
||
List<Map> websiteIdAndidList = trafficHttpStatisticDao.getDomainByWebsiteList(beginDate, endDate);// 获取website_service_id和id的对应关系,group
|
||
// by
|
||
// website_service_id,id
|
||
for (Map map : websiteIdAndidList) {
|
||
Object websiteServiceIdObj = map.get("websiteServiceId");
|
||
Object idObj = map.get("id");
|
||
if (websiteServiceIdObj != null && idObj != null) {
|
||
if (websiteIdAndIdMap.containsKey(String.valueOf(websiteServiceIdObj))) {
|
||
websiteIdAndIdMap.get(String.valueOf(websiteServiceIdObj)).add(String.valueOf(idObj));
|
||
} else {
|
||
List<String> list = new ArrayList<>();
|
||
list.add(String.valueOf(idObj));
|
||
websiteIdAndIdMap.put(String.valueOf(websiteServiceIdObj), list);
|
||
}
|
||
}
|
||
}
|
||
|
||
Set<Long> set = new HashSet<>();
|
||
Map<Long, List<Map>> countAndViewMap = new HashMap<>();// 存储count和map的对应关系,后面根据count过滤,获取top10的count
|
||
List<Map> webIdAndCountList = trafficHttpStatisticDao.getHttpStatisticNoLinkAndPkt(beginDate, endDate);// 获取最近一小时的webid和count的关系
|
||
List<Map> prevWebIdAndCountList = trafficHttpStatisticDao.getHttpStatisticNoLinkAndPkt(getBeforeByHourTime(2),
|
||
beginDate);// 获取最近一小时的webid和count的关系
|
||
for (String websiteServiceId : websiteIdAndIdMap.keySet()) {// 遍历上面获取的websiteServiceId和id的对应关系,拼接json
|
||
Map viewMap = new HashMap<>();
|
||
long count = 0l;// 记录当前websiteServiceId所有的count
|
||
long prevCount = 0l;// 记录当前websiteServiceId所有的count
|
||
List<String> idList = websiteIdAndIdMap.get(websiteServiceId);// 根据websiteServiceId获取对应的id
|
||
for (String id : idList) {
|
||
for (Map webIdAndCountMap : webIdAndCountList) {// 遍历webid和count
|
||
String webId = String.valueOf(webIdAndCountMap.get("webId"));
|
||
if (webId != null && webId.equals(id)) {// 如果webid和id相等则获取count数据并统计
|
||
String countStr = String.valueOf(webIdAndCountMap.get("byteCount"));
|
||
if (countStr != null) {
|
||
count += Long.parseLong(countStr);// 将count累加
|
||
}
|
||
}
|
||
}
|
||
for (Map webIdAndCountMap : prevWebIdAndCountList) {// 遍历webid和count
|
||
String webId = String.valueOf(webIdAndCountMap.get("webId"));
|
||
if (webId != null && webId.equals(id)) {// 如果webid和id相等则获取count数据并统计
|
||
String countStr = String.valueOf(webIdAndCountMap.get("byteCount"));
|
||
if (countStr != null) {
|
||
prevCount += Long.parseLong(countStr);// 将count累加
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
viewMap.put("websiteServiceId", websiteServiceId);
|
||
viewMap.put("count", count);
|
||
viewMap.put("pktNum", 0);
|
||
viewMap.put("byteLen", 0);
|
||
viewMap.put("preCount", prevCount);
|
||
|
||
if (countAndViewMap.containsKey(count)) {// 将每个count和对应的viewmap放到map中,count可能相同所以value是list
|
||
countAndViewMap.get(count).add(viewMap);
|
||
} else {
|
||
List<Map> listMap = new ArrayList<>();
|
||
listMap.add(viewMap);
|
||
countAndViewMap.put(count, listMap);
|
||
}
|
||
set.add(count);
|
||
}
|
||
List<Map> dataList = new ArrayList();
|
||
if (top != null) {
|
||
dataList = getTop10Data(set, countAndViewMap, 1);// 取top10
|
||
} else {
|
||
dataList = getTop10Data(set, countAndViewMap, 2);
|
||
}
|
||
return dataList;
|
||
}
|
||
|
||
/**
|
||
*
|
||
* 主题详情
|
||
*
|
||
* @param beginDate
|
||
* @param endDate
|
||
* @return
|
||
*/
|
||
public List<Map> getTopicDetails(Date beginDate, Date endDate) {
|
||
List<Map> topicAndDomainList = getTopicAndDomainList(beginDate, endDate, null);
|
||
return topicAndDomainList;
|
||
}
|
||
|
||
/**
|
||
*
|
||
* 主题TOP10 默认一小时
|
||
*
|
||
* @param beginDate
|
||
* @param endDate
|
||
* @return
|
||
*/
|
||
public List<Map> getTopicTop10() {
|
||
Date startTime = getBeforeByHourTime(1);// 获取上一个小时
|
||
List<Map> topicAndDomainList = getTopicAndDomainListNoLink(startTime, new Date(), "top");
|
||
return topicAndDomainList;
|
||
}
|
||
|
||
/**
|
||
* 主题网站分类，域名
|
||
*
|
||
**/
|
||
public List<Map> getTopicAndDomainListNoLink(Date beginDate, Date endDate, String top) {
|
||
|
||
Map<String, List<String>> topicIdAndIdMap = new HashMap<>();// 存储topicid和id的对应关系,一个topicid有多个id
|
||
List<Map> topicIdAndIdList = trafficHttpStatisticDao.getDomainByTopicList(beginDate, endDate);// 获取最近一个小时topicId和id的对应关系,group
|
||
for (Map map : topicIdAndIdList) {
|
||
Object topicIdObj = map.get("topicId");
|
||
Object idObj = map.get("id");
|
||
if (topicIdObj != null && idObj != null) {
|
||
if (topicIdAndIdMap.containsKey(String.valueOf(topicIdObj))) {
|
||
topicIdAndIdMap.get(String.valueOf(topicIdObj)).add(String.valueOf(idObj));
|
||
} else {
|
||
List<String> list = new ArrayList<>();
|
||
list.add(String.valueOf(idObj));
|
||
topicIdAndIdMap.put(String.valueOf(topicIdObj), list);
|
||
}
|
||
}
|
||
}
|
||
|
||
Set<Long> set = new HashSet<>();
|
||
Map<Long, List<Map>> countAndViewMap = new HashMap<>();// 存储count和map的对应关系,后面根据count过滤,获取top10的count
|
||
List<Map> webIdAndCountList = trafficHttpStatisticDao.getHttpStatisticNoLinkAndPkt(beginDate, endDate);// 获取最近一小时的webid和count的关系
|
||
for (String topicId : topicIdAndIdMap.keySet()) {// 遍历上面获取的topicid和id的对应关系,拼接json
|
||
Map viewMap = new HashMap<>();
|
||
|
||
List<Map> list = new ArrayList<>();
|
||
long count = 0l;// 记录当前topicid所有的count
|
||
// long linkNum = 0l;
|
||
// long packets = 0l;
|
||
List<String> idList = topicIdAndIdMap.get(topicId);// 根据topicid获取对应的id
|
||
for (String id : idList) {
|
||
for (Map webIdAndCountMap : webIdAndCountList) {// 遍历webid和count
|
||
String webId = String.valueOf(webIdAndCountMap.get("webId"));
|
||
if (webId != null && webId.equals(id)) {// 如果webid和id相等则获取count数据并统计
|
||
String countStr = String.valueOf(webIdAndCountMap.get("byteCount"));
|
||
// String linkNumStr = String.valueOf(webIdAndCountMap.get("linkNum"));
|
||
// String packetsStr = String.valueOf(webIdAndCountMap.get("pktCount"));
|
||
if (countStr != null) {
|
||
count += Long.parseLong(countStr);// 将count累加 转换单位小于0的不加
|
||
}
|
||
// if (linkNumStr != null) {
|
||
// linkNum += Long.parseLong(linkNumStr);// 将count累加
|
||
// }
|
||
// if (packetsStr != null) {
|
||
// packets += Long.parseLong(packetsStr);// 将count累加
|
||
// }
|
||
// webIdAndCountMap.remove("linkNum");
|
||
// webIdAndCountMap.remove("pktCount");
|
||
list.add(webIdAndCountMap);
|
||
}
|
||
}
|
||
}
|
||
Collections.sort(list, new Comparator<Object>() {
|
||
@Override
|
||
public int compare(Object o1, Object o2) {
|
||
if (o1 == null && o2 != null) {
|
||
return 1;
|
||
}
|
||
if (o1 != null && o2 == null) {
|
||
return -1;
|
||
}
|
||
if (o1 == o2 && o1 == null) {
|
||
return 0;
|
||
}
|
||
Map m1 = (Map) o1;
|
||
Map m2 = (Map) o2;
|
||
Object ob1 = m1.get("byteCount");
|
||
Object ob2 = m2.get("byteCount");
|
||
Long b1 = Long.parseLong(ob1.toString());
|
||
Long b2 = Long.parseLong(ob2.toString());
|
||
return -(b1).compareTo(b2);
|
||
}
|
||
});
|
||
if (list.size() > 0) {
|
||
viewMap.put("count", count);
|
||
// viewMap.put("linkNum", linkNum);
|
||
// viewMap.put("packets", packets);
|
||
viewMap.put("domainData", list);
|
||
viewMap.put("topicId", topicId);
|
||
if (countAndViewMap.containsKey(count)) {// 将每个count和对应的viewmap放到map中,count可能相同所以value是list
|
||
countAndViewMap.get(count).add(viewMap);
|
||
} else {
|
||
List<Map> listMap = new ArrayList<>();
|
||
listMap.add(viewMap);
|
||
countAndViewMap.put(count, listMap);
|
||
}
|
||
set.add(count);
|
||
}
|
||
}
|
||
List<Map> dataList = new ArrayList();
|
||
if (top != null) {
|
||
dataList = getTop10Data(set, countAndViewMap, 1);
|
||
} else {
|
||
dataList = getTop10Data(set, countAndViewMap, 2);
|
||
}
|
||
return dataList;
|
||
}
|
||
|
||
public List<Map> getTopicAndDomainList(Date beginDate, Date endDate, String top) {
|
||
|
||
Map<String, List<String>> topicIdAndIdMap = new HashMap<>();// 存储topicid和id的对应关系,一个topicid有多个id
|
||
List<Map> topicIdAndIdList = trafficHttpStatisticDao.getDomainByTopicList(beginDate, endDate);// 获取最近一个小时topicId和id的对应关系,group
|
||
for (Map map : topicIdAndIdList) {
|
||
Object topicIdObj = map.get("topicId");
|
||
Object idObj = map.get("id");
|
||
if (topicIdObj != null && idObj != null) {
|
||
if (topicIdAndIdMap.containsKey(String.valueOf(topicIdObj))) {
|
||
topicIdAndIdMap.get(String.valueOf(topicIdObj)).add(String.valueOf(idObj));
|
||
} else {
|
||
List<String> list = new ArrayList<>();
|
||
list.add(String.valueOf(idObj));
|
||
topicIdAndIdMap.put(String.valueOf(topicIdObj), list);
|
||
}
|
||
}
|
||
}
|
||
|
||
Set<Long> set = new HashSet<>();
|
||
Map<Long, List<Map>> countAndViewMap = new HashMap<>();// 存储count和map的对应关系,后面根据count过滤,获取top10的count
|
||
List<Map> webIdAndCountList = trafficHttpStatisticDao.getTrafficHttpStatistic(beginDate, endDate);// 获取最近一小时的webid和count的关系
|
||
for (String topicId : topicIdAndIdMap.keySet()) {// 遍历上面获取的topicid和id的对应关系,拼接json
|
||
Map viewMap = new HashMap<>();
|
||
List<Map> list = new ArrayList<>();
|
||
long count = 0l;// 记录当前topicid所有的count
|
||
long linkNum = 0l;
|
||
long packets = 0l;
|
||
List<String> idList = topicIdAndIdMap.get(topicId);// 根据topicid获取对应的id
|
||
for (String id : idList) {
|
||
for (Map webIdAndCountMap : webIdAndCountList) {// 遍历webid和count
|
||
String webId = String.valueOf(webIdAndCountMap.get("webId"));
|
||
if (webId != null && webId.equals(id)) {// 如果webid和id相等则获取count数据并统计
|
||
String countStr = String.valueOf(webIdAndCountMap.get("byteCount"));
|
||
String linkNumStr = String.valueOf(webIdAndCountMap.get("linkNum"));
|
||
String packetsStr = String.valueOf(webIdAndCountMap.get("pktCount"));
|
||
if (countStr != null) {
|
||
count += Long.parseLong(countStr);// 将count累加
|
||
}
|
||
if (linkNumStr != null) {
|
||
linkNum += Long.parseLong(linkNumStr);// 将count累加
|
||
}
|
||
if (packetsStr != null) {
|
||
packets += Long.parseLong(packetsStr);// 将count累加
|
||
}
|
||
webIdAndCountMap.remove("linkNum");
|
||
webIdAndCountMap.remove("pktCount");
|
||
list.add(webIdAndCountMap);
|
||
}
|
||
}
|
||
}
|
||
if (list.size() > 0) {
|
||
viewMap.put("count", count);
|
||
viewMap.put("linkNum", linkNum);
|
||
viewMap.put("packets", packets);
|
||
viewMap.put("domainData", list);
|
||
viewMap.put("topicId", topicId);
|
||
if (countAndViewMap.containsKey(count)) {// 将每个count和对应的viewmap放到map中,count可能相同所以value是list
|
||
countAndViewMap.get(count).add(viewMap);
|
||
} else {
|
||
List<Map> listMap = new ArrayList<>();
|
||
listMap.add(viewMap);
|
||
countAndViewMap.put(count, listMap);
|
||
}
|
||
set.add(count);
|
||
}
|
||
}
|
||
List<Map> dataList = new ArrayList();
|
||
if (top != null) {
|
||
dataList = getTop10Data(set, countAndViewMap, 1);
|
||
} else {
|
||
dataList = getTop10Data(set, countAndViewMap, 2);
|
||
}
|
||
return dataList;
|
||
}
|
||
|
||
public String[] getFiledTypeByName(String fieldName) {
|
||
if (fieldName == null) {
|
||
return null;
|
||
}
|
||
String fieldType = null;
|
||
if ("addr_type".equals(fieldName)) {
|
||
fieldType = ntcTotalReportDao.getAddrType();
|
||
}
|
||
if ("trans_type".equals(fieldName)) {
|
||
fieldType = ntcTotalReportDao.getTransType();
|
||
}
|
||
if ("entrance_id".equals(fieldName)) {
|
||
fieldType = ntcTotalReportDao.getEntranceId();
|
||
}
|
||
return fieldType == null ? null : fieldType.split(",");
|
||
}
|
||
|
||
public Map<String, Map> getBandwidthTransEntrance(String beginDate, String endDate,String searchQuotaType) throws ParseException {
|
||
Map<String, Map> resultMap = new HashMap<String, Map>();
|
||
Map<String, ArrayList<TrafficTransStatistic>> listMap = new HashMap<String, ArrayList<TrafficTransStatistic>>();
|
||
List<TrafficTransStatistic> bandwidthListIPvx = new ArrayList<TrafficTransStatistic>();
|
||
List<TrafficTransStatistic> bandwidthListProtocol = new ArrayList<TrafficTransStatistic>();
|
||
bandwidthListIPvx = ntcTotalReportDao.getBandwidthTransIPVx(beginDate, endDate);
|
||
bandwidthListProtocol = ntcTotalReportDao.getBandwidthTransProtocol(beginDate, endDate);
|
||
Map<String, Map> trafficMap = new HashMap<String, Map>();
|
||
if ((!StringUtil.isEmpty(bandwidthListIPvx) && bandwidthListIPvx.size() > 0)
|
||
|| (!StringUtil.isEmpty(bandwidthListProtocol) && bandwidthListProtocol.size() > 0)) {
|
||
// 划分时间段
|
||
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
||
Date startTime = sdf.parse(beginDate);
|
||
Date endTime = sdf.parse(endDate);
|
||
List<Date> dateRangeList = new ArrayList<Date>();
|
||
Calendar calendar = Calendar.getInstance();
|
||
calendar.setTime(startTime);
|
||
|
||
while (calendar.getTime().compareTo(endTime) < 0) {
|
||
dateRangeList.add(calendar.getTime());
|
||
calendar.add(Calendar.MINUTE, Constants.TREND_TIME_INTERVAL);
|
||
}
|
||
String[] addrTypes = getFiledTypeByName("addr_type");
|
||
String[] transTypes = getFiledTypeByName("trans_type");
|
||
String[] entranceIds = getFiledTypeByName("entrance_id");
|
||
if (bandwidthListIPvx != null && bandwidthListIPvx.size() > 0 && bandwidthListProtocol != null
|
||
&& bandwidthListProtocol.size() > 0 && addrTypes != null && addrTypes.length > 0
|
||
&& transTypes != null && transTypes.length > 0 && entranceIds != null && entranceIds.length > 0) {
|
||
// 按区域和类型构建Map
|
||
for (String entranceId : entranceIds) {
|
||
for (String addrType : addrTypes) {
|
||
listMap.put("ipv" + addrType + "Type" + entranceId, new ArrayList<TrafficTransStatistic>());
|
||
}
|
||
}
|
||
for (String entranceId : entranceIds) {
|
||
for (String transType : transTypes) {
|
||
listMap.put("trans" + transType + "Type" + entranceId, new ArrayList<TrafficTransStatistic>());
|
||
}
|
||
}
|
||
// 按区域和类型提取数据到列表中
|
||
for (TrafficTransStatistic tts : bandwidthListIPvx) {
|
||
String addrType = tts.getAddrType();
|
||
|
||
Integer entranceId = tts.getEntranceId();
|
||
Integer transType = tts.getTransType();
|
||
String key = "ipv" + addrType + "Type" + entranceId;
|
||
listMap.get(key).add(tts);
|
||
}
|
||
for (TrafficTransStatistic tts : bandwidthListProtocol) {
|
||
String addrType = tts.getAddrType();
|
||
Integer entranceId = tts.getEntranceId();
|
||
Integer transType = tts.getTransType();
|
||
String key = "trans" + transType + "Type" + entranceId;
|
||
listMap.get(key).add(tts);
|
||
}
|
||
Set<Entry<String, ArrayList<TrafficTransStatistic>>> entrySet = listMap.entrySet();
|
||
for (Entry<String, ArrayList<TrafficTransStatistic>> entry : entrySet) {
|
||
String key = entry.getKey();
|
||
String entranceId = key.substring(key.length() - 1);
|
||
ArrayList<TrafficTransStatistic> value = entry.getValue();
|
||
resultMap.put(key, getNewData(dateRangeList,value,searchQuotaType));
|
||
}
|
||
}
|
||
}
|
||
return resultMap;
|
||
}
|
||
|
||
private Map getNewData(List<Date> dateRangeList,List<TrafficTransStatistic> bandwidthList,String searchQuotaType) {
|
||
Map restMap = new HashMap();
|
||
List<List> restList = new ArrayList<List>();
|
||
int index = 0;
|
||
Long sum = 0l;
|
||
for (int i = 0; i < dateRangeList.size(); i++) {
|
||
Date date = dateRangeList.get(i);
|
||
|
||
List countList = new ArrayList();
|
||
countList.add(date.getTime());
|
||
long num = 0l;
|
||
for (int j = index; j < bandwidthList.size(); j++) {
|
||
TrafficTransStatistic info = bandwidthList.get(j);
|
||
if (info.getStatTime() != null) {
|
||
if (info.getStatTime().compareTo(date) >= 0 && (i + 1 < dateRangeList.size()?info.getStatTime().compareTo(dateRangeList.get(i + 1)) < 0:true)) {
|
||
if ("pps".equalsIgnoreCase(searchQuotaType)) {
|
||
num = Long.parseLong(info.getPps().substring(0, info.getPps().lastIndexOf("."))) + num;
|
||
}else if ("linkNumber".equalsIgnoreCase(searchQuotaType)) {
|
||
num = Long.parseLong(info.getPps().substring(0, info.getPps().lastIndexOf("."))) + num;
|
||
}else {
|
||
num = Long.parseLong(info.getGbps().substring(0, info.getGbps().lastIndexOf(".")))+ num;
|
||
}
|
||
} else {
|
||
index = j;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
countList.add(num);
|
||
sum+=num;
|
||
restList.add(countList);
|
||
}
|
||
restMap.put("sum", sum);
|
||
restMap.put("result", restList);
|
||
return restMap;
|
||
}
|
||
|
||
/**
|
||
*
|
||
* @param beginDate
|
||
* @param endDate
|
||
* @param domain
|
||
* @param entranceId
|
||
* @return
|
||
*/
|
||
/*
|
||
* public List<HashMap> getDomainTrans(String beginDate, String endDate, Integer
|
||
* domain, Integer entranceId) { List<HashMap> listMap = new
|
||
* ArrayList<HashMap>(); HashMap resulMap = new HashMap();
|
||
* List<TrafficHttpFocusStatistic> domainList = new
|
||
* ArrayList<TrafficHttpFocusStatistic>(); domainList =
|
||
* trafficHttpStatisticDao.getDomainTrans(entranceId, beginDate, endDate,
|
||
* domain); List timeList = new ArrayList(); List countList = new ArrayList();
|
||
* if (domainList != null && domainList.size() > 0) { Map<String, Comparable> m
|
||
* = new HashMap<String, Comparable>(); int inter = 1000 * 60 * 30;// 间隔时间为30分钟
|
||
* // 开始时间，结束时间 时间戳 Long b = dateToStamp(beginDate); Long e =
|
||
* dateToStamp(endDate); int num = 0; Long pointTime = b; while (pointTime < e)
|
||
* { Map rm = new HashMap(); Long sumL = 0l; if (pointTime >= e) { break; // 停止
|
||
* } for (TrafficHttpFocusStatistic tt : domainList) { // 实际时间 String time =
|
||
* tt.getTime(); Long t = dateToStamp(time); if (t >= pointTime && t < pointTime
|
||
* + inter) { // 范围之内分到此pointTime组 sumL = sumL + tt.getCount(); } } //
|
||
* 在结束时间只有当值大于0时才记录数据，防止折线降为0引起误会 if (pointTime >= e - inter && sumL > 0) {
|
||
* countList.add(sumL); timeList.add(stampToDate(pointTime)); } if (pointTime <
|
||
* e - inter) { timeList.add(stampToDate(pointTime)); countList.add(sumL); } num
|
||
* = num + 1; pointTime = b + inter * num; } resulMap.put("count", countList);
|
||
* resulMap.put("statTime", timeList); listMap.add(resulMap); } return listMap;
|
||
* }
|
||
*/
|
||
/**
|
||
* 优化后的网站详情域名趋势查询
|
||
*
|
||
* @param beginDate
|
||
* @param endDate
|
||
* @param domain
|
||
* @param entranceId
|
||
* @return
|
||
*/
|
||
public List<HashMap> getDomainTrans2(String begin, String end, Integer domain, Integer entranceId) {
|
||
List<TrafficHttpFocusStatistic> domainList = new ArrayList<TrafficHttpFocusStatistic>();
|
||
domainList = trafficHttpStatisticDao.getDomainTrans(entranceId, begin, end, domain);
|
||
List<HashMap> listMap = new ArrayList<HashMap>();
|
||
if(!StringUtil.isEmpty(domainList)){
|
||
Date beginDate = DateUtils.parseDate(begin);
|
||
Date endDate = DateUtils.parseDate(end);
|
||
|
||
List<Date> dateRangeList = new ArrayList<Date>();
|
||
Calendar calendar = Calendar.getInstance();
|
||
calendar.setTime(beginDate);
|
||
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
||
while (calendar.getTime().compareTo(endDate) < 0) {
|
||
dateRangeList.add(calendar.getTime());
|
||
calendar.add(Calendar.MINUTE, Constants.TREND_TIME_INTERVAL);
|
||
}
|
||
// 存放每个时间点的总数
|
||
Map<String, List<Long>> ipCountListMap = new HashMap<String, List<Long>>();
|
||
int index = 0;
|
||
List resultList = new ArrayList();
|
||
Long total = 0L;
|
||
for (int i = 0; i < dateRangeList.size(); i++) {
|
||
// 存放一个时间点中总数
|
||
List sumList = new ArrayList();
|
||
Date date = dateRangeList.get(i);
|
||
Long num = 0L;
|
||
for (int j = index; j < domainList.size(); j++) {
|
||
TrafficHttpFocusStatistic ipInfo = domainList.get(j);
|
||
if (ipInfo.getStatTime() != null) {
|
||
if (ipInfo.getStatTime().compareTo(date) >= 0 && (i + 1 < dateRangeList.size()?ipInfo.getStatTime().compareTo(dateRangeList.get(i + 1)) < 0:true)) {
|
||
num = num + ipInfo.getCount();
|
||
} else {
|
||
index = j;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
sumList.add(date.getTime());
|
||
sumList.add(num);
|
||
resultList.add(sumList);
|
||
total+=num;
|
||
}
|
||
// 整合 count time
|
||
HashMap ipTrafficMap = new HashMap();
|
||
ipTrafficMap.put("result", resultList);
|
||
ipTrafficMap.put("sum", total);
|
||
listMap.add(ipTrafficMap);
|
||
}
|
||
return listMap;
|
||
}
|
||
|
||
/**
|
||
* 获取活跃Port top10 的趋势图
|
||
*
|
||
* @throws ParseException
|
||
*/
|
||
public List<Map> findTrafficPortActive(String beginDate, String endDate, Integer[] portArray)
|
||
throws ParseException {
|
||
List<Map> listMap = new ArrayList<Map>();
|
||
StringBuilder portStr = new StringBuilder();
|
||
List<LinkedHashMap> portListTop10 = null;
|
||
if (portArray != null && portArray.length > 0) {// 如果有传人参数，获取传人参数
|
||
for (int pi = 0; pi < portArray.length; pi++) {
|
||
portStr.append("'" + portArray[pi] + "',");
|
||
}
|
||
} else {// 否则获取TOP10
|
||
portListTop10 = trafficPortActiveStatisticDao.findTrafficPortActiveTopN(beginDate, endDate);
|
||
for (LinkedHashMap map : portListTop10) {
|
||
portStr.append("'" + map.get("port") + "',");
|
||
}
|
||
}
|
||
if (!StringUtil.isEmpty(portStr) && portStr.indexOf(",") > 0) {
|
||
portStr.deleteCharAt(portStr.lastIndexOf(","));
|
||
}
|
||
Date beginDate1 = DateUtils.strToDate(beginDate, "yyyy-MM-dd HH:mm:ss");
|
||
Date endDate1 = DateUtils.strToDate(endDate, "yyyy-MM-dd HH:mm:ss");
|
||
// if (portListTop10 != null && portListTop10.size() > 0) {
|
||
// StringBuilder portStr = new StringBuilder();
|
||
if (!StringUtil.isEmpty(portStr)) {
|
||
// 如果所有IP在最后一个时间点的count都为0，则移除最后一个点
|
||
// 开始划分时间段,间隔5分钟
|
||
List<Date> dateRangeList = new ArrayList<Date>();
|
||
Calendar calendar = Calendar.getInstance();
|
||
calendar.setTime(beginDate1);
|
||
while (calendar.getTime().compareTo(endDate1) < 0) {
|
||
dateRangeList.add(calendar.getTime());
|
||
calendar.add(Calendar.MINUTE, Constants.TREND_TIME_INTERVAL);
|
||
}
|
||
|
||
ArrayList<TrafficPortActiveStatistic> portInfoList = trafficPortActiveStatisticDao
|
||
.findTrafficPortActive(beginDate, endDate, portStr.toString());
|
||
// 存放每个IP，每个时间点的总数
|
||
Map<String, List<Long>> portCountListMap = new HashMap<String, List<Long>>();
|
||
int index = 0;
|
||
for (int i = 0; i < dateRangeList.size(); i++) {
|
||
// 存放一个时间点中每个IP的总数
|
||
Map<String, Long> portCountMap = new HashMap<String, Long>();
|
||
Date date = dateRangeList.get(i);
|
||
for (int j = index; j < portInfoList.size(); j++) {
|
||
TrafficPortActiveStatistic portInfo = portInfoList.get(j);
|
||
if (portInfo.getStatTime() != null) {
|
||
if (portInfo.getStatTime().compareTo(date) >= 0 && (i + 1 < dateRangeList.size()?portInfo.getStatTime().compareTo(dateRangeList.get(i + 1)) < 0:true)) {
|
||
Long num = portInfo.getSum();
|
||
if (portCountMap.containsKey(portInfo.getPort())) {
|
||
num = num + portCountMap.get(portInfo.getPort());
|
||
}
|
||
portCountMap.put(portInfo.getPort().toString(), num);
|
||
} else {
|
||
index = j;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (portArray != null && portArray.length > 0) {// 如果有传人参数，获取传人参数
|
||
for (int m = 0; m < portArray.length; m++) {
|
||
String port = portArray[m].toString();
|
||
List sumList = new ArrayList();
|
||
sumList.add(date.getTime());
|
||
Long sum = 0l;
|
||
if (portCountMap.containsKey(port)) {
|
||
sum = portCountMap.get(port);
|
||
}
|
||
sumList.add(sum);
|
||
if (portCountListMap.containsKey(port)) {
|
||
List list = portCountListMap.get(port);
|
||
list.add(sumList);
|
||
} else {
|
||
List list = new ArrayList();
|
||
list.add(sumList);
|
||
portCountListMap.put(port, list);
|
||
}
|
||
}
|
||
|
||
} else if (portListTop10 != null) {
|
||
for (LinkedHashMap map : portListTop10) {
|
||
String port = map.get("port").toString();
|
||
List sumList = new ArrayList();
|
||
sumList.add(date.getTime());
|
||
Long sum = 0l;
|
||
if (portCountMap.containsKey(port)) {
|
||
sum = portCountMap.get(port);
|
||
}
|
||
sumList.add(sum);
|
||
if (portCountListMap.containsKey(port)) {
|
||
List list = portCountListMap.get(port);
|
||
list.add(sumList);
|
||
} else {
|
||
List list = new ArrayList();
|
||
list.add(sumList);
|
||
portCountListMap.put(port, list);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// 整合port sum time
|
||
Iterator iterator = portCountListMap.keySet().iterator();
|
||
while (iterator.hasNext()) {
|
||
String port = iterator.next() + "";
|
||
Map trafficPortActiveMap = new HashMap();
|
||
Long total = 0L;
|
||
for (Object obj : portCountListMap.get(port)) {
|
||
List<Long> list = (List) obj;
|
||
total+=list.get(1);
|
||
}
|
||
trafficPortActiveMap.put("port", port);
|
||
trafficPortActiveMap.put("result", portCountListMap.get(port));
|
||
trafficPortActiveMap.put("sum", total);
|
||
listMap.add(trafficPortActiveMap);
|
||
}
|
||
}
|
||
return listMap;
|
||
}
|
||
|
||
/**
|
||
* 根据指标(drop,loop,New Link,Close Link,Pass,Live Link)统计各业务的趋势
|
||
* @throws ParseException
|
||
*/
|
||
public Map trendTotalReport(NtcConnNumReport ntcConnNumReport){
|
||
Map restMap = new HashMap();
|
||
List<NtcConnNumReport> list = ntcTotalReportDao.trendTotalReport(ntcConnNumReport);
|
||
if (list!=null && list.size()>0) {
|
||
//开始划分时间段,间隔5分钟
|
||
Date beginDate;
|
||
Date endDate;
|
||
try {
|
||
beginDate = DateUtils.strToDate(ntcConnNumReport.getSearchReportStartTime(), "yyyy-MM-dd HH:mm:ss");
|
||
endDate = DateUtils.strToDate(ntcConnNumReport.getSearchReportEndTime(), "yyyy-MM-dd HH:mm:ss");
|
||
} catch (ParseException e) {
|
||
// TODO Auto-generated catch block
|
||
throw new RestServiceException("searchReportStartTime或searchReportEndTime参数格式错误", RestBusinessCode.param_formate_error.getValue());
|
||
}
|
||
List<Date> dateRangeList = new ArrayList<Date>();
|
||
List<String> strDateRangeList = new ArrayList<String>();
|
||
Calendar calendar = Calendar.getInstance();
|
||
calendar.setTime(beginDate);
|
||
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
||
while (calendar.getTime().compareTo(endDate)<0) {
|
||
dateRangeList.add(calendar.getTime());
|
||
calendar.add(Calendar.MINUTE, Constants.TREND_TIME_INTERVAL);
|
||
}
|
||
int index = 0;
|
||
List sumList = new ArrayList();
|
||
Long totalNum = 0L;
|
||
for (int i = 0; i < dateRangeList.size(); i++) {
|
||
//存放一个时间点中每个IP的总数
|
||
List tempList = new ArrayList();
|
||
Map<String, Long> ipCountMap = new HashMap<String, Long>();
|
||
Date date = dateRangeList.get(i);
|
||
Long sum = 0l;
|
||
for (int j = index; j < list.size(); j++) {
|
||
NtcConnNumReport info = list.get(j);
|
||
if (info.getReportTime()!=null){
|
||
if(info.getReportTime().compareTo(date)>=0&&(i+1<dateRangeList.size()?info.getReportTime().compareTo(dateRangeList.get(i+1))<0:true)) {
|
||
sum = sum+info.getNum();
|
||
}else{
|
||
index = j;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
totalNum+=sum;
|
||
tempList.add(date.getTime());
|
||
tempList.add(sum);
|
||
sumList.add(tempList);
|
||
}
|
||
restMap.put("sum", totalNum);
|
||
restMap.put("result", sumList);
|
||
}
|
||
return restMap;
|
||
}
|
||
|
||
public Map getAppTrend(TrafficAppFocusStatistic entity) {
|
||
List<TrafficAppFocusStatistic> appFocusList = new ArrayList<TrafficAppFocusStatistic>();
|
||
appFocusList = trafficAppStatisticDao.getAppTrend(entity);
|
||
Map resultMap = new HashMap();
|
||
if(!StringUtil.isEmpty(appFocusList)){
|
||
Date beginDate = DateUtils.parseDate(entity.getSearchStartTime());
|
||
Date endDate = DateUtils.parseDate(entity.getSearchEndTime());
|
||
List<Date> dateRangeList = new ArrayList<Date>();
|
||
Calendar calendar = Calendar.getInstance();
|
||
calendar.setTime(beginDate);
|
||
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
||
while (calendar.getTime().compareTo(endDate) < 0) {
|
||
dateRangeList.add(calendar.getTime());
|
||
calendar.add(Calendar.MINUTE, 1);
|
||
}
|
||
// 存放每个时间点的总数
|
||
Map<String, List<Long>> ipCountListMap = new HashMap<String, List<Long>>();
|
||
int index = 0;
|
||
List resultSipList = new ArrayList();
|
||
List resultDipList = new ArrayList();
|
||
Long sipTotal = 0L;
|
||
Long dipTotal = 0L;
|
||
for (int i = 0; i < dateRangeList.size(); i++) {
|
||
// 存放一个时间点中总数
|
||
List sipList = new ArrayList();
|
||
List dipList = new ArrayList();
|
||
Date date = dateRangeList.get(i);
|
||
Long sipNum = 0L;
|
||
Long dipNum = 0L;
|
||
for (int j = index; j < appFocusList.size(); j++) {
|
||
TrafficAppFocusStatistic info = appFocusList.get(j);
|
||
if (info.getTime() != null) {
|
||
if (info.getTime().compareTo(date) >= 0 && (i + 1 < dateRangeList.size()?info.getTime().compareTo(dateRangeList.get(i + 1)) < 0:true)) {
|
||
sipNum = sipNum + info.getSipNum();
|
||
dipNum = dipNum + info.getDipNum();
|
||
} else {
|
||
index = j;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
sipList.add(date.getTime());
|
||
sipList.add(sipNum);
|
||
resultSipList.add(sipList);
|
||
dipList.add(date.getTime());
|
||
dipList.add(dipNum);
|
||
resultDipList.add(dipList);
|
||
sipTotal+=sipNum;
|
||
dipTotal+=dipNum;
|
||
}
|
||
resultMap.put("sipResult", resultSipList);
|
||
resultMap.put("dipResult", resultDipList);
|
||
resultMap.put("sipSum", sipTotal);
|
||
resultMap.put("dipSum", dipTotal);
|
||
}
|
||
return resultMap;
|
||
}
|
||
|
||
public List<AppConnRecordStatistic> appConnRecordTop100(AppConnRecordStatistic entity) {
|
||
List<AppConnRecordStatistic> list = new ArrayList<AppConnRecordStatistic>();
|
||
list = trafficAppStatisticDao.appConnRecordTop100(entity);
|
||
return list;
|
||
}
|
||
}
|