用jsoup解析word文档转变的html项目实例

青旅半醒 2022-06-05 03:21 232阅读 0赞

本文是记录，分析一套word文档另存为html压缩包的记录。其实分析word文档有很多的方法，但是将他转为html更为灵活一些。也希望有好方法的互相交流，可给我留言

将word转html有很多的方法，我用过的最方便的是docx4j，这里不做记录。此处案例是上传并分析一套多元测评的案例，类似一套心理测试试卷。

下面是试卷简约样本1,第一步，上传并校验压缩包内容![Center][]

一。上传并解压压缩包。 @RequestMapping(value = "/upload", method = RequestMethod.POST) public RestResult<string> uploadPaper( MultiPaperVo multiPaperVo ) \{ try \{ logger.debug("--------开始上传一份多元测评试卷(压缩包形式上传)--------"); MultipartFile uploadFile =multiPaperVo.getUploadFile(); //校验压缩文件 if(uploadFile == null || uploadFile.getSize()<=0 || uploadFile.getName() == null)\{ return RRGenerator.error("压缩文件内无数据"); \} UploadFileUtil uploadFileUtil = SpringContextHolder.getBean(UploadFileUtil.class); String fileName =uploadFileUtil.getAttachPath(UploadFileUtil.FileType.paper, "temc", "zip" ,IdGen.uuid() + uploadFile.getOriginalFilename().substring(uploadFile.getOriginalFilename().lastIndexOf("."))); File tempFile = new File(fileName); if (!tempFile.getParentFile().exists()) \{ tempFile.getParentFile().mkdirs(); \} BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(tempFile)); out.write(uploadFile.getBytes()); out.flush(); out.close(); //2.解压zip List<string> htmlPath = FileUtils.unZipFilesReturnPath(fileName,uploadFileUtil.getTempPath( "zip", IdGen.uuid())); if(htmlPath == null)\{ return RRGenerator.error("压缩文件内未能解析正确htm文件"); \} //3.开始解析html String totalAnalysisEvaluationHtml =papPaperService.totalAnalysisEvaluationHtml(multiPaperVo, htmlPath); if(StringUtils.isNotBlank(totalAnalysisEvaluationHtml))\{ return RRGenerator.error(totalAnalysisEvaluationHtml); \}else\{ return RRGenerator.success(); \} \} catch (Exception e) \{ e.printStackTrace(); logger.debug("上传一份多元测评试卷(压缩包形式上传)发生异常" + e); return RRGenerator.error("上传一份多元测评试卷(压缩包形式上传)发生异常"); \} \} </string></string>

1.有一方法是解析压缩包，解析压缩包代码是

/**
 	 * 针对word TO html 返回html路径
 	 * 解压缩ZIP文件，将ZIP文件里的内容解压到descFileName目录下
 	 * @param zipFileName 需要解压的ZIP文件
 	 * @param descFileName 目标文件
 	 */
 	public static List<String> unZipFilesReturnPath(String zipFileName, String descFileName) {
 		//支持多个试卷上传html解压
 		List<String> htmlFilePath=Lists.newArrayList();
 		Set<String> filesFilePath=new HashSet<>();
 		String descFileNames = descFileName;
 		if (!descFileNames.endsWith(File.separator)) {
 			descFileNames = descFileNames + File.separator;
 		}		
 try {
 			// 根据ZIP文件创建ZipFile对象
 			ZipFile zipFile = new ZipFile(zipFileName,"GBK");
 			ZipEntry entry = null;
 			String entryName = null;
 			String descFileDir = null;
 			byte[] buf = new byte[4096];
 			int readByte = 0;
 			// 获取ZIP文件里所有的entry
 			@SuppressWarnings("rawtypes")
 			Enumeration enums = zipFile.getEntries();
 			// 遍历所有entry
 			while (enums.hasMoreElements()) {
 				entry = (ZipEntry) enums.nextElement();
 				// 获得entry的名字
 				entryName = entry.getName();
 				if((entryName.toLowerCase().contains(".htm") || entryName.toLowerCase().contains(".html")) && entryName.indexOf("/") == -1){
 						htmlFilePath.add(descFileName+"/"+entryName);
 		 }
 				if(entryName.toLowerCase().contains(".files") && entryName.contains("/")){
 					String[] split = entryName.split("/");
 					filesFilePath.add(split[0]);
 				}
 				descFileDir = descFileNames + entryName;
 				if (entry.isDirectory()) {
 					// 如果entry是一个目录，则创建目录
 					new File(descFileDir).mkdirs();
 					continue;
 				} else {
 					// 如果entry是一个文件，则创建父目录
 					new File(descFileDir).getParentFile().mkdirs();
 				}
 				File file = new File(descFileDir);
 				// 打开文件输出流
 				OutputStream os = new FileOutputStream(file);
 				// 从ZipFile对象中打开entry的输入流
 		 InputStream is = zipFile.getInputStream(entry);
 				while ((readByte = is.read(buf)) != -1) {
 					os.write(buf, 0, readByte);
 				}
 				os.close();
 				is.close();
 			}
 			zipFile.close();
 			
 			if(filesFilePath.size() != htmlFilePath.size() ){
 				return null;
 			}
 			logger.debug("文件解压成功!");
 			return htmlFilePath;
 		} catch (Exception e) {
 			logger.debug("文件解压失败：" + e.getMessage());
 			return null;
 		}
 	}

二。接下来就是解析html内容

//总方法
 	@Transactional(readOnly = false)
 	public String totalAnalysisEvaluationHtml(MultiPaperVo multiPaperVo ,List<String> htmlUrlList) {
 		try {
 			if(multiPaperVo ==null || htmlUrlList == null || htmlUrlList.size() < 1 ){
 				return "没有查询到文件信息";
 			}
 			//校验paper数据
 			String checkPaperInfo = this.checkPaperInfo(multiPaperVo);
 			if(StringUtils.isNotBlank(checkPaperInfo)){
 				return checkPaperInfo;
 			}
 			//将paper信息存入
 			QtPaper qtPaper = new QtPaper();			
 			qtPaper = this.insertPaperInfo(multiPaperVo, qtPaper);
 			
 			//循环解析数据
 			for(String htmlUrl : htmlUrlList){
 				if(StringUtils.isBlank(htmlUrl)){
 					continue;
 				}
 				//解析数据
 				File input= new File(htmlUrl);
 				//判断是否有文件
 				if(!input.exists()){
 					logger.debug("file is null:zipan bu dui");
 					continue;
 				}
 				//解析文件
 				Document doc = Jsoup.parse(input, "GBK", "");//input 要解析的文件 ，要解析文件的编码 ，假如没有文件的时候要解析的文件
 				//获取文件内容
 				Element body = doc.body();
 				//处理图片带来的垃圾数据
 				body=this.refiningBody(body);
 				//校验图片信息
 				String cheackImg = this.cheackImg(body);
 				if(StringUtils.isNotBlank(cheackImg)){
 					return cheackImg;
 				}
 				//分解信息
 				List<Element> analysisQtPaper = this.analysisQtPaper(body);
 				if(analysisQtPaper==null || analysisQtPaper.size() < 1){
 					return "试卷中不存在<Ф试卷名称Ф>";
 				}
 				//得到解析的集合
 				TestPaperVo vo = this.arrangePaper(analysisQtPaper);
 				//校验数据
 				String checkExamPaper = this.checkExamPaper( vo , analysisQtPaper , qtPaper);
 				if(StringUtils.isNotBlank(checkExamPaper)){
 					return checkExamPaper;
 				}
 				// 删除以前的图片
 				String deletePic = this.deletePic(qtPaper);
 				if(StringUtils.isNotBlank(deletePic)){
 					logger.error("服务器删除图片出错,图片地址为："+deletePic);
 				}
 				//t图片的替换 
 				body = this.replaceImgs(body, htmlUrl,qtPaper);
 				//判断是否有图片 //如果有
 				Elements links = body.getElementsByTag("img");
 				if(links != null && links.size()>0){
 					analysisQtPaper = this.analysisQtPaper(body);
 					vo = this.arrangePaper(analysisQtPaper);
 				}
 				//分解插入数据方法
 				String insertExamPaperInfo = this.insertExamPaperInfo(vo,qtPaper);
 				if(StringUtils.isNotBlank(insertExamPaperInfo)){
 					return insertExamPaperInfo;
 				}
 			}
 			return null;
 		} catch (Exception e) {
 			e.printStackTrace();
 			return RestCode.FAILURE.getCode();
 		}
 	}

1.我们从解析文件开始说，解析文件就是将文件变为Document,方便后续文件的解析，其实从这开始就是一些业务的数据，然后是获取body的数据，因为我们要的就是文档的内容，其他的就不要了

2.其实文档有图片的话，源码中很多的垃圾解释，而且超级长，据说是ie浏览器低版本采用的东西，我们要将他去掉

/**
 	 * 处理图片带来的垃圾数据
 	 * 
 	 * @param body
 	 * @return
 	 */
 	public Element refiningBody(Element body){
 		Elements elist = body.getElementsByTag("span");
 		for(Element e:elist){
 			while(e.html().indexOf("")+3);
 				e.html(	e.html().replace(str, ""));
 			}
 		}
 		Elements plist = body.getElementsByTag("p");
 		for(Element ep:plist){
 			while(ep.html().indexOf("")+3);
 				ep.html(ep.html().replace(str, ""));
 			}
 		}
 		return body;
 	}

