framework模板下载文件

maven:

 
            org.freemarker
            freemarker
            2.3.28
        


import freemarker.template.*;
import sun.misc.BASE64Encoder;

import java.io.*;
import java.util.Map;

public class DocUtil {
	public Configuration configure = null;
	
	public DocUtil() {
		configure = new Configuration(Configuration.VERSION_2_3_28);
		configure.setDefaultEncoding("utf-8");
	}
	
	/**
	 * 根据Doc模板生成word文件
	 *
	 * @param dataMap      需要填入模板的数据
	 * @param downloadType 文件名称
	 * @param savePath     保存路径
	 */
	public void createDoc(Map dataMap, String downloadType, String savePath) {
		try {
			//加载需要装填的模板
			Template template = null;
			//设置模板装置方法和路径,FreeMarker支持多种模板装载方法。可以重servlet,classpath,数据库装载。
			//加载模板文件,放在testDoc下
			configure.setClassForTemplateLoading(this.getClass(), "/templates");
			//设置对象包装器
//            configure.setObjectWrapper(new DefaultObjectWrapper());
			//设置异常处理器
			configure.setTemplateExceptionHandler(TemplateExceptionHandler.IGNORE_HANDLER);
			//定义Template对象,注意模板类型名字与downloadType要一致
			template = configure.getTemplate(downloadType + ".ftl");
			File outFile = new File(savePath);
			Writer out;
			out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(outFile), "utf-8"));
			template.process(dataMap, out);
			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (TemplateException e) {
			e.printStackTrace();
		}
	}
	
	public String getImageStr(String imgFile) {
		InputStream in;
		byte[] data = null;
		try {
			in = new FileInputStream(imgFile);
			data = new byte[in.available()];
			in.read(data);
			in.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		BASE64Encoder encoder = new BASE64Encoder();
		return encoder.encode(data);
	}
}

测试代码

package com.swad.smas.information.utils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TestDoc {
    public static void main(String[] args) {
        DocUtil docUtil=new DocUtil();
        Map dataMap=new HashMap();
        dataMap.put("name", "Joanna");
        dataMap.put("examNum", "111111111111");
        dataMap.put("IDCard", "222222222222222222");
        dataMap.put("carModel", "C1");
        dataMap.put("driverSchool", "测试驾校");
        dataMap.put("busyType", "初次申领");
        dataMap.put("examDate", "2016-03-10");
        dataMap.put("orderCount", "第1次");
        List pic = new ArrayList<>();
        pic.add(docUtil.getImageStr("D:\\test\\1.jpeg"));
        pic.add(docUtil.getImageStr("D:\\test\\3.png"));
        pic.add(docUtil.getImageStr("D:\\test\\3.png"));
        pic.add(docUtil.getImageStr("D:\\test\\3.png"));
        dataMap.put("images", pic);
        dataMap.put("firstExamTime", "12:41:17-12:44:38");
        dataMap.put("firstExamScores", "0分,不及格");
        dataMap.put("firstDeductItem", "12:44:15 20102 1号倒车入库,车身出线 扣100分");
        //dataMap.put("firstPic1", docUtil.getImageStr("D:\\test\\2.jpeg"));
        //dataMap.put("firstPic2", docUtil.getImageStr("D:\\test\\1.jpeg"));
        //dataMap.put("secondExamTime", "12:46:50-13:05:37");
        //dataMap.put("secondExamScores", "90分,通过");
        //dataMap.put("secondDeductItem", "");
        //dataMap.put("secondPic1", docUtil.getImageStr("D:\\test\\1.jpeg"));
        //dataMap.put("secondPic2", docUtil.getImageStr("D:\\test\\1.jpeg"));
        docUtil.createDoc(dataMap, "testDoc", "D:\\test\\22211.doc");
    }
}
 
  

POI

package com.swad.smas.information.utils;
 
import org.apache.poi.xwpf.model.XWPFHeaderFooterPolicy;
import org.apache.poi.xwpf.usermodel.*;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.*;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.math.BigInteger;
 
 
/**
 * Created by zhouhs on 2017/1/9.
 */
public class WordExportController {
 
