qq_38355767
qq_38355767

Jacob处理Word文档总结

使用Jacob来处理Word文档


Word或Excel程序是以一种COM组件形式存在的。如果能够在Java中调用Word的COM组件，就

能使用它的方法来获取Word文档中的文本信息。目前网上有许多提供这样的工具。

1  Jacob的下载
Jacob 是Java-COM Bridge的缩写，它在Java与微软的COM组件之间构建一座桥梁。使用Jacob

自带的DLL动态链接库，并通过JNI的方式实现了在Java平台上对COM程序的调用。Jacob下载

的地址为：
http://sourceforge.net/project/showfiles.php? group_id=109543&package_id=118368。本书

采用的是jacob_1.11_zip。解压下载的 Jacob_1.11_zip文件后，

2  在Eclipse中配置
（1）将jacob.jar导入工程的Build Path，然后确认自己机器的CPU类型（X86或AMD64），并

选择不同目录下的jacob.dll文件。

（2）将jacob.dll放到% JAVA_HOME%/jre/bin目录下，其中，%JAVA_HOME%就是JDK的安装

目录。注意这个的jre目录必须是Eclipse当前正在使 用的目录，在Eclipse中选择“window-

>Preferences”菜单，在弹出的对话框中选择“Java->Installed JREs”项，

（3）当前选择的JRE是“C:/Program Files/Java/jdk1.5.0_07/jre”目录下的，所以需要把

jacob.dll复制到“C:/Program Files/Java/jdk1.5.0_07/jre/bin”目录下面。

（4）在工程中新建一个ch7.jacob包， 并在包中创建WordReader类。该类将提供一个静态的

extractDoc()方法。它接收两个参数，一个是要处理的DOC文件名，另一个则是输出 的文件名

，然后通过JNI调用Word的API转换内容，该函数的代码如下。

public static void extractDoc(String inputFIle, String outputFile) {

   boolean flag = false; 

   // 打开Word应用程序
   ActiveXComponent app = new ActiveXComponent("Word.Application");
   try {
      // 设置word不可见
      app.setProperty("Visible", new Variant(false));

      // 打开word文件
      Dispatch doc1 = app.getProperty("Documents").toDispatch();

      Dispatch doc2 = Dispatch.invoke(
            doc1,
            "Open",
            Dispatch.Method,
            new Object[] { inputFIle, new Variant(false),
                  new Variant(true) }, new int[1]).toDispatch();

      // 作为txt格式保存到临时文件
      Dispatch.invoke(doc2, "SaveAs", Dispatch.Method, new Object[] {
            outputFile, new Variant(7) }, new int[1]);

      // 关闭word
      Variant f = new Variant(false);
      Dispatch.call(doc2, "Close", f);
      flag = true;

   } catch (Exception e) {
      e.printStackTrace();
   } finally {
      app.invoke("Quit", new Variant[] {});
   }

   if (flag == true) {
      System.out.println("Transformed Successfully");
   } else {
      System.out.println("Transform Failed");
   }

}

（5）创建一个main函数来测试WordReader类，该main函数代码如下。

public static void main(String[] args) {
        WordReader.extractDoc("c:/test.doc","c:/jacob.txt");
}

（6）新生成的txt文件被保存到c:/jacob.txt下

在使用Jacob时，很重要的一点是，用户本地系统中必须安装有Word的应用程序。否则也就无

法建立Java-COM桥，进而无法解析了。

 

解决jacob调用word处理doc文件的内存溢出问题


背景：
有个项目在系统后台用Jacob调用Word进程的API做doc文件处理。在进行压力测试的时候，发现运行一段时间后，内存占用奇高，大约7.4G。由于JVM占用内存限制为2G，因此怀疑多出来的内存应当是Jacob泄露的。

在网路上搜索解决办法，都是要这样调用
[java] view plaincopyprint?ComThread.InitSTA();    
// do something     
ComThread.Release();  
ComThread.InitSTA();
// do something
ComThread.Release();
但是在项目中，使用了线程池进行DOC文件处理，也就是同一时间，会有多个WORD进程在跑，使用ComThread.InitSTA();之后，Jacob仅允许线程池里面的一个线程执行，其他线程都被锁住。

最后修改成ComThread.InitMTA(true);来初始化，经过24小时压力测试，可以同时有多个WORD进程运行，另外也解决了Jacob内存溢出问题。

 

使用JACOB进行Word编程示例




import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;    
  
import com.jacob.activeX.ActiveXComponent;    
import com.jacob.com.ComThread;    
import com.jacob.com.Dispatch;    
import com.jacob.com.Variant;   
import com.sun.star.uno.RuntimeException;
  
import org.apache.log4j.Logger;   
  
/**  
 * @date : 2011-5-5
 * @description : 利用jacob插件生成word 文件！   
 * @author weich  
 */  
public class DOCWriter {   
  
    /** 
     * @date : 2011-5-5
     * 日志记录器
     */  
    private static Logger logger = Logger.getLogger(DOCWriter.class);
  
    /** 
     * @date : 2011-5-5
     * word文档  
     * 在本类中有两种方式可以进行文档的创建,
 
     * 第一种调用 createNewDocument  
     * 第二种调用 openDocument   
     */    
    private Dispatch document = null;    
  
    /** 
     * @date : 2011-5-5
     * word运行程序对象 
     */    
    private ActiveXComponent word = null;    
  
    /** 
     * @date : 2011-5-5
     * 所有word文档 
     */    
    private Dispatch documents = null;    
  
    /**
     * @date :
     * Selection 对象 代表窗口或窗格中的当前所选内容。 所选内容代表文档中选定（或突出显示）的区域，如果文档中没有选定任何内容，则代表插入点。  
     * 每个文档窗格只能有一个Selection 对象，并且在整个应用程序中只能有一个活动的 Selection 对象。  
     */  
    private Dispatch selection = null;    
  
    /**
     * @date : 
     * Range 对象 代表文档中的一个连续区域。 每个 Range 对象由一个起始字符位置和一个终止字符位置定义。  
     * 说明：与书签在文档中的使用方法类似，Range 对象在 Visual Basic 过程中用来标识文档的特定部分。  
     * 但与书签不同的是，Range对象只在定义该对象的过程运行时才存在。  
     * Range对象独立于所选内容。也就是说，您可以定义和处理一个范围而无需更改所选内容。还可以在文档中定义多个范围，但每个窗格中只能有一个所选内容。  
     */  
    private Dispatch range = null;   
  
    /**
     * @date : 
     * PageSetup 对象 该对象包含文档的所有页面设置属性（如左边距、下边距和纸张大小）。  
     */  
    private Dispatch pageSetup = null;   
  
    /**
     * @date : 
     * 文档中的所有表格对象 
     */  
    private Dispatch tables = null;   
  
    /**
     * @date :
     * 一个表格对象 
     */  
    private Dispatch table = null;  
    private  static Boolean isUsed=false;
  
    /**
     * @date : 
     * 表格所有行对象 
     */  
    private Dispatch rows = null;   
  
    /**
     * @date :
     * 表格所有列对象 
     */  
    private Dispatch cols = null;   
  
    /**
     * @date :
     * 表格指定行对象 
     */  
    private Dispatch row = null;   
  
    /**
     * @date :
     * 表格指定列对象 
     * */  
    private Dispatch col = null;   
  
    /**
     * @date :
     * 表格中指定的单元格 
     */  
    private Dispatch cell = null;   
       
    /**
     * @date :
     * 字体 
     */  
    private Dispatch font = null;   
       
    /** 
     * @date :
     * 对齐方式
     */  
    private Dispatch alignment = null;
    
    /**
     * @date :
     * 特殊字符集合
     */
    private static String[] speCharArray = {" ", "&"};
    
    /**
     * @date :
     * 与特殊字符对应的真实字符
     */
    private static String[] parCharArray = {" ", "&"};
  