3.校验图片主要是校验外网图片，因为很多文档从网上直接下载的，图片是个链接，这样的我们暂时不要，假如你需要，校验出来后，你要去外网下载图片，然后上传

/**
    	 * 校验图片的方法
    	 * 
    	 * @param body
    	 * @return
    	 */
    	public String cheackImg(Element body){
    		Elements links = body.getElementsByTag("img");
    		for (Element link : links) {
    			String linkHref = link.attr("src");
    			if(linkHref.contains("http") || linkHref.contains("https")){//如果是外网的绝对路径，不转直接存
    				return "图片包含外网链接图片："+linkHref;
    			}
    		}
    		return null;
    	}

4.分解数据，就是将他按照段落分解，然后存入集合，个人习惯，你也可以直接用

/**
 	 * 分解题目信息
 	 * 
 	 * @param body
 	 * @return
 	 */
 	public List<Element> analysisQtPaper(Element body){
 		//获得第一个标签
 		Element firstElement= body.getElementsContainingOwnText(LabelEnum.PAPERS_NAME.getDesc()).first();
 		if(firstElement == null){
 			return null;
 		}
 //		Elements el = firstElement.parents();
 //		firstElement = el.first();
 		//目前向上获取到p标签 
 		boolean selectP = true;//是否向上
 		while(selectP){
 			if(!firstElement.tagName().equals("p")){
 				firstElement = firstElement.parent();
 			}else{
 				selectP = false;
 			}				
 		}
 		//寻找该标签下所有的兄弟标签
 		boolean isAddFor = true;//是否有下一个兄弟标签
 		List<Element> bodyElementList = new ArrayList<>();//用于存储所有的兄弟信息
 		bodyElementList.add(firstElement);
 		while (isAddFor) {
 			firstElement = firstElement.nextElementSibling();
 			if(firstElement == null){
 				isAddFor=false;
 			}else{
 				bodyElementList.add(firstElement);
 			}
 		}
 		return bodyElementList;
 	}

\*其中有一个是标签枚举类，这些事自定义标签

