linux 虚拟机 kvm

Jacob操作office文档（Word,PPT,Excel）

jacob 操作 word

public boolean doc2pdf(String srcFilePath, String pdfFilePath) {  

        ActiveXComponent app = null;  

        Dispatch doc = null;  

        try {  

            ComThread.InitSTA();  

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

            app.setProperty("Visible", false);  

            Dispatch docs = app.getProperty("Documents").toDispatch();  

            doc = Dispatch.invoke(docs, "Open", Dispatch.Method,  

                    new Object[] { srcFilePath,   

                                                 new Variant(false),   

                                                 new Variant(true),//是否只读  

                                                 new Variant(false),   

                                                 new Variant("pwd") },  

                    new int[1]).toDispatch();  

//          Dispatch.put(doc, "Compatibility", false);  //兼容性检查,为特定值false不正确  

            Dispatch.put(doc, "RemovePersonalInformation", false);  

            Dispatch.call(doc, "ExportAsFixedFormat", pdfFilePath, wdFormatPDF); // word保存为pdf格式宏，值为17  

  

            return true; // set flag true;  

        } catch (ComFailException e) {  

            return false;  

        } catch (Exception e) {  

            return false;  

        } finally {  

            if (doc != null) {  

                Dispatch.call(doc, "Close", false);  

            }  

            if (app != null) {  

                app.invoke("Quit", 0);  

            }  

            ComThread.Release();  

        }  

    }  

Jacob操作ppt

public boolean ppt2pdf(String srcFilePath, String pdfFilePath) {  

        ActiveXComponent app = null;  

        Dispatch ppt = null;  

            try {  

                ComThread.InitSTA();  

                app = new ActiveXComponent("PowerPoint.Application");  

                Dispatch ppts = app.getProperty("Presentations").toDispatch();  

  

                // 因POWER.EXE的发布规则为同步，所以设置为同步发布  

                ppt = Dispatch.call(ppts, "Open", srcFilePath, true,// ReadOnly  

                        true,// Untitled指定文件是否有标题  

                        false// WithWindow指定文件是否可见  

                        ).toDispatch();  

  

                Dispatch.call(ppt, "SaveAs", pdfFilePath, ppSaveAsPDF); //ppSaveAsPDF为特定值32  

  

                return true; // set flag true;  

            } catch (ComFailException e) {  

                return false;  

            } catch (Exception e) {  

                return false;  

            } finally {  

                if (ppt != null) {  

                    Dispatch.call(ppt, "Close");  

                }  

                if (app != null) {  

                    app.invoke("Quit");  

                }  

                ComThread.Release();  

            }  

    }  

Jacob操作Excel

package com;  

import java.io.ObjectInputStream.GetField;  

import java.util.ArrayList;  

import java.util.Date;  

import java.util.List;  

  

import com.jacob.activeX.ActiveXComponent;  

import com.jacob.com.ComThread;  

import com.jacob.com.Dispatch;  

import com.jacob.com.Variant;  

  

  

public class ready {  

    private static ActiveXComponent xl = null; //Excel对象(防止打开多个)  

    private static Dispatch workbooks = null;  //工作簿对象  

    private Dispatch workbook = null; //具体工作簿  

    private Dispatch sheets = null;// 获得sheets集合对象  

    private Dispatch currentSheet = null;// 当前sheet  

    /** 

     * 打开excel文件 

     * @param filepath 文件路径名称 

     * @param visible  是否显示打开 

     * @param readonly 是否只读方式打开 

     */  

    private void OpenExcel(String filepath, boolean visible) {  

        try {  

            initComponents(); //清空原始变量  

            ComThread.InitSTA();  

            if(xl==null)  

                xl = new ActiveXComponent("Excel.Application"); //Excel对象  

            xl.setProperty("Visible", new Variant(visible));//设置是否显示打开excel  

            if(workbooks==null)  

                workbooks = xl.getProperty("Workbooks").toDispatch(); //打开具体工作簿  

                workbook = Dispatch.invoke(workbooks, "Open", Dispatch.Method,  

               new Object[] { srcFilePath,  

                                        new Variant(false), // 是否以只读方式打开  

                                        new Variant(true),  

                                         "1",  

                                        "pwd" },   //输入密码"pwd",若有密码则进行匹配，无则直接打开  

                                         new int[1]).toDispatch();  

        } catch (Exception e) {  

            e.printStackTrace();  

            releaseSource();  

        }  

    }  

    /** 

     * 工作簿另存为 

     * @param filePath 另存为的路径 

     * 例如 SaveAs="D:TEST/c.xlsx" 

     */  

    private void SaveAs(String filePath){  

           Dispatch.call(workbook, "SaveAs",filePath);  

      }  

    /** 

     * 关闭excel文档 

     * @param f 含义不明 （关闭是否保存？默认false） 

     */  

