java docx4j 工具和xdocreport工具创建PDF或者word报表

基础技术调查参考网站：

https://angelozerr.wordpress.com/2012/12/06/how-to-convert-docxodt-to-pdfhtml-with-java/  ---- docx转化为pdf工具的介绍和比较分析

https://github.com/opensagres/xdocreport/wiki/XDocReport103         --XDocReport maven依赖引用介绍

https://stackoverflow.com/questions/38913283/broken-pdf-after-conversion-with-xdocreport      ---示例

https://www.programcreek.com/java-api-examples/index.php?api=org.docx4j.openpackaging.packages.WordprocessingMLPackage   ---docx4j 示例

https://www.programcreek.com/java-api-examples/index.php?source_dir=wte4j-master/wte4j-core/src/main/java/org/wte4j/impl/word/Docx4JWordTemplate.java

http://www.javafind.net/gate.jsp?q=/library/162/docx4j-3.1.0-javadoc/org/docx4j/openpackaging/parts/WordprocessingML/MainDocumentPart.html   --------docx4j  api  该网站需要才可访问

www.javafind.net/gate.jsp?q=/library/162/docx4j-3.1.0-javadoc/org/docx4j/convert/out/pdf/viaXSLFO/PdfSettings.html   

首先创建一个maven工程

在pom文件中配置依赖

		
			fr.opensagres.xdocreport
			fr.opensagres.xdocreport.converter.docx.xwpf
			1.0.6
		
		
			fr.opensagres.xdocreport
			org.apache.poi.xwpf.converter.pdf
			1.0.6
		
		
			com.itextpdf
			itextpdf
			5.4.2
		

工具类 CreateWordUtils

package cn.sh.cx.ce.maint.biz.pdf.utils;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.StringWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;

import javax.xml.bind.JAXBElement;

import org.apache.commons.lang.StringUtils;
import org.apache.poi.util.IOUtils;
import org.apache.poi.xwpf.converter.pdf.PdfConverter;
import org.apache.poi.xwpf.converter.pdf.PdfOptions;
import org.apache.poi.xwpf.usermodel.XWPFDocument;
import org.docx4j.Docx4J;
import org.docx4j.TextUtils;
import org.docx4j.convert.out.FOSettings;
import org.docx4j.dml.wordprocessingDrawing.Inline;
import org.docx4j.finders.RangeFinder;
import org.docx4j.fonts.BestMatchingMapper;
import org.docx4j.fonts.Mapper;
import org.docx4j.fonts.PhysicalFonts;
import org.docx4j.model.properties.table.tr.TrHeight;
import org.docx4j.model.structure.SectionWrapper;
import org.docx4j.openpackaging.exceptions.Docx4JException;
import org.docx4j.openpackaging.exceptions.InvalidFormatException;
import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
import org.docx4j.openpackaging.parts.WordprocessingML.BinaryPartAbstractImage;
import org.docx4j.openpackaging.parts.WordprocessingML.FooterPart;
import org.docx4j.openpackaging.parts.WordprocessingML.MainDocumentPart;
import org.docx4j.relationships.Relationship;
import org.docx4j.utils.BufferUtil;
import org.docx4j.wml.BooleanDefaultTrue;
import org.docx4j.wml.Br;
import org.docx4j.wml.CTBookmark;
import org.docx4j.wml.CTBorder;
import org.docx4j.wml.CTHeight;
import org.docx4j.wml.CTShd;
import org.docx4j.wml.CTVerticalJc;
import org.docx4j.wml.Color;
import org.docx4j.wml.ContentAccessor;
import org.docx4j.wml.Drawing;
import org.docx4j.wml.FldChar;
import org.docx4j.wml.FooterReference;
import org.docx4j.wml.Ftr;
import org.docx4j.wml.HdrFtrRef;
import org.docx4j.wml.HpsMeasure;
import org.docx4j.wml.Jc;
import org.docx4j.wml.JcEnumeration;
import org.docx4j.wml.ObjectFactory;
import org.docx4j.wml.P;
import org.docx4j.wml.PPr;
import org.docx4j.wml.PPrBase.Ind;
import org.docx4j.wml.PPrBase.PBdr;
import org.docx4j.wml.PPrBase.Spacing;
import org.docx4j.wml.R;
import org.docx4j.wml.RFonts;
import org.docx4j.wml.RPr;
import org.docx4j.wml.STBorder;
import org.docx4j.wml.STBrType;
import org.docx4j.wml.STFldCharType;
import org.docx4j.wml.STHint;
import org.docx4j.wml.STLineSpacingRule;
import org.docx4j.wml.STVerticalJc;
import org.docx4j.wml.SectPr;
import org.docx4j.wml.SectPr.PgMar;
import org.docx4j.wml.Tbl;
import org.docx4j.wml.TblBorders;
import org.docx4j.wml.TblGrid;
import org.docx4j.wml.TblGridCol;
import org.docx4j.wml.TblPr;
import org.docx4j.wml.TblWidth;
import org.docx4j.wml.Tc;
import org.docx4j.wml.TcPr;
import org.docx4j.wml.TcPrInner.GridSpan;
import org.docx4j.wml.TcPrInner.HMerge;
import org.docx4j.wml.TcPrInner.TcBorders;
import org.docx4j.wml.TcPrInner.VMerge;
import org.docx4j.wml.Text;
import org.docx4j.wml.TextDirection;
import org.docx4j.wml.Tr;
import org.docx4j.wml.TrPr;
import org.docx4j.wml.U;
import org.docx4j.wml.UnderlineEnumeration;
public class CreateWordUtils {

