java合并多个word 2007 文档 基于docx4j

参考文章:http://dh.swzhinan.com/post/185.html

引入的jar包

<dependency>
            <groupId>org.docx4j</groupId>
            <artifactId>docx4j</artifactId>
            <version>6.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-compress</artifactId>
            <version>1.8.1</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.58</version>
        </dependency>

        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>3.10-FINAL</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>3.10-FINAL</version>
        </dependency>
        <dependency>
            <groupId>org.apache.xmlbeans</groupId>
            <artifactId>xmlbeans</artifactId>
            <version>2.5.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.xmlgraphics</groupId>
            <artifactId>xmlgraphics-commons</artifactId>
            <version>1.3.1</version>
        </dependency>

代码

package com.htsoft.oa.action.sjrh.tool;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

import org.apache.commons.io.IOUtils;
import org.docx4j.dml.wordprocessingDrawing.Inline;
import org.docx4j.jaxb.Context;
import org.docx4j.openpackaging.exceptions.Docx4JException;
import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
import org.docx4j.openpackaging.parts.PartName;
import org.docx4j.openpackaging.parts.WordprocessingML.AlternativeFormatInputPart;
import org.docx4j.openpackaging.parts.WordprocessingML.BinaryPartAbstractImage;
import org.docx4j.openpackaging.parts.WordprocessingML.MainDocumentPart;
import org.docx4j.relationships.Relationship;
import org.docx4j.wml.Br;
import org.docx4j.wml.CTAltChunk;
import org.docx4j.wml.Drawing;
import org.docx4j.wml.ObjectFactory;
import org.docx4j.wml.P;
import org.docx4j.wml.R;
import org.docx4j.wml.STBrType;

import com.alibaba.fastjson.JSONObject;
import com.htsoft.oa.action.sjrh.pojo.MergeResult;

public class WordMergeUtils {
    private static ObjectFactory factory = new ObjectFactory();

