如何利用Java-JACOB操作WORD文档

JACOB是一个JAVA到微软的COM接口的桥梁。使用JACOB允许任何JVM访问COM对象，从而使JAVA应用程序能够调用COM对象。如果你要对 MS Word、Excel 进行处理，JACOB 是一个好的选择。JACOB目前已经成为sourceforge（http://sourceforge.net/projects/jacob-project/）的一个开源项目，本文使用的版本是1.10.1。

因为在项目中用到了这个技术，但是在网上没有查到很符合题目的文章，经过我自己的探索，总结写出了这篇文章。

这篇文章可能不能完全满足你的要求，你也可以按照我的探索方法进行探索：参阅VBA操作Office的组件的书籍，然后参考下面的Tip完成需要的功能。文章最后附完整的测试代码。

生成WORD文档的简单讲解：

1. 初始化com的线程，非常重要，否则第二次创建com对象的时候会出现can’t co-create object异常（参见jacob的帮助文档），完成操作com组件后要调用 realease方法
ComThread.InitSTA();// 初始化com的线程，非常重要！！使用结束后要调用 realease方法

2. 初始化word应用程序，新建一个空白文档，取得文档内容对象//Instantiate objWord //Declare word object
ActiveXComponent objWord = new ActiveXComponent("Word.Application");

//Assign a local word object
Dispatch wordObject = (Dispatch) objWord.getObject();

//Create a Dispatch Parameter to show the document that is opened
Dispatch.put((Dispatch) wordObject, "Visible", new Variant(true));// new Variant(true)表示word应用程序可见
Tip:设置一个对象的属性的时候，利用Dispatch的put方法，给属性赋值。上面这行语句相当于vb的 wordObject.Visible = true 语句

//Instantiate the Documents Property
Dispatch documents = objWord.getProperty("Documents").toDispatch(); //documents表示word的所有文档窗口，（word是多文档应用程序）

//Add a new word document, Current Active Document
Dispatch document = Dispatch.call(documents, "Add").toDispatch(); // 使用Add命令创建一个新文档，用Open命令可以打开一个现有文档
Tip:调用一个对象的方法的时候，利用Dispatch的call方法，上面的语句相当于vb的document = documents.Add() 语句。

Dispatch wordContent = Dispatch.get(document, "Content").toDispatch(); // 取得word文件的内容
Tip:取得一个对象的成员变量（属性）时利用Dispatch的get方法，上面的语句相当于vb的wordContent = document.Content语句

3. 取得word文档的内容后，可以对其内容进行操作
Dispatch.call(wordContent, "InsertAfter", "这里是一个段落的内容");//插入一个段落

4. 设置刚插入的段落的文字格式
Dispatch paragraphs = Dispatch.get(wordContent, "Paragraphs").toDispatch(); // 所有段落
int paragraphCount = Dispatch.get(paragraphs, "Count").toInt(); // 一共的段落数

// 找到刚输入的段落，设置格式
Dispatch lastParagraph = Dispatch.call(paragraphs, "Item",
new Variant(paragraphCount)).
toDispatch(); // 最后一段
Dispatch lastParagraphRange = Dispatch.get(lastParagraph, "Range").
toDispatch();
Dispatch font = Dispatch.get(lastParagraphRange, "Font").toDispatch();
Dispatch.put(font, "Bold", new Variant(true)); // 设置为黑体
Dispatch.put(font, "Italic", new Variant(true)); // 设置为斜体
Dispatch.put(font, "Name", new Variant("宋体")); //
Dispatch.put(font, "Size", new Variant(12)); //小四
注意：如果想插入一个新的空白行，也需要设置段落的文字格式，否则新插入行的文字格式会于刚插入的段落的格式相同。