    /**
     * 创建word文件创建对象. 

     * 
     * @return 创建word对象
     * @throws Exception
     * @author zhouweiwei
     */
    public static WordprocessingMLPackage createWordprocessingMLPackage() throws Exception {
        return WordprocessingMLPackage.createPackage();
    }

    /**
     * 保存word文档的方法. 

     * 
     * @param wordPackage 创建文档的对象
     * @param file 保存路径
     * @throws Exception
     * @author zhouweiwei
     */
    public static void saveWordPackage(WordprocessingMLPackage wordPackage, File file) throws Exception {
        wordPackage.save(file);

    }

    public static void saveWordPackage(WordprocessingMLPackage wordPackage, OutputStream outputStream) throws Exception {
        wordPackage.save(outputStream);

    }

    /**
     * 设置段落间的间隙
     * 
     * @param jcEnumeration
     *            对齐方式
     * @param isSpace
     *            是否设置段前段后值
     * @param before
     *            段前磅数
     * @param after
     *            段后磅数
     * @param beforeLines
     *            段前行数
     * @param afterLines
     *            段后行数
     * @param isLine
     *            是否设置行距
     * @param lineValue
     *            行距值
     * @param sTLineSpacingRule
     *            自动auto 固定exact 最小 atLeast
     * @author zhouweiwei
     */
    public static void setParagraphSpacing(ObjectFactory factory, P p, JcEnumeration jcEnumeration, boolean isSpace,
            String before, String after, String beforeLines, String afterLines, boolean isLine, String lineValue,
            STLineSpacingRule sTLineSpacingRule) {
        PPr pPr = p.getPPr();
        if (pPr == null) {
            pPr = factory.createPPr();
        }
        Jc jc = pPr.getJc();
        if (jc == null) {
            jc = new Jc();
        }
        jc.setVal(jcEnumeration);
        pPr.setJc(jc);

        Spacing spacing = new Spacing();
        if (isSpace) {
            if (before != null) {
                // 段前磅数
                spacing.setBefore(new BigInteger(before));
            }
            if (after != null) {
                // 段后磅数
                spacing.setAfter(new BigInteger(after));
            }
            if (beforeLines != null) {
                // 段前行数
                spacing.setBeforeLines(new BigInteger(beforeLines));
            }
            if (afterLines != null) {
                // 段后行数
                spacing.setAfterLines(new BigInteger(afterLines));
            }
        }
        if (isLine) {
            if (lineValue != null) {
                spacing.setLine(new BigInteger(lineValue));
            }
            spacing.setLineRule(sTLineSpacingRule);
        }
        pPr.setSpacing(spacing);
        p.setPPr(pPr);
    }