    public static void main(String[] args)throws Exception {
        //Blank Document
        XWPFDocument document= new XWPFDocument();
 
        //Write the Document in file system
        FileOutputStream out = new FileOutputStream(new File("D://test/create_table.docx"));
 
 
        //添加标题
        XWPFParagraph titleParagraph = document.createParagraph();
        //设置段落居中
        titleParagraph.setAlignment(ParagraphAlignment.CENTER);
 
        XWPFRun titleParagraphRun = titleParagraph.createRun();
        titleParagraphRun.setText("Java PoI");
        titleParagraphRun.setColor("000000");
        titleParagraphRun.setFontSize(20);
 
 
        //段落
        XWPFParagraph firstParagraph = document.createParagraph();
        XWPFRun run = firstParagraph.createRun();
        run.setText("Java POI 生成word文件。");
        run.setColor("696969");
        run.setFontSize(16);
        
        FileInputStream im =  new FileInputStream(new File("D:\\test/1.jpeg"));
        document.addPictureData(im,Document.PICTURE_TYPE_JPEG);
 
        //设置段落背景颜色
        CTShd cTShd = run.getCTR().addNewRPr().addNewShd();
        cTShd.setVal(STShd.CLEAR);
        cTShd.setFill("97FFFF");
 
 
        //换行
        XWPFParagraph paragraph1 = document.createParagraph();
        XWPFRun paragraphRun1 = paragraph1.createRun();
        paragraphRun1.setText("\r");
 
 
        //基本信息表格
        XWPFTable infoTable = document.createTable();
        //去表格边框
        infoTable.getCTTbl().getTblPr().unsetTblBorders();
 
 
        //列宽自动分割
        CTTblWidth infoTableWidth = infoTable.getCTTbl().addNewTblPr().addNewTblW();
        infoTableWidth.setType(STTblWidth.DXA);
        infoTableWidth.setW(BigInteger.valueOf(9072));
 
 
        //表格第一行
        XWPFTableRow infoTableRowOne = infoTable.getRow(0);
        infoTableRowOne.getCell(0).setText("职位");
        infoTableRowOne.addNewTableCell().setText(": Java 开发工程师");
 
        //表格第二行
        XWPFTableRow infoTableRowTwo = infoTable.createRow();
        infoTableRowTwo.getCell(0).setText("姓名");
        infoTableRowTwo.getCell(1).setText(": seawater");
 
        //表格第三行
        XWPFTableRow infoTableRowThree = infoTable.createRow();
        infoTableRowThree.getCell(0).setText("生日");
        infoTableRowThree.getCell(1).setText(": xxx-xx-xx");
 
        //表格第四行
        XWPFTableRow infoTableRowFour = infoTable.createRow();
        infoTableRowFour.getCell(0).setText("性别");
        infoTableRowFour.getCell(1).setText(": 男");
 
        //表格第五行
        XWPFTableRow infoTableRowFive = infoTable.createRow();
        infoTableRowFive.getCell(0).setText("现居地");
        infoTableRowFive.getCell(1).setText(": xx");
 
 
        //两个表格之间加个换行
        XWPFParagraph paragraph = document.createParagraph();
        XWPFRun paragraphRun = paragraph.createRun();
        paragraphRun.setText("\r");
    
        XWPFParagraph pic = document.createParagraph();
        XWPFRun oicRun = pic.createRun();
        FileInputStream im1 =  new FileInputStream(new File("D:\\test/2.JPEG"));
        oicRun.addPicture(im1,Document.PICTURE_TYPE_JPEG,"2.JPEG",200,400);
        //工作经历表格
        XWPFTable ComTable = document.createTable();
 
 
        //列宽自动分割
        CTTblWidth comTableWidth = ComTable.getCTTbl().addNewTblPr().addNewTblW();
        comTableWidth.setType(STTblWidth.DXA);
        comTableWidth.setW(BigInteger.valueOf(9072));
 
        //表格第一行
        XWPFTableRow comTableRowOne = ComTable.getRow(0);
        comTableRowOne.getCell(0).setText("开始时间");
        comTableRowOne.addNewTableCell().setText("结束时间");
        comTableRowOne.addNewTableCell().setText("公司名称");
        comTableRowOne.addNewTableCell().setText("title");
 
        //表格第二行
        XWPFTableRow comTableRowTwo = ComTable.createRow();
        comTableRowTwo.getCell(0).setText("2016-09-06");
        comTableRowTwo.getCell(1).setText("至今");
        comTableRowTwo.getCell(2).setText("seawater");
        comTableRowTwo.getCell(3).setText("Java开发工程师");
 
        //表格第三行
        XWPFTableRow comTableRowThree = ComTable.createRow();
        comTableRowThree.getCell(0).setText("2016-09-06");
        comTableRowThree.getCell(1).setText("至今");
        comTableRowThree.getCell(2).setText("seawater");
        comTableRowThree.getCell(3).setText("Java开发工程师");
 
 
        CTSectPr sectPr = document.getDocument().getBody().addNewSectPr();
        XWPFHeaderFooterPolicy policy = new XWPFHeaderFooterPolicy(document, sectPr);
 
        //添加页眉
        CTP ctpHeader = CTP.Factory.newInstance();
        CTR ctrHeader = ctpHeader.addNewR();
        CTText ctHeader = ctrHeader.addNewT();
        String headerText = "Java POI create MS word file.";
        ctHeader.setStringValue(headerText);
        XWPFParagraph headerParagraph = new XWPFParagraph(ctpHeader, document);
        //设置为右对齐
        headerParagraph.setAlignment(ParagraphAlignment.RIGHT);
        XWPFParagraph[] parsHeader = new XWPFParagraph[1];
        parsHeader[0] = headerParagraph;
        policy.createHeader(XWPFHeaderFooterPolicy.DEFAULT, parsHeader);
 
 
        //添加页脚
        CTP ctpFooter = CTP.Factory.newInstance();
        CTR ctrFooter = ctpFooter.addNewR();
        CTText ctFooter = ctrFooter.addNewT();
        String footerText = "http://blog.csdn.net/zhouseawater";
        ctFooter.setStringValue(footerText);
        XWPFParagraph footerParagraph = new XWPFParagraph(ctpFooter, document);
        headerParagraph.setAlignment(ParagraphAlignment.CENTER);
        XWPFParagraph[] parsFooter = new XWPFParagraph[1];
        parsFooter[0] = footerParagraph;
        policy.createFooter(XWPFHeaderFooterPolicy.DEFAULT, parsFooter);
 
 
        document.write(out);
        out.close();
        System.out.println("create_table document written success.");
    }
 
 
}