public enum LabelEnum {
 	 PAPERS_NAME("Ф试卷名称Ф", "试卷名称"),
 	 PAPERS_DESC("Ф试卷简介Ф", "试卷简介"),
 	 PAPERS_DEMAND("Ф作答要求Ф", "作答要求"),
 	 PAPERS_INFO_ONE("<Ⅰ卷>", "Ⅰ卷"),
 	 PAPERS_INFO_TWO("<Ⅱ卷>", "Ⅱ卷"),
 	 QUESTION_FATHER_CONTENT("Ф父题内容Ф", "父题内容"),
 	 QUESTION_FATHER_CONTENT_END("Ф父题结束Ф", "父题结束"),
 	 QUESTION_CONTENT("Ф题目内容Ф", "题目内容"),
 	 QUESTION_MODULE("Ф试题所属模块Ф", "试题所属模块"),
 	 QUESTION_SCORE("Ф分值Ф", "分值"),
 	 QUESTION_SUBJECTIVE("Ф主观题Ф", "主观题"),
 	 QUESTION_ANALYZE("Ф试题解析Ф", "试题解析"),
 	 QUESTION_OPTION_APPRAISE("Ф选项评析Ф", "选项评析"),
 	 QUESTION_ANSWER_APPRAISE("Ф答案评析Ф", "答案评析"),
 	 QUESTION_CLASSIFICATION("Ф试题所属分类Ф", "试题所属分类"),
 	 OPTION_COMMENTARY("<★>", "★");
 		String key;
 	 String desc;
 	 LabelEnum(String key, String desc) {
 	 this.key = key;
 	 this.desc = desc;
 	 }
 	 public static LabelEnum getEnumByKey(String key) {
 	 	LabelEnum[] enums = LabelEnum.values();
 	 for (LabelEnum em : enums) {
 	 if (em.getKey().equals(key)) {
 	 return em;
 	 }
 	 }
 	 return null;
 	 }
 		public String getKey() {
 			return key;
 		}
 		public void setKey(String key) {
 			this.key = key;
 		}
 		public String getDesc() {
 			return desc;
 		}
 		public void setDesc(String desc) {
 			this.desc = desc;
 		}
 }

5.分析数据，并将数据分类，代码中的标签内段落数差异很大，所以要做成这样

/**
 	 * 分解数据
 	 * 
 	 * @param bodyList
 	 * @return
 	 */
 	public TestPaperVo arrangePaper(List<Element> bodyList){
 		
 		//试卷名称
 		List<Element> exNameList = new ArrayList<>();
 		//试卷简介
 		List<Element> exDescList = new ArrayList<>();
 		//作答要求
 		List<Element> exDemandList = new ArrayList<>();
 		//卷体信息
 		List<Element> exInfoList = new ArrayList<>();
 		List<Element> exInfoNextList = new ArrayList<>();
 		//题目信息
 		List<List<Element>> exQuestionList = new ArrayList<>();
 		List<Element> questionList = new ArrayList<>();
 		//试题分值		
 		List<Element> questionScoreList = new ArrayList<>();
 		//试题所属模块		
 		List<Element> questionMouduleList = new ArrayList<>();
 		
 		//试题数量
 		Integer questionNum = 0;
 		
 		//设置
 		Boolean isExName = Boolean.FALSE;
 		Boolean isExDesc = Boolean.FALSE;
 		Boolean isDemand = Boolean.FALSE;
 		Boolean isExInfo = Boolean.FALSE;
 		Boolean isNew = Boolean.FALSE;
 		Boolean isAdd = Boolean.FALSE;
 		Boolean isfather = Boolean.FALSE;
 		Boolean isMoudule = Boolean.FALSE;
 		int paperInfo=0;
 		
 		for(int f=0;f< bodyList.size() ; f++){
 			//是否是试卷名称
 			if(bodyList.get(f).text().contains(LabelEnum.PAPERS_NAME.getKey())){
 				isExName= Boolean.TRUE;
 			}
 			//是否是简介
 			if(bodyList.get(f).text().contains(LabelEnum.PAPERS_DESC.getKey())){
 				isExDesc= Boolean.TRUE;
 				isExName= Boolean.FALSE;
 				isDemand= Boolean.FALSE;
 				isExInfo= Boolean.FALSE;
 			}
 			//是否是作答要求
 			if(bodyList.get(f).text().contains(LabelEnum.PAPERS_DEMAND.getKey())){
 				isDemand=Boolean.TRUE;
 				isExName= Boolean.FALSE;
 				isExDesc= Boolean.FALSE;
 				isExInfo= Boolean.FALSE;
 			}
 			//卷体信息
 			if(bodyList.get(f).text().contains(LabelEnum.PAPERS_INFO_ONE.getKey())||bodyList.get(f).text().contains(LabelEnum.PAPERS_INFO_TWO.getKey())){
 				isExInfo = Boolean.TRUE;
 				isExName= Boolean.FALSE;
 				isExDesc= Boolean.FALSE;
 				isDemand= Boolean.FALSE;
 				paperInfo++;
 			}
 			//题目内容 
 			//是否是父题
 			if(bodyList.get(f).text().contains(LabelEnum.QUESTION_FATHER_CONTENT.getKey())){
 				isNew =Boolean.TRUE;
 				isAdd =Boolean.TRUE;
 				isfather =Boolean.TRUE;
 				isExName= Boolean.FALSE;
 				isExDesc= Boolean.FALSE;
 				isDemand= Boolean.FALSE;
 				isExInfo= Boolean.FALSE;
 			}
 			//是父子题目的判断结尾
 			if(bodyList.get(f).text().contains(LabelEnum.QUESTION_FATHER_CONTENT_END.getKey())){
 				isfather =Boolean.FALSE;
 				isExName= Boolean.FALSE;
 				isExDesc= Boolean.FALSE;
 				isDemand= Boolean.FALSE;
 				isExInfo= Boolean.FALSE;
 			}
 			//不是父子题目
 			if(bodyList.get(f).text().contains(LabelEnum.QUESTION_CONTENT.getKey()) && !isfather){
 				isNew =Boolean.TRUE;
 				isAdd =Boolean.TRUE;
 				isExName= Boolean.FALSE;
 				isExDesc= Boolean.FALSE;
 				isDemand= Boolean.FALSE;
 				isExInfo= Boolean.FALSE;
 			}
 			
 			
 			if(bodyList.get(f).text().contains(LabelEnum.QUESTION_MODULE.getKey()) ){
 				isMoudule =Boolean.TRUE;
 			}
 			
 			
 			if(paperInfo>1&&(bodyList.get(f).text().contains(LabelEnum.PAPERS_INFO_ONE.getKey()) || bodyList.get(f).text().contains(LabelEnum.PAPERS_INFO_TWO.getKey()))){
 				isNew =Boolean.TRUE;
 				isAdd =Boolean.TRUE;
 				isExName= Boolean.FALSE;
 				isExDesc= Boolean.FALSE;
 				isDemand= Boolean.FALSE;
 //				isExInfo= Boolean.FALSE;
 			}
 			//根据以上判断是否加入
 			if(isExName){
 				exNameList.add(bodyList.get(f));
 			}
 			if(isExDesc){
 				exDescList.add(bodyList.get(f));
 			}
 			if(isDemand){
 				exDemandList.add(bodyList.get(f));
 			}
 			if(isExInfo){
 				exInfoList.add(bodyList.get(f));
 				exInfoNextList.add(bodyList.get(f+1));
 			}
 			if(isMoudule){
 				questionMouduleList.add(bodyList.get(f));
 				isMoudule = false;
 			}
 			if(isAdd){
 				if(isNew){
 					isNew=false;
 					if(questionList.size()>0){
 						exQuestionList.add(questionList);
 					}
 					questionList = new ArrayList<>();
 				}
 				questionList.add(bodyList.get(f));
 				//如果是最后一个，要判断是否要加、
 				if(f>(bodyList.size()-2)){
 					
 					if(questionList.size()>0){
 						exQuestionList.add(questionList);
 					}
 				}
 			}
 			//试题数量统计
 			if(bodyList.get(f).text().contains(LabelEnum.QUESTION_CONTENT.getKey())){
 				questionNum++;
 			}
 			//试题分值项目
 			if(bodyList.get(f).text().contains(LabelEnum.QUESTION_SCORE.getKey())){
 				questionScoreList.add(bodyList.get(f));
 			}
 		}
 		//添加返回信息
 		TestPaperVo vo = new TestPaperVo();
 		vo.setExNameList(exNameList);
 		vo.setExDescList(exDescList);
 		vo.setExDemandList(exDemandList);
 		vo.setExInfoList(exInfoList);
 		vo.setExQuestionList(exQuestionList);
 		vo.setQuestionNum(questionNum);
 		vo.setQuestionScoreList(questionScoreList);
 		vo.setExInfoNextList(exInfoNextList);
 		vo.setQuestionMouduleList(questionMouduleList);
 		return vo;
 	}

