通过POI类库实现word文档的创建。

思路：

通过自定义变量名，利用替换的方式，将所需数据填入，一般用于生成固定格式的报告。如果需要填入的数据很多，则略繁琐。

注意：

a）、例子中给的只能替换变量，不能根据结果生成多行数据。例如表格等。

b）、目前支持DOC格式，不支持DOCX格式。

 

1、需要新建一个word模版，在需要输入数据的地方填入：

${变量名}

变量名称根据自行需要更改。不可有重复名称。

2、通过POI类，进行变量的替换，以实现word文件的生成。

3、示例：

public static void CreatWordByModel(String  tmpFile, Map<String, String> contentMap, String exportFile) throws Exception{

        InputStream in = null;
        in = new FileInputStream(new File(tmpFile));

        HWPFDocument document = null;
        document = new HWPFDocument(in);
        // 读取文本内容
        Range bodyRange = document.getRange();
        System.out.println(bodyRange.toString());
        System.out.println(bodyRange.text());
        // 替换内容
        for (Map.Entry<String, String> entry : contentMap.entrySet()) {
            bodyRange.replaceText("${" + entry.getKey() + "}", entry.getValue());
        }

        //导出到文件
        try {
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            document.write((OutputStream)byteArrayOutputStream);
            OutputStream outputStream = new FileOutputStream(exportFile);
            outputStream.write(byteArrayOutputStream.toByteArray());
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
}

public static void main(String[] args) throws Exception {
    Map map=new HashMap();
    map.put("data1","20190301");
    map.put("data2","你好");
    map.put("data3","这是一个测试");
    map.put("data4","CSDN");
    map.put("data5","https://blog.csdn.net/yxf771hotmail");
    CreatWordByModel("C:/model.doc",map,"C:/newfile.doc");
}

4、结果：

模版：



结果：



 

                                     打赏



 

 

引入资源库
    implementation 'org.apache.poi:poi:4.1.2'
    implementation 'org.apache.poi:poi-ooxml:4.1.2'
    implementation 'org.apache.poi:poi-ooxml-schemas:4.1.2'

    public void test(HttpServletResponse response){
        try {
            //定义一个Entity放要输出的数据
            EditWordEntity report = new EditWordEntity();
            report.setMonth("April");
            report.setCode("202102");
            report.setTestDate("2020-04-01 to 2020-04-31");
            report.setAAAAA("aaaaaaa");
            report.setBBBBB("bbbbbbb");

            Map<String, String> replaceMap = new HashMap<>();

            replaceMap.put("month", report.getMonth());
            replaceMap.put("code", report.getCode());
            replaceMap.put("testDate", report.getTestDate());
            replaceMap.put("AAAAA", report.getAAAAA());
            replaceMap.put("BBBBB", report.getBBBBB());

            PoiEditWord poiEditWord = new PoiEditWord();
            poiEditWord.downloadReportFile("test poi.docx", replaceMap, response);
        } catch (IOException e) {
            e.printStackTrace();
        }

public class PoiEditWord {

    public void downloadReportFile(String fileName, Map<String, String> replaceMap, HttpServletResponse response) throws IOException {
        InputStream in = null;
        XWPFDocument document = null;
        response.reset();
        response.setContentType("application/x-msdownload");
        ByteArrayOutputStream ostream = new ByteArrayOutputStream();
        OutputStream os = null;
        try {
            response.addHeader("Content-Disposition", "attachment; filename=" + URLEncoder.encode(fileName, "UTF-8"));
            //找到项目中模板文件的位置
            in = Thread.currentThread().getContextClassLoader().getResourceAsStream("test poi.docx");
            //获取docx解析对象
            document = new XWPFDocument(in);
            WordUtil.changeText(document, replaceMap);
            os = response.getOutputStream();
            document.write(os);
            os.write(ostream.toByteArray());os.close();ostream.close();
        } catch (IOException e) { e.printStackTrace(); }
        finally {
            try {
                if (in != null) { in.close(); }
                if (document != null) { document.close(); }
                if (os != null) { os.close(); }
                if (ostream != null) { ostream.close(); }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

//工具类
public class WordUtil {
    /**
     * 遍历文本
     *
     * @param document docx解析对象
     */
    public static void traverse(XWPFDocument document) {
        //获取文档中各段落集合
        List<XWPFParagraph> paragraphs = document.getParagraphs();
        //遍历各段落
        for (XWPFParagraph paragraph : paragraphs) {
            //判断此段落时候需要进行替换
            String text = paragraph.getText();
            List<XWPFRun> runs = paragraph.getRuns();
            for (XWPFRun run : runs) {
                // TODO 处理文本

            }
        }
    }

    /**
     * 替换段落文本
     *
     * @param document docx解析对象
     * @param textMap  需要替换的信息集合
     */
    public static void changeText(XWPFDocument document, Map<String, String> textMap) {
        //获取段落集合
        List<XWPFParagraph> paragraphs = document.getParagraphs();
        for (XWPFParagraph paragraph : paragraphs) {
            //获取到段落中的所有文本内容
            String text = paragraph.getText();
            //判断此段落中是否有需要进行替换的文本
            if (checkText(text)) {
                List<XWPFRun> runs = paragraph.getRuns();
                for (XWPFRun run : runs) {
                    //替换模板原来位置
                    run.setText(changeValue(run.toString(), textMap), 0);
                }
            }
        }
        replaceTableValue(document, textMap);
    }

    public static void replaceTableValue(XWPFDocument document, Map<String, String> textMap){
        Iterator<XWPFTable> it = document.getTablesIterator();
        //表格内容替换添加
        while(it.hasNext()){
            XWPFTable table = it.next();
            int rcount = table.getNumberOfRows();
            for(int i =0 ;i < rcount;i++){
                XWPFTableRow row = table.getRow(i);
                List<XWPFTableCell> cells =  row.getTableCells();
                for (XWPFTableCell cell : cells){
                    for(Map.Entry<String, String> e : textMap.entrySet()){
                        if(checkText(cell.getText())){
                            List<XWPFParagraph> tableParagraphsList = cell.getParagraphs();
                            for (XWPFParagraph paragraph : tableParagraphsList) {
                                String text = paragraph.getText(); //获取到段落中的所有文本内容
                                if (checkText(text)) { //判断此段落中是否有需要进行替换的文本
                                    List<XWPFRun> runs = paragraph.getRuns();
                                    for (XWPFRun run : runs) {
                                        run.setText(changeValue(run.toString(), textMap), 0);//替换模板原来位置
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    /**
     * 判断文本中是否包含$
     *
     * @param text 文本
     * @return 包含返回true, 不包含返回false
     */
    public static boolean checkText(String text) {
        boolean check = false;
        if (text.contains("$")) {
            check = true;
        }
        return check;
    }

    /**
     * 匹配传入信息集合与模板
     *
     * @param value   模板需要替换的区域
     * @param textMap 传入信息集合
     * @return 模板需要替换区域信息集合对应值
     */
    public static String changeValue(String value, Map<String, String> textMap) {
        Set<Map.Entry<String, String>> textSets = textMap.entrySet();
        for (Map.Entry<String, String> textSet : textSets) {
            //匹配模板与替换值 格式${key}
            String key = "${" + textSet.getKey() + "}";
            if (value.contains(key)) {
                value = textSet.getValue();
            }
        }
        //模板未匹配到区域替换为空
        if (checkText(value)) {
            value = "";
        }
        return value;
    }

    /**
     * 为表格插入数据，行数不够添加新行
     *
     * @param table     需要插入数据的表格
     * @param tableList 插入数据集合
     */
    public static void insertTable(XWPFTable table, List<String[]> tableList) {
        //创建行,根据需要插入的数据添加新行，不处理表头
        for (int i = 1; i < tableList.size(); i++) {
            table.createRow();
        }
        //遍历表格插入数据
        List<XWPFTableRow> rows = table.getRows();
        for (int i = 1; i < rows.size(); i++) {
            XWPFTableRow newRow = table.getRow(i);
            List<XWPFTableCell> cells = newRow.getTableCells();
            for (int j = 0; j < cells.size(); j++) {
                XWPFTableCell cell = cells.get(j);
                cell.setText(tableList.get(i - 1)[j]);
            }
        }
    }

    // 给生成的表格设置样式
    public static void setCellWitchAndAlign(XWPFTableCell cell, String width, STVerticalJc.Enum typeEnum, STJc.Enum align){
        CTTc cttc = cell.getCTTc();
        CTTcPr ctPr = cttc.addNewTcPr();
        ctPr.addNewVAlign().setVal(typeEnum);
        cttc.getPList().get(0).addNewPPr().addNewJc().setVal(align);
        CTTblWidth ctTblWidth = (ctPr != null && ctPr.isSetTcW() && ctPr.getTcW()!=null &&ctPr.getTcW().getW()!=null) ? ctPr.getTcW(): ctPr.addNewTcW();
        if(StringUtils.isNotBlank(width)){
            ctTblWidth.setW(new BigInteger(width));
            ctTblWidth.setType(STTblWidth.DXA);

        }
    }
}

最终下载文件效果如图：



参考：https://www.cnblogs.com/bb1008/p/10605943.html

文章目录
POI简介
Excel 03版与07版区别
使用
基本写
基本读
读取不同类型的数据
公式计算

POI简介
基本功能

HSSF － 提供读写Microsoft Excel XLS格式文件的功能。
XSSF － 提供读写Microsoft Excel OOXML XLSX格式文件的功能。
SXSSF －XSSF高速版
HWPF － 提供读写Microsoft Word DOC格式文件的功能。
HSLF － 提供读写Microsoft PowerPoint格式文件的功能。
HDGF － 提供读Microsoft Visio格式文件的功能。
HPBF － 提供读Microsoft Publisher格式文件的功能。
HSMF － 提供读Microsoft Outlook格式文件的功能。

缺点: 会先将所有数据加载到内存,在进行操作,容易OOM
Excel 03版与07版区别

后缀名: 03为xls, 07为xlsx
最大行数: 03最多65536行,07理论无限

使用
        <!--xls 03-->
        <dependency>
             <groupId>org.apache.poi</groupId>
              <artifactId>poi</artifactId>
              <version>3.9</version>
         </dependency>
        <!--xlsx 07-->
          <dependency>
             <groupId>org.apache.poi</groupId>
             <artifactId>poi-ooxml</artifactId>
            <version>3.9</version>
         </dependency>
        <!--日期格式化工具 jdk8 time包吸取了此工具-->
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>2.10.1</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>


基本写
03与07版只是使用的对象不同,生成文件时指定的后缀名不同,其他一样
public void testWrite(){
    //1.创建一个工作簿 07版使用XSSFWorkbook
    Workbook workbook = new HSSFWorkbook();
    //2.创建一个工作表,不指定表名则为sheet1 sheet2 ....
    Sheet sheet=workbook.creatSheet("表一");
    //3.创建一行,程序中的0代表excel中的1
    Row row1 = sheet.createRow(0);
    //4.创建一个单元格,构成(1,1)单元格 
    Cell cell11= row1.createCell(0);
    //5.往单元格中写值
    cell.setCellValue("11")
    //(1,2)单元格
    Cell cell12= row1.createCell(1);
    cell.setCellValue("12")
    
    //6.生成一张表,03版xls后缀,07版xlsx后缀
    FileOutputStream fileOutputStream=new FileOutputStream(Path+"测试表.xls");
    workbook.write(fileOutputStream);
    fileOutputStream.close();
    //((SXSSFWorkbook)Workbook).dispose(); //使用SXSSFWorkbook时清除临时文件
}

HSSFWorkbook,写数据较快,但最多65536行
XSSFWorkbook,写数据时比HSSF慢容易OOM但数量无限制
SXSSFWorkbook为XSSFWorkbook的加速版

更换对象 new SXSSFWorkbook(内存中记录数);
默认将100条记录保存在内存中,如果超过就将最前面的数据写入临时文件.
写入完成后清除临时文件 SXSSFWorkbook.dispose();
但是 合并区域,注释等仍然只能存储在内存中

基本读
public void testWrite(){
    //1.获取文件流
    FileInputStream fileInputStream=new FileInputStream(Path+"测试表.xls");
    //2.读取一个工作簿 
    Workbook workbook = new HSSFWorkbook(fileInputStream);
    //3.读取一个工作表
    //workbook.getSheet("表一"); //根据名字获取
    Sheet sheet = workbook.getSheetAt(0); //根据下标获取
    //4.读取行
    Row row = sheet.getRow(0);
    //5.读取单元格
    Cell cell = row.getCell(0);
    //6.读取单元格的值,类型不同使用方法不同
    cell.getStringCellValue();
    fileInputStream.close();
}

读取不同类型的数据
HSSFCell枚举类中有所有的Excel数据类型
HSSFDateUtil.isCellDateFormatted(cell) 判断cell是否为Date日期类型
public void testWrite(){
    FileInputStream fileInputStream=new FileInputStream(Path+"测试表.xls");
    Workbook workbook = new HSSFWorkbook(fileInputStream);
    Sheet sheet = workbook.getSheetAt(0);
    
    //读取第一行 表头
    Row rowTitle = sheet.getRow(0);
    if(rowTitle!!=null){
        //获取一行中有多少列
        int cellCount=rowTitle.getPhysicalNumberOfCells(); 
        for(int cellNum=0;cellNum<cellCount;cellNum++){
            Cell cell = rowTitle.getCell(cellNum);
            if(cell!=null){
                String cellValue=cell.getStringCellValue();
                System.out.print(cellValue);
            }
        }
        System.out.println();
    }
    
    //读取表内容
    //获取表中总行数
    int rowCount=sheet.getPhysicalNumberOfRows(); 
    for(int rowNum=1;rowNum<rowCount;rowNum++){ //第0行已经获取过了从1开始
        Row rowData=sheet.getRow(rowNum);
        if(rowData!=null){
            //获取一行中有多少列
            int cellCount=rowData.getPhysicalNumberOfCells(); 
            for(int cellNum=0;cellNum<cellCount;cellNum++){
                Cell cell = rowData.getCell(cellNum);
                //匹配列的数据类型
                if(cell!=null){
                    //获取单元格中数据类型
                    int cellType=cell.getCellTpye();
                    String cellValue = "";
                    switch(cellType){
                        case HSSFCell.CELL_TYPE_STRING: //字符串
                            cellValue=cell.getStringCellValue();
                            break;
                        case HSSFCell.CELL_TYPE_BOOLEAN: //boolean
                            cellValue=String.valueOf(cell.getBOOLEANCellValue()); 
                            break;
                        case HSSFCell.CELL_TYPE_NUMERIC: //数字(分日期和普通数字)
                            if(HSSFDateUtil.isCellDateFormatted(cell)){ //日期
                                Date date=cell.getDateCellValue();
                                //格式化日期并赋值给cellValue
                                
                            }else{ //数字
                                //转换为字符串格式
                                cell.setCellType(HSSFCell.CELL_TYPE_STRING);
                                cellValue=cell.toString();
                            }
                            break;
                        case HSSFCell.CELL_TYPE_BLANK: //空
                            break;   
                        case HSSFCell.CELL_TYPE_ERROR: //数据类型错误
                            break;    
                    }
                   System.out.print(cellValue); 
                }
            }
        }
        System.out.println(); 
    }
    fileInputStream.close();
}


注意:数字分日期和普通数字两类

公式计算
FormulaEvaluator 公式计算类
CellValue 公式计算得到的值类,要格式化
FormulaEvaluator formulaEvaluator =new HSSFFormulaEvaluator((HSSFWorkbook)workbook);
int cellType=cell.getCellTpye();
switch(cellType){
    case HSSFCell.CELL_TYPE_FORMULA: //公式
        //获得公式,不获取公式也不影响计算
        String formula=cell.getCellFormula();
      
       //得到计算后的值
       CellValue eva = formulaEvaluator.evaluator(cell);
       //计算后的值要格式化
       String value= eva.formatAsString();
       break;
}

Apache的POI项目可以用来处理MS Office文档，codeplex上还有一个它的.net版本。POI项目可创建和维护操作各种基于OOXML和OLE2文件格式的Java API。大多数MS Office都是OLE2格式的。POI通HSMF子项目来支持Outlook，通过HDGF子项目来支持Visio，通过HPBF子项目来支持Publisher。
使用POI抽取Word简单示例：
要引入poi-3.7.jat和poi-scratchpad-3.7.ajr这两个包。
package msoffice;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import org.apache.poi.hwpf.HWPFDocument;
import org.apache.poi.hwpf.extractor.WordExtractor;
import org.apache.poi.hwpf.usermodel.CharacterRun;
import org.apache.poi.hwpf.usermodel.Paragraph;
import org.apache.poi.hwpf.usermodel.Range;
import org.apache.poi.hwpf.usermodel.Section;
public class Word {
// 直接抽取全部内容
public static String readDoc1(InputStream is) throws IOException {
WordExtractor extractor = new WordExtractor(is);
return extractor.getText();
}
//分章节Section、段落Paragraph、字符串CharacterRun抽取
public static void readDoc2(InputStream is) throws IOException {
HWPFDocument doc=new HWPFDocument(is);
Range r=doc.getRange();
for(int x=0;x
Section s=r.getSection(x);
for(int y=0;y
Paragraph p=s.getParagraph(y);
for(int z=0;z
CharacterRun run=p.getCharacterRun(z);
String text=run.text();
System.out.print(text);
}
}
}
}
public static void main(String[] args) {
File file = new File("/home/orisun/1.doc");
try {
FileInputStream fin = new FileInputStream(file);
String cont = readDoc1(fin);
System.out.println(cont);
fin.close();
fin = new FileInputStream(file);
readDoc2(fin);
fin.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
POI抽取PPT示例：
package msoffice;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import org.apache.poi.hslf.HSLFSlideShow;
import org.apache.poi.hslf.extractor.PowerPointExtractor;
import org.apache.poi.hslf.model.Slide;
import org.apache.poi.hslf.model.TextRun;
import org.apache.poi.hslf.usermodel.SlideShow;
public class PPT {
//直接抽取幻灯片的全部内容
public static String readDoc1(InputStream is) throws IOException{
PowerPointExtractor extractor=new PowerPointExtractor(is);
return extractor.getText();
}
//一张幻灯片一张幻灯片地读取
public static void readDoc2(InputStream is) throws IOException{
SlideShow ss=new SlideShow(new HSLFSlideShow(is));
Slide[] slides=ss.getSlides();
for(int i=0;i
//读取一张幻灯片的标题
String title=slides[i].getTitle();
System.out.println("标题:"+title);
//读取一张幻灯片的内容(包括标题)
TextRun[] runs=slides[i].getTextRuns();
for(int j=0;j
System.out.println(runs[j].getText());
}
}
}
public static void main(String[] args){
File file = new File("/home/orisun/2.ppt");
try{
FileInputStream fin=new FileInputStream(file);
String cont=readDoc1(fin);
System.out.println(cont);
fin.close();
fin=new FileInputStream(file);
readDoc2(fin);
fin.close();
}catch(IOException e){
e.printStackTrace();
}
}
}
Excel文件由多个Workbook组成，一个Workbook由多个Sheet组成。
POI抽取Excel简单示例：
package msoffice;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Iterator;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.extractor.ExcelExtractor;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.ss.usermodel.Row;
public class Excel {
//直接读取Excel的全部内容
public static String readDoc1(InputStream is)throws IOException{
HSSFWorkbook wb=new HSSFWorkbook(new POIFSFileSystem(is));
ExcelExtractor extractor=new ExcelExtractor(wb);
extractor.setFormulasNotResults(false);
extractor.setIncludeSheetNames(true);
return extractor.getText();
}
//读取时细化到Sheet、行甚至单元格
public static double getAvg(InputStream is)throws IOException{
HSSFWorkbook wb=new HSSFWorkbook(new POIFSFileSystem(is));
//获取第一张sheet
HSSFSheet sheet=wb.getSheetAt(0);
double molecule=0.0;
double denominator=0.0;
//按行遍历sheet
Iterator riter=sheet.rowIterator();
while(riter.hasNext()){
HSSFRow row=(HSSFRow)riter.next();
HSSFCell cell1=row.getCell(4);
HSSFCell cell2=row.getCell(4);
if(cell1.getCellType()!=HSSFCell.CELL_TYPE_NUMERIC){
System.err.println("数字类型错误！");
System.exit(-2);
}
if(cell2.getCellType()!=HSSFCell.CELL_TYPE_NUMERIC){
System.err.println("数字类型错误！");
System.exit(-2);
}
denominator+=Double.parseDouble(cell2.toString().trim());
molecule+=Double.parseDouble(cell2.toString().trim())*Float.parseFloat(cell1.toString().trim());
}
return molecule/denominator;
}
public static void main(String[] args){
File file = new File("/home/orisun/3.xls");
try{
FileInputStream fin=new FileInputStream(file);
String cont=readDoc1(fin);
System.out.println(cont);
fin.close();
fin=new FileInputStream(file);
System.out.println("加权平均分"+getAvg(fin));
fin.close();
}catch(IOException e){
e.printStackTrace();
}
}
}