ftl:




    
        
            
                
                
                
                
            
        
    
    
        
            
                
                
                
                
                
                
                
            
        
    
    
        
            
                
                    
                        
                            
                            
                            
                            
                                
                                
                                
                                
                                
                                
                            
                            
                            
                                
                                
                                
                                
                            
                        
                        
                            
                            
                            
                            
                            
                        
                        
                            
                                
                                    
                                    
                                    
                                    
                                    
                                    
                                
                                
                                
                                    
                                    
                                    
                                    
                                
                            
                            
                                
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        姓名
                                    
                                
                            
                            
                                
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        ${name}
                                    
                                
                            
                            
                                
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        准考证号
                                    
                                
                            
                            
                                
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        ${examNum}
                                    
                                
                            
                            
                                
                                    
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        
                                            
                                                
                                                
                                                
                                                
                                                    
                                                
                                                
                                                    
                                                        
                                                            
                                                                
                                                                
                                                                    
                                                                
                                                            
                                                            
                                                                
                                                                
                                                                    
                                                                
                                                            
                                                            
                                                                
                                                                    
                                                                    
                                                                
                                                                
                                                                    
                                                                
                                                            
                                                        
                                                    
                                                
                                            
                                        
                                    
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        
                                            
                                                
                                                
                                                
                                                
                                                    
                                                
                                                
                                                    
                                                        
                                                            
                                                                
                                                                
                                                                    
                                                                
                                                            
                                                            
                                                                
                                                                
                                                                    
                                                                
                                                            
                                                            
                                                                
                                                                    
                                                                    
                                                                
                                                                
                                                                    
                                                                
                                                            
                                                        
                                                    
                                                
                                            
                                        
                                    
                                    
                                
                            
                        
                        
                            
                                
                                    
                                    
                                    
                                    
                                    
                                    
                                
                                
                                
                                    
                                    
                                    
                                    
                                
                            
                            
                                
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        身份证
                                    
                                
                            
                            
                                
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        ${IDCard}
                                    
                                
                            
                            
                                
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        报考车型
                                    
                                
                            
                            
                                
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        ${carModel}
                                    
                                
                            
                            
                                
                                    
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                        
                                    
                                
                            
                        
                        
                            
                                
                                    
                                    
                                    
                                    
                                    
                                    
                                
                                
                                
                                    
                                    
                                    
                                    
                                
                            
                            
                                
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        驾校简称
                                    
                                
                            
                            
                                
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        ${driverSchool}
                                    
                                
                            
                            
                                
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        业务类型
                                    
                                
                            
                            
                                
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        ${busyType}
                                    
                                
                            
                            
                                
                                    
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                        
                                    
                                
                            
                        
                        
                            
                                
                                    
                                    
                                    
                                    
                                    
                                    
                                
                                
                                
                                    
                                    
                                    
                                    
                                
                            
                            
                                
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        考试日期
                                    
                                
                            
                            
                                
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        ${examDate}
                                    
                                
                            
                            
                                
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        预约次数
                                    
                                
                            
                            
                                
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        ${orderCount}
                                    
                                
                            
                            
                                
                                    
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                        
                                    
                                
                            
                        
                        
                            
                                
                                    
                                    
                                    
                                    
                                    
                                    
                                
                                
                                
                                    
                                    
                                    
                                    
                                
                            
                            
                                
                                    
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        科目二考试
                                    
                                
                            
                        
                        
                            
                                
                                    
                                    
                                    
                                    
                                    
                                    
                                
                                
                                
                                    
                                    
                                    
                                    
                                
                            
                            
                                
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        考试时间
                                    
                                
                            
                            
                                
                                    
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        ${firstExamTime}
                                    
                                
                            
                            
                                
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        考试成绩
                                    
                                
                            
                            
                                
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        ${firstExamScores}
                                    
                                
                            
                        
                        
                            
                                
                                    
                                    
                                    
                                    
                                    
                                    
                                
                                
                                
                                    
                                    
                                    
                                    
                                
                            
                            
                                
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        扣分项
                                    
                                
                            
                            
                                
                                    
                                    
                                    
                                
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                        ${firstDeductItem}
                                    
                                
                            
                        
                    
                    
                    
                        
                        
                        
                        
                    
                
            
        
    
    
        
            
                
            
        
    
    
        
            
                
                    
                
            
        
    
    
        
            
                
                    
                
            
        
    
    
        
            
                
                1
                0
                0
                0
                0
                0
                false
                false
                0
                WPS Office_11.1.0.8573_F1E327BC-269C-435d-A152-05C5408002CA
                0
            
        
    
    
        
            
                2019-05-21T08:17:00Z
                2019-05-21T09:15:38Z
                1
            
        
    
    
        
            
                
                    2052-11.1.0.8573
                
            
        
    
    
        
            
                
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                
            
        
    
