前言
JACOB一个Java-COM中间件.通过这个组件你可以在Java应用程序中调用COM组件和Win32程序库。
一、准备
<!--添加本地的jacob.jar包-->
<dependency>
<groupId>com.jacob</groupId>
<artifactId>jacob</artifactId>
<version>1.19</version>
<scope>system</scope>
<systemPath>${basedir}/src/main/resources/lib/jacob.jar</systemPath>
</dependency>
jacob.jar 下载链接 https://mvnrepository.com/artifact/com.jacob/jacob/1.10
二、代码示例
1.JacobUtil 工具类
package com.yl.util;
import com.jacob.activeX.ActiveXComponent;
import com.jacob.com.ComThread;
import com.jacob.com.Dispatch;
import com.jacob.com.Variant;
import org.springframework.stereotype.Component;
import java.io.*;
/**
*
* @author yl
* @date 2020/5/22
* Jacob 操作API
*/
@Component
public class JacobUtil {
/**
* word文档
*/
private Dispatch doc;
/**
* word运行程序对象
*/
private ActiveXComponent word;
/**
* 所有word文档集合
*/
private Dispatch documents;
/**
* 选定的范围或插入点
*/
private Dispatch selection;
private boolean saveOnExit = true;
public JacobUtil() {
ComThread.InitSTA();
if (word == null) {
word = new ActiveXComponent("Word.Application");
word.setProperty("Visible", new Variant(false));
}
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 = ActiveXComponent.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();
}
/**
* 函数名: replaceStr 描述:改变内容
*
* @param strToFind
* @param strToReplace
* @return
* @exception
*/
public void replaceStr(String strToFind, String strToReplace) {
// 提取word文档内容?象
Object content = Dispatch.get(this.doc, "Content").toDispatch();
// 提取find?象,也就?找替?的那个?象
Object finder = Dispatch.get((Dispatch) content, "Find").toDispatch();
boolean rt = true;
Variant f = new Variant(false);
while (rt) {
rt = Dispatch.invoke((Dispatch) finder, "Execute", Dispatch.Method,
new Object[] { strToFind, f, f, f, f, f, f, f, f,
strToReplace, new Variant(true) }, new int[1])
.toBoolean();
}
}
/**
* 把选定选定内容设定为替换文本
*
* @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 newText 要插入的新字符串
*/
public void insertAfterText(String newText) {
moveEnd();
// 取得当前文档的内容
Dispatch wordContent = Dispatch.get(doc, "Content").toDispatch();
// 插入特殊符定位插入点
Dispatch.call(wordContent, "InsertAfter", newText);
}
/**
* 在末尾插入回车
*
*/
public void insertNewParagraph() {
moveEnd();
Dispatch.call(selection, "TypeParagraph");
}
/**
*
* @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 tableIndex
* @param cellRowIdx
* @param cellColIdx
* @param txt
*/
public void putTxtToCellCenter(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 alignment = Dispatch.get(selection, "ParagraphFormat")
.toDispatch();
Dispatch.put(alignment, "Alignment", "3");
Dispatch.put(selection, "Text", txt);
}
/** *//**
* 在当前文档拷贝剪贴板数据
*
* @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;
}
}
}
/** *//**
* 在当前文档指定的位置拷贝来自另一个文档中的图片
*
* @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 anotherDocPath 另一个文档的磁盘路径
* @param paragraphIndex 被拷贝的段落在另一格文档中的序号(从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 paragraphIndex 被拷贝的段落在另一格文档中的序号(从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 被拷贝的表格在word文档中所处的位置(从1开始)
*/
public void copyTable2(String anotherDocPath, int tableIndex) {
// 取得当前文档的内容
Dispatch wordContent = Dispatch.get(doc, "Content").toDispatch();
// 插入特殊符定位插入点
Dispatch.call(wordContent, "InsertAfter", "$selection$");
copyTableFromAnotherDoc(anotherDocPath, tableIndex, "$selection$");
}
/**
* 创建表格
*
* @param pos
* 位置
* @param numCols
* 列数
* @param numRows
* 行数
*/
public void createTable(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");
}
}
/** *//**
* 在指定行前面增加行
*
* @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");
}
/** *//**
* 设置当前选定内容的字体
*
* @param bold
* @param italic
* @param underLine
* 下划线
* @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);
}
public void setFontCenter(String name) {
Dispatch font = Dispatch.get(selection, "Font").toDispatch();
Dispatch alignment = Dispatch.get(selection, "ParagraphFormat")
.toDispatch();
Dispatch.put(alignment, "Alignment", "3");
Dispatch.call(selection, "TypeText", name);
}
/** *//**
* 文件保存或另存为
*
* @param savePath 保存或另存为路径
*
* word 保存或另存为 word
* Dispatch.invoke(this.doc, "SaveAs", Dispatch.Method, new Object[] {
* savePath, new Variant(0) }, new int[1]);
*/
public void save(String savePath, int format) {
/**
* Dispatch.call(doc, "SaveAs", savePath);
* Dispatch.call(Dispatch.call(word, "WordBasic").getDispatch(),
* "FileSaveAs", savePath);
*/
// word 保存或另存为 word
Dispatch.invoke(this.doc, "SaveAs", Dispatch.Method, new Object[] {
savePath, new Variant(format) }, new int[1]);
}
public void saveCall2(String savePath) {
Dispatch.call(Dispatch.call(word, "WordBasic").getDispatch(),"FileSaveAs", savePath);
}
public void saveCall(String savePath, int format) {
Dispatch.call(doc, "SaveAs", savePath, format);
}
/** *//**
* 关闭当前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;
ComThread.Release();
}
/** *//**
* 打印当前word文档
*
*/
public void printFile() {
if (doc != null) {
Dispatch.call(doc, "PrintOut");
}
}
/** *//**
* 删除一行
*
* @param tableIndex
* word文档中的第N张表(从1开始)
*/
public void delRow(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();
Object temp1 = Dispatch.get(rows, "Count");
String temp2 = temp1.toString();
int count = Integer.parseInt(temp2);
while (count > 1) {
Dispatch row = Dispatch.get(rows, "Last").toDispatch();
Dispatch.call(row, "Delete");
rows = Dispatch.get(table, "Rows").toDispatch();
temp1 = Dispatch.get(rows, "Count");
temp2 = temp1.toString();
count = Integer.parseInt(temp2);
}
}
public void setProp(String sName, String sValue) {
Dispatch props = Dispatch.get(doc, "CustomDocumentProperties")
.toDispatch();
Dispatch prop = Dispatch.call(props, "Item", sName).toDispatch();
String sOldVal = Dispatch.get(prop, "Value").toString();
if (!sOldVal.equals(sValue)) {
Dispatch.put(prop, "Value", sValue);
}
}
/** *//**
* @param nType:
* 1, number; 2,bool; 3,date; 4,str;
*/
public void addProp(String sName, int nType, String sValue) {
Dispatch props = Dispatch.get(doc, "CustomDocumentProperties")
.toDispatch();
Dispatch prop = null;
try {
prop = Dispatch.call(props, "Item", sName).toDispatch();
} catch (Exception e) {
prop = null;
}
if (prop != null) {
return;
}
// 1, number; 2,bool; 3,date; 4,str;
prop = Dispatch.call(props, "Add", sName, false, nType, sValue)
.toDispatch();
Dispatch.put(prop, "Value", sValue);
}
public String getProp(String sName) {
String sValue = null;
Dispatch props = Dispatch.get(doc, "CustomDocumentProperties")
.toDispatch();
Dispatch prop = Dispatch.call(props, "Item", sName).toDispatch();
sValue = Dispatch.get(prop, "Value").toString();
@SuppressWarnings("unused")
String sType = Dispatch.get(prop, "Type").toString();
try {
Dispatch prop0 = Dispatch.call(doc, "CustomDocumentProperties",
sName).toDispatch();
sValue = Dispatch.get(prop0, "Value").toString();
} catch (Exception e) {
e.printStackTrace();
}
return sValue;
}
public void fack_change() {
Dispatch _sel = Dispatch.call(doc, "Range", 0, 0).toDispatch();
Dispatch.call(_sel, "InsertBefore", "A");
Dispatch.call(_sel, "Select");
Dispatch.call(_sel, "Delete");
}
/**
* 拷贝Word文档
* @param src
* @param dest
*/
public void copyWordFile(String src, String dest){
InputStream is=null;
OutputStream os=null;
try {
is=new BufferedInputStream(new FileInputStream(src));
os=new BufferedOutputStream(new FileOutputStream(dest));
byte[] b=new byte[256];
int len=0;
try {
while((len=is.read(b))!=-1){
os.write(b,0,len);
}
os.flush();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(is!=null){
try {
is.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(os!=null){
try {
os.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
2.Word文档转其他-操作示例
package com.yl.test;
import com.yl.util.JacobUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import java.io.File;
import java.time.LocalDate;
import java.time.LocalDateTime;
/**
* Word文档转其他
* @author yl
* @date 2020/5/22
*/
@Slf4j
public class WordConvertOther {
@Autowired
private JacobUtil jacobUtil = new JacobUtil();
/**
* WORD 转 PDF 格式
*/
private static final int WORD_TO_PDF_FORMAT_ = 17;
/**
* WORD 转 XML 格式
*/
private static final int WORD_TO_XML_FORMAT_ = 11;
/**
* WORD 转 HTML 格式
*/
private static final int WORD_TO_HTML_FORMAT_ = 8;
/**
* WORD 另存 格式
*/
private static final int WORD_TO_WORD_FORMAT_ = 0;
/**
* WORD 转 PDF
* @param fromFileName
* @param toFileName
*/
public void wordToPDF(String fromFileName, String toFileName){
try{
log.info("word 文档路径=, {}, \t pdf文档路径=, {}", fromFileName, toFileName);
// 打开文档
jacobUtil.openDocument(fromFileName);
// 开始转换
jacobUtil.save(toFileName, WORD_TO_PDF_FORMAT_);
}catch (Exception e){
e.printStackTrace();
}finally {
// 关闭文档
jacobUtil.closeDocument();
// 关闭程序
jacobUtil.close();
}
}
/**
* WORD 转 HTML
* @param fromFileName
* @param toFileName
*/
public void wordToHTML(String fromFileName, String toFileName){
try{
log.info("word 文档路径=, {}, \t html文档路径=, {}", fromFileName, toFileName);
// 打开文档
jacobUtil.openDocument(fromFileName);
// 开始转换
jacobUtil.save(toFileName, WORD_TO_HTML_FORMAT_);
}catch (Exception e){
e.printStackTrace();
}finally {
// 关闭文档
jacobUtil.closeDocument();
// 关闭程序
jacobUtil.close();
}
}
/**
* WORD 转 XML
* @param fromFileName
* @param toFileName
*/
public void wordToXML(String fromFileName, String toFileName){
try{
log.info("word 文档路径=, {}, \t xml文档路径=, {}", fromFileName, toFileName);
// 打开文档
jacobUtil.openDocument(fromFileName);
// 开始转换
jacobUtil.save(toFileName, WORD_TO_XML_FORMAT_);
}catch (Exception e){
e.printStackTrace();
}finally {
// 关闭文档
jacobUtil.closeDocument();
// 关闭程序
jacobUtil.close();
}
}
/**
* WORD 另存
* @param fromFileName
* @param toFileName
*/
public void wordToSave(String fromFileName, String toFileName){
try{
log.info("word 文档路径=, {}, \t 新word文档路径=, {}", fromFileName, toFileName);
// 打开文档
jacobUtil.openDocument(fromFileName);
// 开始转换
jacobUtil.save(toFileName, WORD_TO_WORD_FORMAT_);
// 替换内容
jacobUtil.replaceAllText("东芝电梯", "著水电站");
// 再次转换
jacobUtil.save(toFileName, WORD_TO_WORD_FORMAT_);
}catch (Exception e){
e.printStackTrace();
}finally {
// 关闭文档
jacobUtil.closeDocument();
// 关闭程序
jacobUtil.close();
}
}
/**
* 创建Word文档
* @param fromFileName
* @param toFileName
*/
public void createWord(String fromFileName, String toFileName){
try{
log.info("createWord 文档路径=, {}, \t 新word文档路径=, {}", fromFileName, toFileName);
// 获取临时文件
log.info("创建临时文件");
String proDir = System.getProperty("user.dir") +"/springboot-jacob/src/main/resources";
String tempFileName = proDir +"/temp/"+System.currentTimeMillis()+"-WJZ_Apply.doc";
// 模板文件1
String modelOne = proDir +"/fromFiles/2020-05-22-0922147777meetingInfo.doc";
// 模板文件2
String modelTwo = proDir +"/fromFiles/2020-05-22-0922147777meetingInfomeetingCopytemp.doc";
// 复制模板1到临时文件
jacobUtil.copyWordFile(modelOne, tempFileName);
// 打开临时文件
log.info("打开临时文件");
jacobUtil.openDocument(tempFileName);
// 替换值
// 时间
jacobUtil.replaceAllText("${meeting_date}$", "2020-07-10 08:56:26");
// 地点
jacobUtil.replaceAllText("${meeting_address}$", "上海宝山区");
// 出席者
jacobUtil.replaceAllText("${meeting_attend_dept}$", "程序员XX");
// 复制模板2到临时文件
jacobUtil.copyParagraphFromAnotherDoc(modelTwo, 1);
// 插入数据
String temp;
for (int i = 0; i < 100; i++) {
// 插入标识符
jacobUtil.insertAfterText("${WordContent}$");
// 替换标识符
temp = "本月回复:催款人" + i
+ " 拖欠原因" + i
+ " 现场动态描述" + i
+ " 本月工作实施记录" + i
+ " 客户意见" + i
+ " 代理店意见" + i
+ " 代理店意见" + i;
log.info("WordContent --- temp , {}", temp);
jacobUtil.moveStart();
jacobUtil.replaceAllText(temp, "${WordContent}$");
// 在末尾插入回车
jacobUtil.insertNewParagraph();
jacobUtil.moveEnd();
// 日期
jacobUtil.insertAfterText("${Word_Time}$");
LocalDate today = LocalDate.now();
int year = today.getYear();
int month = today.getMonthValue();
int day = today.getDayOfMonth();
temp = year + "年"
+ month + "月"
+ day + "日" + "会议记录:";
log.info("Word_Time --- temp , {}", temp);
jacobUtil.moveStart();
jacobUtil.replaceAllText(temp, "${Word_Time}$");
// 在末尾插入回车
jacobUtil.insertNewParagraph();
jacobUtil.moveEnd();
jacobUtil.copyParagraphFromAnotherDoc(toFileName, 2);
// COPY 表格
jacobUtil.copyTable2(tempFileName, 1);
jacobUtil.insertNewParagraph();
log.info("执行 "+i+" 次 , "+System.currentTimeMillis());
}
}catch (Exception e){
e.printStackTrace();
}finally {
// 关闭文档
jacobUtil.closeDocument();
// 关闭程序
jacobUtil.close();
}
}
public static void main(String[] args) throws Exception{
String proDir = System.getProperty("user.dir") +"/springboot-jacob/src/main/resources";
WordConvertOther wordConvertOther = new WordConvertOther();
String fromFileName = proDir +"/fromFiles/2020-05-22-0922147777meetingInfo.doc";
String toFileName = proDir +"/toFiles/"+System.currentTimeMillis()+"-meetingInfo.doc";
wordConvertOther.createWord(fromFileName, toFileName);
// String fromFileName = proDir +"/fromFiles/2020-05-22-0922147777WJZ_Apply.doc";
//
// // WORD 转 PDF 自身office不支持
// String toPdfFileName = proDir +"/toFiles/"+System.currentTimeMillis()+"-WJZ_Apply.pdf";
// wordConvertOther.wordToPDF(fromFileName, toPdfFileName);
//
// // WORD 转 HTML OK
// String toHtmlFileName = proDir +"/toFiles/"+System.currentTimeMillis()+"-WJZ_Apply.html";
// wordConvertOther.wordToHTML(fromFileName, toHtmlFileName);
//
// // WORD 转 HTML OK
// String toXmlFileName = proDir +"/toFiles/"+System.currentTimeMillis()+"-WJZ_Apply.xml";
// wordConvertOther.wordToXML(fromFileName, toXmlFileName);
//
// // WORD 另存 OK
// String toWordFileName = proDir +"/toFiles/"+System.currentTimeMillis()+"-WJZ_Apply.doc";
// wordConvertOther.wordToSave(fromFileName, toWordFileName);
}
}
以上