    /**
     * @date :
     * 构造方法  
     */  
    public DOCWriter() {    
    ComThread.InitSTA();
        if (this.word == null) {
            /* 初始化应用所要用到的对象实例 */  
            this.word = new ActiveXComponent("Word.Application");    
            /* 设置Word文档是否可见，true-可见false-不可见 */  
            this.word.setProperty("Visible", new Variant(false));   
            /* 禁用宏 */  
            this.word.setProperty("AutomationSecurity", new Variant(3));   
        }   
        if (this.documents == null) {
            this.documents = word.getProperty("Documents").toDispatch();  
        }   
    }
  //插入上标值;10.5是五号，9是小五，8是六号，12是小四
    public void insertSuperValue(boolean isHomeKey, String toFindText,String text,double size){
    boolean isFind=this.find(toFindText);//查找替换字段;
    if(!"".equals(text) && null != text){
    text = this.replaceSpeChar(text);    //替换字符串中含有的特殊字符
    }
    if(isFind){
    List list=new ArrayList();
    int  start=text.indexOf("     String supOrSub="p";
    int  i = -1;
  int  j = -1;
  try {
  synchronized (isUsed) {
    if(isUsed){
    isUsed=false;
    return;
    }else{
    isUsed=true;
    while(start != -1) {
        supOrSub=text.substring(start+3,start+4);
        i = text.indexOf("");
    j = text.indexOf("");
    if(i!=0){
    list.add(text.substring(0,i));
    }
    if("p".equals(supOrSub)){//如果当前为上标的话;
    list.add("Sup:"+text.substring(i+5,j));
    }else if("b".equals(supOrSub)){
    list.add("Sub:"+text.substring(i+5,j));
    }
    text = text.substring(j+6);
    start = text.indexOf("     if(start==-1){
    if(text.length()>0){
    list.add(text);
    text="";
    }
    }
    }
    isUsed=false;
    }
    }
  if(list.size()<=0){
  list.add(text);
//text="";
  }
    if(list!=null && list.size()>0){
    for(int s=0;s     String dataStr=list.get(s);
    if(dataStr.startsWith("Su")){
    String supState=dataStr.substring(2,3);
    if("p".equals(supState)){
    String supStr=dataStr.substring(4);
    this.insertSupText(supStr);//插入数据;
        this.doSupValue(supStr,true);//设置上标;
        this.font = Dispatch.get(selection,"Font").toDispatch();
        Dispatch.put(font, "Size", size);
        this.moveRight(1);
    }else if("b".equals(supState)){
    String subStr=dataStr.substring(4);
    this.insertSupText(subStr);//插入数据;
    this.doSubValue_fontsize(subStr,true,toFindText);//设置下标;
    this.font = Dispatch.get(selection,"Font").toDispatch();
        Dispatch.put(font, "Size", size);
        this.moveRight(1);
    }else{
    this.insertSupText(dataStr);
    //取消上下标格式化;
    this.doSupValue(dataStr,false);
        this.doSubValue_fontsize(dataStr,false,toFindText);
        this.moveRight(1);
    }
    }else{
    this.insertSupText(dataStr);
    //取消上下标格式化;
    this.doSupValue(dataStr,false);
        this.doSubValue_fontsize(dataStr,false,toFindText);
        this.moveRight(1);
    }
    if(isHomeKey){//返回顶部起点;
    if(s==list.size()-1){
    this.moveStart();
    }
    }
      }
      }
} catch (Exception e) {
new RuntimeException("插入上下标数据时出错");
}finally{
isUsed=false;
}
 
     }
    }
 // 设置是否在前台打开 word 程序 ，
 
    public void setVisible(boolean visible) {
    //word.setProperty("Visible", new Variant(visible)); 
    // 这一句作用相同  
    Dispatch.put(word, "Visible", new Variant(visible));  
    } 
  //插入上标值;
    public void insertSuper(boolean isHomeKey,String text){
    List list=new ArrayList();
    text=(text==null)?"":text;
    text=text.replace("", "");
    text=text.replace("","");
    text=text.replace("","");
    text=text.replace("","");
    text = this.replaceSpeChar(text);    //替换字符串中含有的特殊字符
    int  start=text.indexOf("     String supOrSub="p";
    int  i = -1;
  int  j = -1;
  try {
  synchronized (isUsed) {
    if(isUsed){
    isUsed=false;
    return;
    }else{
    isUsed=true;
    while(start != -1) {
        supOrSub=text.substring(start+3,start+4);
        i = text.indexOf("");
    j = text.indexOf("");
    if(i!=0){
    list.add(text.substring(0,i));
    }
    if("p".equals(supOrSub)){//如果当前为上标的话;
    list.add("Sup:"+text.substring(i+5,j));
    }else if("b".equals(supOrSub)){
    list.add("Sub:"+text.substring(i+5,j));
    }
    text = text.substring(j+6);
    start = text.indexOf("     if(start==-1){
    if(text.length()>0){
    list.add(text);
    text="";
    }
    }
    }
    if(start==-1) {
    if(text.length()>0){
  list.add(text);
  text="";
  }
  }
    isUsed=false;
    }
    }
  if(list.size()<=0){
  list.add(text);
text="";
  }
    if(list!=null && list.size()>0){
    for(int s=0;s     String dataStr=list.get(s);
    if(dataStr.startsWith("Su")){
    String supState=dataStr.substring(2,3);
    if("p".equals(supState)){
    String supStr=dataStr.substring(4);
    this.insertSupText(supStr);//插入数据;
        this.doSupValue(supStr,true);//设置上标;
        this.font = Dispatch.get(selection,"Font").toDispatch();
        Dispatch.put(font, "Size", 10.5);
        this.moveRight(1);
    }else if("b".equals(supState)){
    String subStr=dataStr.substring(4);
    this.insertSupText(subStr);//插入数据;
    this.doSubValue(subStr,true);//设置下标;
    this.font = Dispatch.get(selection,"Font").toDispatch();
        Dispatch.put(font, "Size", 10.5);
        this.moveRight(1);
    }
    }else{
    this.insertSupText(dataStr);
    //取消上下标格式化;
    this.doSupValue(dataStr,false);
        this.doSubValue(dataStr,false);
        if(!"".equals(dataStr)){
        this.moveRight(1);
        }
       
    }
    if(isHomeKey){//返回顶部起点;
    if(s==list.size()-1){
    this.moveStart();
    }
    }
      }
       }
} catch (Exception e) {
new RuntimeException("插入上下标字符串时出错!");
}finally{
isUsed=false;
}
 
    }
    /**
     * @date :
     * 设置页面方向和页边距  
     * @param orientation 可取值0或1，分别代表横向和纵向  
     * @param leftMargin  左边距的值  
     * @param rightMargin  右边距的值  
     * @param topMargin 上边距的值  
     * @param buttomMargin 下边距的值  
     */  
    public void setPageSetup(int orientation, int leftMargin, int rightMargin, int topMargin, int buttomMargin) {   
        logger.debug("设置页面方向和页边距...");   
        if (this.pageSetup == null) {   
            this.getPageSetup();   
        }   
        Dispatch.put(pageSetup, "Orientation", orientation);   
        Dispatch.put(pageSetup, "LeftMargin", leftMargin);   
        Dispatch.put(pageSetup, "RightMargin", rightMargin);   
        Dispatch.put(pageSetup, "TopMargin", topMargin);   
        Dispatch.put(pageSetup, "BottomMargin", buttomMargin);   
    }   
//格式化上标值;
  public void doSupValue(String text,boolean isTrue){
  this.font = Dispatch.get(selection,"Font").toDispatch();
  Dispatch.put(font, "Size", 10.5);
  Dispatch.put(font, "Superscript", new Variant(isTrue));
  }
  //格式化下标值;
  public void doSubValue(String text,boolean isTrue){
  this.font = Dispatch.get(selection,"Font").toDispatch();
  Dispatch.put(font, "Size", 10.5);
  Dispatch.put(font, "Subscript", new Variant(isTrue));
  }
  //格式化下标值;
  public void doSubValue_fontsize(String text,boolean isTrue,String fieldName){
  this.font = Dispatch.get(selection,"Font").toDispatch();
  float size = 0.0f;
  if("SampleNamefp".equals(fieldName) || "ModelSizefp".equals(fieldName)){//报告首页加大字号
  size=15.5f;
  }else if("SampleName".equals(fieldName) || "Brand".equals(fieldName)||"ModelSize".equals(fieldName)||"modelSize".equals(fieldName)||"sampleBatch".equals(fieldName)||"ModelSizeZp".equals(fieldName)||"testStandard".equals(fieldName)||"sampleName".equals(fieldName)){
  size=10.5f;
  }else{
  size=9f;
  }
  Dispatch.put(font, "Size", size);
  Dispatch.put(font, "Subscript", new Variant(isTrue));
  }
    /**
     * @date :
     * 打开文件   
     * @param inputDoc 要打开的文件，全路径   
     * @return Dispatch 打开的文件   
     */    
    public Dispatch openDocument(String inputDoc) {    
        logger.debug("打开Word文档...");   
        this.document = Dispatch.call(documents, "Open", inputDoc).toDispatch();   
        this.getSelection();   
        this.getRange();   
        this.getAlignment();   
        this.getFont();   
        this.getPageSetup(); 
        
        return this.document;    
    }    
  
    /**
     * @date :
     * 创建新的文件  
     * @return Dispache 返回新建文件  
     */  
    public Dispatch createNewDocument() {   
        logger.debug("创建新的文件...");   
        this.document = Dispatch.call(documents, "Add").toDispatch();   
        this.getSelection();   
        this.getRange();   
        this.getPageSetup();   
        this.getAlignment();   
        this.getFont();  
        
        return this.document;   
    }   
  
    /**
     * @date :
     * 选定内容   
     * @return Dispatch 选定的范围或插入点   
     */    
    public Dispatch getSelection() {    
        logger.debug("获取选定范围的插入点...");   
        this.selection = word.getProperty("Selection").toDispatch();  
        
        return this.selection;    
    }    
  
    /**
     * @date : 
     * 获取当前Document内可以修改的部分


 
     * 前提条件：选定内容必须存在  
     * @return 可修改的对象  
     */  
    public Dispatch getRange() {   
        logger.debug("获取当前Document内可以修改的部分...");   
        this.range = Dispatch.get(this.selection, "Range").toDispatch(); 
        
        return this.range;   
    }   
  
    /**
     * @date :
     * 获得当前文档的文档页面属性  
     */  
    public Dispatch getPageSetup() {   
        logger.debug("获得当前文档的文档页面属性...");   
        if (this.document == null) {   
            logger.warn("document对象为空...");   
            return this.pageSetup;   
        }   
        this.pageSetup = Dispatch.get(this.document, "PageSetup").toDispatch();
        
        return this.pageSetup;   
    }   
  
    /**
     * @date : 
     * 把选定内容或插入点向上移动   
     * @param count 移动的距离   
     */    
    public void moveUp(int count) {    
        logger.debug("把选定内容或插入点向上移动...");   
        for (int i = 0; i < count; i++) {   
            Dispatch.call(this.selection, "MoveUp");   
        }   
    }    
  
    /**
     * @date : 
     * 把选定内容或插入点向下移动   
     * @param count 移动的距离   
     */    
    public void moveDown(int count) {    
        logger.debug("把选定内容或插入点向下移动...");   
        for (int i = 0; i < count; i++) {   
            Dispatch.call(this.selection, "MoveDown");
        }   
    }    
  
    /**
     * @date :
     * 把选定内容或插入点向左移动   
     * @param count 移动的距离   
     */    
    public void moveLeft(int count) {    
    logger.debug("把选定内容或插入点向左移动...");   
        for (int i = 0; i < count; i++) {   
            Dispatch.call(this.selection, "MoveLeft");   
        }   
    }    
  
    /**
     * @date :
     * 把选定内容或插入点向右移动   
     * @param count 移动的距离   
     */    
    public void moveRight(int count) {    
        logger.debug("把选定内容或插入点向右移动...");   
        for (int i = 0; i < count; i++) {   
            Dispatch.call(this.selection, "MoveRight");   
        }   
    }   
       
    /**
     * @date :
     * 回车键  
     */  
    public void enterDown(int count) {   
        logger.debug("按回车键...");   
        for (int i = 0; i < count; i++) {   
            Dispatch.call(this.selection, "TypeParagraph");   
        }   
    } 
    
   
  
    /**
     * @date :
     * 把插入点移动到文件首位置   
     */    
    public void moveStart() {    
        logger.debug("把插入点移动到文件首位置...");   
        Dispatch.call(this.selection, "HomeKey", new Variant(6));    
    }    
  
    /**
     * @date : 
     * 从选定内容或插入点开始查找文本   
     * @param toFindText 要查找的文本   
     * @return boolean true-查找到并选中该文本，false-未查找到文本   
     */    
    public boolean find(String toFindText) {    
        logger.debug("从选定内容或插入点开始查找文本" + " 要查找内容：  " + toFindText);   
        /* 从selection所在位置开始查询 */  
        Dispatch find = Dispatch.call(this.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();    
    }    
  
    /**
     * @date : 
     * 把选定内容替换为设定文本   
     * @param newText 替换为文本   
     */    
    public void replace(String newText) {    
        logger.debug("把选定内容替换为设定文本...");   
        /* 设置替换文本 */  
        Dispatch.put(this.selection, "Text", newText);   
    }    
  
    /**
     * @date :
     * 全局替换   
     * @param oldText 要替换的文本   
     * @param replaceObj 替换为文本  
     */    
    public void replaceAll(String oldText, Object replaceObj) {    
        logger.debug("全局替换...");   
        /* 移动到文件开头 */  
        moveStart();    
        /* 表格替换方式 */  
        String newText = (String) replaceObj;   
        /* 图片替换方式 */  
        if (oldText.indexOf("image") != -1 || newText.lastIndexOf(".bmp") != -1 
        || newText.lastIndexOf(".jpg") != -1 || newText.lastIndexOf(".gif") != -1) {    
            while (find(oldText)) {    
                insertImage(newText);    
                Dispatch.call(this.selection, "MoveRight");    
            }    
            /* 正常替换方式 */  
        } else {   
            while (find(oldText)) {    
                replace(newText);    
                Dispatch.call(this.selection, "MoveRight");    
            }    
        }   
    }    
  
    /**
     * @date :
     * 插入图片   
     * @param imagePath 图片文件（全路径）   
     */    
    public void insertImage(String imagePath) {    
        logger.debug("插入图片...");   
        Dispatch.call(this.selection, "TypeParagraph");   
        Dispatch.call(Dispatch.get(this.selection, "InLineShapes").toDispatch(), "AddPicture", imagePath);    
    }    
  
    /**
     * @date :
     * 合并表格  
     *  
     * @param tableIndex 表格起始点  
     * @param fstCellRowIdx 开始行  
     * @param fstCellColIdx 开始列  
     * @param secCellRowIdx 结束行  
     * @param secCellColIdx 结束列  
     */  
    public void mergeCell(int tableIndex, int fstCellRowIdx, int fstCellColIdx, int secCellRowIdx, int secCellColIdx) {
        logger.debug("合并单元格...");   
        if (this.table == null) {
        table = this.getTable(tableIndex);
        }
         
        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);   
    }   
  
    /**
     * @date :
     * 想Table对象中插入数值 
     * List.size()为表格的总行数  
     * String[]的length属性值应该与所创建的表格列数相同  
     * @param list 数据内容  
     */  
    public void insertToTable(List list) {   
        logger.debug("向Table对象中插入数据...");   
        if (list == null || list.size() <= 0) {   
            logger.warn("写出数据集为空...");   
            return;   
        }   
        if (this.table == null) {   
            logger.warn("table对象为空...");   
            return;   
        }   
        for (int i = 0; i < list.size(); i++) {   
            String[]  strs = list.get(i);   
            for (int j = 0; j < strs.length; j++) {   
                /* 遍历表格中每一个单元格，遍历次数与所要填入的内容数量相同 */  
                Dispatch cel = this.getCell(i + 1, j + 1);
                /* 选中此单元格 */  
                Dispatch.call(cel, "Select");   
                /* 写出内容到此单元格中 */  
                Dispatch.put(this.selection, "Text", strs[j]);   
                /* 移动游标到下一个位置 */  
            }   
            this.moveDown(1);   
        }   
        this.enterDown(1);   
    }   
  
    /**
     * @date :
     * 在文档中正常插入文字内容  
     * @param list 数据内容  
     */  
    public void insertToDocument(List list) {
        logger.debug("向Document对象中插入数据...");   
        if (list == null || list.size() <= 0) {
            logger.warn("写出数据集为空...");   
            return;   
        }   
        if (this.document == null) {   
            logger.warn("document对象为空...");   
            return;   
        }   
        for (String str : list) {   
            /* 写出至word中 */  
            //this.applyListTemplate(3, 2);   
            Dispatch.put(this.selection, "Text", str);  
            //this.moveRight(1);
            this.moveDown(1); 
            this.moveUp(1);
            //this.enterDown(1);   
        }   
    }
    
    /**
     * @date :
     * 在文档中正常插入文字内容  
     */  
    public void insertText(String str) {
        logger.debug("向Document对象中插入数据...");   
        if (str == null || str == "") {   
            logger.warn("写出数据集为空...");   
            return;   
        }   
        if (this.document == null) {   
            logger.warn("document对象为空...");   
            return;   
        } 
        Dispatch.put(this.selection, "Text", str);  
        this.moveRight(1);
        
    }   
    /**
     * @date :
     * 创建新的表格  
     *   
     * @param rowCount 行数  
     * @param colCount 列数  
     * @param width 边框数值 0浅色1深色  
     * @return 新创建的表格对象  
     */  
    public Dispatch createNewTable(int rowCount, int colCount, int width) {
        logger.debug("创建新的表格...");   
        if (this.tables == null) {   
            this.getTables();   
        }   
        this.getRange();   
        if (rowCount > 0 && colCount > 0) {   
            this.table = Dispatch.call(this.tables, "Add", this.range, new Variant(rowCount), 
            new Variant(colCount), new Variant(width)).toDispatch();   
        }
        
        /* 返回新创建表格 */  
        return this.table;   
    }   
  
    /**
     * @date        : 
     * @author      : 
     * @description : 创建表格
     * @modify      : 修改人 时间 简单描述 
     * @param pos
     * @param numCols
     * @param numRows
     */
    public void createTable(String pos, int numCols, int numRows) {
    if (find(pos)) { 
    Dispatch tables1 = Dispatch.get(this.document, "Tables").toDispatch();
    Dispatch range1 = Dispatch.get(selection, "Range").toDispatch();
    @SuppressWarnings("unused")
Dispatch newTable = Dispatch.call(tables1, "Add", range1, new Variant(numRows), 
    new Variant(numCols)).toDispatch(); 
    Dispatch.call(selection, "MoveRight"); 
    } 
    } 
    
    /**
     * @date        : 
     * @author      : 
     * @description : 增加一行
     * @modify      : 修改人 时间 简单描述 
     * @param tableIndex
     */
    public void addRow(int tableIndex) { 
    Dispatch tables1 = Dispatch.get(this.document, "Tables").toDispatch();
    //要填充的表格 
    Dispatch table1 = Dispatch.call(tables1, "Item", new Variant(tableIndex)).toDispatch(); 
    //表格的所有行 
    Dispatch rows1 = Dispatch.get(table1, "Rows").toDispatch(); 
    Dispatch.call(rows1, "Add"); 
    } 
    
    /**
     * @date        : 
     * @author      : 
     * @description : 在指定行前面增加一行
     * @modify      : 修改人 时间 简单描述 
     * @param tableIndex
     * @param rowIndex
     */
    //在指定行前面增加一行 
    public void addTableRow(int tableIndex, int rowIndex) { 
    //要填充的表格
    if (this.table == null) {
    this.table = this.getTable(tableIndex);
    }
   
    //表格的所有行 
    this.row = this.getTableRow(rowIndex); 
    Dispatch.call(rows, "Add", new Variant(row));
    } 


    /**
     * @date        : 
     * @author      : 
     * @description : 在第一行前增加一行
     * @modify      : 修改人 时间 简单描述 
     * @param tableIndex
     */
    public void addFirstTableRow(int tableIndex) {
    if (this.table == null) {
    table = this.getTable(tableIndex); 
    }
    //表格的所有行 
    Dispatch rows1 = Dispatch.get(table, "Rows").toDispatch();
    Dispatch row1 = Dispatch.get(rows1, "First").toDispatch();
    Dispatch.call(rows1, "Add", new Variant(row1)); 
    } 
    
    /**
     * @date        : 
     * @author      : 
     * @description : 在最后一行前增加一行
     * @modify      : 修改人 时间 简单描述 
     * @param tableIndex
     */
    public void addLastTableRow(int tableIndex) {
    if (this.table == null) {
    table = this.getTable(tableIndex);
    }
   //表格的所有行 
   Dispatch rows1 = Dispatch.get(table, "Rows").toDispatch(); 
   Dispatch row1 = Dispatch.get(rows1, "Last").toDispatch(); 
   Dispatch.call(rows1, "Add", new Variant(row1)); 
    } 
    
    /**
     * @date        : 
     * @author      : 
     * @description : 增加一列
     * @modify      : 修改人 时间 简单描述 
     * @param tableIndex
     */
    public void addCol(int tableIndex) {
    if(this.table == null) {
    table = this.getTable(tableIndex);
    }
    //表格的所有行 
    Dispatch cols1 = Dispatch.get(table, "Columns").toDispatch();
    Dispatch.call(cols1, "Add").toDispatch();
    Dispatch.call(cols1, "AutoFit");
    } 
    
    /**
     * @date        : 
     * @author      : 
     * @description : 在指定列前面增加表格的列
     * @modify      : 修改人 时间 简单描述 
     * @param tableIndex
     * @param colIndex
     */
    public void addTableCol(int tableIndex, int colIndex) {
    if (this.table == null) {
    table = this.getTable(tableIndex);
    }
   //表格的所有行 
   Dispatch cols1 = Dispatch.get(table, "Columns").toDispatch();
   Dispatch col1 = Dispatch.call(cols1, "Item", new Variant(colIndex)).toDispatch(); 
   Dispatch.call(cols1, "Add", col1).toDispatch(); 
   Dispatch.call(cols1, "AutoFit"); 
    } 
    
    /**
     * @date        : 
     * @author      : 
     * @description : 在第一列之前增加一列
     * @modify      : 修改人 时间 简单描述 
     * @param tableIndex
     */
    public void addFirstTableCol(int tableIndex) {
    if (this.table == null) {
    table = this.getTable(tableIndex);
    }
    // 表格的所有行 
    Dispatch cols1 = Dispatch.get(table, "Columns").toDispatch();
    Dispatch col1 = Dispatch.get(cols1, "First").toDispatch();
    Dispatch.call(cols1, "Add ", col1).toDispatch(); 
    Dispatch.call(cols1, "AutoFit"); 
  } 
    
    /**
     * @date        : 
     * @author      : 
     * @description : 在最后一列前增加一列
     * @modify      : 修改人 时间 简单描述 
     * @param tableIndex
     */
    public void addLastTableCol(int tableIndex) {
    if (this.table == null) {
    table = this.getTable(tableIndex);
    }
    //表格的所有行 
    Dispatch cols1 = Dispatch.get(table, "Columns").toDispatch();
    Dispatch col1 =  Dispatch.get(cols1, "Last").toDispatch();
    Dispatch.call(cols1, "Add", col1).toDispatch(); 
    Dispatch.call(cols1, "AutoFit"); 
  } 
    /**
     * @date :
     * 获取Document对象中的所有Table对象  
     * @return 所有Table对象  
     */  
    public Dispatch getTables() {
        logger.debug("获取所有表格对象...");
        if (this.document == null) {
            logger.warn("document对象为空...");   
            return this.tables;   
        }
        
        this.tables = Dispatch.get(this.document, "Tables").toDispatch();   
        
        return this.tables;   
    }   
       
    /**
     * @date :
     * 获取Document中Table的数量  
     * @return 表格数量  
     */  
    public int getTablesCount() {
        logger.debug("获取文档中表格数量...");   
        if (this.tables == null) {
            this.getTables();   
        }  
        
        return Dispatch.get(tables, "Count").getInt();   
           
    }   
  
    /**
     * @date :
     * 获取指定序号的Table对象  
     * @param tableIndex Table序列  
     * @return  
     */  
    public Dispatch getTable(int tableIndex) {
        logger.debug("获取指定表格对象...");   
        if (this.tables == null) {
            this.getTables();   
        }   
        if (tableIndex >= 0) {
            this.table = Dispatch.call(this.tables, "Item", new Variant(tableIndex)).toDispatch();   
        }
        
        return this.table;   
    }   
  
    /**
     * @date :
     * 获取表格的总列数  
     * @return 总列数  
     */  
    public int getTableColumnsCount() {   
        logger.debug("获取表格总行数...");   
        if (this.table == null) {   
            logger.warn("table对象为空...");   
            return 0;   
        } 
        
        return Dispatch.get(this.cols, "Count").getInt();   
    }   
  
    /**
     * @date :
     * 获取表格的总行数  
     * @return 总行数  
     */  
    public int getTableRowsCount() {
        logger.debug("获取表格总行数...");   
        if (this.table == null) {   
            logger.warn("table对象为空...");   
            return 0;   
        }  
        
        return Dispatch.get(this.rows, "Count").getInt();
    }   
    /**
     * @date :
     * 获取表格列对象  
     * @return 列对象  
     */  
    public Dispatch getTableColumns() {   
        logger.debug("获取表格行对象...");   
        if (this.table == null) {
            logger.warn("table对象为空...");   
            return this.cols;   
        }   
        this.cols = Dispatch.get(this.table, "Columns").toDispatch();   
        
        return this.cols;   
    }   
  
    /**
     * @date :
     * 获取表格的行对象  
     * @return 总行数  
     */  
    public Dispatch getTableRows() {
        logger.debug("获取表格总行数...");   
        if (this.table == null) {
            logger.warn("table对象为空...");   
            return this.rows;   
        }
        
        this.rows = Dispatch.get(this.table, "Rows").toDispatch();
        
        return this.rows;   
    }   
  
    /**
     * @date :
     * 获取指定表格列对象  
     * @return 列对象  
     */  
    public Dispatch getTableColumn(int columnIndex) {   
        logger.debug("获取指定表格行对象...");   
        if (this.cols == null) {
            this.getTableColumns();   
        }   
        if (columnIndex >= 0) {
            this.col = Dispatch.call(this.cols, "Item", new Variant(columnIndex)).toDispatch();   
        }
        
        return this.col;   
    }   
  
    /**
     * @date :
     * 获取表格中指定的行对象  
     * @param rowIndex 行序号  
     * @return 行对象  
     */  
    public Dispatch getTableRow(int rowIndex) {
        logger.debug("获取指定表格总行数...");   
        if (this.rows == null) {
            this.getTableRows();   
        }   
        if (rowIndex >= 0) {
            this.row = Dispatch.call(this.rows, "Item", new Variant(rowIndex)).toDispatch();   
        } 
        
        return this.row;   
    }   
       
    /**
     * @date :
     * 自动调整表格  
     */  
    public void autoFitTable() {   
        logger.debug("自动调整表格...");   
        int count = this.getTablesCount();   
        for (int i = 0; i < count; i++) {   
            Dispatch table1 = Dispatch.call(tables, "Item", new Variant(i + 1)).toDispatch();   
            Dispatch cols1 = Dispatch.get(table1, "Columns").toDispatch();   
            Dispatch.call(cols1, "AutoFit");   
        }   
    }   
  
    /**
     * @date :
     * 获取当前文档中，表格中的指定单元格  
     * @return 指定单元格对象  
     */  
    public Dispatch getCell(int cellRowIdx, int cellColIdx) {   
        logger.debug("获取当前文档中，表格中的指定单元格...");   
        if (this.table == null) {   
            logger.warn("table对象为空...");   
            return this.cell;   
        }   
        if (cellRowIdx >= 0 && cellColIdx >= 0) {
            this.cell = Dispatch.call(this.table, "Cell", new Variant(cellRowIdx), 
            new Variant(cellColIdx)).toDispatch();   
        }
        
        return this.cell;   
    } 
    
    /**
     * @date        : 2011-8-16 下午05:04:40
     * @author      : lvchq
     * @description : 获取表格中的值
     * @modify      : 修改人 时间 简单描述 
     * @param tableIndex
     * @param cellRowIdx 单元格所在行
     * @param cellColIdx 单元格所在列
     * @return
     */
    public String getCellData(int tableIndex, int cellRowIdx, int cellColIdx) {
    logger.debug("获取当前文档中，表格中的指定单元格...");
        if (this.table == null) {
    //lvchq修改  20111013 如果table为空需要初始化table
       table = this.getTable(tableIndex);
        }
        
        Dispatch cellDis = Dispatch.call(table, "Cell", new Variant(cellRowIdx), new Variant(cellColIdx)).toDispatch();
        Dispatch rangeDis = Dispatch.get(cellDis, "Range").toDispatch();
        
        return Dispatch.get(rangeDis, "Text").toString();
    }
  
    /**
     * @date :
     * 设置文档标题  
     * @param title 标题内容  
     */  
    public void setTitle(String title) {
        logger.debug("设置文档标题...");   
        if (title == null || "".equals(title)) {   
            logger.warn("文档标题为空...");   
            return;   
        }
        
        Dispatch.call(this.selection, "TypeText", title);    
    }   
       
    /**
     * @date :
     * 设置当前表格线的粗细  
     * @param width  其中width大于1小于13,如果是0，就代表没有框
     */  
    public void setTableBorderWidth(int width) {   
  
        logger.debug("设置当前表格线的粗细...");   
        if (this.table == null) {
            logger.warn("table对象为空...");   
            return;   
        } 
        
        /*  
         * 设置表格线的粗细 1：代表最上边一条线 2：代表最左边一条线 3：最下边一条线 4：最右边一条线 5：除最上边最下边之外的所有横线  
         * 6：除最左边最右边之外的所有竖线 7：从左上角到右下角的斜线 8：从左下角到右上角的斜线  
         */  
        Dispatch borders = Dispatch.get(table, "Borders").toDispatch();   
        Dispatch border = null;   
        for (int i = 1; i < 7; i++) {   
            border = Dispatch.call(borders, "Item", new Variant(i)).toDispatch();   
            if (width != 0) {   
                Dispatch.put(border, "LineWidth", new Variant(width));   
                Dispatch.put(border, "Visible", new Variant(false));   
            } else if (width == 0) {   
                Dispatch.put(border, "Visible", new Variant(false));   
            }   
        }   
    }   
       
    /**
     * @date :
     * 对当前selection设置项目符号和编号  
     * @param tabIndex  
     *     1: 项目编号  
     *     2: 编号  
     *     3: 多级编号  
     *     4: 列表样式  
     * @param index  
     *     0:表示没有 ,其它数字代表的是该Tab页中的第几项内容  
     */  
    public void applyListTemplate(int tabIndex, int index) {
        logger.debug("对当前selection设置项目符号和编号...");   
        /* 取得ListGalleries对象列表 */  
        Dispatch listGalleries = Dispatch.get(this.word, "ListGalleries").toDispatch();   
        /* 取得列表中一个对象 */  
        Dispatch listGallery = Dispatch.call(listGalleries, "Item", new Variant(tabIndex)).toDispatch();   
        Dispatch listTemplates = Dispatch.get(listGallery, "ListTemplates").toDispatch();   
        if (this.range == null) {
            this.getRange();   
        }   
        Dispatch listFormat = Dispatch.get(this.range, "ListFormat").toDispatch();   
        Dispatch.call(listFormat, "ApplyListTemplate", Dispatch.call(listTemplates, "Item", 
        new Variant(index)), new Variant(true), new Variant(1), new Variant(0));
    }   
       
    /**
     * @date : 
     * 增加文档目录  
     * 目前采用固定参数方式，以后可以动态进行调整  
     */  
    public void addTablesOfContents() {
    /* 取得ActiveDocument、TablesOfContents、range对象 */  
    Dispatch activeDocument = word.getProperty("ActiveDocument").toDispatch();
    Dispatch tablesOfContents = Dispatch.get(activeDocument, "TablesOfContents").toDispatch();
    Dispatch range1 = Dispatch.get(this.selection, "Range").toDispatch();
    /* 增加目录 */  
    Dispatch.call(tablesOfContents, "Add", range1, new Variant(true), new Variant(1), 
    new Variant(3), new Variant(true), new Variant(""), new Variant(true), new Variant(true));
    }   
  
       
    /**
     * @date :
     * 设置当前Selection 位置方式  
     */  
    public void setAlignment(int alignmentType) {   
        logger.debug("设置当前Selection 位置方式...");   
        if (this.alignment == null) {
            this.getAlignment();   
        }   
        Dispatch.put(this.alignment, "Alignment", alignmentType);   
    }   
       
    /** 
     * @date :
     * 获取当前选择区域的对齐方式  
     * @return 对其方式对象  
     */  
    public Dispatch getAlignment() {
        logger.debug("获取当前选择区域的对齐方式...");   
        if (this.selection == null) {
            this.getSelection();   
        }   
        this.alignment = Dispatch.get(this.selection, "ParagraphFormat").toDispatch();
        
        return this.alignment;   
    }   
       
    /**
     * @date :
     * 获取字体对象  
     *   
     * @return 字体对象  
     */  
    public Dispatch getFont() {
        logger.debug("获取字体对象...");   
        if (this.selection == null) {
            this.getSelection();   
        }   
        this.font = Dispatch.get(this.selection, "Font").toDispatch(); 
        
        return this.font;   
    }   
       
    /**
     * @date :
     * 设置选定内容的字体 注：在调用此方法前，选定区域对象selection必须存在  
     * @param fontName 字体名称，例如 "宋体"  
     * @param isBold 粗体  
     * @param isItalic 斜体  
     * @param isUnderline 下划线  
     * @param rgbColor 颜色，例如"255,255,255"  
     * @param fontSize 字体大小  
     * @param Scale 字符间距，百分比值。例如 70代表缩放为70%  
     */  
    public void setFontScale(String fontName, boolean isBold, boolean isItalic, boolean isUnderline, 
    String rgbColor, int Scale, int fontSize,boolean isSub,boolean isSup) {
        logger.debug("设置字体...");   
        if(!"".equals(fontName))
        Dispatch.put(this.font, "Name", fontName);   
        
        Dispatch.put(this.font, "Bold", isBold);   
        Dispatch.put(this.font, "Italic", isItalic);   
        Dispatch.put(this.font, "Underline", isUnderline);   
        if(!"".equals(rgbColor))
        Dispatch.put(this.font, "Color", rgbColor);   
        if(!"".equals(Scale))
        Dispatch.put(this.font, "Scaling", Scale);   
        Dispatch.put(this.font, "Size", fontSize);  
        Dispatch.put(this.font, "Subscript", isSub); 
        Dispatch.put(this.font, "Superscript", isSup); 
    } 
    
    /**
     * @date : 
     * 设置上下标 
     * isSub下标
     * isSup上标
     * 
     */  
    public void setScale(boolean isSub, boolean isSup) {
        logger.debug("设置字体...");          
        Dispatch.put(this.font, "Subscript", isSub); 
        Dispatch.put(this.font, "Superscript", isSup); 
    }
    
    /**
     * @date :
     * 保存文件   
     * @param outputPath 输出文件（包含路径）   
     */    
    public void saveAs(String outputPath) {    
        logger.debug("保存文件...");   
        if (this.document == null) {
            logger.warn("document对象为空...");   
            return;   
        }   
        if (outputPath == null || "".equals(outputPath)) {
            logger.warn("文件保存路径为空...");   
            return;   
        }   
        Dispatch.call(this.document, "SaveAs", outputPath);
    }   
       
    /**
     * @date        : 
     * @author      : 
     * @description : 
     * @modify      : 修改人 时间 简单描述 
     * @param htmlFile
     */
    public void saveAsHtml(String htmlFile) {
        Dispatch.invoke(this.document, "SaveAs", Dispatch.Method, new Object[]{htmlFile, new Variant(8)}, new int[1]);
    }   
  
    /**
     * @date :
     * 关闭文件   
     */    
    public void close() {   
        logger.debug("关闭文件...");   
        if (document == null) {
            logger.warn("document对象为空...");   
            return;   
        }   
        Dispatch.call(document, "Close", new Variant(0));
    }   
  
    /**
     * @date : 
     * 列印word文件  
     */  
    public void printFile() {
        logger.debug("打印文件...");   
        if (document == null) {
            logger.warn("document对象为空...");   
            return;   
        }   
        Dispatch.call(document, "PrintOut");
    }   
  
    /**
     * @date :
     * 退出程序   
     */    
    public void quit() {
        logger.debug("退出程序");   
        word.invoke("Quit", new Variant[0]);
        ComThread.Release(); 
    }
    //插入数据
    public void insertSupText(String fieldValue){
        String repaceText = fieldValue;
        this.selection = Dispatch.get(word, "Selection").toDispatch();
        this.replace(repaceText);
    }
    /**
     * @date        : 
     * @author      : 
     * @description : 查找替换 包含上下标的判断
     * @modify      : 修改人 时间 简单描述 
     * @param fieldName
     * @param fieldValue
     */
    public void replaceTemplate(String fieldName, String fieldValue) {
    this.moveStart();
    String toFindText = fieldName;
        String repaceText = fieldValue;
       
        if (this.find(toFindText)) {
        if ("".equals(repaceText)) {
        this.replace(repaceText);
        } else {
        while (repaceText.indexOf("") > 0 || repaceText.indexOf("") > 0) {
            int i = repaceText.indexOf("");
            int j = repaceText.indexOf("");
            if ((i < j && i > 0) || (j < 0 && i > 0)) {
            this.find("tanwn");    //就是这两行胡乱试了一下竟然成了
                   this.replace("tanwn");    //可能是在两行之间进行了其他操作了
            String firstText = repaceText.substring(0, i);
                this.setScale(false, false);   
                   this.insertText(firstText);
                   this.find("tanwn");    //就是这两行胡乱试了一下竟然成了
                   this.replace("tanwn");    //可能是在两行之间进行了其他操作了
                String supText = repaceText.substring(i + 5, repaceText.indexOf(""));
                this.setScale(false, true);   
                   this.insertText(supText);
                repaceText = repaceText.substring(repaceText.indexOf("") + 6, repaceText.length());
            }
            if ((i > j && j > 0) || (i < 0 && j > 0)) {
            this.find("tanwn");    //就是这两行胡乱试了一下竟然成了
                   this.replace("tanwn");    //可能是在两行之间进行了其他操作了
            String firstText = repaceText.substring(0, j);


                this.setScale(false, false);   
                this.insertText(firstText);
                this.find("tanwn");    //就是这两行胡乱试了一下竟然成了
                   this.replace("tanwn");    //可能是在两行之间进行了其他操作了
                String subText = repaceText.substring(j + 5, repaceText.indexOf(""));


                this.setScale(true, false);   
                   this.insertText(subText);    
                   
                repaceText = repaceText.substring(repaceText.indexOf("") + 6, repaceText.length());
            }
        }
       
        repaceText = this.replaceSpeChar(repaceText);    //替换字符串中含有的特殊字符
       
           if (repaceText != "") {
            this.find("tanwn");    //就是这两行胡乱试了一下竟然成了
               this.replace("tanwn");    //可能是在两行之间进行了其他操作了
           this.setScale(false, false);   
           this.insertText(repaceText);
           }
        }
        }
    }
    
    /**
     * @date        : 2012-1-12 下午02:25:48
     * @author      : lvchq
     * @description : 替换字符串中含有的特殊字符
     * @modify      : 修改人 时间 简单描述 
     * @param replaceText
     * @return
     */
    private String replaceSpeChar(String replaceText) {
    for (int i = 0; i < speCharArray.length; i++) {
    while (replaceText.indexOf(speCharArray[i]) != -1) {
    int j = replaceText.indexOf(speCharArray[i]);
    replaceText = replaceText.substring(0, j) + parCharArray[i] 
                    + replaceText.substring(j + speCharArray[i].length());
    }
    }
   
    return replaceText;
    }
    
    /**
     * @date        :  
     * @author      :  
     * @description : 根据数据库表获取字段和数据，替换模板
     * @modify      : 修改人 时间 简单描述 
     * @param tableName
     * @param strWhere
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws ClassNotFoundException
     * @throws SQLException
     */
    @SuppressWarnings("unchecked")
// public void replaceTemplateByDB(String tableName, String strWhere) 
//     throws InstantiationException, IllegalAccessException, ClassNotFoundException, SQLException {
//     DBTable db = new DBTable();
//        List list = db.getDBTable(tableName, strWhere);
//        
//        for (int m = 0; m < list.size(); m++) {
//         String[]  str = (String[]) list.get(m);
//         this.replaceTemplate(str[1], str[2]);
//        }
//    }
    
    /**
     * @date        :  
     * @author      : 
     * @description : 
     * @modify      : 修改人 时间 简单描述 
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws ClassNotFoundException
     * @throws SQLException
     */
//    public void createWord() throws InstantiationException, IllegalAccessException, 
//     ClassNotFoundException, SQLException {
//     DOCWriter writer = new DOCWriter();  
//        String path = System.getProperty("user.dir");
//        writer.openDocument(path + "/template/委托书.doc");    //打开模板 
//        String textName = "委托书" + new java.text.SimpleDateFormat("yyyymmddhhmmss")
//         .format(new Date()).toString() + ".doc";
//        writer.enterDown(1);   
//        
//        //从数据库获取字段名称和数据,并进行替换
//        writer.replaceTemplateByDB("EntrustForm", " where sampleid=00000000000000000013");
//        //对于枚举值进行处理
//        String fieldName = "SendWay00";
//        String fieldValue = "获取值SendWay";
//        writer.replaceTemplate(fieldName, fieldValue);
//        fieldName = "IfRequire00";
//        fieldValue = "获取值IfRequire";
//        writer.replaceTemplate(fieldName, fieldValue);
//        fieldName = "IfSecrecy00";
//        fieldValue = "获取值IfSecrecy";
//        writer.replaceTemplate(fieldName, fieldValue);
//        fieldName = "IfRecover00";
//        fieldValue = "获取值IfRecover";
//        writer.replaceTemplate(fieldName, fieldValue);
//        fieldName = "GetWay00";
//        fieldValue = "获取值GetWay";
//        writer.replaceTemplate(fieldName, fieldValue);     
//        writer.saveAs(path + "/template/" + textName);
//    }
    
    /**
     * @date        : 
     * @author      : 
     * @description : 
     * @modify      : 修改人 时间 简单描述 
     * @param args
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws ClassNotFoundException
     * @throws SQLException
     */
//    public static void main(String args[]) throws InstantiationException, 
//     IllegalAccessException, ClassNotFoundException, SQLException {
//        DOCWriter writer = new DOCWriter();  
//        String path = System.getProperty("user.dir");
//        writer.openDocument(path + "/template/委托书.doc");    //打开模板 
//        String textName = new java.text.SimpleDateFormat("yyyymmddhhmmss").format(new Date()).toString() + ".doc";
//        writer.enterDown(1);
//        
//        //测试，查找替换，包含上下标的判断
//        String fieldName = "登记表_编号";
//        String fieldValue = "获取值";
//        writer.replaceTemplate(fieldName, fieldValue);
//        //从数据库获取字段名称和数据,并进行替换
//        writer.replaceTemplateByDB("EntrustForm", " where sampleid=00000000000000000013");
//       
//        /---------上侧是上下标的研究，成功了，现在下面研究动态输出表格-----------//
//        List listTable = new ArrayList();   
//  for (int i = 0; i < 10; i++) {
//      String str[] = new String[4];
//      for (int j = 0; j < 4; j++) {
//          str[j] = "第几行第几列" + String.valueOf(j);
//      }   
//      listTable.add(str);   
//  }   
//    writer.setFontScale("幼圆", true, true, true, "1,1,1,1", 70, 14, true, true);
//    for (int i = 0; i < 10; i++) {
//     writer.addTableRow(1, 3);
//    }
//    writer.find("Part");    //移动光标
//        writer.moveRight(3);
//        for (int i = 0; i < listTable.size(); i++) {
//            String[]  strs = listTable.get(i);   
//            for (int j = 0; j < strs.length; j++) {
//                writer.insertText(strs[j]);   
//                writer.moveRight(1); 
//            }   
//            writer.moveRight(1);   
//        }   
//        
//        writer.saveAs(path + "/template/" + textName);
//    }  
//    
    /**
     * @date        : 2011-8-9 上午10:39:15
     * @author      : lvchq
     * @description : 在指定的表格里填入内容
     * @modify      : 修改人 时间 简单描述 
     * @param tableIndex 表格起始点
     * @param cellRowIdx 第几行
     * @param cellColIdx 第几列
     * @param txt 内容字符串
     */
    public void putTxtToCell(int tableIndex, int cellRowIdx, int cellColIdx, String txt) {
    if (this.table == null) {
    table = this.getTable(tableIndex);
    }
   
    Dispatch selCell = Dispatch.call(table, "Cell", new Variant(cellRowIdx), new Variant(cellColIdx)).toDispatch();
    Dispatch.call(selCell, "Select");
    Dispatch.put(selection, "Text", txt);
    }
    
    /**
     * @date :
     * 在指定的表格里填入内容
     * @param tableIndex 表格起始点
     * @param cellRowIdx  第几列
     * @param cellColIdx 第几栏
     * @param txt 内容字符串数组
     */
    @SuppressWarnings("unchecked")
public void putTxtToCell(Dispatch pfont, Dispatch palignment,
    int tableIndex, int cellRowIdx, int cellColIdx, ArrayList txt) {
        // 所有表格
        Dispatch tables1 = Dispatch.get(document, "Tables").toDispatch();
        // 主要内容(即参数数组中的值)
        for (int i = 0; i < txt.size(); i++) {
            String arrtostr = txt.get(i).toString();    // 先将数组元素转成字符串
            String arrsubstr = arrtostr.substring(1, arrtostr.length() - 1);    // 去掉前后'['和']'
            String[] arrsplit = arrsubstr.split(",");    // 字符串数组(在分隔每个元素值)


            for (int j = 0; j < arrsplit.length; j++) {
                // 要填入的表格(对表格列依序填入内容),cellRowIdx++代表从第一列开始
                Dispatch table1 = Dispatch.call(tables1, "Item", new Variant(tableIndex)).toDispatch();
                Dispatch cell1 = Dispatch.call(table1, "Cell", 
                new Variant(cellRowIdx++), new Variant(cellColIdx)).toDispatch();
                // Dispatch.put(cell, "Height",new Variant(1)); //设置列高
                Dispatch.call(cell1, "Select");
                // 主要内容
                // Dispatch.call(selection, "TypeParagraph"); //空一行段落
                // Dispatch.put(alignment, "Alignment", "3"); //(1:置中 2:靠右 3:靠左)
                if (j == 0) {
                    Dispatch.put(selection, "Text", arrsplit[j]); // 写入word的内容
                    Dispatch.put(pfont, "Bold", "1"); // 字型租体(1:租体 0:取消租体)
                    Dispatch.put(pfont, "Color", "1,1,1,1"); // 字型颜色
                    // Dispatch.put(font, "Italic", "1"); //字型斜体(1:斜体 0:取消斜体)
                    // Dispatch.put(font, "Underline", "1"); //文字加底线
                    Dispatch.call(selection, "MoveDown"); // 光标往下一行(才不会输入盖过上一输入位置)
                } else {
                    if (arrsplit[j].indexOf(" ") != -1) {
                        String str = arrsplit[j].replaceAll(" ", "         "); // 作字符串隔行对齐用


                        Dispatch.call(selection, "TypeParagraph"); // 空一行段落
                        Dispatch.put(palignment, "Alignment", "3"); // (1:置中 2:靠右 3:靠左)
                        Dispatch.put(selection, "Text", str); // 写入word的内容
                        Dispatch.put(pfont, "Bold", "0"); // 字型租体(1:租体 0:取消租体)
                        Dispatch.put(pfont, "Color", "1,1,1,0"); // 字型颜色
                        // Dispatch.put(font, "Italic", "1"); //字型斜体(1:斜体 0:取消斜体)
                        // Dispatch.put(font, "Underline", "1"); //文字加底线
                        Dispatch.call(selection, "MoveDown"); // 光标往下一行(才不会输入盖过上一输入位置)
                    } else {
                        Dispatch.put(selection, "Text", arrsplit[j]); // 写入word的内容
                        Dispatch.put(pfont, "Bold", "0"); // 字型租体(1:租体 0:取消租体)
                        Dispatch.put(pfont, "Color", "1,1,1,0"); // 字型颜色
                        // Dispatch.put(font, "Italic", "1"); //字型斜体(1:斜体 0:取消斜体)
                        // Dispatch.put(font, "Underline", "1"); //文字加底线
                        Dispatch.call(selection, "MoveDown"); // 光标往下一行(才不会输入盖过上一输入位置)
                    }
                }
            }
        }
    }
    
    /**
     * @date        : 2012-2-23 下午01:09:18
     * @author      : lvchq
     * @description : 删除一行
     * @modify      : 修改人 时间 简单描述 
     * @param tableIndex
     * @param rowIndex
     */
    public void delRow(int tableIndex, int rowIndex) {  
    if (this.table == null) {
        table = this.getTable(tableIndex);
        }
   
    this.row = this.getTableRow(rowIndex);
    Dispatch.call(row, "Delete");
    }  
}

你可能感兴趣的:(java-util)

  • java-util包下 类说明 小小的coder
    地址:http://gitbook.net/java/util/collections_singletonlist.html
  • 微信开发者验证接口开发 362217990 微信 开发者 token 验证
    微信开发者接口验证。 Token，自己随便定义，与微信填写一致就可以了。 根据微信接入指南描述 http://mp.weixin.qq.com/wiki/17/2d4265491f12608cd170a95559800f2d.html 第一步：填写服务器配置 第二步：验证服务器地址的有效性 第三步：依据接口文档实现业务逻辑 这里主要讲第二步验证服务器有效性。 建一个
  • 一个小编程题-类似约瑟夫环问题 BrokenDreams 编程
            今天群友出了一题：         一个数列,把第一个元素删除,然后把第二个元素放到数列的最后,依次操作下去,直到把数列中所有的数都删除,要求依次打印出这个过程中删除的数。      &
  • linux复习笔记之bash shell (5) 关于减号-的作用 eksliang linux关于减号“-”的含义linux关于减号“-”的用途linux关于“-”的含义linux关于减号的含义
        转载请出自出处： http://eksliang.iteye.com/blog/2105677        管道命令在bash的连续处理程序中是相当重要的，尤其在使用到前一个命令的studout（标准输出）作为这次的stdin（标准输入）时，就显得太重要了，某些命令需要用到文件名，例如上篇文档的的切割命令（split）、还有
  • Unix(3) 18289753290 unix ksh
    1)若该变量需要在其他子进程执行，则可用"$变量名称"或${变量}累加内容 什么是子进程？在我目前这个shell情况下，去打开一个新的shell，新的那个shell就是子进程。一般状态下，父进程的自定义变量是无法在子进程内使用的，但通过export将变量变成环境变量后就能够在子进程里面应用了。 2)条件判断： &&代表and  ||代表or&nbs
  • 关于ListView中性能优化中图片加载问题 酷的飞上天空 ListView
    ListView的性能优化网上很多信息，但是涉及到异步加载图片问题就会出现问题。 具体参看上篇文章http://314858770.iteye.com/admin/blogs/1217594   如果每次都重新inflate一个新的View出来肯定会造成性能损失严重，可能会出现listview滚动是很卡的情况，还会出现内存溢出。 现在想出一个方法就是每次都添加一个标识，然后设置图
  • 德国总理默多克：给国人的一堂“震撼教育”课 永夜-极光 教育
    http://bbs.voc.com.cn/topic-2443617-1-1.html德国总理默多克：给国人的一堂“震撼教育”课　 安吉拉—默克尔，一位经历过社会主义的东德人，她利用自己的博客，发表一番来华前的谈话，该说的话，都在上面说了，全世界想看想传播——去看看默克尔总理的博客吧！ 　　德国总理默克尔以她的低调、朴素、谦和、平易近人等品格给国人留下了深刻印象。她以实际行动为中国人上了一堂
  • 关于Java继承的一个小问题。。。 随便小屋 java
    今天看Java 编程思想的时候遇见一个问题，运行的结果和自己想想的完全不一样。先把代码贴出来！ //CanFight接口 interface Canfight { void fight(); } //ActionCharacter类 class ActionCharacter { public void fight() { System.out.pr
  • 23种基本的设计模式 aijuans 设计模式
    Abstract Factory：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 　　Adapter：将一个类的接口转换成客户希望的另外一个接口。A d a p t e r模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 　　Bridge：将抽象部分与它的实现部分分离，使它们都可以独立地变化。 　　Builder：将一个复杂对象的构建与它的表示分离，使得同
  • 《周鸿祎自述：我的互联网方法论》读书笔记 aoyouzi 读书笔记
    从用户的角度来看,能解决问题的产品才是好产品,能方便/快速地解决问题的产品,就是一流产品.   商业模式不是赚钱模式 一款产品免费获得海量用户后,它的边际成本趋于0,然后再通过广告或者增值服务的方式赚钱,实际上就是创造了新的价值链.   商业模式的基础是用户,木有用户,任何商业模式都是浮云.商业模式的核心是产品,本质是通过产品为用户创造价值. 商业模式还包括寻找需求
  • JavaScript动态改变样式访问技术 百合不是茶 JavaScriptstyle属性ClassName属性
      一:style属性 格式:  HTML元素.style.样式属性="值";   创建菜单:在html标签中创建 或者 在head标签中用数组创建   <html> <head> <title>style改变样式</title> </head> &l
  • jQuery的deferred对象详解 bijian1013 jquerydeferred对象
            jQuery的开发速度很快，几乎每半年一个大版本，每两个月一个小版本。         每个版本都会引入一些新功能，从jQuery 1.5.0版本开始引入的一个新功能----deferred对象。    &nb
  • 淘宝开放平台TOP Bill_chen C++c物流C#
    淘宝网开放平台首页：http://open.taobao.com/ 淘宝开放平台是淘宝TOP团队的产品，TOP即TaoBao Open Platform， 是淘宝合作伙伴开发、发布、交易其服务的平台。 支撑TOP的三条主线为：    1.开放数据和业务流程     * 以API数据形式开放商品、交易、物流等业务；  &
  • 【大型网站架构一】大型网站架构概述 bit1129 网站架构
    大型互联网特点 面对海量用户、海量数据 大型互联网架构的关键指标 高并发 高性能 高可用 高可扩展性 线性伸缩性 安全性 大型互联网技术要点   前端优化 CDN缓存 反向代理 KV缓存 消息系统 分布式存储 NoSQL数据库 搜索 监控 安全 想到的问题： 1.对于订单系统这种事务型系统，如
  • eclipse插件hibernate tools安装 白糖_ Hibernate
    eclipse helios(3.6)版 1.启动eclipse 2.选择 Help > Install New Software...> 3.添加如下地址： http://download.jboss.org/jbosstools/updates/stable/helios/ 4.选择性安装：hibernate tools在All Jboss tool
  • Jquery easyui Form表单提交注意事项 bozch jquery easyui
    jquery easyui对表单的提交进行了封装，提交的方式采用的是ajax的方式，在开发的时候应该注意的事项如下：         1、在定义form标签的时候，要将method属性设置成post或者get，特别是进行大字段的文本信息提交的时候，要将method设置成post方式提交，否则页面会抛出跨域访问等异常。所以这个要
  • Trie tree(字典树)的Java实现及其应用-统计以某字符串为前缀的单词的数量 bylijinnan java实现
    import java.util.LinkedList; public class CaseInsensitiveTrie { /** 字典树的Java实现。实现了插入、查询以及深度优先遍历。 Trie tree's java implementation.(Insert,Search,DFS) Problem Description Igna
  • html css 鼠标形状样式汇总 chenbowen00 htmlcss
    css鼠标手型cursor中hand与pointer  Example：CSS鼠标手型效果 <a href="#" style="cursor:hand">CSS鼠标手型效果</a><br/>  Example：CSS鼠标手型效果 <a href="#" style=&qu
  • [IT与投资]IT投资的几个原则 comsci it
          无论是想在电商,软件,硬件还是互联网领域投资,都需要大量资金,虽然各个国家政府在媒体上都给予大家承诺,既要让市场的流动性宽松,又要保持经济的高速增长....但是,事实上,整个市场和社会对于真正的资金投入是非常渴望的,也就是说,表面上看起来,市场很活跃,但是投入的资金并不是很充足的......    
  • oracle with语句详解 daizj oraclewithwith as
    oracle with语句详解 转 在oracle中，select 查询语句，可以使用with,就是一个子查询，oracle 会把子查询的结果放到临时表中，可以反复使用 例子:注意，这是sql语句，不是pl/sql语句， 可以直接放到jdbc执行的 ----------------------------------------------------------------
  • hbase的简单操作 deng520159 数据库hbase
    近期公司用hbase来存储日志,然后再来分析 ,把hbase开发经常要用的命令找了出来. 用ssh登陆安装hbase那台linux后 用hbase shell进行hbase命令控制台! 表的管理 1）查看有哪些表 hbase(main)> list 2）创建表   # 语法：create <table>, {NAME => <family&g
  • C语言scanf继续学习、算术运算符学习和逻辑运算符 dcj3sjt126com c
    /* 2013年3月11日20:37:32 地点：北京潘家园 功能：完成用户格式化输入多个值 目的：学习scanf函数的使用 */ # include <stdio.h> int main(void) { int i, j, k; printf("please input three number:\n"); //提示用
  • 2015越来越好 dcj3sjt126com 歌曲
    越来越好 房子大了电话小了 感觉越来越好 假期多了收入高了 工作越来越好 商品精了价格活了 心情越来越好 天更蓝了水更清了 环境越来越好 活得有奔头人会步步高 想做到你要努力去做到 幸福的笑容天天挂眉梢 越来越好 婆媳和了家庭暖了 生活越来越好 孩子高了懂事多了 学习越来越好 朋友多了心相通了 大家越来越好 道路宽了心气顺了 日子越来越好 活的有精神人就不显
  • java.sql.SQLException: Value '0000-00-00' can not be represented as java.sql.Tim feiteyizu mysql
    数据表中有记录的time字段（属性为timestamp）其值为：“0000-00-00 00:00:00” 程序使用select 语句从中取数据时出现以下异常： java.sql.SQLException:Value '0000-00-00' can not be represented as java.sql.Date   java.sql.SQLException: Valu
  • Ehcache（07）——Ehcache对并发的支持 234390216 并发ehcache锁ReadLockWriteLock
    Ehcache对并发的支持          在高并发的情况下，使用Ehcache缓存时，由于并发的读与写，我们读的数据有可能是错误的，我们写的数据也有可能意外的被覆盖。所幸的是Ehcache为我们提供了针对于缓存元素Key的Read（读）、Write（写）锁。当一个线程获取了某一Key的Read锁之后，其它线程获取针对于同
  • mysql中blob,text字段的合成索引 jackyrong mysql
      在mysql中，原来有一个叫合成索引的，可以提高blob,text字段的效率性能， 但只能用在精确查询，核心是增加一个列，然后可以用md5进行散列，用散列值查找 则速度快 比如： create table abc(id varchar(10),context blog,hash_value varchar(40)); insert into abc(1,rep
  • 逻辑运算与移位运算 latty 位运算逻辑运算
    源码：正数的补码与原码相同例+7 源码：00000111 补码 ：00000111 （用8位二进制表示一个数） 负数的补码： 符号位为1，其余位为该数绝对值的原码按位取反；然后整个数加1。   -7 源码： 10000111 ，其绝对值为00000111  取反加一：11111001 为-7补码 已知一个数的补码，求原码的操作分两种情况：
  • 利用XSD 验证XML文件 newerdragon javaxmlxsd
    XSD文件 （XML Schema 语言也称作 XML Schema 定义（XML Schema Definition，XSD）。 具体使用方法和定义请参看： http://www.w3school.com.cn/schema/index.asp java自jdk1.5以上新增了SchemaFactory类 可以实现对XSD验证的支持，使用起来也很方便。 以下代码可用在J
  • 搭建 CentOS 6 服务器(12) - Samba rensanning centos
    （1）安装 # yum -y install samba Installed: samba.i686 0:3.6.9-169.el6_5 # pdbedit -a rensn new password:123456 retype new password:123456 …… （2）Home文件夹 # mkdir /etc
  • Learn Nodejs 01 toknowme nodejs
    （1）下载nodejs https://nodejs.org/download/ 选择相应的版本进行下载     （2）安装nodejs 安装的方式比较多，请baidu下 我这边下载的是“node-v0.12.7-linux-x64.tar.gz”这个版本 （1）上传服务器 （2）解压 tar -zxvf  node-v0.12.
  • jquery控制自动刷新的代码举例 xp9802 jquery
    1、html内容部分  复制代码代码示例: <div id='log_reload'> <select name="id_s" size="1"> <option value='2'>-2s-</option> <option value='3'>-3s-</option
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他