    /**
     * 设置缩进 同时设置为true,则为悬挂缩进
     * 
     * @param factory
     *            工厂对象
     * @param p
     *            段落参数
     * @param jcEnumeration
     *            字体水平样式
     * @param firstLine
     *            是否设置首行缩进
     * @param firstLineValue
     *            设置首行缩进值
     * @param hangLine
     *            判断是否设悬挂
     * @param hangValue
     *            设置悬挂值
     * @author zhouweiwei
     */
    public static void setParagraphInd(ObjectFactory factory, P p, JcEnumeration jcEnumeration, boolean firstLine,
            String firstLineValue, boolean hangLine, String hangValue) {
        PPr pPr = p.getPPr();
        if (pPr == null) {
            pPr = factory.createPPr();
        }
        Jc jc = pPr.getJc();
        if (jc == null) {
            jc = new Jc();
        }
        jc.setVal(jcEnumeration);
        pPr.setJc(jc);

        Ind ind = pPr.getInd();
        if (ind == null) {
            ind = new Ind();
        }
        if (firstLine) {
            if (firstLineValue != null) {
                ind.setFirstLineChars(new BigInteger(firstLineValue));
            }
        }
        if (hangLine) {
            if (hangValue != null) {
                ind.setHangingChars(new BigInteger(hangValue));
            }
        }
        pPr.setInd(ind);
        p.setPPr(pPr);
    }

    /**
     * 创建字体样式
     * 
     * @param isBlod
     *            粗体
     * @param isUnderLine
     *            下划线
     * @param isItalic
     *            斜体
     * @param isStrike
     *            删除线
     * @author zhouweiwei
     */
    public static RPr getRPr(ObjectFactory factory, String fontFamily, String colorVal, String fontSize, STHint sTHint,
            boolean isBlod, boolean isUnderLine, boolean isItalic, boolean isStrike) {
        RPr rPr = factory.createRPr();
        RFonts rf = new RFonts();
        rf.setHint(sTHint);
        rf.setAscii(fontFamily);
        rf.setHAnsi(fontFamily);
        rf.setEastAsia(fontFamily);
        rPr.setRFonts(rf);

        BooleanDefaultTrue bdt = factory.createBooleanDefaultTrue();
        rPr.setBCs(bdt);
        if (isBlod) {
            rPr.setB(bdt);
        }
        if (isItalic) {
            rPr.setI(bdt);
        }
        if (isStrike) {
            rPr.setStrike(bdt);
        }
        if (isUnderLine) {
            U underline = new U();
            underline.setVal(UnderlineEnumeration.SINGLE);
            rPr.setU(underline);
        }

        Color color = new Color();
        color.setVal(colorVal);
        rPr.setColor(color);

        HpsMeasure sz = new HpsMeasure();
        sz.setVal(new BigInteger(fontSize));
        rPr.setSz(sz);
        rPr.setSzCs(sz);
        return rPr;
    }

    /**
     * 段落中插入文字和图片
     * 
     * @param wordMLPackage
     *            word文件对象
     * @param factory
     *            工厂对象
     * @param p
     *            段落对象
     * @param fileName
     *            文件名称
     * @param content
     *            文字内容
     * @param bytes
     *            字节流对象
     * @param jcEnumeration
     *            在段落中的位置
     * @return 段落对象P
     * @throws Exception
     * @author zhouweiwei
     * 
     */
    public static P createImageParagraph(WordprocessingMLPackage wordMLPackage, ObjectFactory factory, P p,
            String fileName, String content, byte[] bytes, JcEnumeration jcEnumeration) throws Exception {
        BinaryPartAbstractImage imagePart = BinaryPartAbstractImage.createImagePart(wordMLPackage, bytes);
        // /imagePart.setImageInfo(imageInfo);
        Inline inline = imagePart.createImageInline(fileName, "这是图片", 0, 1, false);
        Text text = factory.createText();
        text.setValue(content);
        text.setSpace("preserve");
        R run = factory.createR();
        p.getContent().add(run);
        run.getContent().add(text);
        Drawing drawing = factory.createDrawing();

        run.getContent().add(drawing);
        drawing.getAnchorOrInline().add(inline);
        PPr pPr = p.getPPr();
        if (pPr == null) {
            pPr = factory.createPPr();
        }
        Jc jc = pPr.getJc();
        if (jc == null) {
            jc = new Jc();
        }
        jc.setVal(jcEnumeration);
        pPr.setJc(jc);
        p.setPPr(pPr);

        setParagraphSpacing(factory, p, jcEnumeration, true, "0", "0", null, null, true, "240", STLineSpacingRule.AUTO);
        return p;
    }