    /**
     * 合并docx
     * 
     * @param streams
     *            要合并的word文件的输入流
     * @param path
     *            合并后的文件的路径
     * @return
     * @throws Docx4JException
     * @throws IOException
     */
    public static File mergeDocx(final List<InputStream> streams, String path) throws Docx4JException, IOException {

        WordprocessingMLPackage target = null;
        final File generated = new File(path);

        int chunkId = 0;
        Iterator<InputStream> it = streams.iterator();
        while (it.hasNext()) {
            InputStream is = it.next();
            if (is != null) {
                try {
                    if (target == null) {
                        // Copy first (master) document
                        OutputStream os = new FileOutputStream(generated);
                        os.write(IOUtils.toByteArray(is));
                        os.close();

                        target = WordprocessingMLPackage.load(generated);
                    } else {
                        MainDocumentPart documentPart = target.getMainDocumentPart();

//                        addPageBreak(documentPart); // 另起一页，换页

                        insertDocx(documentPart, IOUtils.toByteArray(is), chunkId++);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    is.close();
                }
            }
        }

        if (target != null) {
            target.save(generated);
            // Docx4J.save(target, generated, Docx4J.FLAG_NONE);
            return generated;
        } else {
            return null;
        }
    }

    // 插入文档
    private static void insertDocx(MainDocumentPart main, byte[] bytes, int chunkId) {
        try {
            AlternativeFormatInputPart afiPart = new AlternativeFormatInputPart(
                    new PartName("/part" + chunkId + ".docx"));
            // afiPart.setContentType(new ContentType(CONTENT_TYPE));
            afiPart.setBinaryData(bytes);
            Relationship altChunkRel = main.addTargetPart(afiPart);

            CTAltChunk chunk = Context.getWmlObjectFactory().createCTAltChunk();
            chunk.setId(altChunkRel.getId());

            main.addObject(chunk);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * wordML转word，原文件不变，返回转换完成的word文件对象。
     * 
     * @param file
     * @return
     * @throws Docx4JException
     * @throws IOException
     */
    public static File wordMLToWord(File file) throws Docx4JException, IOException {
        WordprocessingMLPackage target = WordprocessingMLPackage.load(file);
        File temp = File.createTempFile(file.getName(), ".doc");
        target.save(temp);
        return temp;
    }

    /**
     * xml转docx，原文件不变，返回转换完成的word文件对象。
     * 
     * @param file
     * @return
     * @throws Docx4JException
     * @throws IOException
     */
    public static File xmlToWord(File file) throws Docx4JException, IOException {
        WordprocessingMLPackage target = WordprocessingMLPackage.load(file);
        File temp = File.createTempFile(file.getName(), ".doc");
        target.save(temp);
        return temp;
    }

    /**
     * 合并wordML文档
     * 
     * @param list
     * @param path
     * @throws Docx4JException
     * @throws IOException
     */
    public static File mergeWordML(List<File> list, String path) throws Docx4JException, IOException {
        final List<InputStream> streams = new ArrayList<InputStream>();
        for (int i = 0; i < list.size(); i++) {
            File file = list.get(i);
            // file = WordMLUtil.wordMLToWord(file); // wordML转word
            streams.add(new FileInputStream(file));
        }
        return WordMergeUtils.mergeDocx(streams, path);
    }

    /**
     * 把文件转换成Byte[] Mapped File way MappedByteBuffer 可以在处理大文件时，提升性能
     * 
     * @param filename
     * @return
     * @throws IOException
     */
    public static byte[] fileToByteArray(String filename) throws IOException {

        RandomAccessFile raf = null;
        FileChannel fc = null;
        try {
            raf = new RandomAccessFile(filename, "r");
            fc = raf.getChannel();
            MappedByteBuffer byteBuffer = fc.map(MapMode.READ_ONLY, 0, fc.size()).load();
            System.out.println(byteBuffer.isLoaded());
            byte[] result = new byte[(int) fc.size()];
            if (byteBuffer.remaining() > 0) {
                byteBuffer.get(result, 0, byteBuffer.remaining());
            }
            return result;
        } catch (IOException e) {
            e.printStackTrace();
            throw e;
        } finally {
            try {
                fc.close();
                raf.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * Docx4j拥有一个由字节数组创建图片部件的工具方法, 随后将其添加到给定的包中. 为了能将图片添加 到一个段落中,
     * 我们需要将图片转换成内联对象. 这也有一个方法, 方法需要文件名提示, 替换文本, 两个id标识符和一个是嵌入还是链接到的指示作为参数.
     * 一个id用于文档中绘图对象不可见的属性, 另一个id用于图片本身不可见的绘制属性. 最后我们将内联 对象添加到段落中并将段落添加到包的主文档部件.
     * 
     * @param word
     *            需要编辑的文件
     * @param imageList
     *            图片对象集合（ 图片对象属性： url 图片文件路径 keyword 文档中的图片占位符 name 图片文件名 ）
     * @throws Exception
     *             不幸的createImageInline方法抛出一个异常(没有更多具体的异常类型)
     */
    public static void addImageToPackage(File word, List<JSONObject> imageList) throws Exception {

        WordprocessingMLPackage wordMLPackage = WordprocessingMLPackage.load(word);

        for (int i = 0; i < imageList.size(); i++) {
            JSONObject image = imageList.get(i);

            byte[] bytes = fileToByteArray(image.getString("url"));

            BinaryPartAbstractImage imagePart = BinaryPartAbstractImage.createImagePart(wordMLPackage, bytes);

            int docPrId = 1;
            int cNvPrId = 2;
            Inline inline = imagePart.createImageInline(image.getString("name"), image.getString("keyword"), docPrId,
                    cNvPrId, false);

            P paragraph = addInlineImageToParagraph(inline);

            wordMLPackage.getMainDocumentPart().addObject(paragraph);
        }

        wordMLPackage.save(word);
    }

    /**
     * Docx4j拥有一个由字节数组创建图片部件的工具方法, 随后将其添加到给定的包中. 为了能将图片添加 到一个段落中,
     * 我们需要将图片转换成内联对象. 这也有一个方法, 方法需要文件名提示, 替换文本, 两个id标识符和一个是嵌入还是链接到的指示作为参数.
     * 一个id用于文档中绘图对象不可见的属性, 另一个id用于图片本身不可见的绘制属性. 最后我们将内联 对象添加到段落中并将段落添加到包的主文档部件.
     * 
     * @param wordFilePath
     *            文件路径
     * @param imageList
     *            图片对象集合（ 图片对象属性： url 图片文件路径 keyword 文档中的图片占位符 name 图片文件名 ）
     * @throws Exception
     *             不幸的createImageInline方法抛出一个异常(没有更多具体的异常类型)
     */
    public static void addImageToPackage(String wordFilePath, List<JSONObject> imageList) throws Exception {
        addImageToPackage(new File(wordFilePath), imageList);
    }

    /**
     * 创建一个对象工厂并用它创建一个段落和一个可运行块R. 然后将可运行块添加到段落中. 接下来创建一个图画并将其添加到可运行块R中. 最后我们将内联
     * 对象添加到图画中并返回段落对象.
     * 
     * @param inline
     *            包含图片的内联对象.
     * @return 包含图片的段落
     */
    private static P addInlineImageToParagraph(Inline inline) {
        // 添加内联对象到一个段落中
        P paragraph = factory.createP();
        R run = factory.createR();
        paragraph.getContent().add(run);
        Drawing drawing = factory.createDrawing();
        run.getContent().add(drawing);
        drawing.getAnchorOrInline().add(inline);
        return paragraph;
    }

    /**
     * 文档结尾添加一个空白页
     * 
     * @throws Docx4JException
     */
    public static void addPageBreak(File word) throws Docx4JException {

        WordprocessingMLPackage wordMLPackage = WordprocessingMLPackage.load(word);

        MainDocumentPart documentPart = wordMLPackage.getMainDocumentPart();

        Br breakObj = new Br();
        breakObj.setType(STBrType.PAGE);

        P paragraph = factory.createP();
        paragraph.getContent().add(breakObj);
        documentPart.getJaxbElement().getBody().getContent().add(paragraph);
        wordMLPackage.save(word);
    }

    /**
     * 文档结尾添加一个空白页
     * 
     * @throws Docx4JException
     */
    public static void addPageBreak(MainDocumentPart documentPart) {
        Br breakObj = new Br();
        breakObj.setType(STBrType.PAGE);

        P paragraph = factory.createP();
        paragraph.getContent().add(breakObj);
        documentPart.getJaxbElement().getBody().getContent().add(paragraph);
    }

    /**
     * 文档结尾添加一个空白页
     * 
     * @throws Docx4JException
     */
    public static void addPageBreak(String wordFilePath) throws Docx4JException {
        addPageBreak(new File(wordFilePath));
    }

    /**
     * 合并word文档 接口方法
     * 
     * @param sourceFiles待合并文件
     * @param mergedFileName合并后的文件名称
     * @throws Exception
     */
    public static MergeResult merge(String djxh, List<String> sourceFiles, String mergedFileName) {

        if (djxh == null || djxh.isEmpty()) {
            return new MergeResult(-1, null, "登记序号为空!", null);
        } else if (sourceFiles == null || sourceFiles.size() <= 0) {
            return new MergeResult(-1, null, "待合并文件路径为空!", null);
        }

        try {
            List<File> files = new ArrayList<File>();
            for (String filePath : sourceFiles) {
                File file = new File(filePath);
                files.add(file);
            }

            // 保存基础路径
            String path = "";
            if ("1".equals(WordStaticFileds.open_Fixed_path)) {
                // 创建固定路径
                path = WordStaticFileds.create_word_path + "word/fixed/" + djxh;
            } else {
                // 创建不固定路径
                path = WordStaticFileds.create_word_path + "word/notFixed/"
                        + new SimpleDateFormat("yyyyMMdd").format(new Date()) + "/" + djxh;
            }

            if (mergedFileName == null || mergedFileName.isEmpty()) {
                if (files.size() > 0) {
                    String oldName = files.get(0).getName();
                    int lastIndexOf = oldName.lastIndexOf(".");
                    if (lastIndexOf > 0) {
                        mergedFileName = oldName.substring(0, lastIndexOf) + "-合并后.docx";
                    }
                }
            }

            File mergedfile = new File(path);

            if (!mergedfile.exists()) {
                mergedfile.mkdirs();
            }

            String mergedFullPath = path + "/" + mergedFileName;
            File mergeWordML = WordMergeUtils.mergeWordML(files, mergedFullPath);
            
            
            return new MergeResult(0, mergeWordML, "合并word文件成功!", mergeWordML.getAbsolutePath());
        } catch (Exception e) {
            return new MergeResult(-1, null, "合并word文件出错!错误信息:" + e.getMessage(), null);
        }

    }
}