5. 将当前文档保存
Dispatch.call(document, "SaveAs", new Variant("C:
abc.doc")); // 保存一个新文档

6. 释放COM线程
ComThread.Release();//释放com线程。根据jacob的帮助文档，com的线程回收不由java的垃圾回收器处理

完整测试代码：（StudyJacob.java 附件中有本文章和java源文件）
import com.jacob.activeX.ActiveXComponent;
import com.jacob.com.Dispatch;
import com.jacob.com.Variant;
import com.jacob.com.ComThread;

public class StudyJacob {

public static void main(String[] args) {
ComThread.InitSTA();// 初始化com的线程，非常重要！！使用结束后要调用 realease方法

//Instantiate objWord //Declare word object
ActiveXComponent objWord = new ActiveXComponent("Word.Application");

//Assign a local word object
Dispatch wordObject = (Dispatch) objWord.getObject();

//Create a Dispatch Parameter to show the document that is opened
Dispatch.put((Dispatch) wordObject, "Visible", new Variant(true));// new Variant(true)表示word应用程序可见

//Instantiate the Documents Property
Dispatch documents = objWord.getProperty("Documents").toDispatch(); //documents表示word的所有文档窗口，（word是多文档应用程序）

//Add a new word document, Current Active Document
Dispatch document = Dispatch.call(documents, "Add").toDispatch(); // 使用Add命令创建一个新文档，用Open命令可以打开一个现有文档

Dispatch wordContent = Dispatch.get(document, "Content").toDispatch(); // 取得word文件的内容

Dispatch.call(wordContent, "InsertAfter", "这里是一个段落的内容");//插入一个段落

Dispatch paragraphs = Dispatch.get(wordContent, "Paragraphs").toDispatch(); // 所有段落
int paragraphCount = Dispatch.get(paragraphs, "Count").toInt(); // 一共的段落数

// 找到刚输入的段落，设置格式
Dispatch lastParagraph = Dispatch.call(paragraphs, "Item",
new Variant(paragraphCount)).
toDispatch(); // 最后一段
Dispatch lastParagraphRange = Dispatch.get(lastParagraph, "Range").
toDispatch();
Dispatch font = Dispatch.get(lastParagraphRange, "Font").toDispatch();
Dispatch.put(font, "Bold", new Variant(true)); // 设置为黑体
Dispatch.put(font, "Italic", new Variant(true)); // 设置为斜体
Dispatch.put(font, "Name", new Variant("宋体")); //
Dispatch.put(font, "Size", new Variant(12)); //小四

Dispatch.call(document, "SaveAs", new Variant("C:
abc.doc")); // 保存一个新文档
ComThread.Release();//释放com线程。根据jacob的帮助文档，com的线程回收不由java的垃圾回收器处理
}

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

如果你想写一个JAVA代码，其中需要调用JACOB提供的功能，而你还是新手，也许篇文章会大大降低你的花费时间。

我将一个关于JACOB的代码分成下面几个步骤：

1) ActiveXComponent ax = new ActiveXComponent("a1");//构建ActiveX组件实例

其中的a1的值和你需要调用的ActiveX控件有关 MS控件名
a1的值

InternetExplorer
InternetExplorer.Application

Excel
Excel.Application

Word
Word.Application

Powerpoint
Powerpoint.Application

vb/java Script
ScriptControl

windows media Player
WMPlayer.OCX

Outlook
Outlook.Application

Visio
Visio.Application

DAO
DAO.PrivateDBEngine.35

MultiFace
MultiFace.Face

2) Dispatch ds = ax.getObject(). toDispatch();//获取Dispatch对象，我们可以把每个Dispatch对象看成是对Activex控件的一个操作，这一步是获得该ActiveX控件的控制权。
（注：中提到过Variant类，这里的ax.getObject()便是获得该对象，我们将其转化为任何对象（类型））

3) Dispatch ds1 = Dispatch.get(ds, "a2").toDispatch(); //获取该ActiveX对象数据结构中的a2属性

4) Dispatch d2 = Dispatch.invoke(ds1, "a3", a4, a5, a6).toDispatch(); //功能调用，对ActiveX对象ds1的a3属性执行a4(Dispatch.Put/Dispatch.Get等)操作，执行后a3的值为a5，a6为错误参数码常定义为new int[1]，
（注：call、get和put方法都是通过该方法实现的)

5) Dispatch ds2 = Dispatch.put(ds, "a7","a8").toDispatch();//将ActiveX对象ds的属性a4的值设置为a5，该方法返回类型同get一样

6) Dispatch ds3 = Dispatch.call(ds1, "a9", a10);//该方法和get方法非常类似，他是把a9属性赋值给a10

Ok其他的方法我觉得很容易理解，这里就不再做描述了。

下面是一个关于excel的代码，也许对您的进一步自学，会有好处

import com.jacob.activeX.ActiveXComponent;
import com.jacob.com.ComThread;
import com.jacob.com.Dispatch;
import com.jacob.com.Variant;

public class ExcelDispatchTest {

public static void main(String[] args) {
ComThread.InitSTA();

ActiveXComponent xl = new ActiveXComponent("Excel.Application");
try {
System.out.println("version=" + xl.getProperty("Version"));
System.out.println("version=" + Dispatch.get(xl, "Version"));
Dispatch.put(xl, "Visible", new Variant(true));
Dispatch workbooks = xl.getProperty("Workbooks").toDispatch();
Dispatch workbook = Dispatch.get(workbooks, "Add").toDispatch();
Dispatch sheet = Dispatch.get(workbook, "ActiveSheet").toDispatch();
Dispatch a1 = Dispatch.invoke(sheet, "Range", Dispatch.Get,
new Object[] { "A1" }, new int[1]).toDispatch();
Dispatch a2 = Dispatch.invoke(sheet, "Range", Dispatch.Get,
new Object[] { "A2" }, new int[1]).toDispatch();
Dispatch.put(a1, "Value", "123.456");
Dispatch.put(a2, "Formula", "=A1*2");
System.out.println("a1 from excel:" + Dispatch.get(a1, "Value"));
System.out.println("a2 from excel:" + Dispatch.get(a2, "Value"));
Variant f = new Variant(false);
Dispatch.call(workbook, "Close", f);
} catch (Exception e) {
e.printStackTrace();
} finally {
xl.invoke("Quit", new Variant[] {});
ComThread.Release();
}
}

这里有一个MSWordManager 类，是jacob官方发布的工具类，里面有大多数Java操作MS Office的工具。

package com.test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

import com.jacob.activeX.ActiveXComponent;
import com.jacob.com.Dispatch;
import com.jacob.com.Variant;

public class MSWordManager {
        // word文档
        private Dispatch doc;