    /**
     * 段落添加图片
     * 
     * @param wordMLPackage
     *            word文件对象
     * @param factory
     *            工厂对象
     * @param bytes
     *            字节流对象
     * @param filenameHint
     *            文件名称
     * @param altText
     *            图片说明
     * @param id1
     *            图片在文档中的在文档中的唯一标识
     * @param id2
     *            图片在文档中的在文档中其他的唯一标识
     * @param isUnderLine
     * @param underLineSize
     *            是否设置下划线
     * @param jcEnumeration
     *            在段落中的位置
     * @return 段落对象 P
     * @throws Exception
     * @author zhouweiwei
     */
    public static P newImage(WordprocessingMLPackage wordMLPackage, ObjectFactory factory, byte[] bytes,
            String filenameHint, String altText, int id1, int id2, boolean isUnderLine, String underLineSize,
            JcEnumeration jcEnumeration) throws Exception {
        BinaryPartAbstractImage imagePart = BinaryPartAbstractImage.createImagePart(wordMLPackage, bytes);
        Inline inline = imagePart.createImageInline(filenameHint, altText, id1, id2, false);
        P p = factory.createP();
        R run = factory.createR();
        p.getContent().add(run);
        Drawing drawing = factory.createDrawing();
        run.getContent().add(drawing);
        drawing.getAnchorOrInline().add(inline);
        PPr pPr = p.getPPr();
        if (pPr == null) {
            pPr = factory.createPPr();
        }
        Jc jc = pPr.getJc();
        if (jc == null) {
            jc = new Jc();
        }
        jc.setVal(jcEnumeration);
        pPr.setJc(jc);
        p.setPPr(pPr);

        if (isUnderLine) {
            PBdr pBdr = pPr.getPBdr();
            if (pBdr == null) {
                pBdr = factory.createPPrBasePBdr();
            }
            CTBorder value = new CTBorder();
            value.setVal(STBorder.SINGLE);
            value.setColor("000000");
            value.setSpace(new BigInteger("0"));
            value.setSz(new BigInteger(underLineSize));
            pBdr.setBetween(value);
            pPr.setPBdr(pBdr);
        }
        setParagraphSpacing(factory, p, jcEnumeration, true, "0", "0", null, null, true, "240", STLineSpacingRule.AUTO);
        return p;
    }

    /**
     * 分页
     * 
     * @param wordMLPackage
     *            文档对象
     * @param factory
     *            工厂对象
     * @param sTBrType
     *            分页类型
     * @author zhouweiwei
     */
    public static void addPageBreak(WordprocessingMLPackage wordMLPackage, ObjectFactory factory, STBrType sTBrType) {
        MainDocumentPart documentPart = wordMLPackage.getMainDocumentPart();
        Br breakObj = new Br();
        breakObj.setType(sTBrType);
        P paragraph = factory.createP();
        paragraph.getContent().add(breakObj);
        documentPart.addObject(paragraph);
    }

    /**
     * 得到页面宽度
     * 
     * @param wordPackage
     * @return
     * @throws Exception
     * @author zhouweiwei
     */
    public static int getWritableWidth(WordprocessingMLPackage wordPackage) throws Exception {
        return wordPackage.getDocumentModel().getSections().get(0).getPageDimensions().getWritableWidthTwips();

    }

    /**
     * 设置word文档内容里页面的页边距
     * 此处设置的为A4
     * 
     * @param wordPackage 文档对象
     * @throws Exception 异常
     * @author zhouweiwei
     */
    public static void setWordPage(WordprocessingMLPackage wordPackage) throws Exception {

        PgMar pgSz = new PgMar();
        pgSz.setLeft(new BigInteger("851"));
        pgSz.setRight(new BigInteger("851"));
        pgSz.setTop(new BigInteger("851"));
        pgSz.setBottom(new BigInteger("851"));
        // 设置页面的宽度
        List sections = wordPackage.getDocumentModel().getSections();
        SectPr sectPr = sections.get(sections.size() - 1).getSectPr();
        sectPr.setPgMar(pgSz);

    }