6.检验此处不错解释，业务需求

public String checkExamPaper(TestPaperVo vo ,List<Element> analysisQtPaper ,QtPaper qtPaper){
 		//验证父题的对应关系
 		String checkFatherLabel = this.checkFatherLabel(analysisQtPaper);
 		if(StringUtils.isNotBlank(checkFatherLabel)){
 			if(checkFatherLabel.length()>50){
 				return "<Ф父题内容Ф>和<Ф父题结束Ф>标签不对应，出错原文内容:"+checkFatherLabel.substring(0, 50);
 			}else{
 				return "<Ф父题内容Ф>和<Ф父题结束Ф>标签不对应，出错原文内容:"+checkFatherLabel;
 			}
 		}
 		//校验标签数量
 		String checkHtmlLabelNum = this.checkHtmlLabelNum(analysisQtPaper);
 		if(StringUtils.isNotBlank(checkHtmlLabelNum)){
 //			return "重复标签："+checkHtmlLabelNum;
 			if(checkHtmlLabelNum.length()>50){
 				return "同行内出现多个标签，出错原文内容:"+checkHtmlLabelNum.substring(0, 50);
 			}else{
 				return "同行内出现多个标签，出错原文内容:"+checkHtmlLabelNum;
 			}
 		}
 		//校验标签和规范
 		String checkHtmlLabelNorm = this.checkHtmlLabelNorm(analysisQtPaper);
 		if(StringUtils.isNotBlank(checkHtmlLabelNorm)){
 //			return "标签不规范："+checkHtmlLabelNorm;
 			if(checkHtmlLabelNorm.length()>50){
 				return 	"试卷中有标签错误，错误原文内容:"+checkHtmlLabelNorm.substring(0,50);
 			}else{
 				return 	"试卷中有标签错误，错误原文内容:"+checkHtmlLabelNorm;
 			}
 		}
 		//校验分数
 		String checkExamScore = this.checkExamScore(qtPaper,vo);
 		if(StringUtils.isNotBlank(checkExamScore)){
 //			return checkExamScore;
 			return "试卷分值总分和小题分值之和不等";
 		}
 		//校验数量
 		if(qtPaper.getQuestionCount() != vo.getQuestionNum()){
 //			return "页面填写题目数量与页面题目数量不相等：页面填写题目数量："+qtPaper.getQuestionCount()+"试卷题目数量"+vo.getQuestionNum();
 			return "试题数目与<Ф题目内容Ф>标签总数不等";
 			
 		}
 		//校验卷体信息
 		if(vo.getExInfoList().size() > 0){
 			//标签要么没有，要么成对出现
 			if(vo.getExInfoList().size() != 2){
 				return "<Ⅰ卷>和<Ⅱ卷>标签不对应";	
 			}
 			if(vo.getExInfoNextList().size()<1 || !vo.getExInfoNextList().get(0).text().equals(vo.getExQuestionList().get(0).get(0).text()) ){
 //				return "卷体信息只能写于第一个题目内容前";
 				return "<Ⅰ卷>和<Ⅱ卷>标签不对应";	
 			}
 			if(vo.getExInfoNextList().size()==2){
 				if(!vo.getExInfoNextList().get(1).text().contains(LabelEnum.QUESTION_FATHER_CONTENT.getKey()) && !vo.getExInfoNextList().get(1).text().contains(LabelEnum.QUESTION_CONTENT.getKey()) ){
 					return "<Ⅰ卷>和<Ⅱ卷>标签不对应";	
 				}
 			}
 		}
 		//卷中题的属性数目必须等于字典中定义的卷属性数目
 		String checkMudule = checkMudule(vo,qtPaper);
 		if(null!= checkMudule){
 			return checkMudule;
 		}
 		
 		//校验题目规范
 		String checkExamTopic = this.checkExamTopic(vo);
 		if(StringUtils.isNotBlank(checkExamTopic)){
 			return checkExamTopic;
 		}
 		return null;
 	}

7.删除照片是这样的，一种类型的卷子只能有一套，这样来说的话，你要上传就要把以前的照片删除，自我判断是否需要