        // word运行程序对象
        private ActiveXComponent word;

        // 所有word文档集合
        private Dispatch documents;

        // 选定的范围或插入点
        private Dispatch selection;

        private boolean saveOnExit =true;

        /** *//**
         *
         * @param visible 为true表示word应用程序可见
         */
        public MSWordManager(boolean visible) {
                if (word == null) {
                        word = new ActiveXComponent("Word.Application");
                        word.setProperty("Visible",new Variant(visible));
                }
                if (documents == null)
                        documents = word.getProperty("Documents").toDispatch();
        }

        /** *//**
         * 设置退出时参数
         *
         * @param saveOnExit boolean true-退出时保存文件，false-退出时不保存文件
         */
        public void setSaveOnExit(boolean saveOnExit) {
                this.saveOnExit = saveOnExit;
        }

        /** *//**
         * 创建一个新的word文档
         *
         */
        public void createNewDocument() {
                doc = Dispatch.call(documents, "Add").toDispatch();
                selection = Dispatch.get(word, "Selection").toDispatch();
        }

        /** *//**
         * 打开一个已存在的文档
         *
         * @param docPath
         */
        public void openDocument(String docPath) {
                closeDocument();
                doc = Dispatch.call(documents, "Open", docPath).toDispatch();
                selection = Dispatch.get(word, "Selection").toDispatch();
        }

        /** *//**
         * 把选定的内容或插入点向上移动
         *
         * @param pos 移动的距离
         */
        public void moveUp(int pos) {
                if (selection == null)
                        selection = Dispatch.get(word, "Selection").toDispatch();
                for (int i = 0; i < pos; i++)
                        Dispatch.call(selection, "MoveUp");

        }

        /** *//**
         * 把选定的内容或者插入点向下移动
         *
         * @param pos 移动的距离
         */
        public void moveDown(int pos) {
                if (selection == null)
                        selection = Dispatch.get(word, "Selection").toDispatch();
                for (int i = 0; i < pos; i++)
                        Dispatch.call(selection, "MoveDown");
        }

        /** *//**
         * 把选定的内容或者插入点向左移动
         *
         * @param pos 移动的距离
         */
        public void moveLeft(int pos) {
                if (selection == null)
                        selection = Dispatch.get(word, "Selection").toDispatch();
                for (int i = 0; i < pos; i++) {
                        Dispatch.call(selection, "MoveLeft");
                }
        }

        /** *//**
         * 把选定的内容或者插入点向右移动
         *
         * @param pos 移动的距离
         */
        public void moveRight(int pos) {
                if (selection == null)
                        selection = Dispatch.get(word, "Selection").toDispatch();
                for (int i = 0; i < pos; i++)
                        Dispatch.call(selection, "MoveRight");
        }

        /** *//**
         * 把插入点移动到文件首位置
         *
         */
        public void moveStart() {
                if (selection == null)
                        selection = Dispatch.get(word, "Selection").toDispatch();
                Dispatch.call(selection, "HomeKey",new Variant(6));
        }

        public void moveEnd() {
                if (selection == null)
                        selection = Dispatch.get(word, "Selection").toDispatch();
                Dispatch.call(selection, "EndKey",new Variant(6));
        }

        /** *//**
         * 从选定内容或插入点开始查找文本
         *
         * @param toFindText 要查找的文本
         * @return boolean true-查找到并选中该文本，false-未查找到文本
         */
        public boolean find(String toFindText) {
                if (toFindText == null || toFindText.equals(""))
                        return false;
                // 从selection所在位置开始查询
                Dispatch find = word.call(selection, "Find").toDispatch();
                // 设置要查找的内容
                Dispatch.put(find, "Text", toFindText);
                // 向前查找
                Dispatch.put(find, "Forward", "True");
                // 设置格式
                Dispatch.put(find, "Format", "True");
                // 大小写匹配
                Dispatch.put(find, "MatchCase","True");
                // 全字匹配
                Dispatch.put(find, "MatchWholeWord","True");
                // 查找并选中
                return Dispatch.call(find, "Execute").getBoolean();
        }

        /** *//**
         * 把选定选定内容设定为替换文本
         *
         * @param toFindText 查找字符串
         * @param newText 要替换的内容
         * @return
         */
        public boolean replaceText(String toFindText, String newText) {
                if (!find(toFindText))
                        return false;
                Dispatch.put(selection, "Text", newText);
                return true;
        }