    /**
     * 设置整列宽度
     * 
     * @param tableWidthPercent
     *            表格占页面宽度百分比
     * @param widthPercent
     *            各列百分比
     * @author zhouweiwei
     */
    public static void setTableGridCol(WordprocessingMLPackage wordPackage, ObjectFactory factory, Tbl table,
            double tableWidthPercent, double[] widthPercent) throws Exception {

        int width = getWritableWidth(wordPackage);
        int tableWidth = (int) (width * tableWidthPercent / 100);
        TblGrid tblGrid = factory.createTblGrid();
        for (int i = 0; i < widthPercent.length; i++) {
            TblGridCol gridCol = factory.createTblGridCol();
            gridCol.setW(BigInteger.valueOf((long) (tableWidth * widthPercent[i] / 100)));
            tblGrid.getGridCol().add(gridCol);
        }
        table.setTblGrid(tblGrid);

        TblPr tblPr = table.getTblPr();
        if (tblPr == null) {
            tblPr = factory.createTblPr();
        }
        TblWidth tblWidth = new TblWidth();
        tblWidth.setType("dxa");// 这一行是必须的,不自己设置宽度默认是auto
        tblWidth.setW(new BigInteger(tableWidth + ""));
        tblPr.setTblW(tblWidth);
        table.setTblPr(tblPr);
    }

    /**
     * 表格水平对齐方式
     * 
     * @param factory
     *            工厂对象
     * @param table
     *            表格对象
     * @param jcEnumeration
     *            表格水平对齐设置
     * @author zhouweiwei
     * 
     */
    public static void setTableAlign(ObjectFactory factory, Tbl table, JcEnumeration jcEnumeration) {
        TblPr tablePr = table.getTblPr();
        if (tablePr == null) {
            tablePr = factory.createTblPr();
        }
        Jc jc = tablePr.getJc();
        if (jc == null) {
            jc = new Jc();
        }
        jc.setVal(jcEnumeration);
        tablePr.setJc(jc);
        table.setTblPr(tablePr);
    }

    /**
     * 表格增加边框
     * 
     * @param table
     *            表格对象
     * @param borderSize
     *            表格边框宽度
     * @author zhouweiwei
     */
    public static void addBorders(Tbl table, String borderSize) {
        table.setTblPr(new TblPr());
        CTBorder border = new CTBorder();
        border.setColor("auto");
        border.setSz(new BigInteger(borderSize));
        border.setSpace(new BigInteger("0"));
        border.setVal(STBorder.SINGLE);
        TblBorders borders = new TblBorders();
        borders.setBottom(border);
        borders.setLeft(border);
        borders.setRight(border);
        borders.setTop(border);
        borders.setInsideH(border);
        borders.setInsideV(border);
        table.getTblPr().setTblBorders(borders);
    }

    /**
     * 设置表格外边框并且去除表格将内部单元格的边框
     * 
     * @param table
     *            表格对象
     * @param borderSize
     *            表格边框的的值
     * @param cellSize
     *            设置单元格的边框值
     * @author zhouweiwei
     */
    public static void hideTableCellLineBorders(Tbl table, String borderSize, String cellSize) {
        table.setTblPr(new TblPr());
        CTBorder tableBorder = new CTBorder();
        tableBorder.setColor("auto");
        tableBorder.setSz(new BigInteger(borderSize));
        tableBorder.setSpace(new BigInteger("0"));
        tableBorder.setVal(STBorder.SINGLE);

        CTBorder cellBorder = new CTBorder();
        cellBorder.setColor("auto");
        cellBorder.setSpace(new BigInteger("0"));
        cellBorder.setVal(STBorder.NONE);

        TblBorders borders = new TblBorders();
        borders.setBottom(tableBorder);
        borders.setLeft(tableBorder);
        borders.setRight(tableBorder);
        borders.setTop(tableBorder);
        borders.setInsideH(cellBorder);
        borders.setInsideV(cellBorder);
        table.getTblPr().setTblBorders(borders);
    }

