java使用jacob操作word文档

ava使用jacob操作word文档

java调用com组件操作word使用总结(jacob)


简单描述


   在此处输入简单摘要


特别声明:使用java-com技术可以完成任何VBA可以完成的office文档操作;


 一、准备工作


   先了解一下概念,JACOB 就是 JAVA-COM Bridge的缩写,提供自动化的访问com的功能,也是通过JNI功能访问windows平台下的com组件或者win32系统库的。这是一个开始于1999年的开源项目的成果,有很多使用者对该项目进行了修改,做出了自己的贡献。


   Jacob下载地址:


              http://sourceforge.net/project/showfiles.php?group_id=109543&package_id=118368


        我在这里下载了Jacob1.14.3和jacob1.9的版本两个版本


  这里下载的是目前最新的Jacob1.14.3的Release版。


      另外java操作word方式还有(个人认为通过jacob最好,自己可以扩展,网上除poi之外几乎全是java-com技术实现的):


      (1):Apache POI - Java API To Access Microsoft Format Files(http://poi.apache.org/);对word处理不够强处理Excel功能可以,但是全是通过java完成的,不需 要com组件支持;


     (2):java2word 是一个在java程序中调用 MS Office Word 文档的组件(类库)。该组件提供了一组简单的接口,以便java程序调用他的服务操作Word 文档。(好象也是用的java-com技术);


     (3)web开发语言操作word的功能最好还是用第三方的控件, 看看这个SOAOFFICE,还可以使用js 写VBA呢http://www.kehansoft.com/soaoffice/doclist.asp


二、安装Jacob


   Jacob的安装非常的简单,我们解开下载的jacob_1.9.zip,在文件夹中找到jacob.dll和jacob.jar两个文件,如果是Jacob1.14.3则是jacob-1.14.3-x86.dll(32位,机和jacob-1.14.3-x64.dll(64位)和jacob.jar两个文件。Jacob.dll直接放到系统的system32文件夹下就行了,连注册都不用的(或者拷贝到jdk或者jre的bin目录下也行,当前测试文件所在的目录也行,就是只要在java.library.path中就可以)。而jacob.jar设置到classpath中去就可以了,或者在IDE开发环境的工程中设置扩展库也一样的,我是这样使用的将jacob-1.14.3-x86.dll或复制到%Tomcat5%\bin目录下将jacob.jar复制到%Tomcot5%\Share\lib目录下,我使用过程中感觉放到这里是一个最终解决办法,当你放哪都有问题的时候。我这样用之后再没有出过因为系统不一样出现的各种各样的问题,当然你作的是web的项目。


       注意使用jacob一写要安装word,我装的word2003,如果是操作word2007就不用jacob了(好像这方面的API)。


对jacob.dll几种配置方法 (网上看到):


2008-07-31 11:59:49


1、把jacob.dll文件,复制到 windows\system32 目录下。(注:我用的时候这个方法不能运行)


2、 把jacob.dll放入 Java\jdk1.5.0_06\jre\bin目录下.把jacob.jar放入 Java\jdk1.5.0_0\jre\lib\ext  


   目录下.可以正常运行。


3、把jacob.dll放入 \glc\src目录下.把jacob.jar放入WEB-INF\lib目录下,也是可以正常运行。


三、使用(以下是我改写的一个word操作类,希望有兴趣的朋友完善,记得发给我一份)


0001 //注意java操作word关键是定位操作对象;
0002  
0003 import com.jacob.activeX.ActiveXComponent;
0004  
0005 import com.jacob.com.Dispatch;
0006  
0007 import com.jacob.com.Variant;
0008  
0009 /**
0010  
0011 * jacob操作MSword类
0012  
0013 * @author
0014  
0015 */
0016  
0017 public class WordBean {
0018  
0019 // word文档
0020  
0021 private Dispatch doc;
0022  
0023 // word运行程序对象
0024  
0025 private ActiveXComponent word;
0026  
0027 // 所有word文档集合
0028  
0029 private Dispatch documents;
0030  
0031 // 选定的范围或插入点
0032  
0033 private Dispatch selection;
0034  
0035 private boolean saveOnExit = true;
0036  
0037 public WordBean()throws Exception{
0038  
0039 if (word == null) {
0040  
0041 word = new ActiveXComponent("Word.Application");
0042  
0043 word.setProperty("Visible"new Variant(false)); //不可见打开word
0044  
0045 word.setProperty("AutomationSecurity"new Variant(3)); //禁用宏
0046  
0047 }
0048  
0049 if (documents == null)
0050  
0051 documents = word.getProperty("Documents").toDispatch();
0052  
0053 }
0054  
0055 /**
0056  
0057 * 设置退出时参数
0058  
0059 *
0060  
0061 * @param saveOnExit
0062  
0063 *            boolean true-退出时保存文件,false-退出时不保存文件
0064  
0065 */
0066  
0067 public void setSaveOnExit(boolean saveOnExit) {
0068  
0069 this.saveOnExit = saveOnExit;
0070  
0071 }
0072  
0073 /**
0074  
0075 * 创建一个新的word文档
0076  
0077 *
0078  
0079 */
0080  
0081 public void createNewDocument() {
0082  
0083 doc = Dispatch.call(documents, "Add").toDispatch();
0084  
0085 selection = Dispatch.get(word, "Selection").toDispatch();
0086  
0087 }
0088  
0089 /**
0090  
0091 * 打开一个已存在的文档
0092  
0093 *
0094  
0095 * @param docPath
0096  
0097 */
0098  
0099 public void openDocument(String docPath) {
0100  
0101 closeDocument();
0102  
0103 doc = Dispatch.call(documents, "Open", docPath).toDispatch();
0104  
0105 selection = Dispatch.get(word, "Selection").toDispatch();
0106  
0107 }
0108  
0109 /**
0110  
0111 *只读 打开一个保护文档,
0112  
0113 * @param docPath-文件全名
0114  
0115 * @param pwd-密码
0116  
0117 */
0118  
0119 public void openDocumentOnlyRead(String docPath, String pwd)throws Exception {
0120  
0121 closeDocument();
0122  
0123 // doc = Dispatch.invoke(documents, "Open", Dispatch.Method,
0124  
0125 // new Object[]{docPath, new Variant(false), new Variant(true), new Variant(true), pwd},
0126  
0127 // new int[1]).toDispatch();//打开word文件
0128  
0129 doc =  Dispatch.callN(documents, "Open"new Object[]{docPath, new Variant(false),
0130  
0131 new Variant(true), new Variant(true), pwd, ""new Variant(false)}).toDispatch();
0132  
0133 selection = Dispatch.get(word, "Selection").toDispatch();
0134  
0135 }
0136  
0137 public void openDocument(String docPath, String pwd)throws Exception {
0138  
0139 closeDocument();
0140  
0141 doc =  Dispatch.callN(documents, "Open"new Object[]{docPath, new Variant(false),
0142  
0143 new Variant(false), new Variant(true), pwd}).toDispatch();
0144  
0145 selection = Dispatch.get(word, "Selection").toDispatch();
0146  
0147 }
0148  
0149 /**
0150  
0151 * 把选定的内容或插入点向上移动
0152  
0153 *
0154  
0155 * @param pos
0156  
0157 *            移动的距离
0158  
0159 */
0160  
0161 public void moveUp(int pos) {
0162  
0163 if (selection == null)
0164  
0165 selection = Dispatch.get(word, "Selection").toDispatch();
0166  
0167 for (int i = 0; i < pos; i++)
0168  
0169 Dispatch.call(selection, "MoveUp");
0170  
0171 }
0172  
0173 /**
0174  
0175 * 把选定的内容或者插入点向下移动
0176  
0177 *
0178  
0179 * @param pos
0180  
0181 *            移动的距离
0182  
0183 */
0184  
0185 public void moveDown(int pos) {
0186  
0187 if (selection == null)
0188  
0189 selection = Dispatch.get(word, "Selection").toDispatch();
0190  
0191 for (int i = 0; i < pos; i++)
0192  
0193 Dispatch.call(selection, "MoveDown");
0194  
0195 }
0196  
0197 /**
0198  
0199 * 把选定的内容或者插入点向左移动
0200  
0201 *
0202  
0203 * @param pos
0204  
0205 *            移动的距离
0206  
0207 */
0208  
0209 public void moveLeft(int pos) {
0210  
0211 if (selection == null)
0212  
0213 selection = Dispatch.get(word, "Selection").toDispatch();
0214  
0215 for (int i = 0; i < pos; i++) {
0216  
0217 Dispatch.call(selection, "MoveLeft");
0218  
0219 }
0220  
0221 }
0222  
0223 /**
0224  
0225 * 把选定的内容或者插入点向右移动
0226  
0227 *
0228  
0229 * @param pos
0230  
0231 *            移动的距离
0232  
0233 */
0234  
0235 public void moveRight(int pos) {
0236  
0237 if (selection == null)
0238  
0239 selection = Dispatch.get(word, "Selection").toDispatch();
0240  
0241 for (int i = 0; i < pos; i++)
0242  
0243 Dispatch.call(selection, "MoveRight");
0244  
0245 }
0246  
0247 /**
0248  
0249 * 把插入点移动到文件首位置
0250  
0251 *
0252  
0253 */
0254  
0255 public void moveStart() {
0256  
0257 if (selection == null)
0258  
0259 selection = Dispatch.get(word, "Selection").toDispatch();
0260  
0261 Dispatch.call(selection, "HomeKey"new Variant(6));
0262  
0263 }
0264  
0265 /**
0266  
0267 * 从选定内容或插入点开始查找文本
0268  
0269 *
0270  
0271 * @param toFindText
0272  
0273 *            要查找的文本
0274  
0275 * @return boolean true-查找到并选中该文本,false-未查找到文本
0276  
0277 */
0278  
0279 @SuppressWarnings("static-access")
0280  
0281 public boolean find(String toFindText) {
0282  
0283 if (toFindText == null || toFindText.equals(""))
0284  
0285 return false;
0286  
0287 // 从selection所在位置开始查询
0288  
0289 Dispatch find = word.call(selection, "Find").toDispatch();
0290  
0291 // 设置要查找的内容
0292  
0293 Dispatch.put(find, "Text", toFindText);
0294  
0295 // 向前查找
0296  
0297 Dispatch.put(find, "Forward""True");
0298  
0299 // 设置格式
0300  
0301 Dispatch.put(find, "Format""True");
0302  
0303 // 大小写匹配
0304  
0305 Dispatch.put(find, "MatchCase""True");
0306  
0307 // 全字匹配
0308  
0309 Dispatch.put(find, "MatchWholeWord""True");
0310  
0311 // 查找并选中
0312  
0313 return Dispatch.call(find, "Execute").getBoolean();
0314  
0315 }
0316  
0317 /**
0318  
0319 * 把选定选定内容设定为替换文本
0320  
0321 *
0322  
0323 * @param toFindText
0324  
0325 *            查找字符串
0326  
0327 * @param newText
0328  
0329 *            要替换的内容
0330  
0331 * @return
0332  
0333 */
0334  
0335 public boolean replaceText(String toFindText, String newText) {
0336  
0337 if (!find(toFindText))
0338  
0339 return false;
0340  
0341 Dispatch.put(selection, "Text", newText);
0342  
0343 return true;
0344  
0345 }
0346  
0347 /**
0348  
0349 * 全局替换文本
0350  
0351 *
0352  
0353 * @param toFindText
0354  
0355 *            查找字符串
0356  
0357 * @param newText
0358  
0359 *            要替换的内容
0360  
0361 */
0362  
0363 public void replaceAllText(String toFindText, String newText) {
0364  
0365 while (find(toFindText)) {
0366  
0367 Dispatch.put(selection, "Text", newText);
0368  
0369 Dispatch.call(selection, "MoveRight");
0370  
0371 }
0372  
0373 }
0374  
0375 /**
0376  
0377 * 在当前插入点插入字符串
0378  
0379 *
0380  
0381 * @param newText
0382  
0383 *            要插入的新字符串
0384  
0385 */
0386  
0387 public void insertText(String newText) {
0388  
0389 Dispatch.put(selection, "Text", newText);
0390  
0391 }
0392  
0393 /**
0394  
0395 *
0396  
0397 * @param toFindText
0398  
0399 *            要查找的字符串
0400  
0401 * @param imagePath
0402  
0403 *            图片路径
0404  
0405 * @return
0406  
0407 */
0408  
0409 public boolean replaceImage(String toFindText, String imagePath) {
0410  
0411 if (!find(toFindText))
0412  
0413 return false;
0414  
0415 Dispatch.call(Dispatch.get(selection, "InLineShapes").toDispatch(),
0416  
0417 "AddPicture", imagePath);
0418  
0419 return true;
0420  
0421 }
0422  
0423 /**
0424  
0425 * 全局替换图片
0426  
0427 *
0428  
0429 * @param toFindText
0430  
0431 *            查找字符串
0432  
0433 * @param imagePath
0434  
0435 *            图片路径
0436  
0437 */
0438  
0439 public void replaceAllImage(String toFindText, String imagePath) {
0440  
0441 while (find(toFindText)) {
0442  
0443 Dispatch.call(Dispatch.get(selection, "InLineShapes").toDispatch(),
0444  
0445 "AddPicture", imagePath);
0446  
0447 Dispatch.call(selection, "MoveRight");
0448  
0449 }
0450  
0451 }
0452  
0453 /**
0454  
0455 * 在当前插入点插入图片
0456  
0457 *
0458  
0459 * @param imagePath
0460  
0461 *            图片路径
0462  
0463 */
0464  
0465 public void insertImage(String imagePath) {
0466  
0467 Dispatch.call(Dispatch.get(selection, "InLineShapes").toDispatch(),
0468  
0469 "AddPicture", imagePath);
0470  
0471 }
0472  
0473 /**
0474  
0475 * 合并单元格
0476  
0477 *
0478  
0479 * @param tableIndex
0480  
0481 * @param fstCellRowIdx
0482  
0483 * @param fstCellColIdx
0484  
0485 * @param secCellRowIdx
0486  
0487 * @param secCellColIdx
0488  
0489 */
0490  
0491 public void mergeCell(int tableIndex, int fstCellRowIdx, int fstCellColIdx,
0492  
0493 int secCellRowIdx, int secCellColIdx) {
0494  
0495 // 所有表格
0496  
0497 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
0498  
0499 // 要填充的表格
0500  
0501 Dispatch table = Dispatch.call(tables, "Item"new Variant(tableIndex))
0502  
0503 .toDispatch();
0504  
0505 Dispatch fstCell = Dispatch.call(table, "Cell",
0506  
0507 new Variant(fstCellRowIdx), new Variant(fstCellColIdx))
0508  
0509 .toDispatch();
0510  
0511 Dispatch secCell = Dispatch.call(table, "Cell",
0512  
0513 new Variant(secCellRowIdx), new Variant(secCellColIdx))
0514  
0515 .toDispatch();
0516  
0517 Dispatch.call(fstCell, "Merge", secCell);
0518  
0519 }
0520  
0521 /**
0522  
0523 * 在指定的单元格里填写数据
0524  
0525 *
0526  
0527 * @param tableIndex
0528  
0529 * @param cellRowIdx
0530  
0531 * @param cellColIdx
0532  
0533 * @param txt
0534  
0535 */
0536  
0537 public void putTxtToCell(int tableIndex, int cellRowIdx, int cellColIdx,
0538  
0539 String txt) {
0540  
0541 // 所有表格
0542  
0543 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
0544  
0545 // 要填充的表格
0546  
0547 Dispatch table = Dispatch.call(tables, "Item"new Variant(tableIndex))
0548  
0549 .toDispatch();
0550  
0551 Dispatch cell = Dispatch.call(table, "Cell"new Variant(cellRowIdx),
0552  
0553 new Variant(cellColIdx)).toDispatch();
0554  
0555 Dispatch.call(cell, "Select");
0556  
0557 Dispatch.put(selection, "Text", txt);
0558  
0559 }
0560  
0561 /**
0562  
0563 * 获得指定的单元格里数据
0564  
0565 *
0566  
0567 * @param tableIndex
0568  
0569 * @param cellRowIdx
0570  
0571 * @param cellColIdx
0572  
0573 * @return
0574  
0575 */
0576  
0577 public String getTxtFromCell(int tableIndex, int cellRowIdx, int cellColIdx) {
0578  
0579 // 所有表格
0580  
0581 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
0582  
0583 // 要填充的表格
0584  
0585 Dispatch table = Dispatch.call(tables, "Item"new Variant(tableIndex))
0586  
0587 .toDispatch();
0588  
0589 Dispatch cell = Dispatch.call(table, "Cell"new Variant(cellRowIdx),
0590  
0591 new Variant(cellColIdx)).toDispatch();
0592  
0593 Dispatch.call(cell, "Select");
0594  
0595 String ret = "";
0596  
0597 ret = Dispatch.get(selection, "Text").toString();
0598  
0599 ret = ret.substring(0, ret.length()-1); //去掉最后的回车符;
0600  
0601 return ret;
0602  
0603 }
0604  
0605 /**
0606  
0607 * 在当前文档拷贝剪贴板数据
0608  
0609 * @param pos
0610  
0611 */
0612  
0613 public void pasteExcelSheet(String pos) {
0614  
0615 moveStart();
0616  
0617 if (this.find(pos)) {
0618  
0619 Dispatch textRange = Dispatch.get(selection, "Range").toDispatch();
0620  
0621 Dispatch.call(textRange, "Paste");
0622  
0623 }
0624  
0625 }
0626  
0627 /**
0628  
0629 * 在当前文档指定的位置拷贝表格
0630  
0631 *
0632  
0633 * @param pos
0634  
0635 *            当前文档指定的位置
0636  
0637 * @param tableIndex
0638  
0639 *            被拷贝的表格在word文档中所处的位置
0640  
0641 */
0642  
0643 public void copyTable(String pos, int tableIndex) {
0644  
0645 // 所有表格
0646  
0647 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
0648  
0649 // 要填充的表格
0650  
0651 Dispatch table = Dispatch.call(tables, "Item"new Variant(tableIndex))
0652  
0653 .toDispatch();
0654  
0655 Dispatch range = Dispatch.get(table, "Range").toDispatch();
0656  
0657 Dispatch.call(range, "Copy");
0658  
0659 if (this.find(pos)) {
0660  
0661 Dispatch textRange = Dispatch.get(selection, "Range").toDispatch();
0662  
0663 Dispatch.call(textRange, "Paste");
0664  
0665 }
0666  
0667 }
0668  
0669 /**
0670  
0671 * 在当前文档指定的位置拷贝来自另一个文档中的表格
0672  
0673 *
0674  
0675 * @param anotherDocPath
0676  
0677 *            另一个文档的磁盘路径
0678  
0679 * @param tableIndex
0680  
0681 *            被拷贝的表格在另一格文档中的位置
0682  
0683 * @param pos
0684  
0685 *            当前文档指定的位置
0686  
0687 */
0688  
0689 public void copyTableFromAnotherDoc(String anotherDocPath, int tableIndex,
0690  
0691 String pos) {
0692  
0693 Dispatch doc2 = null;
0694  
0695 try {
0696  
0697 doc2 = Dispatch.call(documents, "Open", anotherDocPath)
0698  
0699 .toDispatch();
0700  
0701 // 所有表格
0702  
0703 Dispatch tables = Dispatch.get(doc2, "Tables").toDispatch();
0704  
0705 // 要填充的表格
0706  
0707 Dispatch table = Dispatch.call(tables, "Item",
0708  
0709 new Variant(tableIndex)).toDispatch();
0710  
0711 Dispatch range = Dispatch.get(table, "Range").toDispatch();
0712  
0713 Dispatch.call(range, "Copy");
0714  
0715 if (this.find(pos)) {
0716  
0717 Dispatch textRange = Dispatch.get(selection, "Range")
0718  
0719 .toDispatch();
0720  
0721 Dispatch.call(textRange, "Paste");
0722  
0723 }
0724  
0725 catch (Exception e) {
0726  
0727 e.printStackTrace();
0728  
0729 finally {
0730  
0731 if (doc2 != null) {
0732  
0733 Dispatch.call(doc2, "Close"new Variant(saveOnExit));
0734  
0735 doc2 = null;
0736  
0737 }
0738  
0739 }
0740  
0741 }
0742  
0743 /**
0744  
0745 * 在当前文档指定的位置拷贝来自另一个文档中的图片
0746  
0747 *
0748  
0749 * @param anotherDocPath 另一个文档的磁盘路径
0750  
0751 * @param shapeIndex 被拷贝的图片在另一格文档中的位置
0752  
0753 * @param pos 当前文档指定的位置
0754  
0755 */
0756  
0757 public void copyImageFromAnotherDoc(String anotherDocPath, int shapeIndex,
0758  
0759 String pos) {
0760  
0761 Dispatch doc2 = null;
0762  
0763 try {
0764  
0765 doc2 = Dispatch.call(documents, "Open", anotherDocPath)
0766  
0767 .toDispatch();
0768  
0769 Dispatch shapes = Dispatch.get(doc2, "InLineShapes").toDispatch();
0770  
0771 Dispatch shape = Dispatch.call(shapes, "Item",
0772  
0773 new Variant(shapeIndex)).toDispatch();
0774  
0775 Dispatch imageRange = Dispatch.get(shape, "Range").toDispatch();
0776  
0777 Dispatch.call(imageRange, "Copy");
0778  
0779 if (this.find(pos)) {
0780  
0781 Dispatch textRange = Dispatch.get(selection, "Range")
0782  
0783 .toDispatch();
0784  
0785 Dispatch.call(textRange, "Paste");
0786  
0787 }
0788  
0789 catch (Exception e) {
0790  
0791 e.printStackTrace();
0792  
0793 finally {
0794  
0795 if (doc2 != null) {
0796  
0797 Dispatch.call(doc2, "Close"new Variant(saveOnExit));
0798  
0799 doc2 = null;
0800  
0801 }
0802  
0803 }
0804  
0805 }
0806  
0807 /**
0808  
0809 * 创建表格
0810  
0811 *
0812  
0813 * @param pos
0814  
0815 *            位置
0816  
0817 * @param cols
0818  
0819 *            列数
0820  
0821 * @param rows
0822  
0823 *            行数
0824  
0825 */
0826  
0827 public void createTable(String pos, int numCols, int numRows) {
0828  
0829 if (find(pos)) {
0830  
0831 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
0832  
0833 Dispatch range = Dispatch.get(selection, "Range").toDispatch();
0834  
0835 @SuppressWarnings("unused")
0836  
0837 Dispatch newTable = Dispatch.call(tables, "Add", range,
0838  
0839 new Variant(numRows), new Variant(numCols)).toDispatch();
0840  
0841 Dispatch.call(selection, "MoveRight");
0842  
0843 else {
0844  
0845 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
0846  
0847 Dispatch range = Dispatch.get(selection, "Range").toDispatch();
0848  
0849 @SuppressWarnings("unused")
0850  
0851 Dispatch newTable = Dispatch.call(tables, "Add", range,
0852  
0853 new Variant(numRows), new Variant(numCols)).toDispatch();
0854  
0855 Dispatch.call(selection, "MoveRight");
0856  
0857 }
0858  
0859 }
0860  
0861 /**
0862  
0863 * 在指定行前面增加行
0864  
0865 *
0866  
0867 * @param tableIndex
0868  
0869 *            word文件中的第N张表(从1开始)
0870  
0871 * @param rowIndex
0872  
0873 *            指定行的序号(从1开始)
0874  
0875 */
0876  
0877 public void addTableRow(int tableIndex, int rowIndex) {
0878  
0879 // 所有表格
0880  
0881 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
0882  
0883 // 要填充的表格
0884  
0885 Dispatch table = Dispatch.call(tables, "Item"new Variant(tableIndex))
0886  
0887 .toDispatch();
0888  
0889 // 表格的所有行
0890  
0891 Dispatch rows = Dispatch.get(table, "Rows").toDispatch();
0892  
0893 Dispatch row = Dispatch.call(rows, "Item"new Variant(rowIndex))
0894  
0895 .toDispatch();
0896  
0897 Dispatch.call(rows, "Add"new Variant(row));
0898  
0899 }
0900  
0901 /**
0902  
0903 * 在第1行前增加一行
0904  
0905 *
0906  
0907 * @param tableIndex
0908  
0909 *  word文档中的第N张表(从1开始)
0910  
0911 */
0912  
0913 public void addFirstTableRow(int tableIndex) {
0914  
0915 // 所有表格
0916  
0917 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
0918  
0919 // 要填充的表格
0920  
0921 Dispatch table = Dispatch.call(tables, "Item"new Variant(tableIndex))
0922  
0923 .toDispatch();
0924  
0925 // 表格的所有行
0926  
0927 Dispatch rows = Dispatch.get(table, "Rows").toDispatch();
0928  
0929 Dispatch row = Dispatch.get(rows, "First").toDispatch();
0930  
0931 Dispatch.call(rows, "Add"new Variant(row));
0932  
0933 }
0934  
0935 /**
0936  
0937 * 在最后1行前增加一行
0938  
0939 *
0940  
0941 * @param tableIndex
0942  
0943 *            word文档中的第N张表(从1开始)
0944  
0945 */
0946  
0947 public void addLastTableRow(int tableIndex) {
0948  
0949 // 所有表格
0950  
0951 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
0952  
0953 // 要填充的表格
0954  
0955 Dispatch table = Dispatch.call(tables, "Item"new Variant(tableIndex))
0956  
0957 .toDispatch();
0958  
0959 // 表格的所有行
0960  
0961 Dispatch rows = Dispatch.get(table, "Rows").toDispatch();
0962  
0963 Dispatch row = Dispatch.get(rows, "Last").toDispatch();
0964  
0965 Dispatch.call(rows, "Add"new Variant(row));
0966  
0967 }
0968  
0969 /**
0970  
0971 * 增加一行
0972  
0973 *
0974  
0975 * @param tableIndex
0976  
0977 *            word文档中的第N张表(从1开始)
0978  
0979 */
0980  
0981 public void addRow(int tableIndex) {
0982  
0983 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
0984  
0985 // 要填充的表格
0986  
0987 Dispatch table = Dispatch.call(tables, "Item"new Variant(tableIndex))
0988  
0989 .toDispatch();
0990  
0991 // 表格的所有行
0992  
0993 Dispatch rows = Dispatch.get(table, "Rows").toDispatch();
0994  
0995 Dispatch.call(rows, "Add");
0996  
0997 }
0998  
0999 /**
1000  
1001 * 增加一列
1002  
1003 *
1004  
1005 * @param tableIndex
1006  
1007 *            word文档中的第N张表(从1开始)
1008  
1009 */
1010  
1011 public void addCol(int tableIndex) {
1012  
1013 // 所有表格
1014  
1015 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
1016  
1017 // 要填充的表格
1018  
1019 Dispatch table = Dispatch.call(tables, "Item"new Variant(tableIndex))
1020  
1021 .toDispatch();
1022  
1023 // 表格的所有行
1024  
1025 Dispatch cols = Dispatch.get(table, "Columns").toDispatch();
1026  
1027 Dispatch.call(cols, "Add").toDispatch();
1028  
1029 Dispatch.call(cols, "AutoFit");
1030  
1031 }
1032  
1033 /**
1034  
1035 * 在指定列前面增加表格的列
1036  
1037 *
1038  
1039 * @param tableIndex
1040  
1041 *            word文档中的第N张表(从1开始)
1042  
1043 * @param colIndex
1044  
1045 *            制定列的序号 (从1开始)
1046  
1047 */
1048  
1049 public void addTableCol(int tableIndex, int colIndex) {
1050  
1051 // 所有表格
1052  
1053 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
1054  
1055 // 要填充的表格
1056  
1057 Dispatch table = Dispatch.call(tables, "Item"new Variant(tableIndex))
1058  
1059 .toDispatch();
1060  
1061 // 表格的所有行
1062  
1063 Dispatch cols = Dispatch.get(table, "Columns").toDispatch();
1064  
1065 System.out.println(Dispatch.get(cols, "Count"));
1066  
1067 Dispatch col = Dispatch.call(cols, "Item"new Variant(colIndex))
1068  
1069 .toDispatch();
1070  
1071 // Dispatch col = Dispatch.get(cols, "First").toDispatch();
1072  
1073 Dispatch.call(cols, "Add", col).toDispatch();
1074  
1075 Dispatch.call(cols, "AutoFit");
1076  
1077 }
1078  
1079 /**
1080  
1081 * 在第1列前增加一列
1082  
1083 *
1084  
1085 * @param tableIndex
1086  
1087 *            word文档中的第N张表(从1开始)
1088  
1089 */
1090  
1091 public void addFirstTableCol(int tableIndex) {
1092  
1093 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
1094  
1095 // 要填充的表格
1096  
1097 Dispatch table = Dispatch.call(tables, "Item"new Variant(tableIndex))
1098  
1099 .toDispatch();
1100  
1101 // 表格的所有行
1102  
1103 Dispatch cols = Dispatch.get(table, "Columns").toDispatch();
1104  
1105 Dispatch col = Dispatch.get(cols, "First").toDispatch();
1106  
1107 Dispatch.call(cols, "Add", col).toDispatch();
1108  
1109 Dispatch.call(cols, "AutoFit");
1110  
1111 }
1112  
1113 /**
1114  
1115 * 在最后一列前增加一列
1116  
1117 *
1118  
1119 * @param tableIndex
1120  
1121 *            word文档中的第N张表(从1开始)
1122  
1123 */
1124  
1125 public void addLastTableCol(int tableIndex) {
1126  
1127 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
1128  
1129 // 要填充的表格
1130  
1131 Dispatch table = Dispatch.call(tables, "Item"new Variant(tableIndex))
1132  
1133 .toDispatch();
1134  
1135 // 表格的所有行
1136  
1137 Dispatch cols = Dispatch.get(table, "Columns").toDispatch();
1138  
1139 Dispatch col = Dispatch.get(cols, "Last").toDispatch();
1140  
1141 Dispatch.call(cols, "Add", col).toDispatch();
1142  
1143 Dispatch.call(cols, "AutoFit");
1144  
1145 }
1146  
1147 /**
1148  
1149 * 自动调整表格
1150  
1151 *
1152  
1153 */
1154  
1155 @SuppressWarnings("deprecation")
1156  
1157 public void autoFitTable() {
1158  
1159 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
1160  
1161 int count = Dispatch.get(tables, "Count").toInt();
1162  
1163 for (int i = 0; i < count; i++) {
1164  
1165 Dispatch table = Dispatch.call(tables, "Item"new Variant(i + 1))
1166  
1167 .toDispatch();
1168  
1169 Dispatch cols = Dispatch.get(table, "Columns").toDispatch();
1170  
1171 Dispatch.call(cols, "AutoFit");
1172  
1173 }
1174  
1175 }
1176  
1177 /**
1178  
1179 * 调用word里的宏以调整表格的宽度,其中宏保存在document下
1180  
1181 *
1182  
1183 */
1184  
1185 @SuppressWarnings("deprecation")
1186  
1187 public void callWordMacro() {
1188  
1189 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
1190  
1191 int count = Dispatch.get(tables, "Count").toInt();
1192  
1193 Variant vMacroName = new Variant("Normal.NewMacros.tableFit");
1194  
1195 @SuppressWarnings("unused")
1196  
1197 Variant vParam = new Variant("param1");
1198  
1199 @SuppressWarnings("unused")
1200  
1201 Variant para[] = new Variant[] { vMacroName };
1202  
1203 for (int i = 0; i < count; i++) {
1204  
1205 Dispatch table = Dispatch.call(tables, "Item"new Variant(i + 1))
1206  
1207 .toDispatch();
1208  
1209 Dispatch.call(table, "Select");
1210  
1211 Dispatch.call(word, "Run""tableFitContent");
1212  
1213 }
1214  
1215 }
1216  
1217 /**
1218  
1219 * 设置当前选定内容的字体
1220  
1221 *
1222  
1223 * @param boldSize
1224  
1225 * @param italicSize
1226  
1227 * @param underLineSize
1228  
1229 *            下划线
1230  
1231 * @param colorSize
1232  
1233 *            字体颜色
1234  
1235 * @param size
1236  
1237 *            字体大小
1238  
1239 * @param name
1240  
1241 *            字体名称
1242  
1243 */
1244  
1245 public void setFont(boolean bold, boolean italic, boolean underLine,
1246  
1247 String colorSize, String size, String name) {
1248  
1249 Dispatch font = Dispatch.get(selection, "Font").toDispatch();
1250  
1251 Dispatch.put(font, "Name"new Variant(name));
1252  
1253 Dispatch.put(font, "Bold"new Variant(bold));
1254  
1255 Dispatch.put(font, "Italic"new Variant(italic));
1256  
1257 Dispatch.put(font, "Underline"new Variant(underLine));
1258  
1259 Dispatch.put(font, "Color", colorSize);
1260  
1261 Dispatch.put(font, "Size", size);
1262  
1263 }
1264  
1265 /**
1266  
1267 * 设置单元格被选中
1268  
1269 *
1270  
1271 * @param tableIndex
1272  
1273 * @param cellRowIdx
1274  
1275 * @param cellColIdx
1276  
1277 */
1278  
1279 public void setTableCellSelected(int tableIndex, int cellRowIdx, int cellColIdx){
1280  
1281 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
1282  
1283 Dispatch table = Dispatch.call(tables, "Item"new Variant(tableIndex))
1284  
1285 .toDispatch();
1286  
1287 Dispatch cell = Dispatch.call(table, "Cell"new Variant(cellRowIdx),
1288  
1289 new Variant(cellColIdx)).toDispatch();
1290  
1291 Dispatch.call(cell, "Select");
1292  
1293 }
1294  
1295 /**
1296  
1297 * 设置选定单元格的垂直对起方式, 请使用setTableCellSelected选中一个单元格
1298  
1299 * @param align 0-顶端, 1-居中, 3-底端
1300  
1301 */
1302  
1303 public void setCellVerticalAlign(int verticalAlign){
1304  
1305 Dispatch cells = Dispatch.get(selection, "Cells").toDispatch();
1306  
1307 Dispatch.put(cells, "VerticalAlignment"new Variant(verticalAlign));
1308  
1309 }
1310  
1311 /**
1312  
1313 * 设置当前文档中所有表格水平居中方式及其它一些格式,用在将word文件转化为html中,针对申报表
1314  
1315 */
1316  
1317 @SuppressWarnings("deprecation")
1318  
1319 public void setApplyTableFormat(){
1320  
1321 Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
1322  
1323 int tabCount = Integer.valueOf(Dispatch.get(tables, "Count").toString()); //System.out.println(tabCount);
1324  
1325 System.out.println("*******************************************************");
1326  
1327 for(int i=1; i<=tabCount; i++){
1328  
1329 Dispatch table = Dispatch.call(tables, "Item"new Variant(i)).toDispatch();
1330  
1331 Dispatch rows = Dispatch.get(table, "Rows").toDispatch();
1332  
1333 if(i==1){
1334  
1335 Dispatch.put(rows, "Alignment"new Variant(2)); //1-居中,2-Right
1336  
1337 continue ;
1338  
1339 }
1340  
1341 Dispatch.put(rows, "Alignment"new Variant(1)); //1-居中
1342  
1343 Dispatch.call(table, "AutoFitBehavior"new Variant(1));//设置自动调整表格方式,1-根据窗口自动调整
1344  
1345 Dispatch.put(table, "PreferredWidthType"new Variant(1));
1346  
1347 Dispatch.put(table, "PreferredWidth"new Variant(700));
1348  
1349 System.out.println(Dispatch.get(rows, "HeightRule").toString());
1350  
1351 Dispatch.put(rows, "HeightRule"new Variant(1)); //0-自动wdRowHeightAuto,1-最小值wdRowHeightAtLeast, 2-固定wdRowHeightExactly
1352  
1353 Dispatch.put(rows, "Height"new Variant(0.04*28.35));
1354  
1355 //int oldAlign = Integer.valueOf(Dispatch.get(rows, "Alignment").toString());
1356  
1357 //System.out.println("Algin:" + oldAlign);
1358  
1359 }
1360  
1361 }
1362  
1363 /**
1364  
1365 * 设置段落格式
1366  
1367 *
1368  
1369 * @param alignment
1370  
1371 * 0-左对齐, 1-右对齐, 2-右对齐, 3-两端对齐, 4-分散对齐
1372  
1373 * @param lineSpaceingRule
1374  
1375 * @param lineUnitBefore
1376  
1377 * @param lineUnitAfter
1378  
1379 * @param characterUnitFirstLineIndent
1380  
1381 */
1382  
1383 public void setParagraphsProperties(int alignment, int lineSpaceingRule,
1384  
1385 int lineUnitBefore, int lineUnitAfter, int characterUnitFirstLineIndent){
1386  
1387 Dispatch paragraphs = Dispatch.get(selection, "Paragraphs").toDispatch();
1388  
1389 Dispatch.put(paragraphs, "Alignment"new Variant(alignment)); //对齐方式
1390  
1391 Dispatch.put(paragraphs, "LineSpacingRule"new Variant(lineSpaceingRule)); //行距
1392  
1393 Dispatch.put(paragraphs, "LineUnitBefore"new Variant(lineUnitBefore)); //段前
1394  
1395 Dispatch.put(paragraphs, "LineUnitAfter"new Variant(lineUnitAfter)); //段后
1396  
1397 Dispatch.put(paragraphs, "CharacterUnitFirstLineIndent",
1398  
1399 new Variant(characterUnitFirstLineIndent)); //首行缩进字符数
1400  
1401 }
1402  
1403 /**
1404  
1405 * 打印当前段落格式, 使用前,请先选中段落
1406  
1407 */
1408  
1409 public void getParagraphsProperties(){
1410  
1411 Dispatch paragraphs = Dispatch.get(selection, "Paragraphs").toDispatch();
1412  
1413 String val = Dispatch.get(paragraphs, "LineSpacingRule").toString(); //行距
1414  
1415 System.out.println("行距:" + val);
1416  
1417 val = Dispatch.get(paragraphs, "Alignment").toString(); //对齐方式
1418  
1419 System.out.println("对齐方式:" + val); //0-左对齐, 1-右对齐, 2-右对齐, 3-两端对齐, 4-分散对齐
1420  
1421 val = Dispatch.get(paragraphs, "LineUnitBefore").toString(); //段前行数
1422  
1423 System.out.println("段前行数:" + val);
1424  
1425 val = Dispatch.get(paragraphs, "LineUnitAfter").toString(); //段后行数
1426  
1427 System.out.println("段后行数:" + val);
1428  
1429 val = Dispatch.get(paragraphs, "FirstLineIndent").toString(); //首行缩进
1430  
1431 System.out.println("首行缩进:" + val);
1432  
1433 val = Dispatch.get(paragraphs, "CharacterUnitFirstLineIndent").toString(); //首行缩进字符数
1434  
1435 System.out.println("首行缩进字符数:" + val);
1436  
1437 }
1438  
1439 /**
1440  
1441 * 文件保存或另存为
1442  
1443 *
1444  
1445 * @param savePath
1446  
1447 *            保存或另存为路径
1448  
1449 */
1450  
1451 public void save(String savePath) {
1452  
1453 Dispatch.call(Dispatch.call(word, "WordBasic").getDispatch(),
1454  
1455 "FileSaveAs", savePath);
1456  
1457 }
1458  
1459 /**
1460  
1461 * 文件保存为html格式
1462  
1463 *
1464  
1465 * @param savePath
1466  
1467 * @param htmlPath
1468  
1469 */
1470  
1471 public void saveAsHtml(String htmlPath){
1472  
1473 Dispatch.invoke(doc,"SaveAs", Dispatch.Method,
1474  
1475 new Object[]{htmlPath, new Variant(8)}, new int[1]);
1476  
1477 }
1478  
1479 /**
1480  
1481 * 关闭文档
1482  
1483 *@param val 0不保存修改 -1 保存修改 -2 提示是否保存修改
1484  
1485 */
1486  
1487 public void closeDocument(int val) {
1488  
1489 Dispatch.call(doc, "Close"new Variant(val));
1490  
1491 doc = null;
1492  
1493 }
1494  
1495 /**
1496  
1497 * 关闭当前word文档
1498  
1499 *
1500  
1501 */
1502  
1503 public void closeDocument() {
1504  
1505 if (doc != null) {
1506  
1507 Dispatch.call(doc, "Save");
1508  
1509 Dispatch.call(doc, "Close"new Variant(saveOnExit));
1510  
1511 doc = null;
1512  
1513 }
1514  
1515 }
1516  
1517 public void closeDocumentWithoutSave(){
1518  
1519 if (doc != null) {
1520  
1521 Dispatch.call(doc, "Close"new Variant(false));
1522  
1523 doc = null;
1524  
1525 }
1526  
1527 }
1528  
1529 /**
1530  
1531 * 关闭全部应用
1532  
1533 *
1534  
1535 */
1536  
1537 public void close() {
1538  
1539 //closeDocument();
1540  
1541 if (word != null) {
1542  
1543 Dispatch.call(word, "Quit");
1544  
1545 word = null;
1546  
1547 }
1548  
1549 selection = null;
1550  
1551 documents = null;
1552  
1553 }
1554  
1555 /**
1556  
1557 * 打印当前word文档
1558  
1559 *
1560  
1561 */
1562  
1563 public void printFile() {
1564  
1565 if (doc != null) {
1566  
1567 Dispatch.call(doc, "PrintOut");
1568  
1569 }
1570  
1571 }
1572  
1573 /**
1574  
1575 * 保护当前档,如果不存在, 使用expression.Protect(Type, NoReset, Password)
1576  
1577 *
1578  
1579 * @param pwd
1580  
1581 * WdProtectionType 可以是下列 WdProtectionType 常量之一:
1582  
1583 * 1-wdAllowOnlyComments, 2-wdAllowOnlyFormFields, 0-wdAllowOnlyRevisions,
1584  
1585 * -1-wdNoProtection, 3-wdAllowOnlyReading
1586  
1587 *
1588  
1589 */
1590  
1591 public void protectedWord(String pwd){
1592  
1593 String protectionType = Dispatch.get(doc, "ProtectionType").toString();
1594  
1595 if(protectionType.equals("-1")){
1596  
1597 Dispatch.call(doc, "Protect"new Variant(3), new Variant(true), pwd);
1598  
1599 }
1600  
1601 }
1602  
1603 /**
1604  
1605 * 解除文档保护,如果存在
1606  
1607 * @param pwd
1608  
1609 * WdProtectionType 常量之一(Long 类型,只读):
1610  
1611 * 1-wdAllowOnlyComments,2-wdAllowOnlyFormFields、
1612  
1613 * 0-wdAllowOnlyRevisions,-1-wdNoProtection, 3-wdAllowOnlyReading
1614  
1615 *
1616  
1617 */
1618  
1619 public void unProtectedWord(String pwd){
1620  
1621 String protectionType = Dispatch.get(doc, "ProtectionType").toString();
1622  
1623 if(protectionType.equals("3")){
1624  
1625 Dispatch.call(doc, "Unprotect", pwd);
1626  
1627 }
1628  
1629 }
1630  
1631 /**
1632  
1633 * 设置word文档安全级别
1634  
1635 * @param value
1636  
1637 * 1-msoAutomationSecurityByUI  使用“安全”对话框指定的安全设置。
1638  
1639 * 2-msoAutomationSecurityForceDisable  在程序打开的所有文件中禁用所有宏,而不显示任何安全提醒。
1640  
1641 * 3-msoAutomationSecurityLow  启用所有宏,这是启动应用程序时的默认值。
1642  
1643 */
1644  
1645 public void setAutomationSecurity(int value){
1646  
1647 word.setProperty("AutomationSecurity"new Variant(value));
1648  
1649 }
1650  
1651 /**
1652  
1653 * 读取文档中第paragraphsIndex段文字的内容;
1654  
1655 * @param paragraphsIndex
1656  
1657 * @return
1658  
1659 */
1660  
1661 public String getParagraphs(int paragraphsIndex){
1662  
1663 String ret = "";
1664  
1665 Dispatch paragraphs = Dispatch.get(doc, "Paragraphs").toDispatch(); // 所有段落
1666  
1667 int paragraphCount = Dispatch.get(paragraphs, "Count").getInt(); // 一共的段落数
1668  
1669 Dispatch paragraph = null;
1670  
1671 Dispatch range = null;
1672  
1673 if(paragraphCount > paragraphsIndex && 0 < paragraphsIndex){
1674  
1675 paragraph = Dispatch.call(paragraphs, "Item"new Variant(paragraphsIndex)).toDispatch();
1676  
1677 range = Dispatch.get(paragraph, "Range").toDispatch();
1678  
1679 ret = Dispatch.get(range, "Text").toString();
1680  
1681 }
1682  
1683 return ret;
1684  
1685 }
1686  
1687 public static void main(String[] args)throws Exception{
1688  
1689 WordBean word = new WordBean();
1690  
1691 word.createNewDocument();
1692  
1693 word.createTable(""55);
1694  
1695 word.mergeCell(11115);
1696  
1697 word.mergeCell(12125);
1698  
1699 word.mergeCell(13135);
1700  
1701 word.putTxtToCell(1,1,1,"主题");
1702  
1703 word.putTxtToCell(1,2,1,"时间");
1704  
1705 word.putTxtToCell(1,3,1,"人员");
1706  
1707 word.putTxtToCell(1,4,2,"说话了");
1708  
1709 word.save("c:\\jacobTest.doc");
1710  
1711 System.out.print("请打开c:\\jacobTest.doc查看是否有写word成功!");
1712  
1713 word.close();
1714  
1715 }
1716  
1717 }


四.使用错误分析:


1.由于应用程序配置不正确,不能启用dll文件;


解决:版本不对,换另一个版本试一下.


2. 

1 ERROR [http-8080-Processor25] - Servlet.service() for servlet FileUploaded threw exception
2  
3    java.lang.UnsatisfiedLinkError: no jacob-1.14.3-x86 in java.library.path
4  
5    at java.lang.ClassLoader.loadLibrary(Unknown Source)
6  
7    at java.lang.Runtime.loadLibrary0(Unknown Source)
8  
9    at java.lang.System.loadLibrary(Unknown Source)


将dll文件复制到tomcat\bin目录下重新启动tomcat5.5


3.使用过程中(将项目发布到Tomcat5下运行时)提示


1 java.lang.UnsatisfiedLinkError:
2  
3 Native Library D:\Program Files\Apache Software Foundation\Tomcat 5.5\bin\jacob-1.14.3-x86.dll
4  
5 already loaded in another classloader


解决:将%Tomcat 5.5%\webapps\XXXX\WEB-INF\lib\下的jacob.jar包剪切到%Tomcat 5.5%\shared\lib目录下(或删除).




五.自己改写WordBean类:


1.改写前你要知道VBA,熟悉怎样用VBA操作word;


2.将VBA操作改到java代码;要知道com.jacob.com.Dispatch可容纳任何VBA中的集合对象;


如:Dispatch paragraphs = Dispatch.get(doc, "Paragraphs").toDispatch(); // 将Paragraphs 集合对象赋给Dispatch对象;


3.使用VBA对象属性:


如:int paragraphCount = Dispatch.get(paragraphs, "Count").getInt(); //调用Dispatch.get()方法获取Paragraphs 集合对象的Count属性;


4.调用VBA对象方法:


在VBA帮助中我们找到Document 对象Close方法是这样声明的:


expression.Close(SaveChanges, OriginalFormat, RouteDocument)


expression   必需。该表达式返回以上的一个对象。


SaveChanges  Variant 类型,可选。指定保存文档的操作。可以是下列 WdSaveOptions 常量之一:wdDoNotSaveChanges、wdPromptToSaveChanges 或 wdSaveChanges。


OriginalFormat  Variant 类型,可选。指定保存文档的格式。可以是下列 WdOriginalFormat 常量之一:wdOriginalDocumentFormat、wdPromptUser 或 wdWordDocument。


RouteDocument  Variant 类型,可选。如果该属性值为 True,则将文档发送给下一个收件人。如果文档没有附加传送名单,则忽略该参数。


因些我们可在WordBean添加一个这样的方法关闭文档:


1 public void closeDocument(int val) {
2  
3 Dispatch doc = Dispatch.call(documents, "Open", docPath).toDispatch();  //doc是Document对象,调用
4  
5 Dispatch.call(doc, "Close"new Variant(val));  // val 0不保存修改 -1 保存修改 -2 提示是否保存修改,对应VBA中Document 对象Close方法的SaveChanges参数
6  
7 doc = null;
8  
9 }


你会注意到Dispatch类重载了很多call方法,这与VBA中方法基本相似有很多参数是缺省的:


你可还会注意到Dispatch还有个invoke方法其实它和call差不多也是调用VBA对象方法的,只参数的形式不同(我目前这样认为)


Dispatch还有很多方法调用都是为配合调用VBA对象的方法,我还没有时间深入的看,等都明白再补上这部分说明;


参考(自己Gooogle一下):


JAVA 深度控制 WORD;


Aspose.Words for Java 发布-操作word的工具


Java/Office2007 以往java程序员要访问office文档,往往要借助各种各样的com组件,jni是难以避免的,因为office文档(word、excel、ppt)是二进制存储的。但是在许多系统中都要用到office文档,这个java程序员带来了一定的麻烦。  随着office2007的出现,文档存储支持OpenXML,使得java程序读写office文档不用必须借助第三方控件。以word2007为例,文档存储为*.docx文件,这实际上是一个压缩文件,通过java的ZIPjar包、TAR jar包,都可以访问,可以使用100%纯java代码完成对word2007文件的读取、写入操作。  比较详细的一个例子如下:http://www.infoq.com/articles/cracking-office-2007-with-java,有兴趣的可以去参考一下。  另外,office文档操作也有很多其他方法,比如POI、j-Interop等第三方工具包。

你可能感兴趣的:(Java,java,jacob,word)