package https://www.doczj.com/doc/317001185.html,innet.bysj.word;
import java.io.File;
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 https://www.doczj.com/doc/317001185.html,.Dispatch;
import https://www.doczj.com/doc/317001185.html,.Variant;
public class MSWordManager {
// word文档
private Dispatch doc;
// word运行程序对象
private ActiveXComponent word;
// 所有word文档集合
private Dispatch documents;
// 选定的范围或插入点
private Dispatch selection;
private boolean saveOnExit = true;
private static final int WORD_HTML = 8;
private static final int WORD_TXT = 7;
private static final int EXCEL_HTML = 44;
/** *//**
*
* @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),new Variant(1)).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();
V ariant vMacroName = new Variant("Normal.NewMacros.tableFit");
V ariant vParam = new Variant("param1");
V ariant 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");
}
}
// 填充书签
private void fillBookmarks(String[] bookmarks, String[] fillValues) {
}
/**
* WORD转HTML
* @param docfile WORD文件全路径
* @param htmlfile 转换后HTML存放路径
*/
public void wordToHtml(String docfile, String htmlfile) {
ActiveXComponent app = new ActiveXComponent("Word.Application"); // 启动word
try {
app.setProperty("Visible", new Variant(false));
Dispatch docs = app.getProperty("Documents").toDispatch();
Dispatch doc = Dispatch.invoke(
docs,
"Open",
Dispatch.Method,
new Object[] { docfile, new Variant(false),
new Variant(true) }, new int[1]).toDispatch();
/* Dispatch bookmarks = Dispatch.call(doc, "Bookmarks").toDispatch();
for (int i = 1; i <= Dispatch.get(bookmarks, "Count").getInt(); i++) {
Dispatch item = Dispatch.call(bookmarks, "Item", i).toDispatch();
Dispatch range = Dispatch.get(item, "Range").toDispatch();
String name = Dispatch.get(item, "name").toString();
//"@@"+name+"@@"
Dispatch.put(range, "Text", "@"+name+"@");
} */
Dispatch.invoke(doc, "SaveAs", Dispatch.Method, new Object[] {
htmlfile, new Variant(WORD_HTML) }, new int[1]);
V ariant f = new Variant(false);
Dispatch.call(doc, "Close", f);
} catch (Exception e) {
e.printStackTrace();
} finally {
app.invoke("Quit", new Variant[] {});
}
}
public static void main(String args[])throws Exception {
MSWordManager msWordManager = new MSWordManager(true);
msWordManager.createNewDocument();
msWordManager.insertText("aaaaaaaaaaaaaaaaaaaaa");
msWordManager.moveEnd();
msWordManager.close();
}
/**
* 插入页码
* @param startnum
*/
public void insertpagenumber(int startnum) {
//取得活动窗体对象
Dispatch ActiveWindow = word.getProperty("ActiveWindow").toDispatch();
//取得活动窗格对象
Dispatch ActivePane = Dispatch.get(ActiveWindow,"ActivePane").toDispatch();
//取得视窗对象
Dispatch View = Dispatch.get(ActivePane, "View").toDispatch();
Dispatch.put(View, "SeekView", "10"); // 10是设置页脚
final Dispatch Sections = Dispatch.get(doc, "Sections").toDispatch();
final Dispatch item = Dispatch.call(Sections, "Item", new Variant(1)).toDispatch();
final Dispatch footer = Dispatch.get(item, "Footers").toDispatch();
final Dispatch f1 = Dispatch.call(footer, "Item", new Variant(1)).toDispatch();
final Dispatch range = Dispatch.get(f1, "Range").toDispatch();
final Dispatch fields = Dispatch.get(range, "Fields").toDispatch();
Dispatch paragraphFormat=(Dispatch) Dispatch.get(selection,"ParagraphFormat").getDispatch();
Dispatch.put(paragraphFormat, "Alignment", 1);
Dispatch.call(fields, "Add", Dispatch.get(selection, "Range").toDispatch(), new Variant(-1), "Page", true).toDispatch();
// Dispatch.call(selection, "TypeText", "/");
// Dispatch.call(fields, "Add", Dispatch.get(selection, "Range").toDispatch(), new Variant(-1), "NumPages",true).toDispatch();
Dispatch font = Dispatch.get(range, "Font").toDispatch();
Dispatch.put(font,"Name",new Variant("宋体_GB2312"));
Dispatch.put(font, "Size", 9);
Dispatch.put(View, "SeekView", new Variant(0)); //wdSeekMainDocument-0恢复视图;
}
/**
* 执行宏
* @param str 宏的名字
*/
public void callmacros(String str) {
Dispatch.call(word, "Run", new Variant(str));
}
/**
* 插入分页符不分节
*/
public void InsertBreak() {
Dispatch.call(selection, "InsertBreak" , new Variant(7) );
}
/**
* 插入分页符下一节
*/
public void InsertBreakNextPage() {
Dispatch.call(selection, "InsertBreak" , new Variant(2) );
}
/**
* 设置当前段落格式居中，左对齐，右对齐
* @param alignment 0:居左，1：居中，2：居右，3：2端对齐
*/
public void getParagraphsProperties(int alignment){
Dispatch paragraphs = Dispatch.get(selection, "Paragraphs").toDispatch();
Dispatch.put(paragraphs, "Alignment", new Variant(alignment));
}
/** *//**
* 在当前插入点插入图片并设置图片大小
*
* @param imagePath 图片路径
* @param width 宽度
* @param height 高度
*/
public void insertImageAndSet(String imagePath,int width,int height) {
Dispatch picture = Dispatch.call(Dispatch.get(selection,"InLineShapes").toDispatch(),"AddPicture",imagePath).toDis patch(); // 添加图片
//Dispatch.call(picture, "Select"); // 选中图片
Dispatch.put(picture, "Width", new Variant(width)); // 图片的宽度
Dispatch.put(picture, "Height", new Variant(height)); // 图片的高度
}
/** *//**
* 在当前插入点插入标题
*
* @param newText 要插入的新标题
* @param titleLevel 标题的等级
*/
public void insertTitle(String newText,String titleLevel) {
Dispatch.call(selection, "TypeText", newText); // 写入标题内容
Dispatch activeDoc = word.getProperty("ActiveDocument").toDispatch();
Dispatch style = Dispatch.call(activeDoc,"Styles",titleLevel).toDispatch();
Dispatch.put(selection,"Style",style);
}
/**
* 换行
*
*/
public void enter() {
Dispatch.call(selection, "TypeParagraph");
}
/**
* 增加文档目录
*
* 目前采用固定参数方式，以后可以动态进行调整
*/
public void addTablesOfContents()
{
/* 取得ActiveDocument、TablesOfContents、range对象*/
Dispatch ActiveDocument = word.getProperty("ActiveDocument").toDispatch();
Dispatch TablesOfContents =
package com.bjsasc.avidm.avplan.evaluate.util; import java.io.File; import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import com.jacob.activeX.ActiveXComponent; import https://www.doczj.com/doc/317001185.html,FailException; import https://www.doczj.com/doc/317001185.html,Thread; import https://www.doczj.com/doc/317001185.html,.Dispatch; import https://www.doczj.com/doc/317001185.html,.Variant; public class EvaluateJacobWordUtil { /** Word应用对象*/ private ActiveXComponent wordApplication; /** 所有文档对象*/ private Dispatch wdDocuments; /** 当前活动文档对象*/ private Dispatch wdDocument; /** 当前选择范围*/ private Dispatch wdSelection; /** 所有表格对象*/ private Dispatch wdTables; /** 当前表格对象*/ private Dispatch wdTable; /** 单元格对象*/ private Dispatch tbCell; /** 所有书签对象*/ private Dispatch wdBookmarks; /** 当前书签对象*/ private Dispatch wdBookmark; /** empty */ private Dispatch range;
Java 实现word 中写入文字图片的解决方案 JAVA生成WORD文件的方法目前有以下两种方式: 一种是jacob 但是局限于windows平台往往许多JAVA程序运行于其他操作系统在此不讨论该方案; 一种是poi但是他的excel处理很程序word模块还局限于读取word的文本内容,写word文件就更弱项了. 用到的jar包： iText-2.1.5.jar iText-rtf-2.1.4.jar iTextAsian.jar <!-- https://https://www.doczj.com/doc/317001185.html,/artifact/com.lowagie/itext --> <dependency> <groupId>com.lowagie</groupId> <artifactId>itext</artifactId> <version>2.1.5</version> </dependency> <!-- https://https://www.doczj.com/doc/317001185.html,/artifact/com.lowagie/itext-rtf -->
<dependency> <groupId>com.lowagie</groupId> <artifactId>itext-rtf</artifactId> <version>2.1.4</version> </dependency> <!-- https://https://www.doczj.com/doc/317001185.html,/artifact/com.itextpdf/itext-asian --> <dependency> <groupId>com.itextpdf</groupId> <artifactId>itext-asian</artifactId> <version>5.2.0</version> </dependency> /** * 创建word文档步骤: * 1,建立文档 * 2,创建一个书写器 * 3,打开文档 * 4,向文档中写入数据 * 5,关闭文档 */
jacob操作word 自从有了JACOB后，事情变得简单多了。 但是要实现Java灵活的控制Word还是一件非常麻烦的事情。 下面介绍几个WORD常见的对象以及一些典型的处理过程，希望对大家有帮助。 （请注意：JDK1.3.2运行 Jacob比较正常，JDK1.4有问题） private ActiveXComponent word = null; private Dispatch documents = null; private Dispatch vSelection = null; private Dispatch wordfile = null; 1,初始化 word = new ActiveXComponent("Word.Application"); documents = word.getProperty("Documents").toDispatch(); （将JACOB 放在 WINNT\system32\ 下比较简单省事） 2，打开文件 wordfile = Dispatch.invoke( documents, "Open", Dispatch.Method, new Object[] { strFileName, new Variant(true),//是否进行转换 ConfirmConversions
new Variant(false)//是否只读 }, new int[1]).toDispatch(); vSelection = word.getProperty("Selection").toDispatch(); 在WORD中，选定内容进行转换时，不用象Java对象一样来回的重新取，这个对象一直有效。 在WORD中 3,显示WORD word.setProperty("Visible", new Variant(visible)); 4，设置WORD的位置 Dispatch activeWindow = Dispatch.get(word, "Application").toDispatch(); Dispatch.put(activeWindow, "WindowState", new Variant(0)); Dispatch.put(activeWindow, "Top", new Variant(0)); Dispatch.put(activeWindow, "Left", new Variant(0)); Dispatch.put(activeWindow, "Height", new Variant(600)); Dispatch.put(activeWindow, "width", new Variant(800)); 进行将JAVA内的数据和WORD交换，常用的做法是，在WORD上作一些特殊的标记，利用 FIND 和 Replace的方法进行，这个方法不是太好。 个人觉得使用超链接的模式比较方便。 有几大优点： 1， Hyperlink 有3个区域可以让开发者自己利用 ActiveDocument.Hyperlinks.Add Anchor:=Selection.Range,
import java.awt.BorderLayout; import java.awt.Toolkit; import java.awt.event.MouseEvent; import java.awt.event.MouseListener; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.io.RandomAccessFile; import https://www.doczj.com/doc/317001185.html,.HttpURLConnection; import https://www.doczj.com/doc/317001185.html,.URL; import java.util.ArrayList; import java.util.Arrays; import java.util.Date; import java.util.List; import javax.swing.ImageIcon; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JPanel; import javax.swing.SwingUtilities; import https://www.doczj.com/doc/317001185.html,mon.UIUtils; import chrriis.dj.nativeswing.swtimpl.NativeInterface; import https://www.doczj.com/doc/317001185.html,ponents.JWebBrowser; import https://www.doczj.com/doc/317001185.html,ponents.WebBrowserCommandEvent; import https://www.doczj.com/doc/317001185.html,ponents.WebBrowserEvent; import https://www.doczj.com/doc/317001185.html,ponents.WebBrowserListener; import https://www.doczj.com/doc/317001185.html,ponents.WebBrowserNavigationEvent; import https://www.doczj.com/doc/317001185.html,ponents.WebBrowserWindowOpeningEvent; import https://www.doczj.com/doc/317001185.html,ponents.WebBrowserWindowWillOpenEvent; import com.jacob.activeX.ActiveXComponent; import https://www.doczj.com/doc/317001185.html,Thread; import https://www.doczj.com/doc/317001185.html,.Dispatch; import https://www.doczj.com/doc/317001185.html,.Variant; import com.mohe.utils.system.L; /** * 主窗体 * * @author dxm * */ public class MainFrame extends JFrame {
JAVA操作word Java操作Microsoft Word之jacob(1) 现在我们一起来看看，用J1ava如何操作Microsoft Word。 jacob，官网是https://www.doczj.com/doc/317001185.html,/jacob 这是一个开源的工具。最新版本1.7 官方的解释是：The JACOB Project: A JAva-COM Bridge 这是官方对下载文件的说明： jacob.jar: a JAR file for the java classes which you must add to your CLASSPATH. The package names replace com.ms with com.jacob (for example https://www.doczj.com/doc/317001185.html,.Variant maps to https://www.doczj.com/doc/317001185.html,.Variant. jacob.dll: a small Win32 DLL which you must add to your PATH. samples: provided in Java source and compiled form to demonstrate various features of the product. In particular, a set of wrapper classes for Microsoft? ADO are provided as samples. 开发环境： JDK 1.6 MyEclipse Enterprise Workbench Version: 7.0 Milestone-1 Tomcat 5.5.27 现在MyEclipse中新建一个项目jacob，将jacob的jar包放到该项目的类库中。 我的jacob版本是1.14.3 。
Java读取word文档解决方案 java读取word文档时，虽然网上介绍了很多插件poi、java2Word、jacob、itext等等，poi无法读取格式(新的API估计行好像还在处于研发阶段，不太稳定，做项目不太敢用)；java2Word、jacob容易报错找不到注册，比较诡异，我曾经在不同的机器上试过，操作方法完全一致，有的机器不报错，有的报错，去他们论坛找高人解决也说不出原因，项目部署用它有点玄；itxt好像写很方便但是我查了好久资料没有见到过关于读的好办法。经过一番选择还是折中点采用rtf最好，毕竟rtf是开源格式，不需要借助任何插件，只需基本IO操作外加编码转换即可。rtf格式文件表面看来和doc没啥区别，都可以用word打开，各种格式都可以设定。 -----实现的功能：读取rtf模板内容（格式和文本内容），替换变化部分，形成新的rtf文档。 -----实现思路：模板中固定部分手动输入，变化的部分用$info$表示，只需替换$info$即可。 1、采用字节的形式读取rtf模板内容 2、将可变的内容字符串转为rtf编码 3、替换原文中的可变部分，形成新的rtf文档 主要程序如下：
以上为核心代码，剩余部分就是替换，从新组装java中的String.replace(oldstr,newstr);方法可以实现，在这就不贴了。源代码部分详见附件。运行源代码前提： c盘创建YQ目录，将附件中"模板.rtf"复制到YQ目录之下，运行OpreatorRTF.java文件即可，就会在YQ 目录下生成文件名如：21时15分19秒_cheney_记录.rtf的文件。。。。。文件名是在程序中指定的呵呵。由于是由商业软件中拆分出的demo所以只是将自己原来的写的程序分离，合并在一个java文件中，所以有的方法在示例程序中看似多余，没有必要那么麻烦。 对于替换部分需要循环的特例程序，我不好拆分，里面很容易暴露商业软件的东西，所以就不贴了，有需要的话可以加我QQ或者MSN，一起讨论呵呵。附件传了半天也没有传上去，没有办法只有这样搞了呵呵。模板文件附件无法存放，需要的直接联系呵呵。其实直接看以下的java程序部分，就会明白
JAVA操作word jacob(1) 现在我们一起来看看，用Java如何操Word。 jacob，官网是https://www.doczj.com/doc/317001185.html,/jacob 这是一个开源的工具。最新版本1.7 官方的解释是：The JACOB Project: A JAva-COM Bridge 开发环境： JDK 1.6 MyEclipse Enterprise Workbench Version: 7.0 Milestone-1 Tomcat 5.5.27 现在MyEclipse中新建一个项目jacob，将jacob的jar包放到该项目的类库中。 我的jacob版本是1.14.3 。
下面这一步非常重要，就是拷贝jacob目录中jacob-1.14.3-x86.dll文件到系统环境变量目录中一般情况就放在当前jdk中bin目录下。
。 这里有一个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 https://www.doczj.com/doc/317001185.html,.Dispatch; import https://www.doczj.com/doc/317001185.html,.Variant; public class MSWordManager { // word文档
java生成word的几种方案 1、Jacob是Java-COM Bridge的缩写，它在Java与微软的COM组件之间构建一座桥梁。 使用Jacob自带的DLL动态链接库，并通过JNI的方式实现了在Java平台上对COM程序的调用。DLL动态链接库的生成需要windows平台的支持。 2、Apache POI包括一系列的API，它们可以操作基于MicroSoft OLE 2 Compound Document Format的各种格式文件，可以通过这些API在Java中读写Excel、Word 等文件。他的excel处理很强大，对于word还局限于读取，目前只能实现一些简单文件的操作，不能设置样式。 3、Java2word是一个在java程序中调用MS Office Word 文档的组件(类库)。该组件提 供了一组简单的接口，以便java程序调用他的服务操作Word 文档。 这些服务包括：打开文档、新建文档、查找文字、替换文字，插入文字、插入图片、插入表格，在书签处插入文字、插入图片、插入表格等。填充数据到表格中读取表格数据，1.1版增强的功能：指定文本样式，指定表格样式。如此，则可动态排版word 文档。 4、iText操作Excel还行。对于复杂的大量的word也是噩梦。用法很简单, 但是功能很少, 不 能设置打印方向等问题。 5、JSP输出样式基本不达标，而且要打印出来就更是惨不忍睹。 6、用XML做就很简单了。Word从2003开始支持XML格式，大致的思路是先用office2003 或者2007编辑好word的样式，然后另存为xml，将xml翻译为FreeMarker模板，最后用java来解析FreeMarker模板并输出Doc。经测试这样方式生成的word文档完全符合office标准，样式、内容控制非常便利，打印也不会变形，生成的文档和office中编辑文档完全一样。 java生成pdf方案总结 1. Jasper Report生成pdf：设计思路是先生成模板，然后得到数据，最后将两者整合得到结果。但是Jasper Report的问题在于，其生成模板的方式过于复杂，即使有IDE的帮助，我们还是需要对其中的众多规则有所了解才行，否则就会给调试带来极大的麻烦。 2. openoffice生成pdf：openoffice是开源软件且能在windows和linux平台下运行。 3. itext + flying saucer生成pdf：itext和flying saucer都是免费开源的，且与平台无关，结合css和velocity技术，可以很好的实现。 一般使用第三种方案比较多，它实现的步骤是非常简单的。
使用JACOB进行Word编程示例 2015年7月2日 13:44 Jacob项目的官方地址：https://www.doczj.com/doc/317001185.html,/projects/jacob-project/ 官方介绍： JACOB is a JAVA-COM Bridge that allows you to call COM Automation components from Java. It uses JNI to make native calls to the COM libraries. JACOB runs on x86 and x64 environments supporting 32 bit and 64 bit JVMs 它是一个使用jni来调用com组件及其库文件的工具。这里仅介绍处理word文档。 首先要部署其dll文件。jacob-1.14.3-x86.dll 或 jacob-1.14.3-x64.dll，下载的文件解压后即可看到。我是直接将dll文件放在windows\system32目录下的，方便，当然也有其他做法。 其次，就是把其jar文件路径加入Windows路径中。 接着就可以在你的Java程序中调用了。我总结下大概有下面几个阶段： 1. 初始化相关参数，代码如下： // 打开Word应用程序 ActiveXComponent app = new ActiveXComponent("Word.Application"); // 设置word不可见 app.setProperty("Visible", new Variant(false)); // 打开word文件 Dispatch word = app.getProperty("Documents").toDispatch(); Dispatch doc = Dispatch.invoke(word, "Open", Dispatch.Method, new Object[] {" File Name", new Variant(false), new Variant(false) }, new int[1]).toDispatch(); //获取指针 Dispatch cursor = app.getProperty("Selection").toDispatch(); 如上，我们打开了一个名为File Name的word文件，你可能会觉得最后那句看起来很繁琐，是的，有更好的代替方式，如下： Dispatch doc = Dispatch.call(word, "Open", new Variant(false), new Variant(false) ).toDisptach(); 这正是Jacob给我们提供的两种调用方式。 2. 处理word文档，如果你先前有VBA相关开发经验，那就简单了。没有的也没事，打开office程序目录下的2052\VBAWD10.chm，这里有Word的对象模型的所有记录。 接着讲述下Jacob中两种最常用的类型： Variant：这是一种可变的类型，用于Jacob中几乎所有函数的返回值，并可转换为其他任何类型，包括Java基本类型。当然，应该按需要与规则来。Dispatch：Object represents MS level dispatch object. Each instance of this points at some data structure on the MS windows side.就是说可以代表所有对象模型。 import java.util.ArrayList; import java.util.List; import com.jacob.activeX.ActiveXComponent;
Java操作Word文档 操作微软word办公软件的开发工具： 1.Apache基金会提供的POI 2.通过freemarker去解析xml 3.Java2word 4.iText 5.Jacob 通过对以上工具的对比，本人发现还是Itext比较简单易用，很容易上手，能够很轻松的处理word的样式、表格等。 贴上代码，供大家参考： Jar包准备： itext-2.0.1.jar -------------------核心包 iTextAsian.jar--------------------解决word样式、编码问题扩展包 1、设置标题样式 public static Paragraph setParagraphTitle(String content,Font contentFont){ Paragraph p = new Paragraph(content, contentFont); p.setAlignment(Table.ALIGN_CENTER); p.setIndentationLeft(60); p.setIndentationRight(60); p.setSpacingBefore(20); return p; } 2、设置内容样式：
public static Paragraph setParagraphStyle(String content,Font contentFont){ Paragraph p = new Paragraph(content, contentFont); p.setFirstLineIndent(40);// 首行缩进 p.setAlignment(Paragraph.ALIGN_JUSTIFIED);// 对齐方式 p.setLeading(30);// 行间距 p.setIndentationLeft(60);// 左边距,右边距 p.setIndentationRight(60); return p; } 3、设置文档末尾时间： public static Paragraph setParagraphTime(Font contentFont){ Paragraph p = new Paragraph(FormatUtil.getCurrentDate(), contentFont); p.setIndentationLeft(250); p.setIndentationRight(60); p.setLeading(30); p.setFirstLineIndent(40); return p; } 4、开始写word文档咯： public static void WriteDoc(String path,Map
通过Java调用OCX控件有几种方法，JNI、JACOB、Jawin等 1.JNI 最直接的方式，也是最麻烦的方式，需要自己完成所有的工作，不推荐。 2.Jawin 尝试了一下，效果不错，但相对来说，其编程风格更贴近Windows，离Java有点远 3.Jacob 使用Jacob非常方便，Java编程风格，需要了解的知识比较少。 下载地址https://www.doczj.com/doc/317001185.html,/projects/jacob-project/ Jacob的使用方法 1.初始化 ComThread.InitMTA(true); ActiveXComponent com = new ActiveXComponent("组件的ProgID") ; Dispatch disp = com.getObject(); 2.调用控件里面的方面 2.1调用无参的方法，并返回一个short值 Dispatch.call(disp, "Init").getShort(); 2.2调用有一个参数的方法，并返回一个boolean值 Dispatch.call(disp,"Method",new Variant(args)).getBoolean(); 调用多个参数依次类推，注意在传递参数前，将Java中的参数转换成Variant。 问题解决 在使用Jacob调用OCX控件时，总是出一个异常 Exception in thread "main" https://www.doczj.com/doc/317001185.html,FailException: A COM exception has been encountered: At Invoke of: Init Description: 灾难性故障 通过Jawin调用，会出现8000FFFF错误。 这个错误是由ActiveX结构设计造成的。 在Ole4.0版本之前，外部程序是可以直接调用OCX中方法的。Ole4.0之后，每次调用控件中的方法，系统会自动检查是否允许调用，即运行COleControl.IsInvokeAllowed (DISPID) 该方法检查控件是否正确的初始化或者是否通过持久存储接口正确加载，如果两个条件有一个满足，即返回TRUE，否则返回FALSE。 当控件在MFC中使用时，很多细节，如初始化，都被过滤了，这样，大多数用户都不会遇到这个问题。但是，当我们从C、C++的dll中调用控件时，不满足上述条件，该方法返回FALSE，这时候再调用任何控件方法，都会出现上述异常。 解决方法很简单，在OCX控件中，重写COleControl.IsInvokeAllowed (DISPID)方法，即在控件的CMyNameCtrl中增加一个方法 BOOL CMyNameCtrl::IsInvokeAllowed (DISPID) { return TRUE; } 问题解决 首先，大家先要了解一下jacob ，官方的解释是Java COM Bridge，即java和
Jacob操作Word详细教程 博客分类： java技术 JavaTomcatQQ应用服务器F# 首先，大家先要了解一下jacob ，官方的解释是Java COM Bridge，即java和 com组件间的桥梁，这里说说为什么我们用jacob操纵word。而不直接使用java去做？ 这要原因：在Java开源世界没有很好工具来操作Word文档,POI对word操作还是很不完善,所以我们无法使用它很方便操作word文档来满足我们需求。相比之下使用jacob操作word文档非常方便。也比较容易。 jacob 下载地址:https://www.doczj.com/doc/317001185.html,/jacob/这个网址还可以下载到源码和例子程序 jacob 使用方法：将jacob1.7里面jacob.jar添加到我们应用程序环境中，并将 jacob.dl（l就是我前面说的com组件）把放到c:/windows/system32下。如果是web环境中，需要将jacod.jar放到Tomcat的lib目录下.（如果用Tomcat服务器） 值得注意的是，不同的版本的系统使用不同的dll文件 所以如果你编译成功，但运行失败一般是dll文件问题 遇到这种情况，可以到 https://www.doczj.com/doc/317001185.html,/jacob-project/jacob_1.9.zip?modtime= 1109437002&big_mirror=0 下载其他的版本的 dll 文件。 下面这段程序是我在别人代码基础上进行一些改进（增加了一些新方法，渴望各位同行批评指正） Java代码 1.package com.bperp.word.util; 2. 3.import java.io.BufferedInputStream; 4.import java.io.BufferedOutputStream; 5.import java.io.File; 6.import java.io.FileInputStream;
public boolean doc2pdf(String srcFilePath, String pdfFilePath) { ActiveXComponent app = null; Dispatch doc = null; try { ComThread.InitSTA(); app = new ActiveXComponent("Word.Application"); app.setProperty("Visible", false); Dispatch docs = app.getProperty("Documents").toDispatch(); doc = Dispatch.invoke(docs, "Open", Dispatch.Method, new Object[] { srcFilePath, new Variant(false), new Variant(true),//是否只读 new Variant(false), new Variant("pwd") }, new int[1]).toDispatch(); // Dispatch.put(doc, "Compatibility", false); //兼容性检查,为特定值false不正确 Dispatch.put(doc, "RemovePersonalInformation", false); Dispatch.call(doc, "ExportAsFixedFormat", pdfFilePath, wdFormatPDF); // word保存为pdf格式宏，值为17 return true; // set flag true; } catch (ComFailException e) { return false; } catch (Exception e) { return false; } finally { if (doc != null) { Dispatch.call(doc, "Close", false); } if (app != null) { app.invoke("Quit", 0); } ComThread.Release(); } } Jacob操作ppt public boolean ppt2pdf(String srcFilePath, String pdfFilePath) { ActiveXComponent app = null; Dispatch ppt = null; try {
如何使用jacob将word转换为PDF 收藏 一、代码实现功能介绍： word文档转换为PDF文件的功能。 二、使用的环境条件： 正是由于jacob的jni这种特性，所以运行jacob的机器上必须要有jacob.dll在系统的path 中，而且还要有相应的被调用的com组件存在。 下面列表说明了本项目使用的软件环境和一些注意事项： 1.Word2003、Adobe Acrobat 8.0 Professional(注：也可以使用7.5以上版本，我在做的时候，7.0版本有一些BUG，后又重新安装了8.0版本，安装地址及破解地址分别为： https://www.doczj.com/doc/317001185.html,//200611/AcroPro80_efg.rar https://www.doczj.com/doc/317001185.html,//200611/AcroPro80_Crack.rar)； 2.并且关闭了Adobe PDF打印机属性->Adobe PDF Setting中的“do not send fonts to PDF”选项（注：此属性在Adobe Reader中的文件－>打印的属性中进行设置。如果使用7.5以下版本可能会不好用，无法进行设置）； 3.安装了gs811w32.rar(PDF转换时所需要的脚本ps)，地址为： https://www.doczj.com/doc/317001185.html,/gs811w32.rar 4.安装了postscript.rar(PDF虚拟打印机的驱动)，地址为： https://www.doczj.com/doc/317001185.html,/Resource/DownLoad/postscript.rar 虚拟打印机安装完成之后，控制面板》打印机及其他硬件》打印机和传真》添加打印机（如果添加时显示“操作无法完成。打印后台程序服务没有运行。”请打开控制面板》性能和维护》管理工具》服务》找到“Print Spooler”》右击属性》启动）》选择本地打印机（如果没有打印机请将“检测并安装即插打印机”的钩去掉）》下一步》选择“使用以下端口”（My Document/*.pdf (Adobe PDF Port)）》下一步，记住打印机的名字：Adobe PDF）》下一步（打印机请选择：不测试） 5.下载得到了jacob.jar。地址为： https://www.doczj.com/doc/317001185.html,/project/showfiles.php?group_id=109543&package_id=118368 将解压后的源代码包中jacob.dll存放到system32目录下。（注：目前比较稳定的版本分别为1.7、1.8、1.9，我用的是1.8版本） 注意： 第1、2个条件是必须的。不然会可能出现下面的错误： 三、原理: doc -> ps ->pdf >>>> office 2003 ->gs811w32->Adobe Acrobat 8->postscript->打印机 四、源代码： package com.bjinfotech.practice.jacob;
《酶工程》试题一参考答案: 一、填空题（每空1分，共28分） 1、日本称为“酵素”的东西，中文称为酶,英文则为Enzyme,是库尼（Kuhne）于1878年首先使用的。其实它存在于生物体的细胞内与细胞外。 2、1926年，萨姆纳（Sumner）首先制得脲酶结晶，并指出酶的本质是蛋白质。他因这一杰出贡献，获1947年度诺贝尔化学奖。 3、目前我国广泛使用的高产糖比酶优良菌株菌号为As3.4309,高产液化酶优良菌株菌号为 BF7.658。在微生物分类上，前者属于霉菌，后者属于细菌。 4、1960年，查柯柏（Jacob）和莫洛德（Monod）提出了操纵子学说，认为DNA分子中，与酶生物合成有关的基因有四种，即操纵基因、调节基因、启动基因和结构基因。 5、借助双功能试剂使酶分子之间发生交联作用，制成网状结构的固定化酶的方法称为交联法。 6、酶的分离纯化方法中，根据目的酶与杂质分子大小差别有凝胶过滤法，超滤法和超离心法三种。 7、由于各种分子形成结晶条件的不同，也由于变性的蛋白质和酶不能形成结晶，因此酶结晶既是纯化手段，也是纯化标志。 名词术语的解释与区别（每组6分，共30分） 1、酶生物合成中的转录与翻译 酶合成中的转录是指以核苷三磷酸为底物，以DNA链为模板，在RNA聚合酶的作用下合成RNA 分子。酶合成中的翻译是指以氨基酸为底物，以mRNA为模板，在酶和辅助因子的共同作用下合成蛋白质的多肽链。 2、诱导与阻遏 酶合成的诱导是指加入某种物质使酶的合成开始或加速进行的过程；酶合成的阻遏作用则是指加入某种物质使酶的合成中止或减缓进行的过程。这些物质分别称为诱导物及阻遏物。 3、酶回收率与酶纯化比（纯度提高比） 酶的回收率是指某纯化步骤后酶的总活力与该步骤前的总活力之比。酶的纯化比是之某纯化步骤后的酶的比活力与该步骤前的比活力之比。 4、酶的变性与酶的失活 酶的变性是指酶分子结构中的氢键、二硫键及范德华力被破坏，酶的空间结构也受到破坏，原来有序、完整的结构变成了无序，松散的结构，失去了原有的生理功能。酶的失活则是指酶的自身活性受损（包括辅酶、金属离子受损），失去了与底物结合的能力。 5、α－淀粉酶与β－淀粉酶 二者的区别在于α－淀粉酶是一种内酶，可以跨越淀粉分子的α－1，6键到分子内部进行随机切割，所得的产物为α型的麦芽糖和环糊精，它使碘色消失的速度较快，但还原糖较慢；β－淀粉酶则是一种外酶，不能跨越α－1，6键，只能从淀粉的非还原末端2个2个地进行切割，所得的产物为β型的麦芽糖和界限糊精，它使碘色消失较慢，但还原糖较快，二者的共同点在于都能水解α－1，4键和都不能水解α－1，6键。 四、问答题 1、举出四例，说明酶在医学上有广阔的用途。 （1）医药用酶：a.消化用酶：α、β－淀粉酶、胰酶、胰蛋白酶 b.消炎用酶：木瓜蛋白酶、菠萝酶 c.溶纤维酶：尿酸酶、链激酶、溶栓酶 d.肿瘤用酶：L－天冬酰胺酶、谷氨酰胺酶
竭诚为您提供优质文档/双击可除jacob,操作word表格 篇一：jacob读取word表格 packagetest; importjava.io.bufferedReader; importjava.io.FileReader; importjava.io.ioexception; importjava.util.arraylist; importjava.util.list; importbean.dx; importcom.jacob.activex.activexcomponent; https://www.doczj.com/doc/317001185.html,thread; https://www.doczj.com/doc/317001185.html,.dispatch; https://www.doczj.com/doc/317001185.html,.Variant; publicclassReadwordbystream{ publicstaticvoidmain(string[]args)throwsioexception { dispatchworddoc=null;
activexcomponentword=null; try{ word=newactivexcomponent("word.application"); word.setproperty("Visible",newVariant(false)); dispatchdocuments=word.getproperty("documents").tod ispatch(); worddoc=dispatch.call(documents,"open","d:\\word\\1 .doc").todispatch(); dispatchtables=dispatch.get(worddoc,"tables").todis patch(); dispatchtable=dispatch.call(tables,"item",newVarian t(1)).todispatch();dispatchrows=dispatch.get(table, "Rows").todispatch(); dispatchcolumns=dispatch.get(table,"columns").todis patch();dispatchcell; dispatchrange; stringdata;
java jacob 操作word 文档，进行写操作，如生成表格，添加图片jacob-1.15-M3.zip jacob-1.15-M3-x86.dll copy 到c:\\windows\system32 引入jacob.jar 示例代码 import java.io.File; import com.jacob.activeX.ActiveXComponent; import https://www.doczj.com/doc/317001185.html,.Dispatch; import https://www.doczj.com/doc/317001185.html,.Variant; class WordBean { // 代表一个word 程序 private ActiveXComponent MsWordApp = null; // 代表进行处理的word 文档 private Dispatch document = null; public WordBean() { // Open Word if we\'ve not done it already if (MsWordApp == null) { MsWordApp = new ActiveXComponent("Word.Application"); } } // 设置是否在前台打开word 程序， public void setVisible(boolean visible) { MsWordApp.setProperty("Visible", new Variant(visible)); // 这一句作用相同 // Dispatch.put(MsWordApp, "Visible", new Variant(visible)); } // 创建一个新文档 public void createNewDocument() { // Find the Documents collection object maintained by Word // documents表示word的所有文档窗口，（word是多文档应用程序） Dispatch documents = Dispatch.get(MsWordApp, "Documents").toDispatch(); // Call the Add method of the Documents collection to create // a new document to edit document = Dispatch.call(documents, "Add").toDispatch(); } // 打开一个存在的word文档,并用document 引用引用它