    /**
     * 表格增加边框 可以设置上下左右四个边框样式以及横竖水平线样式
     * 
     * @param table
     *            表格对象
     * @param topBorder
     *            表格上边框样式
     * @param bottomBorder
     *            表格底边框样式
     * @param leftBorder
     *            表格左边框样式
     * @param rightBorder
     *            表格右边框样式
     * @param hBorder
     *            表格水平方向线的样式
     * @param vBorder
     *            表格垂直方向线的样式
     * @author zhouweiwei
     */
    public static void addBorders(Tbl table, CTBorder topBorder, CTBorder bottomBorder, CTBorder leftBorder,
            CTBorder rightBorder, CTBorder hBorder, CTBorder vBorder) {
        table.setTblPr(new TblPr());
        TblBorders borders = new TblBorders();
        borders.setBottom(bottomBorder);
        borders.setLeft(leftBorder);
        borders.setRight(rightBorder);
        borders.setTop(bottomBorder);
        borders.setInsideH(hBorder);
        borders.setInsideV(vBorder);
        table.getTblPr().setTblBorders(borders);
    }

    /**
     * 单元格上下左右边框设置
     * 
     * @param tc
     *            单元格对象
     * @param topBorder
     *            边框样式对象
     * @param bottomBorder
     *            单元格底部边框样式
     * @param leftBorder
     *            单元格左边框样式
     * @param rightBorder
     *            设置单元格右边框的样式
     * @param tcPr
     *            单元格样式对象
     * @author zhouweiwei
     */
    public static void addCellBorders(Tc tc, CTBorder topBorder, CTBorder bottomBorder, CTBorder leftBorder,
            CTBorder rightBorder, TcPr tcPr) {
        TcBorders borders = new TcBorders();
        borders.setBottom(bottomBorder);
        borders.setLeft(leftBorder);
        borders.setRight(rightBorder);
        borders.setTop(topBorder);
        tcPr.setTcBorders(borders);
        tc.setTcPr(tcPr);
    }

    /**
     * 设置行的高度
     * 
     * @param factory
     *            工程对象
     * @param tr
     *            行对象
     * @param heigth
     *            行高度
     * @author zhouweiwei
     */
    public static void setTableTrHeight(ObjectFactory factory, Tr tr, String heigth) {
        TrPr trPr = tr.getTrPr();
        if (trPr == null) {
            trPr = factory.createTrPr();
        }
        CTHeight ctHeight = new CTHeight();
        ctHeight.setVal(new BigInteger(heigth));
        TrHeight trHeight = new TrHeight(ctHeight);
        trHeight.set(trPr);
        tr.setTrPr(trPr);

    }

    /**
     * 新增单元格
     * 
     * @param factory
     *            工程对象
     * @param tableRow
     *            表格行对象
     * @param content
     *            填充内容
     * @param rpr
     *            写入样式对象
     * @param jcEnumeration
     *            段落位置设置
     * @param hasBgColor
     *            是否设置颜色
     * @param backgroudColor
     *            背景颜色
     * @author zhouweiwei
     * 
     */
    public static void addTableCell(ObjectFactory factory, Tr tableRow, String content, RPr rpr,
            JcEnumeration jcEnumeration, boolean hasBgColor, String backgroudColor) {
        Tc tableCell = factory.createTc();
        P p = factory.createP();
        setParagraphSpacing(factory, p, jcEnumeration, true, "0", "0", null, null, true, "240", STLineSpacingRule.AUTO);
        Text t = factory.createText();
        t.setValue(content);
        R run = factory.createR();
        // 设置表格内容字体样式
        run.setRPr(rpr);

        TcPr tcPr = tableCell.getTcPr();
        if (tcPr == null) {
            tcPr = factory.createTcPr();
        }

        // 设置内容垂直方向位置
        setCellContentHPosition(factory, tcPr, STVerticalJc.CENTER);
        run.getContent().add(t);
        p.getContent().add(run);
        tableCell.getContent().add(p);
        if (hasBgColor) {
            CTShd shd = tcPr.getShd();
            if (shd == null) {
                shd = factory.createCTShd();
            }
            shd.setColor("auto");
            shd.setFill(backgroudColor);
            tcPr.setShd(shd);
        }
        tableCell.setTcPr(tcPr);

        tableRow.getContent().add(tableCell);

    }