    private void CloseExcel(boolean f) {  

        try {  

            Dispatch.call(workbook, "Save");  

            Dispatch.call(workbook, "Close", new Variant(f));  

        } catch (Exception e) {  

            e.printStackTrace();  

        } finally {  

                releaseSource();  

        }    

    }  

    /* 

     * 初始化 

     * */  

    private void initComponents(){  

        workbook = null;  

        currentSheet = null;  

        sheets = null;  

    }  

    /** 

     * 释放资源 

     */  

    private static void releaseSource(){  

        if(xl!=null){  

            xl.invoke("Quit", new Variant[] {});  

            xl = null;  

        }  

        workbooks = null;  

        ComThread.Release();  

        System.gc();  

    }  

    /** 

     * 得到当前sheet 

     * @return 

     */  

    private Dispatch getCurrentSheet() {  

        currentSheet = Dispatch.get(workbook, "ActiveSheet").toDispatch();  

        return currentSheet;  

    }  

    /** 

     * 修改当前工作表的名字 

     * @param newName 

     */  

    private void modifyCurrentSheetName(String newName) {  

        Dispatch.put(getCurrentSheet(), "name", newName);    

    }  

  

    /** 

     * 得到当前工作表的名字 

     * @return 

     */  

    private String getCurrentSheetName(Dispatch sheets) {  

        return Dispatch.get(sheets, "name").toString();  

    }  

    /** 

     * 通过工作表名字得到工作表 

     * @param name sheetName 

     * @return 

     */  

    private Dispatch getSheetByName(String name) {  

        return Dispatch.invoke(getSheets(), "Item", Dispatch.Get, new Object[]{name}, new int[1]).toDispatch();  

    }  

    /** 

     *  得到sheets的集合对象 

     * @return 

     */  

    private Dispatch getSheets() {  

        if(sheets==null)  

            sheets = Dispatch.get(workbook, "sheets").toDispatch();  

        return sheets;  

    }  

    /** 

     * 通过工作表索引得到工作表(第一个工作簿index为1) 

     * @param index 

     * @return  sheet对象 

     */  

    private Dispatch getSheetByIndex(Integer index) {  

        return Dispatch.invoke(getSheets(), "Item", Dispatch.Get, new Object[]{index}, new int[1]).toDispatch();  

    }  

  

    /** 

     * 得到sheet的总数 

     * @return 

     */  

    private int getSheetCount() {  

        int count = Dispatch.get(getSheets(), "count").toInt();  

        return count;  

    }  

    /** 

     * 给所有的sheet添加背景 

     * @param filepath 图片路径 

     */  

    public void setBlackGroudPrituce(String filepath)  

    {  

        int num=this.getSheetCount();  

        for (int i = 1; i <= num; i++) {  

            Dispatch sheets=this.getSheetByIndex(i);  

            Dispatch.call(sheets,"SetBackgroundPicture",filepath);  

        }     

    }  

    /** 

     *  添加新的工作表(sheet)，并且隐藏（添加后为默认为当前激活的工作表） 

     */  

    public void addSheet(String name) {  

//      for (int i = 1; i <= this.getSheetCount(); i++) {  

//          Dispatch sheets=this.getSheetByIndex(i);  

//         if(name.equals(this.getCurrentSheetName(sheets)))  

//            {  

//                return false;  

//             }             

//         }   

          currentSheet=Dispatch.get(Dispatch.get(workbook, "sheets").toDispatch(), "add").toDispatch();  

        //  Dispatch.put(currentSheet,"Name",name);  

          Dispatch.put(currentSheet, "Visible", new Boolean(false));  

          System.out.println("插入信息为:"+name);  

    }  

    /** 

     * 得到工作薄的名字 

     * @return 

     */  

    private String getWorkbookName() {  

        if(workbook==null)  

            return null;  

        return Dispatch.get(workbook, "name").toString();  

    }  

    /**  

     *  获取所有表名 

     */  

    public List findSheetName()  

    {  

        int num=this.getSheetCount();  

        List list=new ArrayList();  

        for (int i = 1; i <= num; i++) {  

            currentSheet=this.getSheetByIndex(i);  

            list.add(this.getCurrentSheetName(currentSheet));    

           }   

        return list;  

    }  

    /** 

     * 设置页脚信息 

     */  

    private void setFooter(String foot) {  

        currentSheet=this.getCurrentSheet();  

        Dispatch PageSetup=Dispatch.get(currentSheet,"PageSetup").toDispatch();  

        Dispatch.put(PageSetup,"CenterFooter",foot);  

    }  

    /** 

     * 获取页脚信息 

     */  

    private String getFooter() {  

        currentSheet=this.getCurrentSheet();  

        Dispatch PageSetup=Dispatch.get(currentSheet,"PageSetup").toDispatch();  

        return Dispatch.get(PageSetup,"CenterFooter").toString();  

    }  

    /** 

     * 锁定工作簿 

     */  

    private void setPassword() {  

        Dispatch.call(workbook, "Protect",123,true,false);  

    }  