        /** *//**
         * 全局替换文本
         *
         * @param toFindText 查找字符串
         * @param newText 要替换的内容
         */
        public void replaceAllText(String toFindText, String newText) {
                while (find(toFindText)) {
                        Dispatch.put(selection, "Text", newText);
                        Dispatch.call(selection, "MoveRight");
                }
        }

        /** *//**
         * 在当前插入点插入字符串
         *
         * @param newText 要插入的新字符串
         */
        public void insertText(String newText) {
                Dispatch.put(selection, "Text", newText);
        }

        /** *//**
         *
         * @param toFindText 要查找的字符串
         * @param imagePath 图片路径
         * @return
         */
        public boolean replaceImage(String toFindText, String imagePath) {
                if (!find(toFindText))
                        return false;
                Dispatch.call(Dispatch.get(selection, "InLineShapes").toDispatch(),
                                "AddPicture", imagePath);
                return true;
        }

        /** *//**
         * 全局替换图片
         *
         * @param toFindText 查找字符串
         * @param imagePath 图片路径
         */
        public void replaceAllImage(String toFindText, String imagePath) {
                while (find(toFindText)) {
                        Dispatch.call(Dispatch.get(selection, "InLineShapes").toDispatch(),
                                        "AddPicture", imagePath);
                        Dispatch.call(selection, "MoveRight");
                }
        }

        /** *//**
         * 在当前插入点插入图片
         *
         * @param imagePath 图片路径
         */
        public void insertImage(String imagePath) {
                Dispatch.call(Dispatch.get(selection, "InLineShapes").toDispatch(),
                                "AddPicture", imagePath);
        }

        /** *//**
         * 合并单元格
         *
         * @param tableIndex
         * @param fstCellRowIdx
         * @param fstCellColIdx
         * @param secCellRowIdx
         * @param secCellColIdx
         */
        public void mergeCell(int tableIndex,int fstCellRowIdx,int fstCellColIdx,
                        int secCellRowIdx, int secCellColIdx) {
                // 所有表格
                Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
                // 要填充的表格
                Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
                                .toDispatch();
                Dispatch fstCell = Dispatch.call(table, "Cell",
                                new Variant(fstCellRowIdx),new Variant(fstCellColIdx))
                                .toDispatch();
                Dispatch secCell = Dispatch.call(table, "Cell",
                                new Variant(secCellRowIdx),new Variant(secCellColIdx))
                                .toDispatch();
                Dispatch.call(fstCell, "Merge", secCell);
        }

        /** *//**
         * 在指定的单元格里填写数据
         *
         * @param tableIndex
         * @param cellRowIdx
         * @param cellColIdx
         * @param txt
         */
        public void putTxtToCell(int tableIndex,int cellRowIdx,int cellColIdx,
                        String txt) {
                // 所有表格
                Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
                // 要填充的表格
                Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
                                .toDispatch();
                Dispatch cell = Dispatch.call(table, "Cell", new Variant(cellRowIdx),
                                new Variant(cellColIdx)).toDispatch();
                Dispatch.call(cell, "Select");
                Dispatch.put(selection, "Text", txt);
        }

        /** *//**
         * 在当前文档拷贝数据
         *
         * @param pos
         */
        public void copy(String toCopyText) {
                moveStart();
                if (this.find(toCopyText)) {
                        Dispatch textRange = Dispatch.get(selection, "Range").toDispatch();
                        Dispatch.call(textRange, "Copy");
                }
        }

        /** *//**
         * 在当前文档粘帖剪贴板数据
         *
         * @param pos
         */
        public void paste(String pos) {
                moveStart();
                if (this.find(pos)) {
                        Dispatch textRange = Dispatch.get(selection, "Range").toDispatch();
                        Dispatch.call(textRange, "Paste");
                }
        }

        /** *//**
         * 在当前文档指定的位置拷贝表格
         *
         * @param pos 当前文档指定的位置
         * @param tableIndex 被拷贝的表格在word文档中所处的位置
         */
        public void copyTable(String pos,int tableIndex) {
                Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
                Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
                                .toDispatch();
                Dispatch range = Dispatch.get(table, "Range").toDispatch();
                Dispatch.call(range, "Copy");
                if (this.find(pos)) {
                        Dispatch textRange = Dispatch.get(selection, "Range").toDispatch();
                        Dispatch.call(textRange, "Paste");
                }
        }

        /** *//**
         * 在当前文档末尾拷贝来自另一个文档中的段落
         *
         * @param anotherDocPath 另一个文档的磁盘路径
         * @param tableIndex 被拷贝的段落在另一格文档中的序号(从1开始)
         */
        public void copyParagraphFromAnotherDoc(String anotherDocPath,
                        int paragraphIndex) {
                Dispatch wordContent = Dispatch.get(doc, "Content").toDispatch(); // 取得当前文档的内容
                Dispatch.call(wordContent, "InsertAfter","$selection$");// 插入特殊符定位插入点
                copyParagraphFromAnotherDoc(anotherDocPath, paragraphIndex,
                                "$selection$");
        }