    /**
     * 创建一般单元格
     * 
     * @param factory
     *            工厂对象
     * @param tr
     *            表格行对象
     * @param content
     *            单元格填充对象
     * @param rpr
     *            内容写入对象
     * @param jcEnumeration
     *            设置内容在单元格的位置
     * @param hasBgColor
     *            是否设置背景颜色
     * @param backgroudColor
     *            背景颜色的值
     * @param isGridSpan
     *            是否设置表格跨列
     * @param gridSpanSize
     *            表格跨列的大小（跨几列）
     * @author zhouweiwei
     */
    public static void createNormalCell(ObjectFactory factory, Tr tr, String content, RPr rpr,
            JcEnumeration jcEnumeration, boolean hasBgColor, String backgroudColor, boolean isGridSpan,
            String gridSpanSize) {
        Tc tableCell = factory.createTc();
        P p = factory.createP();
        setParagraphSpacing(factory, p, jcEnumeration, true, "0", "0", null, null, true, "240", STLineSpacingRule.AUTO);
        Text t = factory.createText();
        t.setValue(content);
        R run = factory.createR();
        // 设置表格内容字体样式
        run.setRPr(rpr);
        TcPr tcPr = tableCell.getTcPr();
        if (tcPr == null) {
            tcPr = factory.createTcPr();
        }
        // 设置内容垂直方向位置
        setCellContentHPosition(factory, tcPr, STVerticalJc.CENTER);
        // 设置单元格是否跨列
        if (isGridSpan) {
            setCellMerge(tcPr, factory, gridSpanSize);
        }

        run.getContent().add(t);
        p.getContent().add(run);
        tableCell.getContent().add(p);
        if (hasBgColor) {
            CTShd shd = tcPr.getShd();
            if (shd == null) {
                shd = factory.createCTShd();
            }
            shd.setColor("auto");
            shd.setFill(backgroudColor);
            tcPr.setShd(shd);

        }

        tableCell.setTcPr(tcPr);
        tr.getContent().add(tableCell);
    }

    /**
     * 创建含有边框的段落
     * 
     * @param wordMLPackage
     * @param t
     * @param factory
     * @param p
     * @param topBorder
     * @param bottomBorder
     * @param leftBorder
     * @param rightBorder
     * @author zhouweiwei
     */
    public static void createParagraghLine(WordprocessingMLPackage wordMLPackage, MainDocumentPart t,
            ObjectFactory factory, P p, CTBorder topBorder, CTBorder bottomBorder, CTBorder leftBorder,
            CTBorder rightBorder) {
        PPr ppr = new PPr();
        PBdr pBdr = new PBdr();
        pBdr.setTop(topBorder);
        pBdr.setBottom(bottomBorder);
        pBdr.setLeft(leftBorder);
        pBdr.setRight(rightBorder);
        ppr.setPBdr(pBdr);
        p.setPPr(ppr);
    }

    /**
     * 设置文字方向 tbRlV 垂直
     * 
     * @param wordPackage
     * @param textDirection
     *            字体方向值 设置垂直tbRlV
     * @return 文字方向TextDirection
     * @author zhouweiwei
     */
    public static TextDirection setDocTextDirection(WordprocessingMLPackage wordPackage, String textDirection) {
        SectPr sectPr = wordPackage.getDocumentModel().getSections().get(0).getSectPr();
        TextDirection textDir = sectPr.getTextDirection();
        if (StringUtils.isNotBlank(textDirection)) {

            if (textDir == null) {
                textDir = new TextDirection();
                sectPr.setTextDirection(textDir);
            }
            textDir.setVal(textDirection);
        }
        return textDir;
    }

    /**
     * 设置表格单元跨列
     * 
     * @param tcPr
     *            单元个样式对象
     * @param factory
     *            对象工厂
     * @param gridSpanSize
     *            单元格跨行数
     * @return 返回单元格的样式对象
     * @author zhouweiwei
     */
    public static TcPr setCellMerge(TcPr tcPr, ObjectFactory factory, String gridSpanSize) {

        GridSpan gr = factory.createTcPrInnerGridSpan();
        gr.setVal(new BigInteger(gridSpanSize));
        tcPr.setGridSpan(gr);

        return tcPr;
    }

