Jacob替换word中指定文本

public class JacobWord {

private boolean saveOnExit;

//word文档
Dispatch doc = null;

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

//所有word文档
static Dispatch documents;

static{
word = new ActiveXComponent("Word.Application");
word.setProperty("Visible", new Variant(false));
documents = word.getProperty("Documents").toDispatch();
}

//构造函数
public JacobWord(){
saveOnExit = true;
}
/**
* 打开文件
* @param documents
* @param inputDocPath
* @return
*/
private Dispatch open(Dispatch documents,String inputDocPath){
return Dispatch.call(documents,"Open",inputDocPath).toDispatch();
}

/**
* 选定内容
* @param word
* @return
*/
private Dispatch select(ActiveXComponent word){
return word.getProperty("Selection").toDispatch();
}

/**
* 把插入点移动到文件首位置
* @param selection
*/
private void moveStart(Dispatch selection){
Dispatch.call(selection, "HomeKey",new Variant(6));
}

/**
* 从选定内容或插入点开始查找文本
* @param selection 选定内容
* @param toFindText    要查找的文本
* @return  true：查找到并选中该文本；false：未查找到文本。
*/
private boolean find(Dispatch selection,String toFindText){
//从selection所在位置开始查询
Dispatch find = Dispatch.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 selection
* @param newText
*/
private void replace(Dispatch selection,String newText){
Dispatch.put(selection, "Text", newText);
}

/**
* 全局替换
* @param selection
* @param oldText
* @param replaceObj
*/
private void replaceAll(Dispatch selection,String oldText,Object replaceObj){
moveStart(selection);
String newText = (String)replaceObj;
while(find(selection,oldText)){
replace(selection,newText);
Dispatch.call(selection, "MoveRight");
}
}

/**
* 打印
* @param document
*/
private void print(Dispatch document){
Dispatch.call(document, "PrintOut");
}

/**
* 保存文件
* @param word
* @param outputPath
*/
private void save(ActiveXComponent word,String outputPath){
Dispatch.call(Dispatch.call(word, "WordBasic").getDispatch(), "FileSaveAs",outputPath);
}

/**
* 关闭文件
* @param doc
*/
private void close(Dispatch doc){
Dispatch.call(doc, "Close",new Variant(true));
}

/**
* 保存打印doc文档
* @param inputDocPath
* @param outPutDocPath
* @param data
* @param isPrint
*/
public void saveDoc(String inputDocPath,String outPutDocPath,HashMap data,boolean isPrint){
//初始化com的线程
ComThread.InitSTA();
//word运行程序对象
ActiveXComponent word = new ActiveXComponent("Word.Application");
//文档对象
Dispatch wordObject = (Dispatch) word.getObject();
//设置属性  Variant(true)表示word应用程序可见
Dispatch.put((Dispatch)wordObject,"Visible", new Variant(false));
//word所有文档
Dispatch documents = word.getProperty("Documents").toDispatch();
//打开文档
Dispatch document = this.open(documents,inputDocPath);
Dispatch selection = this.select(word);
Iterator keys = data.keySet().iterator();
String oldText;
Object newValue;
while(keys.hasNext()){
oldText = (String)keys.next();
newValue = data.get(oldText);
this.replaceAll(selection, oldText, newValue);
}
//是否打印
if(isPrint){
this.print(document);
}
this.save(word,outPutDocPath);
this.close(document);
word.invoke("Quit", new Variant[0]);
//关闭com的线程
ComThread.Release();
}
}

原文链接：http://yulun7777777.iteye.com/blog/350379

以下部分为保留痕迹的相关写法：

package app.util;

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

public class WordBean {
// word文档
private Dispatch doc;
// word运行程序对象
private ActiveXComponent word;
// 所有word文档集合
private Dispatch documents;
// 选定的范围或插入点
private Dispatch selection;
private boolean saveOnExit = true;

public WordBean() throws Exception {
if (word == null) {
word = new ActiveXComponent("Word.Application");
word.setProperty("Visible", new Variant(false)); // 不可见打开word
word.setProperty("AutomationSecurity", new Variant(3)); // 禁用宏
}
if (documents == null)
documents = word.getProperty("Documents").toDispatch();
}
/**
* 重载，制定文档用户名称，主要用于痕迹保留时候显示对应的用户
* @param username
* @throws Exception
*/
public WordBean(String username) throws Exception {
if (word == null) {
word = new ActiveXComponent("Word.Application");
word.setProperty("UserName", new Variant(username));
word.setProperty("Visible", new Variant(false)); // 不可见打开word
word.setProperty("AutomationSecurity", new Variant(3)); // 禁用宏
}
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();
Dispatch.put(doc, "TrackRevisions", new Variant(true));
Dispatch.put(doc, "PrintRevisions", new Variant(true));
Dispatch.put(doc, "ShowRevisions", new Variant(true));
selection = Dispatch.get(word, "Selection").toDispatch();
}

/**
*
* *只读 打开一个保护文档, *
*
* @param docPath-文件全名 *
* @param pwd-密码
*
*/

public void openDocumentOnlyRead(String docPath, String pwd)
throws Exception {
closeDocument();
doc = Dispatch.callN(
documents,
"Open",
new Object[] { docPath, new Variant(false),

new Variant(true), new Variant(true), pwd, "",
new Variant(false) }).toDispatch();
selection = Dispatch.get(word, "Selection").toDispatch();
}

public void openDocument(String docPath, String pwd) throws Exception {
closeDocument();
doc = Dispatch.callN(
documents,
"Open",
new Object[] { docPath, new Variant(false), new Variant(false),
new Variant(true), pwd }).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));

}

/**
* * 从选定内容或插入点开始查找文本 * *
*
* @param toFindText *
*            要查找的文本 *
* @return boolean true-查找到并选中该文本，false-未查找到文本
*
*/

@SuppressWarnings("static-access")
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);

}

public void closeDocument() {
if (doc != null) {
// Dispatch.call(doc, "ShowRevisions", new Variant(saveOnExit));
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");
}
}

/**
* * 获得指定的单元格里数据 * *
*
* @param tableIndex *
* @param cellRowIdx *
* @param cellColIdx *
* @return
*
*/

public String getTxtFromCell(int tableIndex, int cellRowIdx, int cellColIdx) {

// 所有表格

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

String ret = "";

ret = Dispatch.get(selection, "Text").toString();

ret = ret.substring(0, ret.length() - 1); // 去掉最后的回车符;

return ret;

}

/**
* * 在当前文档拷贝剪贴板数据 *
*
* @param pos
*
*/

public void pasteExcelSheet(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 *
*            被拷贝的表格在另一格文档中的位置 *
* @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;

}

}
}

}

原文部分源码来源于：http://www.blogjava.net/jinn/archive/2008/07/18/215709.html保留作者权利

参考文档有：http://home.searchfull.net:8080/2428009-jacob+%E6%93%8D%E4%BD%9C+word+.html 保留作者权利

jccob官网：http://danadler.com/jacob/

原文链接：http://feohoo.iteye.com/blog/732980

注意：如果你使用的IDE能启动tomcat这样的服务器，同时你使用组件是在J2EE程序中，可能运行报错，处理方式，单独启动服务器，不要使用IDE启动服务器，然后OK