        /** *//**
         * 在当前文档指定的位置拷贝来自另一个文档中的段落
         *
         * @param anotherDocPath 另一个文档的磁盘路径
         * @param tableIndex 被拷贝的段落在另一格文档中的序号(从1开始)
         * @param pos 当前文档指定的位置
         */
        public void copyParagraphFromAnotherDoc(String anotherDocPath,
                        int paragraphIndex, String pos) {
                Dispatch doc2 = null;
                try {
                        doc2 = Dispatch.call(documents, "Open", anotherDocPath)
                                        .toDispatch();
                        Dispatch paragraphs = Dispatch.get(doc2, "Paragraphs").toDispatch();

                        Dispatch paragraph = Dispatch.call(paragraphs, "Item",
                                        new Variant(paragraphIndex)).toDispatch();
                        Dispatch range = Dispatch.get(paragraph, "Range").toDispatch();
                        Dispatch.call(range, "Copy");
                        if (this.find(pos)) {
                                Dispatch textRange = Dispatch.get(selection, "Range")
                                                .toDispatch();
                                Dispatch.call(textRange, "Paste");
                        }
                } catch (Exception e) {
                        e.printStackTrace();
                } finally {
                        if (doc2 != null) {
                                Dispatch.call(doc2, "Close",new Variant(saveOnExit));
                                doc2 = null;
                        }
                }
        }

        /** *//**
         * 在当前文档指定的位置拷贝来自另一个文档中的表格
         *
         * @param anotherDocPath 另一个文档的磁盘路径
         * @param tableIndex 被拷贝的表格在另一格文档中的序号(从1开始)
         * @param pos 当前文档指定的位置
         */
        public void copyTableFromAnotherDoc(String anotherDocPath,int tableIndex,
                        String pos) {
                Dispatch doc2 = null;
                try {
                        doc2 = Dispatch.call(documents, "Open", anotherDocPath)
                                        .toDispatch();
                        Dispatch tables = Dispatch.get(doc2, "Tables").toDispatch();
                        Dispatch table = Dispatch.call(tables, "Item",
                                        new Variant(tableIndex)).toDispatch();
                        Dispatch range = Dispatch.get(table, "Range").toDispatch();
                        Dispatch.call(range, "Copy");
                        if (this.find(pos)) {
                                Dispatch textRange = Dispatch.get(selection, "Range")
                                                .toDispatch();
                                Dispatch.call(textRange, "Paste");
                        }
                } catch (Exception e) {
                        e.printStackTrace();
                } finally {
                        if (doc2 != null) {
                                Dispatch.call(doc2, "Close",new Variant(saveOnExit));
                                doc2 = null;
                        }
                }
        }

        /** *//**
         * 在当前文档指定的位置拷贝来自另一个文档中的图片
         *
         * @param anotherDocPath 另一个文档的磁盘路径
         * @param shapeIndex 被拷贝的图片在另一格文档中的位置
         * @param pos 当前文档指定的位置
         */
        public void copyImageFromAnotherDoc(String anotherDocPath,int shapeIndex,
                        String pos) {
                Dispatch doc2 = null;
                try {
                        doc2 = Dispatch.call(documents, "Open", anotherDocPath)
                                        .toDispatch();
                        Dispatch shapes = Dispatch.get(doc2, "InLineShapes").toDispatch();
                        Dispatch shape = Dispatch.call(shapes, "Item",
                                        new Variant(shapeIndex)).toDispatch();
                        Dispatch imageRange = Dispatch.get(shape, "Range").toDispatch();
                        Dispatch.call(imageRange, "Copy");
                        if (this.find(pos)) {
                                Dispatch textRange = Dispatch.get(selection, "Range")
                                                .toDispatch();
                                Dispatch.call(textRange, "Paste");
                        }
                } catch (Exception e) {
                        e.printStackTrace();
                } finally {
                        if (doc2 != null) {
                                Dispatch.call(doc2, "Close",new Variant(saveOnExit));
                                doc2 = null;
                        }
                }
        }

        /** *//**
         * 创建表格
         *
         * @param pos    位置
         * @param cols 列数
         * @param rows 行数
         */
        public void createTable(int numCols,int numRows){//(String pos, int numCols, int numRows) {
//                if (!find(pos)) {
                        Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
                        Dispatch range = Dispatch.get(selection, "Range").toDispatch();
                        Dispatch newTable = Dispatch.call(tables, "Add", range,
                                        new Variant(numRows),new Variant(numCols)).toDispatch();
                        Dispatch.call(selection, "MoveRight");
                        moveEnd();
//                }
        }

