You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
893 lines
39 KiB
893 lines
39 KiB
package com.system.log.service; |
|
|
|
import Log.LogBackup; |
|
import Log.LogConfig; |
|
import Log.LogEntity; |
|
import Log.repo.LogBackupRepository; |
|
import Log.repo.LogConfigRepository; |
|
import Log.repo.LogEntityRepository; |
|
import com.alibaba.fastjson.JSONArray; |
|
import com.alibaba.fastjson.JSONObject; |
|
import com.google.inject.Inject; |
|
import com.google.inject.persist.Transactional; |
|
import com.hypaas.db.JPA; |
|
import com.hypaas.rpc.ActionRequest; |
|
import com.hypaas.rpc.ActionResponse; |
|
import com.system.log.LogTypeEnum; |
|
import com.system.log.vo.LogRecordVO; |
|
import java.io.*; |
|
import java.text.DecimalFormat; |
|
import java.text.ParseException; |
|
import java.text.SimpleDateFormat; |
|
import java.util.*; |
|
import java.util.regex.Matcher; |
|
import java.util.regex.Pattern; |
|
import module.LogStatus; |
|
import net.lingala.zip4j.core.ZipFile; |
|
import net.lingala.zip4j.exception.ZipException; |
|
import net.lingala.zip4j.model.ZipParameters; |
|
import net.lingala.zip4j.util.Zip4jConstants; |
|
import org.apache.commons.lang3.StringUtils; |
|
import org.apache.poi.hssf.usermodel.HSSFCell; |
|
import org.apache.poi.hssf.usermodel.HSSFRow; |
|
import org.apache.poi.hssf.usermodel.HSSFSheet; |
|
import org.apache.poi.hssf.usermodel.HSSFWorkbook; |
|
|
|
public class LogService { |
|
|
|
@Inject LogEntityRepository logEntityRepository; |
|
|
|
@Inject LogConfigRepository logConfigRepository; |
|
|
|
@Inject LogBackupRepository logBackupRepository; |
|
|
|
public JSONObject getDirContent(String logType, String startTime, String endTime, String keyWord) |
|
throws IOException { |
|
// 定义集合，存放文件名称 |
|
List<String> fileList; |
|
// 获取Tomcat的CATALINA_BASE属性 |
|
String catalinaBase = System.getProperty("catalina.base"); |
|
// 获取localhost_access_log所在文件目录 |
|
String accessLogDir = catalinaBase + "\\logs"; |
|
// 找到过滤出的localhost_access_log文件，将文件的绝对路径放入集合中 |
|
fileList = getFilePath(accessLogDir, startTime, endTime); |
|
// 获取所有文件下符合过滤条件内容并返回 |
|
return getFileContent(fileList, logType, startTime, endTime, keyWord); |
|
} |
|
|
|
// 找出文件夹下指定日志文件名并返回 |
|
private List<String> getFilePath(String accessLogDir, String startTime, String endTime) { |
|
// 定义集合，存放当前符合筛选条件的文件名 |
|
List<String> filePathList = new ArrayList<>(); |
|
// 如果不传开始时间与结束时间，指定为null即可，默认输出当天的日志 |
|
if (StringUtils.isEmpty(startTime) && StringUtils.isEmpty(endTime)) { |
|
// 以yyyy-MM-dd格式获取当天日期 |
|
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd"); |
|
String date = simpleDateFormat.format(new Date(System.currentTimeMillis())); |
|
File LogFile = new File(accessLogDir); |
|
File[] file = LogFile.listFiles(); |
|
for (File file1 : file) { |
|
if (file1.toString().contains("localhost_access_log") && file1.toString().contains(date)) { |
|
// 如果此文件是localhost_access_log文件并且是当天的文件，将其放入集合返回 |
|
filePathList.add(file1.getPath()); |
|
return filePathList; |
|
} |
|
} |
|
} else { |
|
filePathList = getFile(accessLogDir, startTime, endTime); |
|
} |
|
return filePathList; |
|
} |
|
|
|
// 使用日历类将符合条件的日志文件放入集合中返回 |
|
private List<String> getFile(String accessLogDir, String startTime, String endTime) { |
|
// 获取传入的开始时间与结束时间的毫秒数，开始时间直接将时分秒置零处理，结束时间将其加上一天后再将其置零处理， |
|
// 这样做的目的是保证取出符合本次过滤时间的所有文件 |
|
List<String> fileList = new ArrayList<>(); |
|
long[] time = getZeroLongTime(startTime, endTime); |
|
// 遍历指定目录中的文件，筛选出符合条件的日志文件 |
|
File LogFile = new File(accessLogDir); |
|
File[] file = LogFile.listFiles(); |
|
for (File file1 : file) { |
|
if (file1.toString().contains("localhost_access_log")) { |
|
// 如果文件名包含"localhost_access_log"，则判断时间是否符合要求，如果符合，放入集合中 |
|
if ((getFileLongTime(file1.toString()) + 1000 > time[0]) |
|
&& (getFileLongTime(file1.toString()) + 1000 < time[1])) { |
|
fileList.add(file1.getPath()); |
|
} |
|
} |
|
} |
|
return fileList; |
|
} |
|
|
|
// 获取文件名中的时间毫秒值 |
|
private long getFileLongTime(String fileName) { |
|
Date date; |
|
long milliseconds = 0; |
|
String regex = "\\d{4}-\\d{2}-\\d{2}"; |
|
Pattern pattern = Pattern.compile(regex); |
|
Matcher matcher = pattern.matcher(fileName); |
|
if (matcher.find()) { |
|
String time = matcher.group(0); |
|
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd"); |
|
|
|
try { |
|
date = simpleDateFormat.parse(time); |
|
} catch (ParseException e) { |
|
throw new RuntimeException(e); |
|
} |
|
milliseconds = date.getTime(); |
|
} |
|
return milliseconds; |
|
} |
|
|
|
// 输入开始时间与结束时间获得对应的零点毫秒数，方便筛选日志文件，必须以"yyyy-MM-dd HH:mm:ss"的形式输入 |
|
private long[] getZeroLongTime(String startTime, String endTime) { |
|
// 用于存放毫秒数结果的数组 |
|
long[] longTime = new long[2]; |
|
Calendar calendar = Calendar.getInstance(); |
|
// 开始处理开始时间，得到毫秒值 |
|
calendar.set(Calendar.YEAR, Integer.parseInt(startTime.substring(0, 4))); |
|
// 日历类中，00表示1月, 01表示2月，故应该减1 |
|
calendar.set(Calendar.MONTH, Integer.parseInt(startTime.substring(5, 7)) - 1); |
|
calendar.set(Calendar.DATE, Integer.parseInt(startTime.substring(8, 10))); |
|
// 这是将当天的【秒】设置为0 |
|
calendar.set(Calendar.SECOND, 0); |
|
// 这是将当天的【分】设置为0 |
|
calendar.set(Calendar.MINUTE, 0); |
|
// 这是将当天的【时】设置为0 |
|
calendar.set(Calendar.HOUR_OF_DAY, 0); |
|
longTime[0] = calendar.getTimeInMillis(); |
|
// 开始处理结束时间，得到毫秒值 |
|
calendar.set(Calendar.YEAR, Integer.parseInt(endTime.substring(0, 4))); |
|
calendar.set(Calendar.MONTH, Integer.parseInt(endTime.substring(5, 7)) - 1); |
|
calendar.set(Calendar.DATE, Integer.parseInt(endTime.substring(8, 10)) + 1); |
|
calendar.set(Calendar.SECOND, 0); |
|
calendar.set(Calendar.MINUTE, 0); |
|
calendar.set(Calendar.HOUR_OF_DAY, 0); |
|
longTime[1] = calendar.getTimeInMillis(); |
|
return longTime; |
|
} |
|
|
|
// 输入开始时间与结束时间获得对应的标准毫秒数，方便筛选每个日志文件中的数据，必须以"yyyy-MM-dd HH:mm:ss"的形式输入 |
|
public long getLongTime(String time) { |
|
Date date; |
|
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); |
|
try { |
|
date = simpleDateFormat.parse(time); |
|
} catch (ParseException e) { |
|
throw new RuntimeException(e); |
|
} |
|
return date.getTime(); |
|
} |
|
|
|
// 获取 |
|
private long getLogContentLongTime(String logContent) { |
|
Date date; |
|
SimpleDateFormat simpleDateFormat = |
|
new SimpleDateFormat("dd/MMM/yyyy:HH:mm:ss", Locale.ENGLISH); |
|
try { |
|
// 取出日志文件中例如22/Feb/2024:10:04:32 +0800的部分，转化为毫秒 |
|
date = |
|
simpleDateFormat.parse( |
|
logContent.substring(logContent.indexOf("[") + 1, logContent.indexOf("[") + 21)); |
|
} catch (ParseException e) { |
|
throw new RuntimeException(e); |
|
} |
|
return date.getTime(); |
|
} |
|
|
|
// 返回日志文件的详细内容(StringBuffer) |
|
private JSONObject getFileContent( |
|
List<String> fileList, String logType, String startTime, String endTime, String keyWord) { |
|
JSONArray jsonArray = new JSONArray(); |
|
if (StringUtils.isEmpty(logType)) { |
|
logType = ""; |
|
} |
|
if (StringUtils.isEmpty(keyWord)) { |
|
keyWord = ""; |
|
} |
|
for (String file : fileList) { |
|
try { |
|
// 设置读取器，读取fileList中的文件 |
|
BufferedReader bufferedReader = new BufferedReader(new FileReader(file)); |
|
String line; |
|
// 如果开始时间与结束时间为空，则fileList里只有一个当天的日志文件，不需要时间过滤，只过滤日志类型与关键字即可 |
|
if (StringUtils.isEmpty(startTime) && StringUtils.isEmpty(endTime)) { |
|
// 判断下一行不为空就读取出来进行条件判断 |
|
while ((line = bufferedReader.readLine()) != null) { |
|
// 判断本行数据是否包含输入的日志类型与关键字信息，如果包含，写入文件 |
|
if (LogTypeEnum.Interface.getValue().equals(logType)) { |
|
if ((!line.contains(LogTypeEnum.Exception.getValue())) && line.contains(keyWord)) { |
|
jsonArray.add(logAnalysis(line, file)); |
|
} |
|
} else { |
|
if (line.contains(logType) && line.contains(keyWord)) { |
|
jsonArray.add(logAnalysis(line, file)); |
|
} |
|
} |
|
} |
|
} else { |
|
// 如果开始时间与结束时间不为空，则fileList里不确定有几个日志文件，由于考虑精确到时分秒，需要时间过滤， |
|
// 还需要过滤日志类型与关键字 |
|
while ((line = bufferedReader.readLine()) != null) { |
|
if (LogTypeEnum.Interface.getValue().equals(logType)) { |
|
if (getLongTime(startTime) <= getLogContentLongTime(line) |
|
&& getLongTime(endTime) >= getLogContentLongTime(line) |
|
&& ((!line.contains(LogTypeEnum.Exception.getValue())) |
|
&& line.contains(keyWord))) { |
|
jsonArray.add(logAnalysis(line, file)); |
|
} |
|
} else { |
|
if (getLongTime(startTime) <= getLogContentLongTime(line) |
|
&& getLongTime(endTime) >= getLogContentLongTime(line) |
|
&& (line.contains(logType) && line.contains(keyWord))) { |
|
jsonArray.add(logAnalysis(line, file)); |
|
} |
|
} |
|
} |
|
} |
|
} catch (Exception e) { |
|
e.getStackTrace(); |
|
} |
|
} |
|
JSONObject jsonObject = new JSONObject(); |
|
JSONObject selectContent = new JSONObject(); |
|
jsonObject.put("code", 200); |
|
jsonObject.put("msg", "操作成功"); |
|
selectContent.put("content", jsonArray); |
|
jsonObject.put("data", selectContent); |
|
return jsonObject; |
|
} |
|
|
|
// 解析日志，提取关键信息 |
|
private JSONObject logAnalysis(String logContent, String fileName) { |
|
JSONObject logDetail = new JSONObject(); |
|
LogRecordVO logRecordVO = new LogRecordVO(); |
|
SimpleDateFormat simpleDateFormat = |
|
new SimpleDateFormat("dd/MMM/yyyy:HH:mm:ss", Locale.ENGLISH); |
|
try { |
|
// 以yyyy-MM-dd HH:mm:ss形式提取时间 |
|
long l = |
|
simpleDateFormat |
|
.parse( |
|
logContent.substring(logContent.indexOf("[") + 1, logContent.indexOf("[") + 21)) |
|
.getTime(); |
|
SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); |
|
String date = simpleDateFormat1.format(l); |
|
logRecordVO.setTime(date); |
|
// 提取ip地址 |
|
String ipAddress = logContent.substring(0, logContent.indexOf("-") - 1); |
|
logRecordVO.setIpAddress(ipAddress); |
|
// 写入文件名l |
|
logRecordVO.setFileSource(fileName); |
|
// 写入文件内容 |
|
String log = |
|
logContent.substring(logContent.indexOf("]") + 2, logContent.length()).replace("\"", ""); |
|
logRecordVO.setLogContent(log); |
|
return (JSONObject) JSONObject.toJSON(logRecordVO); |
|
} catch (ParseException e) { |
|
throw new RuntimeException(e); |
|
} |
|
} |
|
|
|
public File getFileZip(ActionRequest request, ActionResponse response) { |
|
String password = request.getContext().get("password").toString(); |
|
String confirmPassword = request.getContext().get("confirmPassword").toString(); |
|
String startTime = request.getContext().get("startTime").toString(); |
|
String endTime = request.getContext().get("endTime").toString(); |
|
String logType = request.getContext().get("logType").toString(); |
|
String keyWord = request.getContext().get("keyWord").toString(); |
|
// 判断密码和确认密码是否都不为空且一致，如果不一致直接返回null |
|
if (StringUtils.isEmpty(password) |
|
|| StringUtils.isEmpty(confirmPassword) |
|
|| !password.equals(confirmPassword)) { |
|
return null; |
|
} |
|
|
|
// 定义集合，存放文件名称 |
|
List<String> fileList; |
|
// 获取Tomcat的CATALINA_BASE属性 |
|
String catalinaBase = System.getProperty("catalina.base"); |
|
// 获取localhost_access_log所在文件目录 |
|
String accessLogDir = catalinaBase + "\\logs"; |
|
// 找到过滤出的localhost_access_log文件，将文件的绝对路径放入集合中 |
|
fileList = getFilePath(accessLogDir, startTime, endTime); |
|
// 查询出所有的记录 |
|
JSONObject selectResult = getFileContent(fileList, logType, startTime, endTime, keyWord); |
|
|
|
try { |
|
// 创建临时文件，将查询的结果写入临时文件 |
|
File tempFile = File.createTempFile("log", ".txt"); |
|
FileWriter writer = new FileWriter(tempFile); |
|
writer.write(selectResult.toString()); |
|
writer.close(); |
|
|
|
// 根据时间设定输出文件名 |
|
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss"); |
|
String date = simpleDateFormat.format(new Date(System.currentTimeMillis())); |
|
|
|
// 获取临时文件目录 |
|
String tempDir = System.getProperty("java.io.tmpdir"); |
|
String tempFilePath = tempDir + "/" + date + ".zip"; |
|
System.out.println(tempFilePath); |
|
// 在临时文件目录中创建一个随机名称的zip文件 |
|
File file = new File(tempFilePath); |
|
ZipFile zipFile = new ZipFile(file); |
|
ZipParameters parameters = new ZipParameters(); // 设置zip包的一些参数集合 |
|
parameters.setEncryptFiles(true); // 是否设置密码（此处设置为：是） |
|
parameters.setCompressionMethod(Zip4jConstants.COMP_DEFLATE); // 压缩方式(默认值) |
|
parameters.setCompressionLevel(Zip4jConstants.DEFLATE_LEVEL_NORMAL); // 普通级别（参数很多） |
|
parameters.setEncryptionMethod(Zip4jConstants.ENC_METHOD_STANDARD); // 加密级别 |
|
parameters.setPassword(password); // 压缩包密码 |
|
// 向zip文件中根据设置的参数写入数据 |
|
zipFile.createZipFile(tempFile, parameters); |
|
return file; |
|
} catch (ZipException e) { |
|
throw new RuntimeException(e); |
|
} catch (IOException e) { |
|
throw new RuntimeException(e); |
|
} |
|
} |
|
|
|
// public JSONObject getFileChange() { |
|
// // 定义集合，存放文件名称 |
|
// List<String> fileList; |
|
// // 获取Tomcat的CATALINA_BASE属性 |
|
// String catalinaBase = System.getProperty("catalina.base"); |
|
// // 获取localhost_access_log所在文件目录 |
|
// String accessLogDir = catalinaBase + "\\logs"; |
|
// // 找到过滤出的localhost_access_log文件，将文件的绝对路径放入集合中 |
|
// fileList = getFilePath(accessLogDir, null, null); |
|
// // 返回当天日志文件 |
|
// return getFileContent(fileList, null, null, null, null); |
|
// } |
|
|
|
public File exportLog(ActionRequest request, ActionResponse response, String userAuth) |
|
throws IOException { |
|
String password = request.getContext().get("password").toString(); |
|
String confirmPassword = request.getContext().get("confirmPassword").toString(); |
|
String startTime = request.getContext().get("exportStartTime").toString(); |
|
String endTime = request.getContext().get("exportEndTime").toString(); |
|
if (!password.equals(confirmPassword)) { |
|
response.setAlert("两次输入的密码不一致!"); |
|
return null; |
|
} |
|
// 密码正则表达式校验 |
|
String regex = |
|
"^(?![0-9A-Za-z]+$)(?![0-9A-Z\\W]+$)(?![0-9a-z\\W]+$)(?![A-Za-z\\W]+$)[0-9A-Za-z~!@#$%^&*()_+`\\-={}|\\[\\]\\\\:\";'<>?,./]{6,16}$"; |
|
Pattern pattern = Pattern.compile(regex); |
|
Matcher matcher = pattern.matcher(password); |
|
if (!matcher.find()) { |
|
// 密码不通过正则校验 |
|
response.setAlert("密码需要包含6-16位数字+大写字母+小写字母+特殊字符!"); |
|
return null; |
|
} |
|
|
|
List<LogEntity> selectResult = new ArrayList<>(); |
|
List<LogEntity> logEntitiesList = logEntityRepository.all().fetch(); |
|
if (startTime != null && endTime != null) { |
|
// 如果输入的开始时间与结束时间都不为空，则输出时间范围内符合用户角色的所有记录 |
|
for (LogEntity logEntity : logEntitiesList) { |
|
if ((getSqlLongTime(logEntity.getTime()) > getSqlLongTime(startTime)) |
|
&& (getSqlLongTime(logEntity.getTime()) < getSqlLongTime(endTime)) |
|
&& userAuth.equals(logEntity.getUserAuth().getValue())) { |
|
selectResult.add(logEntity); |
|
} |
|
} |
|
} |
|
|
|
if (startTime == null && endTime != null) { |
|
// 如果输入的开始时间为空，则输出结束时间之前的符合用户角色的所有记录 |
|
for (LogEntity logEntity : logEntitiesList) { |
|
if ((getSqlLongTime(logEntity.getTime()) < getSqlLongTime(endTime)) |
|
&& userAuth.equals(logEntity.getUserAuth().getValue())) { |
|
selectResult.add(logEntity); |
|
} |
|
} |
|
} |
|
|
|
if (startTime != null && endTime == null) { |
|
// 如果输入的结束时间为空，则输出开始时间之后的符合用户角色的所有记录 |
|
for (LogEntity logEntity : logEntitiesList) { |
|
if ((getSqlLongTime(logEntity.getTime()) > getSqlLongTime(startTime)) |
|
&& userAuth.equals(logEntity.getUserAuth().getValue())) { |
|
selectResult.add(logEntity); |
|
} |
|
} |
|
} |
|
|
|
if (startTime == null && endTime == null) { |
|
// 如果输入的时间都为空，则输出符合用户角色的所有记录 |
|
for (LogEntity logEntity : logEntitiesList) { |
|
if (userAuth.equals(logEntity.getUserAuth().getValue())) { |
|
selectResult.add(logEntity); |
|
} |
|
} |
|
} |
|
// Object jsonObject = JSONObject.toJSON(selectResult); |
|
return exportLogExcelZip(selectResult, password); |
|
} |
|
|
|
public long getSqlLongTime(Object time) { |
|
// logEntity.getTime()形式 "2024-02-04T14:03:45.114" |
|
// startTime()形式 "2024-02-04 14:03" |
|
Date date; |
|
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); |
|
if (time.toString().length() < 19) { |
|
time = time.toString().replace("T", " ") + ":00"; |
|
} else { |
|
time = time.toString().substring(0, 19).replace("T", " "); |
|
} |
|
try { |
|
date = simpleDateFormat.parse(time.toString()); |
|
} catch (ParseException e) { |
|
throw new RuntimeException(e); |
|
} |
|
return date.getTime(); |
|
} |
|
|
|
// 导出为Excel类型 |
|
public File exportLogExcelZip(List<LogEntity> selectResult, String password) throws IOException { |
|
// 创建一个工作簿，也就是Excel文件 |
|
HSSFWorkbook wb = new HSSFWorkbook(); |
|
// 创建一个工作表 |
|
HSSFSheet sheet = wb.createSheet(); |
|
// 第一行，标题 |
|
HSSFRow row0 = sheet.createRow(0); |
|
HSSFCell cell0 = row0.createCell(0); |
|
cell0.setCellValue("操作日志表"); |
|
// 第二行，表头 |
|
HSSFRow row1 = sheet.createRow(1); |
|
row1.createCell(0).setCellValue("id"); |
|
row1.createCell(1).setCellValue("address"); |
|
row1.createCell(2).setCellValue("content"); |
|
row1.createCell(3).setCellValue("hashValue"); |
|
row1.createCell(4).setCellValue("levelDesc"); |
|
row1.createCell(5).setCellValue("levelNum"); |
|
row1.createCell(6).setCellValue("module"); |
|
row1.createCell(7).setCellValue("objectName"); |
|
row1.createCell(8).setCellValue("opType"); |
|
row1.createCell(9).setCellValue("result"); |
|
row1.createCell(10).setCellValue("resultDesc"); |
|
row1.createCell(11).setCellValue("status"); |
|
row1.createCell(12).setCellValue("time"); |
|
row1.createCell(13).setCellValue("userAuth"); |
|
row1.createCell(14).setCellValue("userAuthDesc"); |
|
row1.createCell(15).setCellValue("userId"); |
|
|
|
// 向表中写入数据 |
|
int rowInt = 2; |
|
for (LogEntity logEntity : selectResult) { |
|
HSSFRow row = sheet.createRow(rowInt++); |
|
int index = 0; |
|
row.createCell(index++).setCellValue(logEntity.getId()); |
|
row.createCell(index++).setCellValue(logEntity.getAddress()); |
|
row.createCell(index++).setCellValue(logEntity.getContent()); |
|
row.createCell(index++).setCellValue(logEntity.getHashValue()); |
|
row.createCell(index++).setCellValue(logEntity.getLevelDesc()); |
|
row.createCell(index++).setCellValue(logEntity.getLevelNum().getValue()); |
|
row.createCell(index++).setCellValue(logEntity.getModule()); |
|
row.createCell(index++).setCellValue(logEntity.getObjectName()); |
|
row.createCell(index++).setCellValue(logEntity.getOpType().getValue()); |
|
row.createCell(index++).setCellValue(logEntity.getResult()); |
|
row.createCell(index++).setCellValue(logEntity.getResultDesc()); |
|
row.createCell(index++).setCellValue(logEntity.getStatus()); |
|
row.createCell(index++).setCellValue(logEntity.getTime().toString()); |
|
row.createCell(index++).setCellValue(logEntity.getUserAuth().getValue()); |
|
row.createCell(index++).setCellValue(logEntity.getUserAuthDesc()); |
|
row.createCell(index++).setCellValue(logEntity.getUserId()); |
|
} |
|
FileOutputStream fos = null; |
|
try { |
|
// 输出文件,创建字节输出流 |
|
File tempFile = new File(File.createTempFile("log", ".xls").getPath()); |
|
fos = new FileOutputStream(tempFile); |
|
wb.write(fos); |
|
fos.flush(); |
|
|
|
// 根据时间设定输出文件名 |
|
SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss"); |
|
String date = simpleDateFormat1.format(new Date(System.currentTimeMillis())); |
|
|
|
// 获取临时文件目录 |
|
String tempDir = System.getProperty("java.io.tmpdir"); |
|
String tempFilePath = tempDir + "/" + date + ".zip"; |
|
System.out.println(tempFilePath); |
|
// 在临时文件目录中创建一个随机名称的zip文件 |
|
File file = new File(tempFilePath); |
|
ZipFile zipFile = new ZipFile(file); |
|
ZipParameters parameters = new ZipParameters(); // 设置zip包的一些参数集合 |
|
parameters.setEncryptFiles(true); // 是否设置密码（此处设置为：是） |
|
parameters.setCompressionMethod(Zip4jConstants.COMP_DEFLATE); // 压缩方式(默认值) |
|
parameters.setCompressionLevel(Zip4jConstants.DEFLATE_LEVEL_NORMAL); // 普通级别（参数很多） |
|
parameters.setEncryptionMethod(Zip4jConstants.ENC_METHOD_STANDARD); // 加密级别 |
|
parameters.setPassword(password); // 压缩包密码 |
|
// 向zip文件中根据设置的参数写入数据 |
|
zipFile.createZipFile(tempFile, parameters); |
|
return file; |
|
} catch (ZipException e) { |
|
throw new RuntimeException(e); |
|
} finally { |
|
fos.close(); |
|
} |
|
} |
|
|
|
public File exportLogZip(Object selectResult, String password) { |
|
try { |
|
// 创建临时文件，将查询的结果写入临时文件 |
|
File tempFile = File.createTempFile("log", ".txt"); |
|
FileWriter writer = new FileWriter(tempFile); |
|
writer.write(selectResult.toString()); |
|
writer.close(); |
|
|
|
// 根据时间设定输出文件名 |
|
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss"); |
|
String date = simpleDateFormat.format(new Date(System.currentTimeMillis())); |
|
|
|
// 获取临时文件目录 |
|
String tempDir = System.getProperty("java.io.tmpdir"); |
|
String tempFilePath = tempDir + "/" + date + ".zip"; |
|
System.out.println(tempFilePath); |
|
// 在临时文件目录中创建一个随机名称的zip文件 |
|
File file = new File(tempFilePath); |
|
ZipFile zipFile = new ZipFile(file); |
|
ZipParameters parameters = new ZipParameters(); // 设置zip包的一些参数集合 |
|
parameters.setEncryptFiles(true); // 是否设置密码（此处设置为：是） |
|
parameters.setCompressionMethod(Zip4jConstants.COMP_DEFLATE); // 压缩方式(默认值) |
|
parameters.setCompressionLevel(Zip4jConstants.DEFLATE_LEVEL_NORMAL); // 普通级别（参数很多） |
|
parameters.setEncryptionMethod(Zip4jConstants.ENC_METHOD_STANDARD); // 加密级别 |
|
parameters.setPassword(password); // 压缩包密码 |
|
// 向zip文件中根据设置的参数写入数据 |
|
zipFile.createZipFile(tempFile, parameters); |
|
return file; |
|
} catch (ZipException e) { |
|
throw new RuntimeException(e); |
|
} catch (IOException e) { |
|
throw new RuntimeException(e); |
|
} |
|
} |
|
|
|
public JSONObject setLogConfig(Integer threshold, Integer backupCycle, String backupStartTime) { |
|
List<LogBackup> logBackupList = logBackupRepository.all().fetch(); |
|
if (logBackupList.size() == 0) { |
|
LogBackup logBackup = new LogBackup(); |
|
logBackup.setBackupCycle(backupCycle); |
|
logBackup.setThreshold(threshold); |
|
logBackup.setBackupStartTime(backupStartTime); |
|
saveBackup(logBackup); |
|
} else { |
|
LogBackup logBackupSelectResult = logBackupRepository.find(logBackupList.get(0).getId()); |
|
logBackupSelectResult.setBackupCycle(backupCycle); |
|
logBackupSelectResult.setThreshold(threshold); |
|
logBackupSelectResult.setBackupStartTime(backupStartTime); |
|
saveBackup(logBackupSelectResult); |
|
} |
|
|
|
LogConfig logConfig = new LogConfig(); |
|
logConfig.setThreshold(threshold); |
|
logConfig.setBackupCycle(backupCycle); |
|
logConfig.setStatus(LogStatus.waitBackup); |
|
|
|
// 起始备份时间为手动输入的备份开始时间,结束时间需要通过备份周期计算 |
|
logConfig.setLogStartTime(backupStartTime); |
|
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); |
|
Calendar calendar = Calendar.getInstance(); |
|
Date date = null; |
|
String logEndTime = null; |
|
try { |
|
date = simpleDateFormat.parse(backupStartTime); |
|
calendar.setTime(date); |
|
calendar.add(Calendar.DAY_OF_YEAR, backupCycle); |
|
Long longTime = calendar.getTime().getTime(); |
|
// 将日志结束时间转化为"yyyy-MM-dd HH:mm:ss"格式 |
|
logEndTime = simpleDateFormat.format(longTime); |
|
} catch (ParseException e) { |
|
throw new RuntimeException(e); |
|
} |
|
logConfig.setLogEndTime(logEndTime); |
|
List<LogConfig> list = logConfigRepository.all().fetch(); |
|
if (list.size() != 0) { |
|
// 说明已经有记录了，要先将原来的主配置找到改为历史配置 |
|
for (LogConfig config : list) { |
|
if ("Current".equals(config.getRecordType())) { |
|
LogConfig logConfig1 = logConfigRepository.find(config.getId()); |
|
logConfig1.setRecordType("History"); |
|
saveConfig(logConfig1); |
|
break; |
|
} |
|
} |
|
} |
|
logConfig.setRecordType("Current"); |
|
saveConfig(logConfig); |
|
JSONObject jsonObject = new JSONObject(); |
|
jsonObject.put("code", 200); |
|
jsonObject.put("msg", "保存成功"); |
|
return jsonObject; |
|
} |
|
|
|
@Transactional |
|
public LogConfig saveConfig(LogConfig entity) { |
|
return JPA.save(entity); |
|
} |
|
|
|
@Transactional |
|
public LogBackup saveBackup(LogBackup entity) { |
|
return JPA.save(entity); |
|
} |
|
|
|
public void deleteSystemManageUserBackup(ActionRequest request, ActionResponse response) { |
|
Long id = (Long) request.getContext().get("id"); |
|
LogConfig logConfig = logConfigRepository.find(id); |
|
if (null == logConfig) { |
|
response.setError("未查询到此条记录"); |
|
return; |
|
} |
|
String filePath = logConfig.getFilePath(); |
|
File file = new File(filePath + "systemManageUser.zip"); |
|
// if (file.delete()) { |
|
// logConfig.setStatus(LogStatus.alreadyDelete); |
|
// response.setNotify("日志备份文件删除成功！"); |
|
// saveConfig(logConfig); |
|
// response.setReload(true); |
|
// } else { |
|
// response.setError("日志备份文件删除失败！"); |
|
// response.setReload(true); |
|
// } |
|
file.delete(); |
|
logConfig.setStatus(LogStatus.alreadyDelete); |
|
response.setNotify("日志备份文件删除成功！"); |
|
saveConfig(logConfig); |
|
response.setReload(true); |
|
} |
|
|
|
public void secondBackup(ActionRequest request, ActionResponse response) { |
|
Long id = (Long) request.getContext().get("id"); |
|
LogConfig logConfig = logConfigRepository.find(id); |
|
if (null == logConfig) { |
|
response.setError("未查询到此条记录"); |
|
response.setReload(true); |
|
return; |
|
} |
|
if (!LogStatus.backupFail.getValue().equals(logConfig.getStatus().getValue())) { |
|
response.setNotify("该条记录状态非备份失败"); |
|
response.setReload(true); |
|
return; |
|
} |
|
String backupTime = null; |
|
String filePath = null; |
|
try { |
|
filePath = backupLogExcelZip(selectRecord(logConfig)); |
|
} catch (IOException e) { |
|
response.setError("重新备份失败！"); |
|
response.setReload(true); |
|
throw new RuntimeException(e); |
|
} |
|
// 需要将状态改为已备份,并添加备份时间，计算备份大小，将当前配置改为历史配置 |
|
logConfig.setStatus(LogStatus.alreadyBackup); |
|
backupTime = getStringTime(System.currentTimeMillis()); |
|
logConfig.setBackupStartTime(backupTime); |
|
logConfig.setBackupTime(backupTime); |
|
// 计算文件大小，单位以M表示，精确小数点后两位 |
|
Map<String, String> fileSizeMap = getSize(filePath); |
|
logConfig.setThresholdSystemManageUserSize(fileSizeMap.get("1")); |
|
logConfig.setThresholdSecurityUserSize("2"); |
|
logConfig.setThresholdSecurityAuditUserSize("3"); |
|
logConfig.setThresholdServiceUserSize("4"); |
|
logConfig.setFilePath(filePath); |
|
if (logConfig.getRecordType().equals("Current")) { |
|
logConfig.setRecordType("History"); |
|
// 如果是当前配置，要添加一条新的记录，将记录改为待配置，因为当前是主配置，历史配置的话不需要，备份一次即可 |
|
LogConfig newRecord = new LogConfig(); |
|
newRecord.setRecordType("Current"); |
|
// 日志开始时间就是上次备份时间，根据备份周期计算日志结束时间 |
|
newRecord.setLogStartTime(backupTime); |
|
newRecord.setLogEndTime(getEndTime(backupTime, logConfig.getBackupCycle())); |
|
newRecord.setStatus(LogStatus.waitBackup); |
|
logConfigRepository.save(newRecord); |
|
} |
|
saveConfig(logConfig); |
|
response.setReload(true); |
|
} |
|
|
|
public Map<String, List<LogEntity>> selectRecord(LogConfig logConfig) { |
|
Map<String, List<LogEntity>> map = new HashMap<>(); |
|
List<LogEntity> serviceUserSelectResult = new ArrayList<>(); |
|
List<LogEntity> securityUserSelectResult = new ArrayList<>(); |
|
List<LogEntity> securityAuditUserSelectResult = new ArrayList<>(); |
|
List<LogEntity> systemManageUserResult = new ArrayList<>(); |
|
|
|
List<LogEntity> logEntityList = logEntityRepository.all().fetch(); |
|
for (LogEntity logEntity : logEntityList) { |
|
if (getSqlLongTime(logEntity.getTime()) > getLongTime(logConfig.getLogStartTime()) |
|
&& getSqlLongTime(logEntity.getTime()) < getLongTime(logConfig.getLogEndTime())) { |
|
// 如果当条记录时间大于开始时间小于结束时间，则判断角色 |
|
if (logEntity.getUserAuth().getValue().equals("1")) { |
|
// 系统管理员 |
|
systemManageUserResult.add(logEntity); |
|
} |
|
if (logEntity.getUserAuth().getValue().equals("2")) { |
|
// 安全保密员 |
|
securityUserSelectResult.add(logEntity); |
|
} |
|
if (logEntity.getUserAuth().getValue().equals("3")) { |
|
// 安全审计员 |
|
securityAuditUserSelectResult.add(logEntity); |
|
} |
|
if (logEntity.getUserAuth().getValue().equals("4")) { |
|
// 业务用户 |
|
serviceUserSelectResult.add(logEntity); |
|
} |
|
map.put("systemManageUser", systemManageUserResult); |
|
map.put("securityUser", securityUserSelectResult); |
|
map.put("securityAuditUser", securityAuditUserSelectResult); |
|
map.put("serviceUser", serviceUserSelectResult); |
|
} |
|
} |
|
return map; |
|
} |
|
|
|
// 备份日志，导出为Excel类型 |
|
public String backupLogExcelZip(Map<String, List<LogEntity>> selectResult) throws IOException { |
|
String tempFilePath = null; |
|
Set<Map.Entry<String, List<LogEntity>>> entries = selectResult.entrySet(); |
|
// 根据时间设定输出文件名 |
|
SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss-SSS"); |
|
String date = simpleDateFormat1.format(new Date(System.currentTimeMillis())); |
|
for (Map.Entry<String, List<LogEntity>> entry : entries) { |
|
// 创建一个工作簿，也就是Excel文件 |
|
HSSFWorkbook wb = new HSSFWorkbook(); |
|
// 创建一个工作表 |
|
HSSFSheet sheet = wb.createSheet(); |
|
// 第一行，标题 |
|
HSSFRow row0 = sheet.createRow(0); |
|
HSSFCell cell0 = row0.createCell(0); |
|
cell0.setCellValue("操作日志表"); |
|
// 第二行，表头 |
|
HSSFRow row1 = sheet.createRow(1); |
|
row1.createCell(0).setCellValue("id"); |
|
row1.createCell(1).setCellValue("address"); |
|
row1.createCell(2).setCellValue("content"); |
|
row1.createCell(3).setCellValue("hashValue"); |
|
row1.createCell(4).setCellValue("levelDesc"); |
|
row1.createCell(5).setCellValue("levelNum"); |
|
row1.createCell(6).setCellValue("module"); |
|
row1.createCell(7).setCellValue("objectName"); |
|
row1.createCell(8).setCellValue("opType"); |
|
row1.createCell(9).setCellValue("result"); |
|
row1.createCell(10).setCellValue("resultDesc"); |
|
row1.createCell(11).setCellValue("status"); |
|
row1.createCell(12).setCellValue("time"); |
|
row1.createCell(13).setCellValue("userAuth"); |
|
row1.createCell(14).setCellValue("userAuthDesc"); |
|
row1.createCell(15).setCellValue("userId"); |
|
|
|
// 向表中写入数据 |
|
int rowInt = 2; |
|
for (LogEntity logEntity : entry.getValue()) { |
|
HSSFRow row = sheet.createRow(rowInt++); |
|
int index = 0; |
|
row.createCell(index++).setCellValue(logEntity.getId()); |
|
row.createCell(index++).setCellValue(logEntity.getAddress()); |
|
row.createCell(index++).setCellValue(logEntity.getContent()); |
|
row.createCell(index++).setCellValue(logEntity.getHashValue()); |
|
row.createCell(index++).setCellValue(logEntity.getLevelDesc()); |
|
row.createCell(index++).setCellValue(logEntity.getLevelNum().getValue()); |
|
row.createCell(index++).setCellValue(logEntity.getModule()); |
|
row.createCell(index++).setCellValue(logEntity.getObjectName()); |
|
row.createCell(index++).setCellValue(logEntity.getOpType().getValue()); |
|
row.createCell(index++).setCellValue(logEntity.getResult()); |
|
row.createCell(index++).setCellValue(logEntity.getResultDesc()); |
|
row.createCell(index++).setCellValue(logEntity.getStatus()); |
|
row.createCell(index++).setCellValue(logEntity.getTime().toString()); |
|
row.createCell(index++).setCellValue(logEntity.getUserAuth().getValue()); |
|
row.createCell(index++).setCellValue(logEntity.getUserAuthDesc()); |
|
row.createCell(index++).setCellValue(logEntity.getUserId()); |
|
} |
|
FileOutputStream fos = null; |
|
try { |
|
|
|
// 输出文件,创建字节输出流 |
|
File tempFile = new File(File.createTempFile("log", ".xls").getPath()); |
|
fos = new FileOutputStream(tempFile); |
|
wb.write(fos); |
|
fos.flush(); |
|
|
|
// 获取临时文件目录 |
|
String tempDir = System.getProperty("java.io.tmpdir"); |
|
tempFilePath = tempDir + "\\" + date; |
|
String realFilePath = tempDir + "\\" + date + entry.getKey() + ".zip"; |
|
// 在临时文件目录中创建一个随机名称的zip文件 |
|
File file = new File(realFilePath); |
|
ZipFile zipFile = new ZipFile(file); |
|
ZipParameters parameters = new ZipParameters(); // 设置zip包的一些参数集合 |
|
// parameters.setEncryptFiles(true); // 是否设置密码（此处设置为：是） |
|
parameters.setCompressionMethod(Zip4jConstants.COMP_DEFLATE); // 压缩方式(默认值) |
|
parameters.setCompressionLevel(Zip4jConstants.DEFLATE_LEVEL_NORMAL); // 普通级别（参数很多） |
|
// parameters.setEncryptionMethod(Zip4jConstants.ENC_METHOD_STANDARD); // 加密级别 |
|
// 向zip文件中根据设置的参数写入数据 |
|
zipFile.createZipFile(tempFile, parameters); |
|
|
|
} catch (ZipException e) { |
|
throw new RuntimeException(e); |
|
} finally { |
|
fos.close(); |
|
} |
|
} |
|
return tempFilePath; |
|
} |
|
|
|
public String getStringTime(long time) { |
|
SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); |
|
return simpleDateFormat1.format(time); |
|
} |
|
|
|
public String getEndTime(String time, Integer backupCycle) { |
|
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); |
|
Calendar calendar = Calendar.getInstance(); |
|
Date date = null; |
|
String logEndTime = null; |
|
try { |
|
date = simpleDateFormat.parse(time); |
|
calendar.setTime(date); |
|
calendar.add(Calendar.DAY_OF_YEAR, backupCycle); |
|
Long longTime = calendar.getTime().getTime(); |
|
// 将日志结束时间转化为"yyyy-MM-dd HH:mm:ss"格式 |
|
logEndTime = simpleDateFormat.format(longTime); |
|
return logEndTime; |
|
} catch (ParseException e) { |
|
throw new RuntimeException(e); |
|
} |
|
} |
|
|
|
public Map<String, String> getSize(String filePath) { |
|
Map<String, String> map = new HashMap<>(); |
|
map.put("1", getFileSize(filePath + "systemManageUser.zip")); |
|
map.put("2", getFileSize(filePath + "securityUser.zip")); |
|
map.put("3", getFileSize(filePath + "securityAuditUser.zip")); |
|
map.put("4", getFileSize(filePath + "serviceUser.zip")); |
|
return map; |
|
} |
|
|
|
// 计算文件大小，单位为M，保留两位小数 |
|
public String getFileSize(String filePath) { |
|
File file = new File(filePath); |
|
long fileSize = file.length(); |
|
DecimalFormat df = new DecimalFormat("#.00"); |
|
// 将字节转换为兆字节（MB）并格式化输出 |
|
double fileSizeInKB = (double) fileSize / 1024; |
|
if (fileSizeInKB > 1024) { |
|
double fileSizeInMB = (double) fileSize / (1024 * 1024); |
|
if (fileSizeInMB > 1024) { |
|
double fileSizeInGB = (double) fileSize / (1024 * 1024 * 1024); |
|
String formattedNumber = df.format(fileSizeInGB); |
|
double result = Double.parseDouble(formattedNumber); |
|
return result + "GB"; |
|
} |
|
String formattedNumber = df.format(fileSizeInMB); |
|
double result = Double.parseDouble(formattedNumber); |
|
return result + "MB"; |
|
} |
|
String formattedNumber = df.format(fileSizeInKB); |
|
double result = Double.parseDouble(formattedNumber); |
|
return result + "KB"; |
|
} |
|
|
|
public JSONObject selectLogConfig() { |
|
JSONObject jsonObject = new JSONObject(); |
|
jsonObject.put("code", 200); |
|
jsonObject.put("msg", "操作成功"); |
|
List<LogBackup> logBackupList = logBackupRepository.all().fetch(); |
|
if (logBackupList.size() == 0) { |
|
jsonObject.put("data", null); |
|
return jsonObject; |
|
} else { |
|
JSONObject selectResult = new JSONObject(); |
|
selectResult.put("threshold", logBackupList.get(0).getThreshold()); |
|
selectResult.put("backupCycle", logBackupList.get(0).getBackupCycle()); |
|
selectResult.put("backupStartTime", logBackupList.get(0).getBackupStartTime()); |
|
jsonObject.put("data", selectResult); |
|
return jsonObject; |
|
} |
|
} |
|
}
|
|
|