crowdsource-backend/src/main/java/edu/nju/service/OssFileService.java

package edu.nju.service;

import com.aliyun.oss.ClientBuilderConfiguration;
import com.aliyun.oss.ClientException;
import com.aliyun.oss.OSSException;
import com.aliyun.oss.model.*;
import edu.nju.configuration.OSSConfiguration;
import edu.nju.entities.BugDetail;
import edu.nju.model.enums.UploadType;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
import org.springframework.web.multipart.MultipartFile;

import java.util.List;
import com.alibaba.fastjson.JSON;
import com.aliyun.oss.OSS;
import edu.nju.dao.*;
import edu.nju.entities.*;
import edu.nju.util.OssAliyun;
import edu.nju.util.TransUtil;
import org.json.JSONArray;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.io.*;
import java.lang.reflect.Field;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream;

/**
 * @Author JiaWei Xu
 * @Date 2021-01-04 15:53
 * @Email xjwhhh233@outlook.com
 */
@Slf4j
@Service
@ConditionalOnExpression("${useOss}==true")
public class OssFileService implements FileService {
	private static final int BUFFER_SIZE = 2048;
	@Autowired
	ExamDao examDao;

	@Autowired
	BugDao bugDao;

	@Autowired
	ReportDao reportDao;

	@Autowired
	TestCaseDao testCaseDao;

	@Autowired
	CaseToBugDao caseToBugDao;

	@Autowired
	BugScoreDao bugScoreDao;

	@Autowired
	BugMirrorDao bugMirrorDao;

	@Autowired
	BugHistoryDao bugHistoryDao;

	@Autowired
	BugDetailDao bugDetailDao;

	@Autowired
	private OSSConfiguration ossConfig;

	private OSS client;

	private String key;

	@Value("${upload.thread.maxSize}")
	private String uploadThreadMaxSize;

	@Value("${upload.chunkSize}")
	private String uploadChunkSize;

	@Value("${upload.chunkMaxPartCount}")
	private String uploadChunkMaxPartCount;

	private ExecutorService executorService;

	private List<PartETag> partETags = Collections.synchronizedList(new ArrayList<PartETag>());


	@Value("${cpSerialNum}")
	private String cpSerialNum;

	@Value("${save.path}")
	private String savePath;

	@Value("${save.folder}")
	private String folderName;

	@Value("${save.input}")
	private String inputName;

	@Value("${save.output}")
	private String outputName;

	@Override
	public void uploadImage() {

	}

	@Override
	public List<BugDetail> importBugInfo(MultipartFile sourceZipFile, MultipartFile sourceJsonFile, String originalCaseId, String cpSerialNum) {
		return saveBugDetail(sourceZipFile,sourceJsonFile,originalCaseId,cpSerialNum);
	}

	@Override
	public List<BugDetail> exportBugInfo(String caseId) {
		List<BugDetail> bugDetailList = getBugDetailListByCaseId(caseId);
		bugDetailToFile(bugDetailList,caseId);
		return bugDetailList;
	}