    /** 

     * 设置名称管理器 

     * @param name 名称管理器名 不能以数字或者下划线开头，中间不能包含空格和其他无效字符 

     * @param comment 备注 

     * @param place 备注位置  

     * @return 

     */  

    public void setName(String name,String place,String comment) {  

        Dispatch Names=Dispatch.get(workbook, "Names").toDispatch();  

        Dispatch.call(Names,"Add",name,place,false).toDispatch();  

        Dispatch.put(Names, "Comment", comment); //插入备注  

    }  

    /** 

     * 获取名称管理器 

     * @param name 名称管理器名 

     * @return 

     */  

    public String getName(String name) {  

        Dispatch Names=Dispatch.get(workbook, "Names").toDispatch();  

        Dispatch Name=Dispatch.call(Names,"Item",name).toDispatch();  

        return Dispatch.get(Name, "Value").toString();  

    }  

    /** 

     *  单元格写入值 

     * @param sheet  被操作的sheet 

     * @param position 单元格位置，如：C1 

     * @param type 值的属性 如：value 

     * @param value 

     */  

    private void setValue(String position, Object value) {  

        currentSheet=this.getCurrentSheet();  

        Dispatch cell = Dispatch.invoke(currentSheet, "Range",  

                Dispatch.Get, new Object[] { position }, new int[1])  

                .toDispatch();  

        Dispatch.put(cell, "Value", value);  

        String color=this.getColor(cell);  

        this.setFont(cell,color);  

    }  

    /** 

     *  设置字体 

     */  

    private void setFont(Dispatch cell,String color)  

    {  

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

        //Dispatch.put(font,"FontStyle", "Bold Italic");  

        Dispatch.put(font,"size", "1");  

        Dispatch.put(font,"color",color);  

    }  

    /** 

     *  获取背景颜色 

     */  

    private String getColor(Dispatch cell)  

    {  

        Dispatch Interior=Dispatch.get(cell, "Interior").toDispatch();  

        String color=Dispatch.get(Interior, "color").toString();  

        return color;  

    }  

    /** 

     * 单元格读取值 

     * @param position 单元格位置，如： C1 

     * @param sheet  

     * @return 

     */  

    private Variant getValue(String position) {  

        currentSheet=this.getCurrentSheet();  

        Dispatch cell = Dispatch.invoke(currentSheet, "Range", Dispatch.Get,  

                new Object[] { position }, new int[1]).toDispatch();  

        Variant value = Dispatch.get(cell, "Value");  

        return value;  

    }   

    /** 

     * 获取最大行数 

     * @return 

     */  

    private int getRowCount() {  

        currentSheet=this.getCurrentSheet();  

        Dispatch UsedRange=Dispatch.get(currentSheet, "UsedRange").toDispatch();  

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

        int num=Dispatch.get(rows, "count").getInt();  

        return num;  

    }  

    /** 

     * 获取最大列数 

     * @return 

     */  

    private int getColumnCount() {  

        currentSheet=this.getCurrentSheet();  

        Dispatch UsedRange=Dispatch.get(currentSheet, "UsedRange").toDispatch();  

        Dispatch Columns=Dispatch.get(UsedRange, "Columns").toDispatch();  

        int num=Dispatch.get(Columns, "count").getInt();  

        return num;  

    }  

    /** 

     * 获取位置 

     * @param rnum 最大行数 

     * @param cnum 最大列数 

     */  

    private String getCellPosition(int rnum,int cnum)  

    {    

          String cposition="";  

          if(cnum>26)  

          {  

              int multiple=(cnum)/26;  

              int remainder=(cnum)%26;  

              char mchar=(char)(multiple+64);  

              char rchar=(char)(remainder+64);  

              cposition=mchar+""+rchar;  

          }  

          else  

          {  

              cposition=(char)(cnum+64)+"";  

          }  

          cposition+=rnum;  

          return cposition;  

    }  

     

     /* 

      * 取消兼容性检查，在保存或者另存为时改检查会导致弹窗 

      */  

    private viod setCheckCompatibility(){  

        Dispatch.put(wookbook, "CheckCompatibility", false);  

   }  

  

     /* 

      *  为每个表设置打印区域 

      */  

    private void setPrintArea(){  

        int count = Dispatch.get(sheets, "count").changeType(Variant.VariantInt).getInt();  

        for (int i = count; i >= 1; i--) {  

               sheet = Dispatch.invoke(sheets, "Item",  

                       Dispatch.Get, new Object[] { i }, new int[1]).toDispatch();  

           Dispatch page = Dispatch.get(sheet, "PageSetup").toDispatch();  

           Dispatch.put(page, "PrintArea", false);  

           Dispatch.put(page, "Orientation", 2);  

           Dispatch.put(page, "Zoom", false);      //值为100或false  

           Dispatch.put(page, "FitToPagesTall", false);  //所有行为一页  

           Dispatch.put(page, "FitToPagesWide", 1);      //所有列为一页(1或false)     

    }   

   }  

}