        /** *//**
         * 在指定行前面增加行
         *
         * @param tableIndex word文件中的第N张表(从1开始)
         * @param rowIndex 指定行的序号(从1开始)
         */
        public void addTableRow(int tableIndex,int rowIndex) {
                // 所有表格
                Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
                // 要填充的表格
                Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
                                .toDispatch();
                // 表格的所有行
                Dispatch rows = Dispatch.get(table, "Rows").toDispatch();
                Dispatch row = Dispatch.call(rows, "Item",new Variant(rowIndex))
                                .toDispatch();
                Dispatch.call(rows, "Add", new Variant(row));
        }

        /** *//**
         * 在第1行前增加一行
         *
         * @param tableIndex word文档中的第N张表(从1开始)
         */
        public void addFirstTableRow(int tableIndex) {
                // 所有表格
                Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
                // 要填充的表格
                Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
                                .toDispatch();
                // 表格的所有行
                Dispatch rows = Dispatch.get(table, "Rows").toDispatch();
                Dispatch row = Dispatch.get(rows, "First").toDispatch();
                Dispatch.call(rows, "Add", new Variant(row));
        }

        /** *//**
         * 在最后1行前增加一行
         *
         * @param tableIndex
         *                        word文档中的第N张表(从1开始)
         */
        public void addLastTableRow(int tableIndex) {
                // 所有表格
                Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
                // 要填充的表格
                Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
                                .toDispatch();
                // 表格的所有行
                Dispatch rows = Dispatch.get(table, "Rows").toDispatch();
                Dispatch row = Dispatch.get(rows, "Last").toDispatch();
                Dispatch.call(rows, "Add", new Variant(row));
        }

        /** *//**
         * 增加一行
         *
         * @param tableIndex word文档中的第N张表(从1开始)
         */
        public void addRow(int tableIndex) {
                Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
                // 要填充的表格
                Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
                                .toDispatch();
                // 表格的所有行
                Dispatch rows = Dispatch.get(table, "Rows").toDispatch();
                Dispatch.call(rows, "Add");
        }

        /** *//**
         * 增加一列
         *
         * @param tableIndex word文档中的第N张表(从1开始)
         */
        public void addCol(int tableIndex) {
                // 所有表格
                Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
                // 要填充的表格
                Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
                                .toDispatch();
                // 表格的所有行
                Dispatch cols = Dispatch.get(table, "Columns").toDispatch();
                Dispatch.call(cols, "Add").toDispatch();
                Dispatch.call(cols, "AutoFit");
        }

        /** *//**
         * 在指定列前面增加表格的列
         *
         * @param tableIndex word文档中的第N张表(从1开始)
         * @param colIndex    指定列的序号 (从1开始)
         */
        public void addTableCol(int tableIndex,int colIndex) {
                // 所有表格
                Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
                // 要填充的表格
                Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
                                .toDispatch();
                // 表格的所有行
                Dispatch cols = Dispatch.get(table, "Columns").toDispatch();
                System.out.println(Dispatch.get(cols, "Count"));
                Dispatch col = Dispatch.call(cols, "Item",new Variant(colIndex))
                                .toDispatch();
                // Dispatch col = Dispatch.get(cols, "First").toDispatch();
                Dispatch.call(cols, "Add", col).toDispatch();
                Dispatch.call(cols, "AutoFit");
        }

        /** *//**
         * 在第1列前增加一列
         *
         * @param tableIndex word文档中的第N张表(从1开始)
         */
        public void addFirstTableCol(int tableIndex) {
                Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
                // 要填充的表格
                Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
                                .toDispatch();
                // 表格的所有行
                Dispatch cols = Dispatch.get(table, "Columns").toDispatch();
                Dispatch col = Dispatch.get(cols, "First").toDispatch();
                Dispatch.call(cols, "Add", col).toDispatch();
                Dispatch.call(cols, "AutoFit");
        }

        /** *//**
         * 在最后一列前增加一列
         *
         * @param tableIndex word文档中的第N张表(从1开始)
         */
        public void addLastTableCol(int tableIndex) {
                Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
                // 要填充的表格
                Dispatch table = Dispatch.call(tables, "Item", new Variant(tableIndex))
                                .toDispatch();
                // 表格的所有行
                Dispatch cols = Dispatch.get(table, "Columns").toDispatch();
                Dispatch col = Dispatch.get(cols, "Last").toDispatch();
                Dispatch.call(cols, "Add", col).toDispatch();
                Dispatch.call(cols, "AutoFit");
        }

        /** *//**
         * 自动调整表格
         *
         */
        public void autoFitTable() {
                Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
                int count = Dispatch.get(tables,"Count").toInt();
                for (int i = 0; i < count; i++) {
                        Dispatch table = Dispatch.call(tables, "Item", new Variant(i + 1))
                                        .toDispatch();
                        Dispatch cols = Dispatch.get(table, "Columns").toDispatch();
                        Dispatch.call(cols, "AutoFit");
                }
        }