/**
    	 * 删除以前所有的图片
    	 * 
    	 * @param qtPaper
    	 * @return
    	 */
    	public String deletePic(QtPaper qtPaper){
    		UploadFileUtil uploadFileUtil  =  SpringContextHolder.getBean(UploadFileUtil.class);
    		String paperPice =	qtPaper.getGrade()+"_"+qtPaper.getClassDivideType()+"_"+qtPaper.getTestType();
    		String imagePath = uploadFileUtil.getImagePath(UploadFileUtil.FileType.paper, "temc", paperPice);//要删除的路径
    		//截取图片地址
    		String[] split = imagePath.split(paperPice);
    		imagePath = split[0]+paperPice;
    		//如果删除成功返回空，如果失败返回删除路径
    		//删除的方法
    		boolean deleteDir = FileUtils.deleteDir(new File(imagePath));
    		if(deleteDir){
    			return null;
    		}else{
    			return imagePath;
    		}
    	}

8.替换图片主要作用是将上传的图片地址重新放入文档内容中，并将3k以下变为64的码

/**
    	 * 替换图片
    	 * @param body
    	 * @param htmlUrl
    	 * @return
    	 */
    	public Element replaceImgs(Element body,String htmlUrl,QtPaper qtPaper ){
    	String paperPice =	qtPaper.getGrade()+"_"+qtPaper.getClassDivideType()+"_"+qtPaper.getTestType();
    		
    		Elements links = body.getElementsByTag("img");
    		UploadFileUtil uploadFileUtil  =  SpringContextHolder.getBean(UploadFileUtil.class);
    		//在此处获取所有的图片   可将图片替换
    		for (Element link : links) {
    			String linkHref = link.attr("src");
    				String fileName =uploadFileUtil.getImagePath(UploadFileUtil.FileType.paper,  "temc", paperPice, IdGen.uuid() +linkHref.substring(linkHref.lastIndexOf("/")+1,linkHref.length()));
    				//把文件从临时目录拷贝到正式目录,超过3k文件保存，否则base64存储
    				FileUtils.copyFile(htmlUrl.substring(0, htmlUrl.lastIndexOf("/")+1)+linkHref, fileName);
    				String picurl = uploadFileUtil.getImageUrl(fileName);
    				linkHref = FileUtils.getImageStr(fileName);
    				if(linkHref.equals("0")){
    					link.attr("src",picurl);
    				}else{
    					link.attr("src",linkHref);
    				}
    		}
    		
    		return body;
    	}

/**
    	  * @Description: 根据图片地址转换为base64编码字符串
    	  * @Author: 
    	  * @CreateTime: 
    	  * @return
    	  */
    	 public static String getImageStr(String imgFile) {
    		 String imageString="data:image/png;base64,";//拼上base64显示标签
    	     InputStream inputStream = null;
    	     byte[] data = null;
    	     try {
    	         inputStream = new FileInputStream(imgFile);
    	         data = new byte[inputStream.available()];
    	         inputStream.read(data);
    	         inputStream.close();
    	     } catch (IOException e) {
    	         e.printStackTrace();
    	     }
    	     // 加密
    	     imageString =imageString+ new String(Base64.encodeBase64(data));
    	     return imageString;
    	 }

9.因为上文将该类下图片全部删掉了，所以本文由图片就去重新分析一下，具体为什么，记不清了

10。分析插入数据。只贴代码，不做解释，待会贴几个方法

/**
 	 * 插入数据信息
 	 * 
 	 * @param vo
 	 */
 	private String insertExamPaperInfo(TestPaperVo vo,QtPaper qtPaper) {
 		//paper信息
 		List<String> labelList = new ArrayList<>();
 		if(vo.getExNameList() != null && vo.getExNameList().size()>0){
 			labelList.add("<"+LabelEnum.PAPERS_NAME.getKey()+">");
 			qtPaper.setPaperName(this.deleteLabelString(vo.getExNameList(),labelList));//试卷名称
 		}
 		qtPaper.setClassify(Constants.TEST_ASSESSMENT_CLASSIFY_MULTI);//测评分类
 		qtPaper.setPaperState(Constants.UNPUBLISH_PAPER_STATE);//是否发布
 		qtPaper.setDelFlag(Constants.DEL_FLAG_NORMAL);//是否删除
 		if(vo.getExDescList() != null && vo.getExDescList().size()>0){
 			labelList.clear();
 			labelList.add("<"+LabelEnum.PAPERS_DESC.getKey()+">");
 			qtPaper.setDescription(this.deleteLabelString(vo.getExDescList(),labelList));//简介
 		}
 		if(vo.getExDemandList() != null && vo.getExDemandList().size() > 0){
 			labelList.clear();
 			labelList.add("<"+LabelEnum.PAPERS_DEMAND.getKey()+">");
 			qtPaper.setDemand(this.deleteLabelString(vo.getExDemandList(),labelList));//简介
 		}
 		//循环得到题目具体信息
 		TransferVo tVo= new TransferVo();
 		if(vo.getExInfoList()!= null && vo.getExInfoList().size() >0 ){
 			if(vo.getExInfoList().get(0).text().contains(LabelEnum.PAPERS_INFO_ONE.getKey()) ){
 				tVo.setPaperInfo(Constants.PAPER_INFO_ONE);
 			}else{
 				tVo.setPaperInfo(Constants.PAPER_INFO_TWO);
 			}
 		}
 		//取卷体信息第一个作为卷体信息
 		List<QtQuestion> questions = new ArrayList<>();
 		for(List<Element> elListFor : vo.getExQuestionList()){
 			//判断是否包含卷体信息
 			if(elListFor.get(0).text().contains(LabelEnum.PAPERS_INFO_ONE.getKey()) || elListFor.get(0).text().contains(LabelEnum.PAPERS_INFO_TWO.getKey()) ){
 				if(elListFor.get(0).text().contains(LabelEnum.PAPERS_INFO_ONE.getKey())){
 					tVo.setPaperInfo(Constants.PAPER_INFO_ONE);
 				}else{
 					tVo.setPaperInfo(Constants.PAPER_INFO_TWO);
 				}
 				continue;
 			}
 			//判断是否是父子题
 			if(elListFor.get(0).text().contains(LabelEnum.QUESTION_FATHER_CONTENT.getKey()) ){
 				QtQuestion combingFatherTopic = this.combingFatherTopic(elListFor, tVo);
 				questions.add(combingFatherTopic);
 			}else{//单体
 				QtQuestion combingAloneTopic = this.combingAloneTopic(elListFor, tVo, null, Constants.Level_SINGLE);
 				questions.add(combingAloneTopic);
 			}
 		}
 		qtPaper.setQuestions(questions);
 		//调用插入方法
 		boolean savePaperWithQuestions = ptPaperService.saveWithQuestions(qtPaper); 
 		if(!savePaperWithQuestions){
 			return "信息入库时失败，请稍后重试！";
 		}
 		return null;
 	}

