JACob实现java与com组件的相互操作

软件的互操作性是一个我们经常面临的问题，如果 Java 可以自由的调用其他语言和平台的成熟代码，可以充分利用您的
Java 技能，大大提高您的生产力。现有的 Java COM 互操作技术有很多种实现，JACOB 开源项目提供了一个简单方便的通用调用框架，本文就结合一个实例来介绍 JACOB 项目的使用和优点。

我们在实现复杂软件或者进行集成环境的测试时，往往要与各种应用程序打交道。理想情况下，如果能用一种编程语言实现所有功能是很令人憧憬的，但由于遗留代码、语言的能力和厂商的互操作性的策略不同，这往往是一个不现实的目标。比如您可以使用
C#，C++ 或 VB 等语言方便的操作 Outlook 邮箱，但是如果您是一个 Java 程序员，事情就不那么简单了。如果我们可以在 Java 中调用 COM 组件，就可以充分利用您的 Java 技能和现有的成熟 COM 工具包，大大简化应用开发的过程。

COM 组件提供了一种与其他语言的互操作方式，叫做自动化（Automation）。现有的 Java COM 互操作的解决方案有很多种，由于设计目的的不同，在性能、易用性等方面都有很大的区别。本文介绍的 JACOB 开源项目，致力于简化 Java 操作 COM 组件，提供了一个虚拟机独立的自动化服务器实现，由于其通用性设计，您可以非常简单地完成对现有应用的集成。

JACOB 项目的由来

首先，我们将了解 JACOB 项目的基本情况，探讨在什么样的情况下选择它来完成您的任务

有关自动化的更多细节，您可以参考相关文档和书籍，我们仅做简单介绍。调用 COM 中暴露出来的方法，主要有两种机制：早期绑定和晚期绑定。

早期绑定显式的声明对象、数据类型等，编译器获取了足够的信息在编译期进行链接和优化，这样通常可以获得更好的性能，通过这种机制实现 Bridge 调用可以参考 IBM 的 RJCB 项目，它提供了一套高性能的解决方案。当然您需要了解更多 COM 组件的细节，虽然框架为您完成了大部分的生成 Bridge 代码的工作，但是总体来说，编码工作量还是偏大，编码难度也比较高，而且 RJCB 仅支持那些提供早期绑定的 vtable 接口的 COM API。

而晚期绑定方式是通过 IDispatch接口来实现，类似
Java 的反射机制，您可以按照名称或者 ID 进行方法调用，这种设计主要目的是支持脚本语言操作 COM，因为脚本是解释执行的，通常都不支持指针也就没有 C++ 中的 vtable 机制，无法实现早期绑定。这种方式的缺点是在一定程度上性能较差，由于是在运行时按照名字或者 ID 进行对象的调用，只有运行时才确切知道调用的是哪个对象，哪个方法，这样必然带来一定的开销和延迟。但是这种方式的优点也是非常明显的，简单、灵活，您可以不必关注动态链接库的细节，可以非常快地完成代码开发工作。

JACOB 开源项目提供的是一个 JVM 独立的自动化服务器实现，其核心是基于 JNI 技术实现的 Variant, Dispatch 等接口，设计参考了 Microsoft VJ++ 内置的通用自动化服务器，但是 Microsoft 的实现仅仅支持自身的 JVM。通过 JACOB，您可以方便地在 Java 语言中进行晚期绑定方式的调用。

下图是一个对 JACOB 结构的简单说明



实际案列，java操作Word文档，包括word文档的创建、写入文本、插入表格、打印等一系列操作，环境准备，下载jacob类库，我们可以通过下面两种方式获取：

我的资源中：http://download.csdn.net/detail/harderxin/8240309

官方网站：http://danadler.com/jacob/

下载后我们需要两个文件，一个是jacob.jar，另一个是一个dll文件，根据你的操作系统来决定，32位操作系统(jacob-1.17-M2-x86.dll)，64位操作系统(jacob-1.17-M2-x64.dll)，新建java项目工程，将jacob.jar加入到工程中；

下面一步很重要，就是将jacob-1.14.3-x86.dll设置到系统的环境变量中，我们也可以将其放到当前jdk的bin目录下面：



如果没有设置上面那个dll文件，那么程序运行会抛出下面的异常信息：



下面，我们来编写我们的程序，主要是用到jacob中的几个主要的API：ActiveXComponent、Dispatch、Variant

[java] view
plain copy







package com.xin.test;

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");

}

}

}

创建测试程序：

[java] view
plain copy







/**

* 使用jacob对office操作

* @author dell

*

*/

public class Client {

public static void main(String[] args) {

MSWordManager manager = new MSWordManager(true);

// 生成一个MSwordManager对象,并且设置显示Word程序

manager.createNewDocument();

// 创建一个新的.doc文件

manager.insertText("Test jacob");

// 插入文本

manager.save("d:\\1.doc");

// 保存.doc文件

manager.close();

manager.closeDocument();

//manager.moveEnd();//将光标移至末尾

}

}

运行结果，我们则通过java在d盘符下面创建了一个1.doc，其中的内容为Test jacob

使用jacob操作excel：

[java] view
plain copy







public class Client2 {

public static void main(String[] args)

{

ActiveXComponent xl = new ActiveXComponent("Excel.Application");

Dispatch xlo = xl.getObject();

try {

System.out.println("version="+xl.getProperty("Version"));

System.out.println("version="+Dispatch.get(xlo, "Version"));

xl.setProperty("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[] {});

}

}

}

运行结果是创建了excel文件，得到其相应的属性。

--用到主要的方法

ActiveXComponent中创建不同的控件调用不同的值

* 假设创建的对象名称为ax，常用对照如下：

* Word——Word.Application

* Excel——Excel.Application

* Powerpoint——Powerpoint.Application

* Outlook——Outlook.Application

经查找发现,其实"Word.Application.12"就是com在注册表中的progID; ProgID是程序员给某个CLSID指定一个易记的名字，其 组成：<program>.<component>.<version> 在注册表HKey_Classes_Root下，有版本号的ProgID和无版本号的ProgID都有列出，一般无版本号的除了有CLSID子键外会还有CurVer子键来标明版本

ax.getObject()--获得对应控件的Dispatch对象

documents=ax.getProperty("Documents")--获得对应控件的Dispatch对象

get(a,"b")--获得a对象数据结构中的b属性

call(a,"b"，"c")--该方法和get方法非常类似,是把b属性赋值给c

put(a,"b","c")--将ax对象a的属性b设置为c

转载于：http://blog.csdn.net/harderxin/article/details/41825593?utm_source=tuicool&utm_medium=referral