    /**
     * 设置表格内容垂直方向的位置
     * 
     * @param factory
     *            工厂对象
     * @param tcPr
     *            表格样式对象
     * @param Value
     *            表格样式垂直样式设置值
     * @return tcPr 返回表格样式
     * @author zhouweiwei
     */
    public static TcPr setCellContentHPosition(ObjectFactory factory, TcPr tcPr, STVerticalJc Value) {
        CTVerticalJc valign = factory.createCTVerticalJc();
        valign.setVal(Value);
        tcPr.setVAlign(valign);
        return tcPr;
    }

    /**
     * 设置单元格边框底部边框显示样式
     * 
     * @param factory
     *            工厂对象
     * @param tableCell
     *            单元格
     * @param sTBorder
     *            底部边框的线条样式
     * @author zhouweiwei
     */
    public static void setTableCellBoder(ObjectFactory factory, Tc tableCell, STBorder sTBorder) {
        // 给下边框设置虚线
        tableCell.setTcPr(factory.createTcPr());
        CTBorder cellBorder = factory.createCTBorder();
        cellBorder.setColor("auto");
        cellBorder.setSpace(new BigInteger("1"));
        cellBorder.setVal(sTBorder);

        TcBorders tableBorder = new TcBorders();
        tableBorder.setBottom(cellBorder);
        tableCell.getTcPr().setTcBorders(tableBorder);
    }

    /**
     * 设置单元格边框左部边框显示样式
     * 
     * @param factory
     * @param tableCell
     * @param sTBorder
     */
    public static void setTableCellLeftBoder(ObjectFactory factory, Tc tableCell, STBorder sTBorder) {
        // 给下边框设置虚线
        tableCell.setTcPr(factory.createTcPr());
        CTBorder cellBorder = factory.createCTBorder();
        cellBorder.setColor("auto");
        cellBorder.setSpace(new BigInteger("0"));
        cellBorder.setVal(sTBorder);

        TcBorders tableBorder = new TcBorders();
        tableBorder.setLeft(cellBorder);
        tableCell.getTcPr().setTcBorders(tableBorder);
    }

    /**
     * 跨行和并
     * 
     * @param tbl
     *            表格对象
     * @param col
     *            列对象
     * @param fromRow
     *            要合并行的开始处
     * @param toRow
     *            要合并行的结束处
     * @author zhouweiwei
     */
    public static void mergeCellsVertically(Tbl tbl, int col, int fromRow, int toRow) {
        if (col < 0 || fromRow < 0 || toRow < 0) {
            return;
        }
        for (int rowIndex = fromRow; rowIndex <= toRow; rowIndex++) {
            Tc tc = getTc(tbl, rowIndex, col);
            if (tc == null) {
                break;
            }
            TcPr tcPr = getTcPr(tc);
            VMerge vMerge = tcPr.getVMerge();
            if (vMerge == null) {
                vMerge = new VMerge();
                tcPr.setVMerge(vMerge);
            }
            if (rowIndex == fromRow) {
                vMerge.setVal("restart");
            } else {
                vMerge.setVal("continue");
            }
        }
    }

    /**
     * 得到单元格内容
     * 
     * @param tc
     * @return
     * @throws Exception
     * @author zhouweiwei
     */
    public static String getTcContent(Tc tc) throws Exception {
        return getElementContent(tc);
    }

    public static String getElementContent(Object obj) throws Exception {
        StringWriter stringWriter = new StringWriter();
        TextUtils.extractText(obj, stringWriter);

        return stringWriter.toString();
    }

    /**
     * @Description:得到指定位置的单元格
     * @author zhouweiwei
     */
    public static Tc getTc(Tbl tbl, int row, int cell) {
        if (row < 0 || cell < 0) {
            return null;
        }
        List trList = getTblAllTr(tbl);
        if (row >= trList.size()) {
            return null;
        }
        List tcList = getTrAllCell(trList.get(row));
        if (cell >= tcList.size()) {
            return null;
        }
        return tcList.get(cell);
    }

    /**
     * @Description:得到所有表格
     * @author zhouweiwei
     */
    public static List getAllTbl(WordprocessingMLPackage wordMLPackage) {
        MainDocumentPart mainDocPart = wordMLPackage.getMainDocumentPart();
        List