        /** *//**
         * 调用word里的宏以调整表格的宽度,其中宏保存在document下
         *
         */
        public void callWordMacro() {
                Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
                int count = Dispatch.get(tables,"Count").toInt();
                Variant vMacroName = new Variant("Normal.NewMacros.tableFit");
                Variant vParam = new Variant("param1");
                Variant para[] = new Variant[] { vMacroName };
                for (int i = 0; i < para.length; i++) {
                        Dispatch table = Dispatch.call(tables, "Item", new Variant(i + 1))
                                        .toDispatch();
                        Dispatch.call(table, "Select");
                        Dispatch.call(word, "Run","tableFitContent");
                }
        }

        /** *//**
         * 设置当前选定内容的字体
         *
         * @param boldSize
         * @param italicSize
         * @param underLineSize 下划线
         * @param colorSize 字体颜色
         * @param size 字体大小
         * @param name 字体名称
         */
        public void setFont(boolean bold,boolean italic,boolean underLine,
                        String colorSize, String size, String name) {
                Dispatch font = Dispatch.get(selection, "Font").toDispatch();
                Dispatch.put(font, "Name", new Variant(name));
                Dispatch.put(font, "Bold", new Variant(bold));
                Dispatch.put(font, "Italic", new Variant(italic));
                Dispatch.put(font, "Underline",new Variant(underLine));
                Dispatch.put(font, "Color", colorSize);
                Dispatch.put(font, "Size", size);
        }

        /** *//**
         * 文件保存或另存为
         *
         * @param savePath 保存或另存为路径
         */
        public void save(String savePath) {
                Dispatch.call(
                                (Dispatch) Dispatch.call(word, "WordBasic").getDispatch(),
                                "FileSaveAs", savePath);
        }

        /** *//**
         * 关闭当前word文档
         *
         */
        public void closeDocument() {
                if (doc != null) {
                        Dispatch.call(doc, "Save");
                        Dispatch.call(doc, "Close",new Variant(saveOnExit));
                        doc = null;
                }
        }

        /** *//**
         * 关闭全部应用
         *
         */
        public void close() {
                closeDocument();
                if (word != null) {
                        Dispatch.call(word, "Quit");
                        word = null;
                }
                selection = null;
                documents = null;
        }

        /** *//**
         * 打印当前word文档
         *
         */
        public void printFile() {
                if (doc != null) {
                        Dispatch.call(doc, "PrintOut");
                }
        }

        public staticvoid main(String args[])throws Exception {



                MSWordManager msWordManager = new MSWordManager(true);
                msWordManager.createNewDocument();



                msWordManager.insertText("aaaaaaaaaaaaaaaaaaaaa");
                msWordManager.moveEnd();




                msWordManager.close();

        }


}

新建一个类T，来测试一下jacob是否能用，代码如下

package com.test;

public class T {

        public staticvoid main(String[] args) {
                // TODO Auto-generated method stub
                     MSWordManager ms=new MSWordManager(true);
//生成一个MSwordManager对象,并且设置显示Word程序
                     ms.createNewDocument();
//创建一个新的.doc文件
                     ms.insertText("Test jacob");
//插入文本
                     ms.save("c://1.doc");
//保存.doc文件
                     ms.close();
                     ms.closeDocument();
        }

}

运行后C盘生成了1.doc文件，

