jacob 使用模板导出word

/*************************************

*

*作用：利用jacob插件根据模板word生成word 文件！

*

*传入数据为HashMap对象，对象中的Key代表word模板中要替换的字段，Value代表用来替换的值。

* word模板中所有要替换的字段（即HashMap中的Key）以特殊字符开头和结尾，如：$code$、$date$……，以免执行错误的替换。

* 所有要替换为图片的字段，Key中需包含image或者Value为图片的全路径（目前只判断文件后缀名为：.bmp、.jpg、.gif）。

* 要替换表格中的数据时，HashMap中的Key格式为“table$R@N”，其中：R代表从表格的第R行开始替换，N代表word模板中的第N张表格；

* Value为ArrayList对象，ArrayList中包含的对象统一为String[]，一条String[]代表一行数据，ArrayList中第一条记录为特殊记录，

* 记录的是表格中要替换的列号，如：要替换第一列、第三列、第五列的数据，则第一条记录为String[3] {“1”,”3”,”5”}。

*

*

*create on 2007.3.6

*author fgl

*

*

************************************/

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import com.jacob.activeX.ActiveXComponent;

import com.jacob.com.ComThread;

import com.jacob.com.Dispatch;

import com.jacob.com.Variant;

public class Java2Word {

private boolean saveOnExit;

/**

* word文档

*/

private Dispatch doc = null;

/**

* word运行程序对象

*/

private ActiveXComponent word;

/**

* 所有word文档

*/

private Dispatch documents;

/**

* 构造函数

*/

public Java2Word() {

saveOnExit = false;

word = new ActiveXComponent("Word.Application");

word.setProperty("Visible", new Variant(false));

documents = word.getProperty("Documents").toDispatch();

}

/**

* 设置参数：退出时是否保存

*

* @param saveOnExit

* true-退出时保存文件，false-退出时不保存文件

*/

public void setSaveOnExit(boolean saveOnExit) {

this.saveOnExit = saveOnExit;

}

/**

* 得到参数：退出时是否保存

*

* @return boolean true-退出时保存文件，false-退出时不保存文件

*/

public boolean getSaveOnExit() {

return saveOnExit;

}

/**

* 打开文件

*

* @param inputDoc

* 要打开的文件，全路径

* @return Dispatch 打开的文件

*/

public Dispatch open(String inputDoc) {

return Dispatch.call(documents, "Open", inputDoc).toDispatch();

}

/**

* 选定内容

*

* @return Dispatch 选定的范围或插入点

*/

public Dispatch select() {

return word.getProperty("Selection").toDispatch();

}

/**

* 把选定内容或插入点向上移动

*

* @param selection

* 要移动的内容

* @param count

* 移动的距离

*/

public void moveUp(Dispatch selection, int count) {

for (int i = 0; i < count; i++)

Dispatch.call(selection, "MoveUp");

}

/**

* 把选定内容或插入点向下移动

*

* @param selection

* 要移动的内容

* @param count

* 移动的距离

*/

public void moveDown(Dispatch selection, int count) {

for (int i = 0; i < count; i++)

Dispatch.call(selection, "MoveDown");

}

/**

* 把选定内容或插入点向左移动

*

* @param selection

* 要移动的内容

* @param count

* 移动的距离

*/

public void moveLeft(Dispatch selection, int count) {

for (int i = 0; i < count; i++)

Dispatch.call(selection, "MoveLeft");

}

/**

* 把选定内容或插入点向右移动

*

* @param selection

* 要移动的内容

* @param count

* 移动的距离

*/

public void moveRight(Dispatch selection, int count) {

for (int i = 0; i < count; i++)

Dispatch.call(selection, "MoveRight");

}

/**

* 把插入点移动到文件首位置

*

* @param selection

* 插入点

*/

public void moveStart(Dispatch selection) {

Dispatch.call(selection, "HomeKey", new Variant(6));

}

/**

* 从选定内容或插入点开始查找文本

*

* @param selection

* 选定内容

* @param toFindText

* 要查找的文本

* @return boolean true-查找到并选中该文本，false-未查找到文本

*/

public 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

* 替换为文本

*/

public void replace(Dispatch selection, String newText) {

// 设置替换文本

Dispatch.put(selection, "Text", newText);

}

/**

* 全局替换

*

* @param selection

* 选定内容或起始插入点

* @param oldText

* 要替换的文本

* @param newText

* 替换为文本

*/

public void replaceAll(Dispatch selection, String oldText, Object replaceObj) {

// 移动到文件开头

moveStart(selection);

if (oldText.startsWith("table") || replaceObj instanceof List) {

replaceTable(selection, oldText, (List) replaceObj);

} else {

String newText = (String) replaceObj;

if (oldText.indexOf("image") != -1

|| newText.lastIndexOf(".bmp") != -1

|| newText.lastIndexOf(".jpg") != -1

|| newText.lastIndexOf(".gif") != -1)

while (find(selection, oldText)) {

replaceImage(selection, newText);

Dispatch.call(selection, "MoveRight");

}

else

while (find(selection, oldText)) {

replace(selection, newText);

Dispatch.call(selection, "MoveRight");

}

}

}

/**

* 替换图片

*

* @param selection

* 图片的插入点

* @param imagePath

* 图片文件（全路径）

*/

public void replaceImage(Dispatch selection, String imagePath) {

Dispatch.call(Dispatch.get(selection, "InLineShapes").toDispatch(),

"AddPicture", imagePath);

}

/**

* 替换表格

*

* @param selection

* 插入点

* @param tableName

* 表格名称，形如table$1@1、table$2@1...table$R@N，R代表从表格中的第N行开始填充，

* N代表word文件中的第N张表

* @param fields

* 表格中要替换的字段与数据的对应表

*/

public void replaceTable(Dispatch selection, String tableName, List dataList) {

if (dataList.size() <= 1) {

System.out.println("Empty table!");

return;

}

// 要填充的列

String[] cols = (String[]) dataList.get(0);

// 表格序号

String tbIndex = tableName.substring(tableName.lastIndexOf("@") + 1);

// 从第几行开始填充

int fromRow = Integer.parseInt(tableName.substring(

tableName.lastIndexOf("$") + 1, tableName.lastIndexOf("@")));

// 所有表格

Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();

// 要填充的表格

Dispatch table = Dispatch.call(tables, "Item", new Variant(tbIndex))

.toDispatch();

// 表格的所有行

Dispatch rows = Dispatch.get(table, "Rows").toDispatch();

// 填充表格

for (int i = 1; i < dataList.size(); i++) {

// 某一行数据

String[] datas = (String[]) dataList.get(i);

// 在表格中添加一行

if (Dispatch.get(rows, "Count").getInt() < fromRow + i - 1)

Dispatch.call(rows, "Add");

// 填充该行的相关列

for (int j = 0; j < datas.length; j++) {

// 得到单元格

Dispatch cell = Dispatch.call(table, "Cell",

Integer.toString(fromRow + i - 1), cols[j])

.toDispatch();

// 选中单元格

Dispatch.call(cell, "Select");

// 设置格式

Dispatch font = Dispatch.get(selection, "Font").toDispatch();

Dispatch.put(font, "Bold", "0");

Dispatch.put(font, "Italic", "0");

// 输入数据

Dispatch.put(selection, "Text", datas[j]);

}

}

}

/**

* 保存文件

*

* @param outputPath

* 输出文件（包含路径）

*/

public void save(String outputPath) {

Dispatch.call(Dispatch.call(word, "WordBasic").getDispatch(),

"FileSaveAs", outputPath);

}

/**

* 关闭文件

*

* @param document

* 要关闭的文件

*/

public void close(Dispatch doc) {

Dispatch.call(doc, "Close", new Variant(saveOnExit));

}

/**

* 退出程序

*/

public void quit() {

word.invoke("Quit", new Variant[0]);

ComThread.Release();

}

/**

* 根据模板、数据生成word文件

*

* @param inputPath

* 模板文件（包含路径）

* @param outPath

* 输出文件（包含路径）

* @param data

* 数据包（包含要填充的字段、对应的数据）

*/

public void toWord(String inputPath, String outPath, HashMap data) {

String oldText;

Object newValue;

try {

doc = open(inputPath);

Dispatch selection = select();

Iterator keys = data.keySet().iterator();

while (keys.hasNext()) {

oldText = (String) keys.next();

newValue = data.get(oldText);

replaceAll(selection, oldText, newValue);

}

save(outPath);

} catch (Exception e) {

System.out.println("操作word文件失败！"+e.getMessage());

} finally {

if (doc != null)

close(doc);

}

}

public static void main(String[] args) {

Java2Word java2word = new Java2Word();

HashMap<String, String> data = new HashMap<String,String>();

data.put("$VAR$", "君不见黄河之水天上来");

java2word.toWord("F:\\template.doc", "F:\\result.doc", data);

}

}