<#list images as image>
    
        ${image}
    

    
        
            
                
                
                
                
                
                
                
                
                
                
                
                
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                
                
                
                
            
        
    
    
        
            
                
                    
                        
                            
                        
                    
                
                
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                        
                        
                    
                    
                        
                        
                        
                        
                        
                    
                
                
                    
                    
                    
                    
                
                
                    
                    
                    
                    
                    
                        
                        
                            
                            
                            
                            
                        
                    
                
                
                    
                    
                    
                    
                    
                        
                        
                    
                    
                        
                            
                            
                            
                            
                            
                            
                        
                        
                    
                
            
        
    
    
        
            
                
                    
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                        
                            
                        
                    
                    
                        
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                        
                        
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                        
                    
                    
                        
                            
                                
                            
                            
                                
                                    
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                    
                                
                                
                            
                            
                                
                                    
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                        
                                    
                                
                                
                            
                        
                        
                            
                                
                                    
                                
                                
                                
                            
                            
                                
                                    
                                
                                
                                
                            
                            
                                
                                    
                                
                                
                                
                            
                        
                        
                            
                                
                            
                            
                                
                            
                            
                                
                                    
                                        
                                            
                                        
                                    
                                
                            
                        
                        
                            
                                
                            
                            
                                
                                    
                                    
                                
                            
                            
                                
                                    
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                    
                                        
                                            
                                            
                                        
                                    
                                
                                
                            
                        
                    
                
                
            
        
    
    

你可能感兴趣的:(JAVA)