    这样也是没有实际意义，所以我们要加入数据库。
    数据库依然是DB2 9.5 ，用户名db2admin 密码abc 表名admin
    我在这个项目中添加了Hibernate框架，Java程序代码如下

package com.dao;

import java.util.List;

public class Test {
        public staticvoid main(String[] args) {
                AdminDAO dao = new AdminDAO();
                List list = dao.findAll();
                MSWordManager ms=new MSWordManager(false);
                ms.createNewDocument();
                for (int i=1;i<=list.size();i++){
                        Admin admin = (Admin)list.get(1);
                        ms.insertText(admin.getName());
                        ms.insertText("本文章由jacob自动生成");
                        ms.moveEnd();
                }
                 ms.save("c://1.doc");
                 ms.closeDocument();
                 ms.close();
        }
}

运行程序后，进入c盘，打开生成的1.doc文件。

这就是Java利用开源工具jacob操作Microsoft Word

上一次我们用iText这个工具在Java环境下操作PDF文件，现在我们换一个工具：BFO
iText的确小巧，但是功能也有限制，只能简单的生成PDF文件，BFO却不同，能设置字体、版面等元素。
如何利用Java-JACOB操作WORD文档
官方网站为：http://big.faceless.org/products/pdf/
最新版本是：2.11.4
官方的解释：The Big Faceless Java PDF Library is the smartest Java PDF library for creating, editing, displaying and printing Acrobat PDF documents.
下载链接为：http://big.faceless.org/products/bfopdf-2.11.4.zip

我的开发环境：JDK1.6+MyEclipse7+Tomcat5.5.27
首先在MyEclipse中新建一个项目BFO，将下载的jar文件放入该项目的类库中。
如何利用Java-JACOB操作WORD文档

新建一个Class（类）CreateBook.java，Package（包）为com.bfo 代码如下：
package com.bfo;
import org.faceless.pdf2.*;
import java.util.Locale;
import java.awt.Color;
import java.util.*;
import java.io.*;
/**
* 创建一个PDF文档，内容来源于一个TXT文本文件。
*
* author：小段
*/
public class CreateBook
{
    private static PDFStyle numstyle;
    private static int pagenum = 1;
    private static PDF pdf;
    private static final String PAGESIZE = "A4-Landscape";
    private static final float WIDTH, HEIGHT;
    static {
        PDFPage page = new PDFPage(PAGESIZE);
        WIDTH = (page.getWidth()/2) - 100;
        HEIGHT = page.getHeight()    - 100;
    }
    public static void main(String args[]) throws IOException {
        String filename = args.length > 0 ? args[0] : "C:\\bfo.txt";
        // 设置文本源文件，并且创建一个PDF对象。
        pdf = new PDF();
        pdf.setLocale(Locale.ENGLISH);
        // 创建一个新的PDF格式，设置字体（罗马字体）、字号（11）以及颜色（黑色）。
        PDFStyle textstyle = new PDFStyle();
        textstyle.setFont(new StandardFont(StandardFont.TIMES), 11);
        textstyle.setFillColor(Color.black);
        textstyle.setTextAlign(PDFStyle.TEXTALIGN_JUSTIFY);
        numstyle = new PDFStyle();
        numstyle.setFont(new StandardFont(StandardFont.TIMES), 8);
        numstyle.setFillColor(Color.black);
        numstyle.setTextAlign(PDFStyle.TEXTALIGN_CENTER);
        LayoutBox chapter = new LayoutBox(WIDTH);
        int chapternumber = 0;
        BufferedReader in = new BufferedReader(new FileReader(filename));
        String line;
        long starttime = System.currentTimeMillis();
        System.out.println(new Date()+": Starting file");
        // 文件开始被读取.
        while ((line=in.readLine())!=null) {
            line = line.trim();
            if (line.length()==0) {
                line = "\n\n";
            } else {
                line += " ";
            }
            // 调用requote方法。
            line = textstyle.getFont().requote(line, pdf.getLocale());
            // 开始将内容写进PDF文档。
            if (line.startsWith("Chapter ")) {
                if (chapternumber>0) {
                    System.out.println(new Date()+": Writing Chapter "+chapternumber);
                    writeChapter(chapter, chapternumber);
                }
                chapternumber++;
                chapter = new LayoutBox(WIDTH);
            }
            chapter.addText(line, textstyle, pdf.getLocale());
        }
        // 将最后一个段落写入PDF文档
        System.out.println(new Date()+": Writing Chapter "+chapternumber);
        writeChapter(chapter, chapternumber);
        System.out.println(new Date()+": Compressing and writing to file");
        OutputStream out = new FileOutputStream("C:\\BFO.pdf");
        pdf.render(out);
        out.close();
        // 显示操作PDF文档的总共时间。
        System.out.println("Total time was "+(System.currentTimeMillis()-starttime)+"ms");
    }
    private static void writeChapter(LayoutBox chapter, int chapternumber) {
        PDFPage page=null;
        boolean firstpage = true;
        float left;
        // 测量文本高度以前，必须清空缓存。
        chapter.flush();
        while (chapter!=null) {
            // 清空布局格式。
            LayoutBox next=null;
            if (chapter.getHeight() > HEIGHT) {
                next = chapter.splitAt(HEIGHT);
            }
            if (pagenum%2 == 1) {
                page = pdf.newPage(PAGESIZE);
                left = 50;
                // 写下页数。
                page.setStyle(numstyle);
                page.drawText("Page "+ pagenum, page.getWidth()/4, 30);
                page.drawText("Page "+ (pagenum+1), 3*page.getWidth()/4, 30);
            } else {
                 left = (page.getWidth()/2)+50;
            }
            page.drawLayoutBox(chapter, left, page.getHeight()-50);
            chapter = next;
            pagenum++;
            // 如果是第一页的话，添加一个书签。
            if (firstpage) {
                pdf.getBookmarks().add(new PDFBookmark("Chapter "+chapternumber, PDFAction.goTo(page)));
                firstpage = false;
            }
        }
        // 确定下一个段落应该写在剩下的页面。
        pagenum |= 1;
    }
}

这是我C:\bfo.txt的内容：
如何利用Java-JACOB操作WORD文档

运行CreateBook.java后，控制台显示信息：

同时发现C盘根目录下生成了bfo.pdf文件。打开内容为：

这样一来，我们就能将一个TXT文本文件转换成PDF文档。

本文出自 “小段” 博客，请务必保留此出处http://xiaoduan.blog.51cto.com/502137/136692

秒客网

如何利用Java-JACOB操作WORD文档

相关文章