• 使用Docx4j创建word文档

    原文标题：Creating Word documents with Docx4j

    原文链接：http://blog.iprofs.nl/2012/09/06/creating-word-documents-with-docx4j/

    原文作者：lvdpal

    发表时间：2012年9月6日

    注：第一次翻译博客；由于个人水平不高，而且英语仅有四级水平，所以错误很多，请大家见谅！！！只是国内关于docx4j的博客极少，感觉这篇入门博客挺不错，勉强翻译过来，希望对大家有所帮助。

    一段时间之前，我为一个想要在word和excel中作报表的客户提供服务。我以前的项目中生成过PDF文件和CSV文件，但从来没有处理过docx和xlsx文件。这些天了解到MS Office是基于XML的。我不禁想知道是否有一些库来帮助我生成这些文件。经过一番在线搜索，结果表明确实有：Docx4j。我开始去试用这个新库看它能做些什么。

    在官方网站上你可以了解到docx4j可以读取、更新、创建docx、xlsx和pptx文档。我只需要生成文档，所以我没有尝试读取和更新文档，但原理是一样的。Docx4j已经自带了不少示例程序，但我发现其中的一些例子同时展示了多样东西或者没有完全展示我需要了解的。所以有不少东西我不得不自己解决。幸运的是docx4j严格遵循Office Open XML标准，所以还不算太难。总而言这，我对这个库所提供的功能非常满意。

    在这个博客中我会展示一些我试用docx4j生成docx文档时创建的例子：

    一些提示

    在真正示例开始之前有几处提示。首先，在使用docx创建文档的时候，看看你使用word软件创建文档时生成的xml。当你使用一个ZIP压缩工具（例如7zip）打开一个docx文件时会找到这些XML文件。看一下都是些什么样的文件以及它们包含了哪些信息。通常情况下，如果你想得到什么东西，可以通过查看Word软件自己生成了什么而从中得到很多帮助。

    其次，去看一下 the Office Open Specification。

    现在让我们来看一些代码。

    用一些文本创建文档

    最简单的例子就是创建一个新word文档并向其中添加一些文本内容。

    运行下面代码：

    [java] view plaincopy
     
    1. WordprocessingMLPackage wordMLPackage = WordprocessingMLPackage.createPackage();  
    2. wordMLPackage.getMainDocumentPart().addParagraphOfText("Hello Word!");  
    3. wordMLPackage.save(new java.io.File("src/main/files/HelloWord1.docx"));  


    结果生成一个如下所示的文件：

    这里发生的就是一个word文档由一个带有文档部件的包组成。Docx4j提供一个创建包的工具方法（第1行）；然后你可以从这个包中获取主文档部件并向其中添加一个文本段落（第2行）；最后将这个包保存（第3行）。就这么简单，当然，如果你想做不仅仅是向文档中添加一些文本内容，那么你需要做更多的工作。

    添加带样式的文本

    然而即使添加带样式的文本也并不需要做过多的工作，不是向文档添加一个普通的文本段落，而是只需要添加一个带样式的段落。

     
    [java] view plain copy
     
    1. WordprocessingMLPackage wordMLPackage = WordprocessingMLPackage.createPackage();  
    2. wordMLPackage.getMainDocumentPart().addStyledParagraphOfText("Title", "Hello Word!");  
    3. wordMLPackage.getMainDocumentPart().addStyledParagraphOfText("Subtitle","This is a subtitle!");  
    4. wordMLPackage.save(new java.io.File("src/main/files/HelloWord2.docx"));  




    添加表格

    当我们想添加一个表格时，情况开始变得复杂一些。直到现在我们的代码都如此简单以至于不需要拆分到多个方法中，所以我仅仅只展示了代码中相关的数行。但这个示例我们需要第二个方法，所以我会展示整个类。

     
    [java] view plain copy
     
    1. public class AddingATable {  
    2.     private static WordprocessingMLPackage  wordMLPackage;  
    3.     private static ObjectFactory factory;  
    4.    
    5.     public static void main (String[] args) throws Docx4JException {  
    6.     wordMLPackage = WordprocessingMLPackage.createPackage();  
    7.     factory = Context.getWmlObjectFactory();  
    8.    
    9.     Tbl table = factory.createTbl();  
    10.     Tr tableRow = factory.createTr();  
    11.    
    12.     addTableCell(tableRow, "Field 1");  
    13.     addTableCell(tableRow, "Field 2");  
    14.    
    15.     table.getContent().add(tableRow);  
    16.    
    17.     wordMLPackage.getMainDocumentPart().addObject(table);  
    18.    
    19.     wordMLPackage.save(new java.io.File("src/main/files/HelloWord4.docx"));  
    20.     }  
    21.    
    22.     private static void addTableCell(Tr tableRow, String content) {  
    23.     Tc tableCell = factory.createTc();  
    24.     tableCell.getContent().add(  
    25.         wordMLPackage.getMainDocumentPart().createParagraphOfText(content));  
    26.     tableRow.getContent().add(tableCell);  
    27.     }  
    28. }  


    我们再一次创建了word包，只是这一次我们将其保存为一个属性，从而我们可以在第二个方法中访问它。然后我们同样创建了一个对象工厂（ObjectFactory），这是一个帮助我们创建本例中所需要的具体对象的工具类，例如表格、表格行及表格列等具体对象。

    然后我们创建了表格，创建了行并且在行中添加了两个单元格。最后我们将行添加到表格中，将表格添加到主文档部件并且将包保存。

    给表格添加边框

    现在我们拥有了一个表格，让我们给它添加一些边框。这需要深入研究一下表格的结构。

     
    [java] view plain copy
     
    1. public class TableWithBorders {  
    2.     private static WordprocessingMLPackage  wordMLPackage;  
    3.     private static ObjectFactory factory;  
    4.    
    5.     public static void main (String[] args) throws Docx4JException {  
    6.         wordMLPackage = WordprocessingMLPackage.createPackage();  
    7.         factory = Context.getWmlObjectFactory();  
    8.    
    9.         Tbl table = createTableWithContent();  
    10.    
    11.         addBorders(table);  
    12.    
    13.         wordMLPackage.getMainDocumentPart().addObject(table);  
    14.         wordMLPackage.save(new java.io.File(  
    15.             "src/main/files/HelloWord5.docx") );  
    16.     }  
    17.    
    18.     private static void addBorders(Tbl table) {  
    19.         table.setTblPr(new TblPr());  
    20.         CTBorder border = new CTBorder();  
    21.         border.setColor("auto");  
    22.         tborder.setSz(new BigInteger("4"));  
    23.         border.setSpace(new BigInteger("0"));  
    24.         border.setVal(STBorder.SINGLE);  
    25.    
    26.         TblBorders borders = new TblBorders();  
    27.         borders.setBottom(border);  
    28.         borders.setLeft(border);  
    29.         borders.setRight(border);  
    30.         borders.setTop(border);  
    31.         borders.setInsideH(border);  
    32.         borders.setInsideV(border);  
    33.         table.getTblPr().setTblBorders(borders);  
    34.     }  
    35.    
    36.     private static Tbl createTableWithContent() {  
    37.         Tbl table = factory.createTbl();  
    38.         Tr tableRow = factory.createTr();  
    39.    
    40.         addTableCell(tableRow, "Field 1");  
    41.         addTableCell(tableRow, "Field 2");  
    42.    
    43.         table.getContent().add(tableRow);  
    44.         return table;  
    45.     }  
    46.    
    47.     private static void addTableCell(Tr tableRow, String content) {  
    48.         Tc tableCell = factory.createTc();  
    49.         tableCell.getContent().add(  
    50.         wordMLPackage.getMainDocumentPart().  
    51.             createParagraphOfText(content));  
    52.         tableRow.getContent().add(tableCell);  
    53.     }  
    54. }  


    首先我们创建了一个默认颜色（黑色）、粗细尺寸为4、间距为0的单线边框的边框组件（Border component），然后边框被应用到表格的四周以及表格内部水平和垂直的边框。随后我们将边框应用到表格；所有其它的代码与前面的示例一样。

    给表格添加样式

    接下来的问题--给表格添加样式让我忙活了一阵子，我们的客户想要在表格中使用粗体文本并且需要多种大小的字体。

    这个示例程序有点复杂，注释和代码交织在一起。

     
    [java] view plain copy
     
    1. public class TableWithStyledContent {  
    2.     private static WordprocessingMLPackage  wordMLPackage;  
    3.     private static ObjectFactory factory;  
    4.    
    5.     /** 
    6.       *  跟前面的做的一样, 我们再一次创建了一个表格, 并添加了三个单元格, 其中有两个 
    7.       *  单元带有样式. 在新方法中我们传进表格行, 单元格内容, 是否为粗体及字体大小作 
    8.       *  为参数. 你需要注意, 因为the Office Open specification规范定义这个属性是半个 
    9.       *  点(half-point)大小, 因此字体大小需要是你想在Word中显示大小的两倍,  
    10.      */  
    11.     public static void main (String[] args) throws Docx4JException {  
    12.         wordMLPackage = WordprocessingMLPackage.createPackage();  
    13.         factory = Context.getWmlObjectFactory();  
    14.    
    15.         Tbl table = factory.createTbl();  
    16.         Tr tableRow = factory.createTr();  
    17.    
    18.         addRegularTableCell(tableRow, "Normal text");  
    19.         addStyledTableCell(tableRow, "Bold text", true, null);  
    20.         addStyledTableCell(tableRow, "Bold large text", true, "40");  
    21.    
    22.         table.getContent().add(tableRow);  
    23.         addBorders(table);  
    24.    
    25.         wordMLPackage.getMainDocumentPart().addObject(table);  
    26.         wordMLPackage.save(new java.io.File("src/main/files/HelloWord6.docx") );  
    27.     }  
    28.    
    29.     /** 
    30.      *  本方法创建单元格, 添加样式后添加到表格行中 
    31.      */  
    32.     private static void addStyledTableCell(Tr tableRow, String content,  
    33.                         boolean bold, String fontSize) {  
    34.         Tc tableCell = factory.createTc();  
    35.         addStyling(tableCell, content, bold, fontSize);  
    36.         tableRow.getContent().add(tableCell);  
    37.     }  
    38.    
    39.     /** 
    40.      *  这里我们添加实际的样式信息, 首先创建一个段落, 然后创建以单元格内容作为值的文本对象;  
    41.      *  第三步, 创建一个被称为运行块的对象, 它是一块或多块拥有共同属性的文本的容器, 并将文本对象添加 
    42.      *  到其中. 随后我们将运行块R添加到段落内容中. 
    43.      *  直到现在我们所做的还没有添加任何样式, 为了达到目标, 我们创建运行块属性对象并给它添加各种样式. 
    44.      *  这些运行块的属性随后被添加到运行块. 最后段落被添加到表格的单元格中. 
    45.      */  
    46.     private static void addStyling(Tc tableCell, String content, boolean bold, String fontSize) {  
    47.         P paragraph = factory.createP();  
    48.    
    49.         Text text = factory.createText();  
    50.         text.setValue(content);  
    51.    
    52.         R run = factory.createR();  
    53.         run.getContent().add(text);  
    54.    
    55.         paragraph.getContent().add(run);  
    56.    
    57.         RPr runProperties = factory.createRPr();  
    58.         if (bold) {  
    59.             addBoldStyle(runProperties);  
    60.         }  
    61.    
    62.         if (fontSize != null && !fontSize.isEmpty()) {  
    63.             setFontSize(runProperties, fontSize);  
    64.         }  
    65.    
    66.         run.setRPr(runProperties);  
    67.    
    68.         tableCell.getContent().add(paragraph);  
    69.     }  
    70.    
    71.     /** 
    72.      *  本方法为可运行块添加字体大小信息. 首先创建一个"半点"尺码对象, 然后设置fontSize 
    73.      *  参数作为该对象的值, 最后我们分别设置sz和szCs的字体大小. 
    74.      *  Finally we'll set the non-complex and complex script font sizes, sz and szCs respectively. 
    75.      */  
    76.     private static void setFontSize(RPr runProperties, String fontSize) {  
    77.         HpsMeasure size = new HpsMeasure();  
    78.         size.setVal(new BigInteger(fontSize));  
    79.         runProperties.setSz(size);  
    80.         runProperties.setSzCs(size);  
    81.     }  
    82.    
    83.     /** 
    84.      *  本方法给可运行块属性添加粗体属性. BooleanDefaultTrue是设置b属性的Docx4j对象, 严格 
    85.      *  来说我们不需要将值设置为true, 因为这是它的默认值. 
    86.      */  
    87.     private static void addBoldStyle(RPr runProperties) {  
    88.         BooleanDefaultTrue b = new BooleanDefaultTrue();  
    89.         b.setVal(true);  
    90.         runProperties.setB(b);  
    91.     }  
    92.    
    93.     /** 
    94.      *  本方法像前面例子中一样再一次创建了普通的单元格 
    95.      */  
    96.     private static void addRegularTableCell(Tr tableRow, String content) {  
    97.         Tc tableCell = factory.createTc();  
    98.         tableCell.getContent().add(  
    99.             wordMLPackage.getMainDocumentPart().createParagraphOfText(  
    100.                 content));  
    101.         tableRow.getContent().add(tableCell);  
    102.     }  
    103.    
    104.     /** 
    105.      *  本方法给表格添加边框 
    106.      */  
    107.     private static void addBorders(Tbl table) {  
    108.         table.setTblPr(new TblPr());  
    109.         CTBorder border = new CTBorder();  
    110.         border.setColor("auto");  
    111.         border.setSz(new BigInteger("4"));  
    112.         border.setSpace(new BigInteger("0"));  
    113.         border.setVal(STBorder.SINGLE);  
    114.    
    115.         TblBorders borders = new TblBorders();  
    116.         borders.setBottom(border);  
    117.         borders.setLeft(border);  
    118.         borders.setRight(border);  
    119.         borders.setTop(border);  
    120.         borders.setInsideH(border);  
    121.         borders.setInsideV(border);  
    122.         table.getTblPr().setTblBorders(borders);  
    123.     }  
    124. }  

    纵向合并单元格

    有时你想要一个三列的表格，其中第一列将多行组合在一起。

     
    [java] view plain copy
     
    1. package com.zyh.sample.docx4j;  
    2.   
    3. public class TableWithMergedCells {  
    4.     private static WordprocessingMLPackage  wordMLPackage;  
    5.     private static ObjectFactory factory;  
    6.    
    7.     /** 
    8.      *  创建一个带边框的表格并添加四个带内容的行, 然后将表格添加到文档并保存 
    9.      */  
    10.     public static void main (String[] args) throws Docx4JException {  
    11.         wordMLPackage = WordprocessingMLPackage.createPackage();  
    12.         factory = Context.getWmlObjectFactory();  
    13.    
    14.         Tbl table = factory.createTbl();  
    15.         addBorders(table);  
    16.    
    17.         addTableRowWithMergedCells("Heading 1", "Heading 1.1",  
    18.             "Field 1", table);  
    19.         addTableRowWithMergedCells(null, "Heading 1.2", "Field 2", table);  
    20.    
    21.         addTableRowWithMergedCells("Heading 2", "Heading 2.1",  
    22.             "Field 3", table);  
    23.         addTableRowWithMergedCells(null, "Heading 2.2", "Field 4", table);  
    24.    
    25.         wordMLPackage.getMainDocumentPart().addObject(table);  
    26.         wordMLPackage.save(new java.io.File(  
    27.             "src/main/files/HelloWord9.docx") );  
    28.     }  
    29.    
    30.     /** 
    31.      *  本方法创建一行, 并向其中添加合并列, 然后添加再两个普通的单元格. 随后将该行添加到表格 
    32.      */  
    33.     private static void addTableRowWithMergedCells(String mergedContent,  
    34.             String field1Content, String field2Content, Tbl table) {  
    35.         Tr tableRow1 = factory.createTr();  
    36.    
    37.         addMergedColumn(tableRow1, mergedContent);  
    38.    
    39.         addTableCell(tableRow1, field1Content);  
    40.         addTableCell(tableRow1, field2Content);  
    41.    
    42.         table.getContent().add(tableRow1);  
    43.     }  
    44.    
    45.     /** 
    46.      *  本方法添加一个合并了其它行单元格的列单元格. 如果传进来的内容是null, 传空字符串和一个为null的合并值. 
    47.      */  
    48.     private static void addMergedColumn(Tr row, String content) {  
    49.         if (content == null) {  
    50.             addMergedCell(row, "", null);  
    51.         } else {  
    52.             addMergedCell(row, content, "restart");  
    53.         }  
    54.     }  
    55.    
    56.     /** 
    57.      *  我们创建一个单元格和单元格属性对象. 
    58.      *  也创建了一个纵向合并对象. 如果合并值不为null, 将它设置到合并对象中. 然后将该对象添加到 
    59.      *  单元格属性并将属性添加到单元格中. 最后设置单元格内容并将单元格添加到行中. 
    60.      *   
    61.      *  如果合并值为'restart', 表明要开始一个新行. 如果为null, 继续按前面的行处理, 也就是合并单元格. 
    62.      */  
    63.     private static void addMergedCell(Tr row, String content, String vMergeVal) {  
    64.         Tc tableCell = factory.createTc();  
    65.         TcPr tableCellProperties = new TcPr();  
    66.    
    67.         VMerge merge = new VMerge();  
    68.         if(vMergeVal != null){  
    69.             merge.setVal(vMergeVal);  
    70.         }  
    71.         tableCellProperties.setVMerge(merge);  
    72.    
    73.         tableCell.setTcPr(tableCellProperties);  
    74.         if(content != null) {  
    75.                 tableCell.getContent().add(  
    76.                 wordMLPackage.getMainDocumentPart().  
    77.                     createParagraphOfText(content));  
    78.         }  
    79.    
    80.         row.getContent().add(tableCell);  
    81.     }  
    82.    
    83.     /** 
    84.      *  本方法为给定的行添加一个单元格, 并以给定的段落作为内容 
    85.      */  
    86.     private static void addTableCell(Tr tr, String content) {  
    87.         Tc tc1 = factory.createTc();  
    88.         tc1.getContent().add(  
    89.             wordMLPackage.getMainDocumentPart().createParagraphOfText(content));  
    90.         tr.getContent().add(tc1);  
    91.     }  
    92.    
    93.     /** 
    94.      *  本方法为表格添加边框 
    95.      */  
    96.     private static void addBorders(Tbl table) {  
    97.         table.setTblPr(new TblPr());  
    98.         CTBorder border = new CTBorder();  
    99.         border.setColor("auto");  
    100.         border.setSz(new BigInteger("4"));  
    101.         border.setSpace(new BigInteger("0"));  
    102.         border.setVal(STBorder.SINGLE);  
    103.    
    104.         TblBorders borders = new TblBorders();  
    105.         borders.setBottom(border);  
    106.         borders.setLeft(border);  
    107.         borders.setRight(border);  
    108.         borders.setTop(border);  
    109.         borders.setInsideH(border);  
    110.         borders.setInsideV(border);  
    111.         table.getTblPr().setTblBorders(borders);  
    112.     }  
    113. }  

    为表格设置列宽

    作为本博客的最后一个示例, 我会展示怎样为表格设置列宽。

     
    [java] view plain copy
     
    1. public class SettingColumnWidthForTable {  
    2.     private static WordprocessingMLPackage  wordMLPackage;  
    3.     private static ObjectFactory factory;  
    4.    
    5.     /** 
    6.      *  创建一个带边框的表格并添加一行. 然后添加两个带内容的单元格并给定宽度. 
    7.      */  
    8.     public static void main (String[] args) throws Docx4JException {  
    9.         wordMLPackage = WordprocessingMLPackage.createPackage();  
    10.         factory = Context.getWmlObjectFactory();  
    11.    
    12.         Tbl table = factory.createTbl();  
    13.         addBorders(table);  
    14.    
    15.         Tr tr = factory.createTr();  
    16.    
    17.         addTableCellWithWidth(tr, "Field 1", 2500);  
    18.         addTableCellWithWidth(tr, "Field 2", 0);  
    19.    
    20.         table.getContent().add(tr);  
    21.    
    22.         wordMLPackage.getMainDocumentPart().addObject(table);  
    23.         wordMLPackage.save(new java.io.File(  
    24.             "src/main/files/HelloWord13.docx") );  
    25.     }  
    26.    
    27.     /** 
    28.      *  本方法创建一个单元格并将给定的内容添加进去. 
    29.      *  如果给定的宽度大于0, 将这个宽度设置到单元格. 
    30.      *  最后, 将单元格添加到行中. 
    31.      */  
    32.     private static void addTableCellWithWidth(Tr row, String content, int width){  
    33.         Tc tableCell = factory.createTc();  
    34.         tableCell.getContent().add(  
    35.             wordMLPackage.getMainDocumentPart().createParagraphOfText(  
    36.                 content));  
    37.    
    38.         if (width > 0) {  
    39.             setCellWidth(tableCell, width);  
    40.         }  
    41.         row.getContent().add(tableCell);  
    42.     }  
    43.    
    44.     /** 
    45.      *  本方法创建一个单元格属性集对象和一个表格宽度对象. 将给定的宽度设置到宽度对象然后将其添加到 
    46.      *  属性集对象. 最后将属性集对象设置到单元格中. 
    47.      */  
    48.     private static void setCellWidth(Tc tableCell, int width) {  
    49.         TcPr tableCellProperties = new TcPr();  
    50.         TblWidth tableWidth = new TblWidth();  
    51.         tableWidth.setW(BigInteger.valueOf(width));  
    52.         tableCellProperties.setTcW(tableWidth);  
    53.         tableCell.setTcPr(tableCellProperties);  
    54.     }  
    55.    
    56.     /** 
    57.      *  本方法为表格添加边框 
    58.      */  
    59.     private static void addBorders(Tbl table) {  
    60.         table.setTblPr(new TblPr());  
    61.         CTBorder border = new CTBorder();  
    62.         border.setColor("auto");  
    63.         border.setSz(new BigInteger("4"));  
    64.         border.setSpace(new BigInteger("0"));  
    65.         border.setVal(STBorder.SINGLE);  
    66.    
    67.         TblBorders borders = new TblBorders();  
    68.         borders.setBottom(border);  
    69.         borders.setLeft(border);  
    70.         borders.setRight(border);  
    71.         borders.setTop(border);  
    72.         borders.setInsideH(border);  
    73.         borders.setInsideV(border);  
    74.         table.getTblPr().setTblBorders(borders);  
    75.     }  
    76. }  

    总结

    在这篇文章中，我展示了如何创建一个文档、如何为其应用样式以及添加带样式的表格。以后的文章我会展示更多的关于docx文档的示例（比如添加目录、添加图片、添加页眉和页脚等）以及一些关于xlsx文档的示例。
  • 相关阅读:
    msp430入门学习43
    msp430入门学习42
    msp430入门学习41
    msp430入门学习40
    msp430入门学习37
    msp430入门学习36
    msp430入门学习35
    JAVA三大特性之三——多态
    JAVA三大特性之二——继承
    JAVA三大特性之一——封装
  • 原文地址：https://www.cnblogs.com/cxxjohnson/p/7886275.html
Copyright © 2020-2023  润新知