	@Override
	public String sliceUploadFile(String fileName, String caseId, MultipartFile file){
		key = fileName;
		executorService = Executors.newFixedThreadPool(Integer.parseInt(uploadThreadMaxSize));

		ClientBuilderConfiguration conf = new ClientBuilderConfiguration();
		// 连接空闲超时时间，超时则关闭连接（单位：毫秒）。默认为60000毫秒。
		conf.setIdleConnectionTime(Long.parseLong(ossConfig.getIdleConnectionTime()));
		client = ossConfig.ossClientConf(conf);

		try {
			// 获取文件后缀并新建一个类型为File的targetFile，用于后续MultipartFile转File
			String prefix=fileName.substring(fileName.lastIndexOf("."));
			final File targetFile = File.createTempFile(fileName, prefix);

			// 声明一个上传ID，uploadId
			String uploadId = claimUploadId();
			log.info("声明一个上传ID：" + uploadId);

			// 分片上传的每片的大小
			final long partSize = Integer.parseInt(uploadChunkSize) * 1024 * 1024L;   // 5MB

			// MultipartFile转成File
			file.transferTo(targetFile);

			long fileLength = targetFile.length();
			// 计算分片的数量
			int partCount = (int) (fileLength / partSize);
			if (fileLength % partSize != 0) {
				partCount++;
			}
			// 校验是否超过限制的最大分片数量
			if (partCount > Integer.parseInt(uploadChunkMaxPartCount)) {
				throw new RuntimeException("分片数量不能超过" + uploadChunkMaxPartCount);
			} else {
				log.info("分片数量为： " + partCount);
			}

			// 分片上传文件到OSS
			log.info("------------开始分片上传文件到OSS------------");
			// 重新初始化，否则会一直add导致数量不一致
			partETags = Collections.synchronizedList(new ArrayList<PartETag>());
			for (int i = 0; i < partCount; i++) {
				long startPos = i * partSize;
				long curPartSize = (i + 1 == partCount) ? (fileLength - startPos) : partSize;
				executorService.execute(new PartUploader(targetFile, startPos, curPartSize, i + 1, uploadId));
			}

			// 等待所有分片上传完成
			executorService.shutdown();
			while (!executorService.isTerminated()) {
				try {
					executorService.awaitTermination(1, TimeUnit.SECONDS);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}

			log.info("partETags的数量：" + partETags.size());
			// 判断是否所有的分片上传完成
			if (partETags.size() != partCount) {
				throw new RuntimeException("文件上传失败，由于存在部分分片未上传完成。");
			} else {
				log.info("----------文件分片上传成功 " + fileName + "----------");
			}

			// View all parts uploaded recently
//            listAllParts(uploadId);

			// Complete to upload multiparts
			completeMultipartUpload(uploadId);

			// Fetch the object that newly created at the step below.
//            log.info("Fetching an object");
//            client.getObject(new GetObjectRequest(ossConfig.getBucketName(), key), targetFile);
			return ossConfig.getBaseUrl() + "/" + key;
		} catch (OSSException oe) {
			log.info("Caught an OSSException, which means your request made it to OSS, "
					+ "but was rejected with an error response for some reason.");
			log.info("Error Message: " + oe.getErrorMessage());
			log.info("Error Code:       " + oe.getErrorCode());
			log.info("Request ID:      " + oe.getRequestId());
			log.info("Host ID:           " + oe.getHostId());
		} catch (ClientException ce) {
			log.info("Caught an ClientException, which means the client encountered "
					+ "a serious internal problem while trying to communicate with OSS, "
					+ "such as not being able to access the network.");
			log.info("Error Message: " + ce.getMessage());
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			/*
			 * Do not forget to shut down the client finally to release all allocated resources.
			 */
			if (client != null) {
				client.shutdown();
			}
		}
		return "";
	}

	private class PartUploader implements Runnable {

		private File localFile;
		private long startPos;
		private long partSize;
		private int partNumber;
		private String uploadId;

		public PartUploader(File localFile, long startPos, long partSize, int partNumber, String uploadId) {
			this.localFile = localFile;
			this.startPos = startPos;
			this.partSize = partSize;
			this.partNumber = partNumber;
			this.uploadId = uploadId;
		}

		@Override
		public void run() {
			InputStream instream = null;
			try {
				instream = new FileInputStream(this.localFile);
				instream.skip(this.startPos);

				UploadPartRequest uploadPartRequest = new UploadPartRequest();
				uploadPartRequest.setBucketName(ossConfig.getBucketName());
				uploadPartRequest.setKey(key);
				uploadPartRequest.setUploadId(this.uploadId);
				uploadPartRequest.setInputStream(instream);
				uploadPartRequest.setPartSize(this.partSize);
				uploadPartRequest.setPartNumber(this.partNumber);

				UploadPartResult uploadPartResult = client.uploadPart(uploadPartRequest);
				log.info("分片 " + this.partNumber + " 完成");

				synchronized (partETags) {
					partETags.add(uploadPartResult.getPartETag());
				}
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				if (instream != null) {
					try {
						instream.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
			}
		}
	}

	private String claimUploadId() {
		InitiateMultipartUploadRequest request = new InitiateMultipartUploadRequest(ossConfig.getBucketName(), key);
		InitiateMultipartUploadResult result = client.initiateMultipartUpload(request);
		return result.getUploadId();
	}

	private void completeMultipartUpload(String uploadId) {
		// Make part numbers in ascending order
		Collections.sort(partETags, new Comparator<PartETag>() {
			@Override
			public int compare(PartETag p1, PartETag p2) {
				return p1.getPartNumber() - p2.getPartNumber();
			}
		});

		log.info("Completing to upload multiparts");
		CompleteMultipartUploadRequest completeMultipartUploadRequest =
				new CompleteMultipartUploadRequest(ossConfig.getBucketName(), key, uploadId, partETags);
		client.completeMultipartUpload(completeMultipartUploadRequest);
	}

	/**
	 * 根据caseId获取对应bug信息
	 *
	 * @param caseId
	 * @return
	 */
	public List<BugDetail> getBugDetailListByCaseId(String caseId) {
		List<BugDetail> bugDetailList = new ArrayList<>();
		Exam crowdCase = examDao.findById(caseId);
		if (crowdCase != null) {
			List<Report> reportList = reportDao.findByCaseId(caseId);
			for (Report report : reportList) {
				String reportId = report.getId();
				List<TestCase> testCaseList = testCaseDao.findByReport(reportId);
				for (TestCase testCase : testCaseList) {
					String testCaseId = testCase.getId();
					CaseToBug caseToBug = caseToBugDao.findById(testCaseId);
					if (caseToBug != null) {
						List<String> bugIdList = caseToBug.getBug_id();
						for (String bugId : bugIdList) {
							BugDetail bugDetail = new BugDetail();
							bugDetail.setId(bugId);
							//bug基本属性
							Bug bug = bugDao.findByid(bugId);
							if (bug != null) {
								bugDetail.setBugCategory(bug.getBug_category());
								bugDetail.setSeverity(TransUtil.severityTransFromInt(bug.getSeverity()));
								bugDetail.setRecurrent(TransUtil.recurrentTransFromInt(bug.getRecurrent()));
								bugDetail.setBugCreateTime(TransUtil.formatTimeMillis(bug.getCreate_time_millis()));
								bugDetail.setBugPage(bug.getBug_page());
								bugDetail.setTitle(bug.getTitle());
								bugDetail.setBugDescription(bug.getDescription());
								bugDetail.setImgUrl(bug.getImg_url());
							}
							//bugScore属性
							BugScore bugScore = bugScoreDao.findById(bugId);
							if (bugScore != null) {
								bugDetail.setScore(bugScore.getGrade());
							}
							//bugMirror属性
							BugMirror bugMirror = bugMirrorDao.findById(bugId);
							if (bugMirror != null) {
								Set<String> goodWorkerIdSet = new HashSet<>();
								Set<String> badWorkerIdSet = new HashSet<>();
								Set<String> goodReportIdSet = bugMirror.getGood();
								Set<String> badReportIdSet = bugMirror.getBad();
								int goodNum = 0;
								int badNum = 0;
								for (String goodReportId : goodReportIdSet) {
									Report goodReport = reportDao.findById(goodReportId);
									if (goodReport != null) {
										goodNum++;
										goodWorkerIdSet.add(goodReport.getWorker_id());
									}
								}
								for (String badReportId : badReportIdSet) {
									Report badReport = reportDao.findById(badReportId);
									if (badReport != null) {
										badNum++;
										badWorkerIdSet.add(badReport.getWorker_id());
									}
								}
								bugDetail.setGoodNum(goodNum);
								bugDetail.setBadNum(badNum);
								bugDetail.setGoodWorkerId(goodWorkerIdSet);
								bugDetail.setBadWorkerId(badWorkerIdSet);
							}
							//bugHistory属性
							BugHistory bugHistory = bugHistoryDao.findByid(bugId);
							if (bugHistory != null) {
								bugDetail.setParent(bugHistory.getParent());
								bugDetail.setChildren(bugHistory.getChildren());
								bugDetail.setRoot(bugHistory.getRoot());
							}
							//testCase属性
							bugDetail.setTestCaseId(testCase.getId());
							bugDetail.setTestCaseName(testCase.getName());
							bugDetail.setTestCaseFront(testCase.getFront());
							bugDetail.setTestCaseBehind(testCase.getBehind());
							bugDetail.setTestCaseDescription(testCase.getDescription());
							bugDetail.setTestCaseCreateTime(TransUtil.formatTimeMillis(testCase.getCreate_time_millis()));
							//report属性
							bugDetail.setReportId(report.getId());
							bugDetail.setReportName(report.getName());
							bugDetail.setScriptLocation(report.getScript_location());
							bugDetail.setReportLocation(report.getReport_location());
							bugDetail.setLogLocation(report.getLog_location());
							bugDetail.setDeviceModel(report.getDevice_model());
							bugDetail.setDeviceBrand(report.getDevice_brand());
							bugDetail.setDeviceOs(report.getDevice_os());
							//worker属性
							bugDetail.setWorkerId(report.getWorker_id());
							//众测任务属性
							bugDetail.setCaseAppName(crowdCase.getName());
							bugDetail.setCasePaperType(crowdCase.getPaper_type());
							bugDetail.setCaseTestType(crowdCase.getTest_type());
							bugDetail.setCaseDescription(crowdCase.getDescription());
							bugDetail.setCaseRequireDoc("");
							bugDetail.setCaseTakeId(report.getCase_take_id());
							//cp序列号
							bugDetail.setCpSerialNum(cpSerialNum);
							bugDetailList.add(bugDetail);
						}
					}
				}
			}
		}
		return bugDetailList;
	}

	public List<BugDetail> saveBugDetail(MultipartFile sourceZipFile, MultipartFile sourceJsonFile, String originalCaseId, String cpSerialNum) {
		try {
			//读取文件流并保存在本地
			String zipFilePath= savePath + folderName + inputName + "/imageZip/"+originalCaseId+"/"+cpSerialNum+"/"+originalCaseId+".zip";
			File zipFile=new File(zipFilePath);
			if(!zipFile.getParentFile().exists()) { zipFile.getParentFile().mkdirs(); }
			if(!sourceZipFile.isEmpty()) { sourceZipFile.transferTo(zipFile); }
			String jsonFilePath= savePath + folderName + inputName + "/"+originalCaseId+"/"+cpSerialNum+"/"+originalCaseId+".json";
			File jsonFile=new File(jsonFilePath);
			if(!jsonFile.getParentFile().exists()) { jsonFile.getParentFile().mkdirs(); }
			if(!sourceJsonFile.isEmpty()) { sourceJsonFile.transferTo(jsonFile); }
			//读取本地文件
			BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(jsonFile));
			ByteArrayOutputStream buf = new ByteArrayOutputStream();
			int result = bufferedInputStream.read();
			while (result != -1) {
				buf.write((byte) result);
				result = bufferedInputStream.read();
			}
			String json = buf.toString();
			//转为bugDetail
			List<BugDetail> bugDetailList = JSON.parseArray(json, BugDetail.class);
			for (BugDetail bugDetail : bugDetailList) {
				bugDetail.setOriginalCaseId(originalCaseId);
				//修改图片文件路径为oss路径
				String imageUrl = bugDetail.getImgUrl();
				String[] imageUrlArray = imageUrl.split(",");
				StringBuilder stringBuilder = new StringBuilder();
				for (String imageUrlStr : imageUrlArray) {
					if(!"".equals(imageUrl)) {
						String[] filePath = imageUrlStr.split("/");
						String fileName = filePath[filePath.length - 1];
						String newImageUrl = ossConfig.getBaseUrl() + folderName + "/" + UploadType.IMAGE + originalCaseId + "/" + cpSerialNum + "/" + fileName;
						stringBuilder.append(newImageUrl).append(",");
					}
				}
				bugDetail.setImgUrl(stringBuilder.toString());
				bugDetailDao.save(bugDetail);
			}
			//解压图片文件，上传至oss
			String destPath= savePath + folderName + inputName + "/imageUnzip/"+originalCaseId+"/"+cpSerialNum;
			File unzipFile=new File(destPath);
			if(!unzipFile.getParentFile().exists()) { unzipFile.getParentFile().mkdirs(); }
			unZip(zipFile,destPath,originalCaseId,cpSerialNum);
			return bugDetailList;
		} catch (IOException e) {
			e.printStackTrace();
		}
		return new ArrayList<>();
	}

	private void bugDetailToFile(List<BugDetail> bugDetailList, String caseId) {
		String[] titles = {"bug_id", "bug_category", "severity", "recurrent", "bug_create_time", "bug_page", "title",
				"description", "img_url",
				"score", "parent", "children", "root", "good_num", "good_worker_id", "bad_num", "bad_worker_id",
				"test_case_id", "test_case_name", "test_case_front", "test_case_behind", "test_case_description", "test_case_create_time",
				"report_id", "report_name", "report_create_time", "script_location", "report_location", "log_location", "device_model", "device_brand", "device_os",
				"worker_id",
				"case_app_name", "case_paper_type", "case_test_type", "case_description", "case_require_doc",
				"case_take_id", "originalCaseId", "cpSerialNum"};
		File csvFile = exportCsv(titles, bugDetailList, caseId);
		File jsonFile = exportJson(bugDetailList, caseId);
		String csvObjectName = folderName.substring(1) + outputName + "/"+caseId+"/"+cpSerialNum+"/" + csvFile.getName();
		String jsonObjectName = folderName.substring(1) + outputName + "/"+caseId+"/"+cpSerialNum+"/" + jsonFile.getName();
		uploadToOss(csvObjectName,csvFile);
		uploadToOss(jsonObjectName,jsonFile);
	}

	private File exportJson(List<BugDetail> bugDetailList, String caseId) {
		try {
			File file = new File(savePath + folderName + outputName + "/" + caseId + "/" + caseId + ".json");
			if(!file.getParentFile().exists()) { file.getParentFile().mkdirs(); }
			JSONArray jsonArray = new JSONArray(bugDetailList);
			Writer write = new OutputStreamWriter(new FileOutputStream(file), StandardCharsets.UTF_8);
			write.write(jsonArray.toString());
			write.flush();
			write.close();
			return file;
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}


	private <T> File exportCsv(String[] titles, List<T> list, String caseId) {
		try {
			File file = new File(savePath + folderName + outputName + "/" + caseId + "/" + caseId + ".csv");
			if(!file.getParentFile().exists()) { file.getParentFile().mkdirs(); }
			//构建输出流，同时指定编码
			OutputStreamWriter ow = new OutputStreamWriter(new FileOutputStream(file), StandardCharsets.UTF_8);
			//csv文件是逗号分隔，除第一个外，每次写入一个单元格数据后需要输入逗号
			for (String title : titles) {
				ow.write(title);
				ow.write(",");
			}
			//写完文件头后换行
			ow.write("\r\n");
			//写内容
			for (Object obj : list) {
				//利用反射获取所有字段
				Field[] fields = obj.getClass().getDeclaredFields();
				for (Field field : fields) {
					//设置字段可见性
					field.setAccessible(true);
					//防止某个field没有赋值
					if (field.get(obj) == null) {
						ow.write("");
					} else {
						//解决csv文件中对于逗号和双引号的转义问题
						ow.write("\"" + field.get(obj).toString().replaceAll("\"", "\"\"") + "\"");
					}
					ow.write(",");
				}
				//写完一行换行
				ow.write("\r\n");
			}
			ow.flush();
			ow.close();
			return file;
		} catch (IOException | IllegalAccessException e) {
			e.printStackTrace();
		}
		return null;
	}

	private void uploadToOss(String objectName,File file) {
		if (file != null) {
			OSS ossClient = ossConfig.ossClient();
			OssAliyun.uploadFile(ossClient, ossConfig.getBucketName(), objectName, file);
		} else {
			System.out.println("file is null");
		}
	}

	/**
	 * zip解压
	 *
	 * @param srcFile     zip源文件
	 * @param destDirPath 解压后的目标文件夹
	 * @throws RuntimeException 解压失败会抛出运行时异常
	 */

	private void unZip(File srcFile, String destDirPath,String originalCaseId,String fromCpSerialNum) throws RuntimeException {
		long start = System.currentTimeMillis();
		// 判断源文件是否存在
		if (!srcFile.exists()) {
			throw new RuntimeException(srcFile.getPath() + "所指文件不存在");
		}
		// 开始解压
		ZipFile zipFile = null;
		try {
			zipFile = new ZipFile(srcFile);
			Enumeration<?> entries = zipFile.entries();

			while (entries.hasMoreElements()) {
				ZipEntry entry = (ZipEntry) entries.nextElement();
				System.out.println("解压" + entry.getName());
				// 如果是文件夹，就创建个文件夹
				if (entry.isDirectory()) {
					String dirPath = destDirPath + "/" + entry.getName();
					File dir = new File(dirPath);
					dir.mkdirs();
				} else {
					// 如果是文件，就先创建一个文件，然后用io流把内容copy过去
					File targetFile = new File(destDirPath + "/" + entry.getName());
					// 保证这个文件的父文件夹必须要存在
					if (!targetFile.getParentFile().exists()) {
						targetFile.getParentFile().mkdirs();
					}
					targetFile.createNewFile();
					// 将压缩文件内容写入到这个文件中
					InputStream is = zipFile.getInputStream(entry);
					FileOutputStream fos = new FileOutputStream(targetFile);
					int len;
					byte[] buf = new byte[BUFFER_SIZE];
					while ((len = is.read(buf)) != -1) {
						fos.write(buf, 0, len);
					}
					// 关流顺序，先打开的后关闭
					fos.close();
					is.close();
					//图片文件上传至oss
					String objectName = folderName + "/image/"+originalCaseId+"/"+fromCpSerialNum+"/" + targetFile.getName();
					uploadToOss(objectName,targetFile);
				}
			}
			long end = System.currentTimeMillis();
			System.out.println("解压完成，耗时：" + (end - start) + " ms");
		} catch (Exception e) {
			throw new RuntimeException("unzip error from ZipUtils", e);
		} finally {
			if (zipFile != null) {
				try {
					zipFile.close();

				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

	private void toZip(String srcDir, OutputStream out, boolean keepDirStructure)
			throws RuntimeException {
		long start = System.currentTimeMillis();
		ZipOutputStream zos = null;
		try {
			zos = new ZipOutputStream(out);
			File sourceFile = new File(srcDir);
			compress(sourceFile, zos, sourceFile.getName(), keepDirStructure);
			long end = System.currentTimeMillis();
			System.out.println("压缩完成，耗时：" + (end - start) + " ms");
		} catch (Exception e) {
			throw new RuntimeException("zip error from ZipUtils", e);
		} finally {
			if (zos != null) {
				try {
					zos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

	/**
	 * 递归压缩方法
	 *
	 * @param sourceFile       源文件
	 * @param zos              zip输出流
	 * @param name             压缩后的名称
	 * @param keepDirStructure 是否保留原来的目录结构,true:保留目录结构;
	 *                         false:所有文件跑到压缩包根目录下(注意：不保留目录结构可能会出现同名文件,会压缩失败)
	 * @throws Exception
	 */
	private void compress(File sourceFile, ZipOutputStream zos, String name,
	                      boolean keepDirStructure) throws Exception {
		byte[] buf = new byte[BUFFER_SIZE];
		if (sourceFile.isFile()) {
			// 向zip输出流中添加一个zip实体，构造器中name为zip实体的文件的名字
			zos.putNextEntry(new ZipEntry(name));
			// copy文件到zip输出流中
			int len;
			FileInputStream in = new FileInputStream(sourceFile);
			while ((len = in.read(buf)) != -1) {
				zos.write(buf, 0, len);
			}
			// Complete the entry
			zos.closeEntry();
			in.close();
		} else {
			File[] listFiles = sourceFile.listFiles();
			if (listFiles == null || listFiles.length == 0) {
				// 需要保留原来的文件结构时,需要对空文件夹进行处理
				if (keepDirStructure) {
					// 空文件夹的处理
					zos.putNextEntry(new ZipEntry(name + "/"));
					// 没有文件，不需要文件的copy
					zos.closeEntry();
				}

			} else {
				for (File file : listFiles) {
					// 判断是否需要保留原来的文件结构
					if (keepDirStructure) {
						// 注意：file.getName()前面需要带上父文件夹的名字加一斜杠,
						// 不然最后压缩包中就不能保留原来的文件结构,即：所有文件都跑到压缩包根目录下了
						compress(file, zos, name + "/" + file.getName(), true);
					} else {
						compress(file, zos, file.getName(), false);
					}
				}
			}
		}
	}
}