/**
 	 * 父子题目的方法
 	 * @param elListFor
 	 * @param tVo
 	 * @return
 	 */
 	public QtQuestion combingFatherTopic(List<Element> elListFor, TransferVo tVo){
 		//先得到父题内容
 		boolean isFatherTitle = false;
 		List<Element> fatherTitleList = new ArrayList<>();
 		//试题解析
 		boolean isFatherAnalyze = false;
 		List<Element> fatherAnalyzeList = new ArrayList<>();
 		//所有小题目
 		boolean isQuestion = false;
 		boolean isNew = false;
 		List<List<Element>> questionList = new ArrayList<>();
 		//单个题目
 		List<Element> questionSingleList = new ArrayList<>();
 		for(Element elFor : elListFor){
 			if(elFor.text().contains(LabelEnum.QUESTION_FATHER_CONTENT.getKey())){
 				isFatherTitle=true;
 			}
 			if(!isQuestion && elFor.text().contains(LabelEnum.QUESTION_ANALYZE.getKey()) ){
 				isFatherAnalyze=true;
 				isFatherTitle=false;
 			}
 			if(elFor.text().contains(LabelEnum.QUESTION_CONTENT.getKey())){
 				isNew =true;
 				isQuestion=true;
 				isFatherTitle=false;
 				isFatherAnalyze=false;
 			}
 			if(elFor.text().contains(LabelEnum.QUESTION_FATHER_CONTENT_END.getKey())){
 				if(questionSingleList.size()>0){
 					questionList.add(questionSingleList);
 				}
 				isQuestion=false;
 			}
 			if(isFatherTitle){
 				fatherTitleList.add(elFor);
 			}
 			if(isFatherAnalyze){
 				fatherAnalyzeList.add(elFor);
 			}
 			if(isQuestion){
 				if(isNew){
 					isNew=false;
 					if(questionSingleList.size()>0){
 						questionList.add(questionSingleList);
 					}
 					questionSingleList = new ArrayList<>();
 				}
 				questionSingleList.add(elFor);
 			}
 		}
 		//梳理父子题
 		List<String> labellist =new ArrayList<>();
 		labellist.add(LabelEnum.QUESTION_FATHER_CONTENT.getKey());
 		String description =this.deleteLabelString(fatherTitleList , labellist);
 		//父标题
 		QtQuestion insertQtQuestion = this.insertQtQuestion( tVo,null, description, null,"",Constants.Level_ParentChild_PARENT,0);
 		List<QtQuestionAttribute> attributes = new ArrayList<>(); // 试题属性
 		List<QtQuestion> children = new ArrayList<>(); // 该题的子题，注意设置对应的 level
 		//判断是否有解析
 		if(fatherAnalyzeList.size() > 0 ){
 			labellist.clear();
 			labellist.add(LabelEnum.QUESTION_ANALYZE.getKey());
 			QtQuestionAttribute insertQtQuestionAttribute = this.insertQtQuestionAttribute("stsxAnalysis", this.deleteLabelString(fatherAnalyzeList , labellist));
 			attributes.add(insertQtQuestionAttribute);
 			insertQtQuestion.setAttributes(attributes);
 		}
 		for(int f=0 ; f<questionList.size() ; f++){
 			QtQuestion combingAloneTopic = combingAloneTopic(questionList.get(f), tVo, f+1,Constants.Level_ParentChild_CHILD);
 			children.add(combingAloneTopic);
 		}
 		insertQtQuestion.setChildren(children);
 		return insertQtQuestion;
 	}
 	
 	/**
 	 * 单体题目的方法
 	 * 
 	 * @param elListFor
 	 * @param tVo
 	 * @param orderNumber 父子题目的时候才传递
 	 * @param level 等级
 	 */
 	public QtQuestion combingAloneTopic(List<Element> elListFor ,TransferVo tVo,Integer orderNumber,String level){
 		if(elListFor == null || elListFor.size() < 1){
 			return null;
 		}
 		//设置题目内容集合
 		Boolean isTitleContent =Boolean.FALSE;
 		List<Element> titleContentList = new ArrayList<>();
 		//所属模块
 		Boolean isModule =Boolean.FALSE;
 		List<Element> moduleList = new ArrayList<>();
 		//试题所属分类
 		Boolean isClassification =Boolean.FALSE;
 		List<Element> classificationList = new ArrayList<>();
 		//分值
 		Boolean isScore =Boolean.FALSE;
 		List<Element> scoreList = new ArrayList<>();
 		//主客观
 		Boolean isObjective =Boolean.TRUE;//客观
 		//试题解析
 		Boolean isQuestionAnalyze =Boolean.FALSE;
 		List<Element> questionAnalyzeList = new ArrayList<>();
 		//选项评析
 		Boolean isQuestionOptionAppraise =Boolean.FALSE;
 		List<Element> questionOptionAppraiseList = new ArrayList<>();
 		//答案评析
 		Boolean isQuestionAnswerAppraise =Boolean.FALSE;
 		List<Element> questionAnswerAppraiseList = new ArrayList<>();
 		//循环数据
 		for(Element elFor : elListFor){
 			if(elFor.text().contains(LabelEnum.QUESTION_CONTENT.getKey())){
 				isTitleContent =Boolean.TRUE;
 				isModule =Boolean.FALSE;
 				isClassification =Boolean.FALSE;
 				isScore =Boolean.FALSE;
 				isQuestionAnalyze =Boolean.FALSE;
 				isQuestionOptionAppraise =Boolean.FALSE;
 				isQuestionAnswerAppraise =Boolean.FALSE;
 			}
 			if(elFor.text().contains(LabelEnum.QUESTION_MODULE.getKey())){
 				isModule =Boolean.TRUE;
 				isTitleContent =Boolean.FALSE;
 				isClassification =Boolean.FALSE;
 				isScore =Boolean.FALSE;
 				isQuestionAnalyze =Boolean.FALSE;
 				isQuestionOptionAppraise =Boolean.FALSE;
 				isQuestionAnswerAppraise =Boolean.FALSE;
 			}
 			if(elFor.text().contains(LabelEnum.QUESTION_CLASSIFICATION.getKey())){
 				isClassification =Boolean.TRUE;
 				isTitleContent =Boolean.FALSE;
 				isModule =Boolean.FALSE;
 				isScore =Boolean.FALSE;
 				isQuestionAnalyze =Boolean.FALSE;
 				isQuestionOptionAppraise =Boolean.FALSE;
 				isQuestionAnswerAppraise =Boolean.FALSE;
 			}
 			if(elFor.text().contains(LabelEnum.QUESTION_SCORE.getKey())){
 				isScore =Boolean.TRUE;
 				isTitleContent =Boolean.FALSE;
 				isModule =Boolean.FALSE;
 				isClassification =Boolean.FALSE;
 				isQuestionAnalyze =Boolean.FALSE;
 				isQuestionOptionAppraise =Boolean.FALSE;
 				isQuestionAnswerAppraise =Boolean.FALSE;
 			}
 			if(elFor.text().contains(LabelEnum.QUESTION_SUBJECTIVE.getKey())){
 				isObjective =Boolean.FALSE;
 				isTitleContent =Boolean.FALSE;
 				isModule =Boolean.FALSE;
 				isClassification =Boolean.FALSE;
 				isScore =Boolean.FALSE;
 				isQuestionAnalyze =Boolean.FALSE;
 				isQuestionOptionAppraise =Boolean.FALSE;
 				isQuestionAnswerAppraise =Boolean.FALSE;
 			}
 			if(elFor.text().contains(LabelEnum.QUESTION_ANALYZE.getKey())){
 				isQuestionAnalyze =Boolean.TRUE;
 				isTitleContent =Boolean.FALSE;
 				isModule =Boolean.FALSE;
 				isClassification =Boolean.FALSE;
 				isScore =Boolean.FALSE;
 				isQuestionOptionAppraise =Boolean.FALSE;
 				isQuestionAnswerAppraise =Boolean.FALSE;
 			}
 			if(elFor.text().contains(LabelEnum.QUESTION_OPTION_APPRAISE.getKey())){
 				isQuestionOptionAppraise =Boolean.TRUE;
 				isTitleContent =Boolean.FALSE;
 				isModule =Boolean.FALSE;
 				isClassification =Boolean.FALSE;
 				isScore =Boolean.FALSE;
 				isQuestionAnalyze =Boolean.FALSE;
 				isQuestionAnswerAppraise =Boolean.FALSE;
 			}
 			if(elFor.text().contains(LabelEnum.QUESTION_ANSWER_APPRAISE.getKey())){
 				isQuestionAnswerAppraise =Boolean.TRUE;
 				isTitleContent =Boolean.FALSE;
 				isModule =Boolean.FALSE;
 				isClassification =Boolean.FALSE;
 				isScore =Boolean.FALSE;
 				isQuestionAnalyze =Boolean.FALSE;
 				isQuestionOptionAppraise =Boolean.FALSE;
 			}
 			if(isTitleContent){
 				titleContentList.add(elFor);
 			}
 			if(isModule){
 				moduleList.add(elFor);
 			}
 			if(isClassification){
 				classificationList.add(elFor);
 			}
 			if(isScore){
 				scoreList.add(elFor);
 			}
 			if(isQuestionAnalyze){
 				questionAnalyzeList.add(elFor);
 			}
 			if(isQuestionOptionAppraise){
 				questionOptionAppraiseList.add(elFor);
 			}
 			if(isQuestionAnswerAppraise){
 				questionAnswerAppraiseList.add(elFor);
 			}
 		}
 		//获得数据信息
 		List<String> labellist =new ArrayList<>();
 		//题目
 		labellist.add(LabelEnum.QUESTION_CONTENT.getKey());
 		String description =this.deleteLabelString(titleContentList , labellist);
 		//模块
 		labellist.clear();
 		labellist.add(LabelEnum.QUESTION_MODULE.getKey());
 		String module =this.deleteLabelString(moduleList , labellist);
 		//分类
 		labellist.clear();
 		labellist.add(LabelEnum.QUESTION_CLASSIFICATION.getKey());
 		String classification =this.deleteLabelString(classificationList , labellist);
 		//分值
 		List<Integer> elementScore = this.getElementScore(scoreList.get(0).text());
 		Integer topScore =0;
 		if(elementScore.size()>1){
 			for(Integer doFor : elementScore){
 				if(topScore < doFor){
 					topScore=doFor;
 				}
 			}
 		}else{
 			topScore =elementScore.get(0);
 		}
 		//试题解析
 		String questionAnalyze ="";
 		if(questionAnalyzeList.size()>0){
 			labellist.clear();
 			labellist.add(LabelEnum.QUESTION_ANALYZE.getKey());
 			questionAnalyze =this.deleteLabelString(questionAnalyzeList , labellist);
 		}
 		//答案
 		String questionAnswerAppraise = "";
 		if(questionAnswerAppraiseList.size()>0){
 			labellist.clear();
 			labellist.add(LabelEnum.QUESTION_ANSWER_APPRAISE.getKey());
 			questionAnswerAppraise =this.deleteLabelString(questionAnswerAppraiseList , labellist);
 		}
 		
 		//开始对表
 		//QtQuestion
 		QtQuestion insertQtQuestion = this.insertQtQuestion(tVo, isObjective?Constants.QuestionTypeChoice:Constants.QuestionTypeEssay, description, orderNumber,"", level, topScore);
 		//QtQuestionAttribute //四个
 		List<QtQuestionAttribute> attributes = new ArrayList<>(); // 试题属性
 		if(questionAnalyzeList.size()>0){
 			QtQuestionAttribute insertQtQuestionAttribute = this.insertQtQuestionAttribute("stsxAnalysis", questionAnalyze);//试题解析
 			attributes.add(insertQtQuestionAttribute);
 		}
 		if(questionAnswerAppraiseList.size()>0){
 			QtQuestionAttribute insertQtQuestionAttribute2 = this.insertQtQuestionAttribute("stsxEvaluate", questionAnswerAppraise);//答案评析
 			attributes.add(insertQtQuestionAttribute2);
 		}
 		if(StringUtils.isNotBlank(module)){
 			Integer modules = charAtStringReturnDouble(module);
 			if(null != modules){
 				QtQuestionAttribute insertQtQuestionAttribute3 = this.insertQtQuestionAttribute("stsxModule", modules.toString());//所属模块
 				attributes.add(insertQtQuestionAttribute3);
 			}
 		}
 		if(StringUtils.isNotBlank(classification)){
 			QtQuestionAttribute insertQtQuestionAttribute4 = this.insertQtQuestionAttribute("stsxType", classification);//所属分类
 			attributes.add(insertQtQuestionAttribute4);
 		}
 		//insertQtQuestionChoice
 		if(isObjective){
 			List<QtQuestionAnswer> choices = this.insertQtQuestionChoice(questionOptionAppraiseList, elementScore, topScore);
 			insertQtQuestion.setAnswers(choices);
 		}
 		//返回类信息
 		
 		insertQtQuestion.setAttributes(attributes);
 		return insertQtQuestion;
 	}

11.下面贴几个自己写的方法类

/**
 	 * 去除标签的方法 string删除标签 
 	 * 
 	 * @param elementList
 	 * @param labellist
 	 * @return
 	 */
 	public String deleteLabelString(List<Element> elementList ,List<String> labellist){
 		String returnData ="";
 		//判断是否为空
 		if(elementList==null || elementList.size()<1 || labellist==null || labellist.size()<1){
 			return returnData;
 		}
 		boolean isTitle = false;
 		for(String leFor : labellist){
 			if(leFor.contains(LabelEnum.PAPERS_NAME.getKey()) || leFor.contains(LabelEnum.QUESTION_MODULE.getKey())|| leFor.contains(LabelEnum.QUESTION_CLASSIFICATION.getKey())){
 				isTitle = true;
 			}
 		}
 		
 		for(Element elFor : elementList){
 			String resultData =null;
 			//对图片进行内容处理
 			boolean isConstains = false;
 			for(String laFor : labellist){
 				if(elFor.text().contains(laFor)){
 					isConstains =true;
 				}
 			}
 			if(isConstains){
 				//删除第一个>以前的东西
 				String[] split = elFor.text().split(">");
 				int length = split[0].length();
 				if(elFor.text().length()>length){
 					resultData = elFor.text().substring((length+1), elFor.text().length());
 				}
 			}else{
 				resultData = elFor.text();
 			}
 			//判断是否含有图片
 			Elements elementsByTag = elFor.getElementsByTag("img");
 			if(elementsByTag.size()>0){//有图片
 				//判断是不是只有图片
 				boolean isNull= true;
 				if(StringUtils.isNotBlank(resultData)){//不是空
 					char[] charArray = resultData.toCharArray();
 					charArrayFor:
 					for(char charFor : charArray){
 						if(!Character.isSpaceChar(charFor) ){
 							isNull=false;
 							break charArrayFor;
 						}
 					}
 				}
 				if(isNull){//只有图片的
 					returnData=returnData+"";
 					for(Element imgFor : elementsByTag){
 						returnData=returnData+imgFor.toString();
 					}
 					returnData=returnData+"";
 				}else{//图片和文字都有的
 					//将图片处替换
 					for(int i =0;i<elementsByTag.size() ;i++){
 						Element parent = elementsByTag.get(i).parent();
 						parent.appendElement("span").text("<Ф图片"+i+"Ф>");
 //						elementsByTag.get(i).html("<Ф图片"+i+"Ф>");
 					}	
 					//将el变文字
 					if(isConstains){
 						//删除第一个>以前的东西
 						String[] split = elFor.text().split(">");
 						int length = split[0].length();
 						if(elFor.text().length()>length){
 							resultData = elFor.text().substring((length+1), elFor.text().length());
 						}
 					}else{
 						resultData = elFor.text();
 					}
 					//将img去替换
 					for(int i =0;i<elementsByTag.size() ;i++){
 						resultData = resultData.replaceAll("<Ф图片"+i+"Ф>", elementsByTag.get(i).toString());
 					}
 					returnData=returnData+""+resultData+"";
 				}
 			}else{//没有图片
 				if(StringUtils.isNotBlank(resultData)){
 					if(isTitle){
 						returnData=returnData+resultData;
 					}else{
 						returnData=returnData+""+resultData+"";
 					}
 				}
 				
 			}
 		}
 		return returnData;
 	}

此方法中，判断有图片后的for循环方法，charArrayFor，其实是判断是否有中文空格啥的

/**
    	 * 分解字符串得到数字和.的方法
    	 * 
    	 * @param str
    	 * @return
    	 */
    	public  Integer charAtStringReturnDouble(String str){
    		String returnStr = new String();
    		str = str.trim();
    		Pattern p=Pattern.compile("(\\d+\\.\\d+)");
    	      Matcher m=p.matcher(str);
    	      if(m.find()){
    	    	  returnStr=m.group(1);
    	      }else{
    	         p= Pattern.compile("(\\d+)");
    	         m=p.matcher(str);
    	         if(m.find()){
    	        	 returnStr=m.group(1);
    	         }
    	      }
    	      if(StringUtils.isNotBlank(returnStr)){
    	    	 return    Integer.parseInt(returnStr);
    	      }else{
    	    	  return null;
    	      }
    	}

先写到这，下片文章，写一下关于jsoup的方法，假如以后用，能用到嫩

[Center]: /images/20220605/15fa1e10576343e7a42db855600b369d.png