使用Jacob与Word文件交互

// 打开Word应用程序
ActiveXComponent app = new ActiveXComponent("Word.Application");
// 设置word不可见
app.setProperty("Visible", new Variant(false));
// 打开word文件
Dispatch word = app.getProperty("Documents").toDispatch();
Dispatch doc = Dispatch.invoke(word, "Open", Dispatch.Method, new Object[] {"File Name", new Variant(false), new Variant(false) }, new int[1]).toDispatch();
//获取指针
Dispatch cursor = app.getProperty("Selection").toDispatch();

Dispatch doc = Dispatch.call(word, "Open", new Variant(false), new Variant(false)).toDisptach();

//获取其属性，表格的集合
Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
//调用方法取得其中的第一张表格
Dispatch table = Dispatch.call(this.tables, "Item", new Variant(0)).toDispatch();
//修改此表格第一行第一列的单元格
Dispatch cell = Dispatch.call(table,"Cell", Integer.toString(1), Integer.toString(1)).toDispatch();
Dispatch.call(cell, "Select");
Dispatch.put(cursor, "Text", "New String");

//关闭文档且不保存
Dispatch.call(doc, "Close", new Variant(false));
//退出进程对象
app.invoke("Quit", new Variant[] {});

import com.jacob.com.*;
import com.jacob.activeX.*;

/**
 *
 * @author Lonsy
 */
public class WordHandle {
    
    //运行时的Word程序
    private ActiveXComponent app;

    //word对象
    private Dispatch words;

    //当前的word文档
    private Dispatch doc;

    //当前光标位置
    private Dispatch cursor;

    //当前文档是否只读
    private boolean readOnly;

    //当前文档中所有表格
    private Dispatch tables;

    //当前所在表格
    private Dispatch table;

    private int count;

    public WordHandle()
    {
        this.app = new ActiveXComponent("Word.Application");
        this.app.setProperty("Visible", new Variant(false));    // 设置word不可见
        words = this.app.getProperty("Documents").toDispatch();
        this.doc = null;
        this.cursor = null;
        this.readOnly = true;
        this.count = 0;
    }

    /**
     * 打开word文件
     * @param fileName 文件名，使用绝对路径
     * @param readOnly 是否只读
     * @return
     * @throws java.lang.Exception
     */
    public boolean open(String fileName, boolean readOnly) throws Exception
    {
        if (doc != null)
        {
            System.out.println("当前文件未关闭");
            return false;
        }
        this.doc = Dispatch.invoke(this.words, "Open", Dispatch.Method, new Object[] {fileName, new Variant(false), new Variant(readOnly)}, new int[1]).toDispatch();
        this.cursor = app.getProperty("Selection").toDispatch();
        this.tables = Dispatch.get(this.doc,"Tables").toDispatch();
        this.readOnly = readOnly;
        this.count = Dispatch.get(Dispatch.get(this.doc, "Words").toDispatch(), "Count").getInt() - 1;
        System.out.println("打开文件" + fileName + (readOnly ? " ReadOnly" : " Writable"));
        return true;
    }

    /**
     * 建立新的Word文件
     * @return
     * @throws java.lang.Exception
     */
    public boolean newFile() throws Exception
    {
        if (doc != null)
        {
            System.out.println("当前文件未关闭");
            return false;
        }
        this.doc = Dispatch.call(this.words, "Add").toDispatch();
        this.readOnly = false;
        this.cursor = app.getProperty("Selection").toDispatch();
        this.tables = Dispatch.get(this.doc,"Tables").toDispatch();
        System.out.println("新建word文档");
        return true;
    }

    /**
     * 关闭当前文件，并不保存
     * @return
     */
    public boolean close()
    {
        String fileName = null;
        if (this.doc != null)
        {
            try
            {
                fileName = Dispatch.get(this.doc, "Name").getString();
                Dispatch.call(this.doc, "Close", new Variant(false));
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
            finally
            {
                this.doc = null;
            }
        }
        System.out.println("关闭文件 " + fileName);
        return true;
    }

    /**
     * 退出
     * @return
     */
    public boolean quit()
    {
        try
        {
            this.app.invoke("Quit", new Variant[] {});
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        System.out.println("退出word");
        return true;
    }

    /**
     * 另存为
     * @param fileName 目标文件名，为绝对路径
     * @return
     */
    public boolean saveAs(String fileName) throws Exception
    {
        if (this.doc == null)
        {
            System.out.println("当前无文件");
            return false;
        }
        else
        {
            Dispatch.call(this.doc, "SaveAs", fileName);
            System.out.println("另存为" + fileName);
            return true;
        }
    }

    /**
     * 保存
     * @return
     */
    public boolean save() throws Exception
    {
        if (this.doc == null)
        {
            System.out.println("当前无文档，无法保存");
            return false;
        }
        else
        {
            if (this.readOnly)
            {
                System.out.println("只读文档，保存失败");
                return false;
            }
            Dispatch.call(this.doc, "Save");
            System.out.println("保存完成");
            return true;
        }
    }

    /**
     * 将光标或选定内容向右移动
     * @param step
     * @return
     */
    public boolean moveRight(int steps) throws Exception
    {
        //int start = Dispatch.get(this.cursor, "Start").getInt();
        //Dispatch.put(this.cursor, "Start", start + steps);
        for (int i=0; i<steps; i++)
        {
            Dispatch.call(cursor, "MoveRight");
        }
        return true;
    }

    /**
     * 将光标或选定内容向左移动
     * @param step
     * @return
     */
    public boolean moveLeft(int steps) throws Exception
    {
        for (int i=0; i<steps; i++)
        {
            Dispatch.call(cursor, "MoveLeft");
        }
        return true;
    }

    /**
     * 从当前位置起查找指定内容，并将光标移到相应位置上
     * @param str
     * @return 光标位置，未找到则为0
     * @throws java.lang.Exception
     */
    public int search(String str) throws Exception
    {
        // 从cursor所在位置开始查询
        Dispatch find = Dispatch.call(this.cursor, "Find").toDispatch();
        // 设置要查找的内容
        Dispatch.put(find, "Text", str);
        // 向前查找
        Dispatch.put(find, "Forward", "True");
        // 设置格式
        Dispatch.put(find, "Format", "True");
        // 大小写匹配
        Dispatch.put(find, "MatchCase", "True");
        // 全字匹配
        Dispatch.put(find, "MatchWholeWord", "True");
        // 查找
        if (!Dispatch.call(find,"Execute").getBoolean())
            return 0;
        else
        {
            return Dispatch.get(this.cursor, "Start").getInt();
        }
    }

    /**
     * 从当前位置起查找指定内容，并只将光标开始处移到相应位置上
     * @param str
     * @return 光标位置，未找到则为0
     * @throws java.lang.Exception
     */
    public int searchOnly(String str) throws Exception
    {
        // 从cursor所在位置开始查询
        Dispatch find = Dispatch.call(this.cursor, "Find").toDispatch();
        // 设置要查找的内容
        Dispatch.put(find, "Text", str);
        // 向前查找
        Dispatch.put(find, "Forward", "True");
        // 大小写匹配
        Dispatch.put(find, "MatchCase", "True");
        // 全字匹配
        Dispatch.put(find, "MatchWholeWord", "True");
        if (!Dispatch.call(find,"Execute").getBoolean())
            return 0;
        else
        {
            int start = Dispatch.get(this.cursor, "Start").getInt();
            Dispatch.put(this.cursor, "End", this.count);
            //System.out.println(start);
            return start;
        }
    }

    public String getBetween(int start, int end) throws Exception
    {
        Dispatch range = Dispatch.get(this.cursor, "Range").toDispatch();
        Dispatch.call(range,"SetRange", start, end);
        return Dispatch.get(range, "Text").getString();
    }

    public String getLineAfter(int start) throws Exception
    {
        Dispatch.put(this.cursor, "Start", start);
        int length = Dispatch.call(this.cursor, "EndKey").getInt() + start;
        return getBetween(start, length);
    }

    public String getLine(int position) throws Exception
    {
        Dispatch.put(this.cursor, "Start", position);
        Dispatch.call(this.cursor, "SelectRow");
        int start = Dispatch.get(this.cursor, "Start").getInt();
        int end = Dispatch.get(this.cursor, "End").getInt();
        return getBetween(start, start + end);
    }

    public boolean gotoPage(int index) throws Exception
    {
        Dispatch.invoke(this.cursor, "Goto", Dispatch.Method, new Object[] {1, 2, String.valueOf(index)}, new int[1]);
        //Dispatch.call(this.cursor, "GoTo", "wdGoToLine", "wdGoToNext", String.valueOf(index), null);
        return true;
    }

    public int getCurrentCursor() throws Exception
    {
        return Dispatch.get(this.cursor, "Start").getInt();
    }

    public boolean setCursorMode() throws Exception
    {
        Dispatch.put(this.cursor, "End", Dispatch.get(this.cursor, "Start").getInt());
        return true;
    }

    public boolean gotoHome() throws Exception
    {
        Dispatch.put(this.cursor, "Start", 0);
        return true;
    }

    /**
     * 在光标后指定便宜插入字符串，并将光标移到新位置
     * @param str
     * @return
     * @throws java.lang.Exception
     */
    public boolean insert(int steps, String str) throws Exception
    {
        int start = Dispatch.get(this.cursor, "Start").getInt() + steps;
        Dispatch.put(this.cursor, "Start", start);
        Dispatch.call(this.cursor, "InsertBefore", str);
        this.getCount();
        Dispatch.put(this.cursor, "Start", start + str.length());
        //System.out.println(Dispatch.get(this.cursor, "Start").getInt() + "   " + (Dispatch.get(this.cursor, "Start").getInt()+Dispatch.get(this.cursor, "End").getInt()));
        return true;
    }

    /**
     * 用指定的字符串替代当前选定的内容
     * @param str
     * @return
     * @throws java.lang.Exception
     */
    public boolean replace(String str) throws Exception
    {
        Dispatch.put(this.cursor, "Text", str);
        return true;
    }

    /**
     * 获取当前文档中的表格数
     * @return
     * @throws java.lang.Exception
     */
    public int getTableNum() throws Exception
    {
        return Dispatch.get(this.tables, "Count").getInt();
    }
    
    /**
     * 设定当前工作表格
     * @param index
     * @return
     * @throws java.lang.Exception
     */
    public boolean setCurrentTable(int index) throws Exception
    {
        this.table = Dispatch.call(this.tables, "Item", new Variant(index)).toDispatch();
        Dispatch.call(this.table, "Select");
        return true;
    }
    
    /**
     * 获取指定单元格的内容
     * @param row
     * @param col
     * @return
     * @throws java.lang.Exception
     */
    public String getCell(int row, int col) throws Exception
    {
        Dispatch cell = Dispatch.call(table, "Cell", Integer.toString(row), Integer.toString(col)).toDispatch();
        Dispatch.call(cell,"Select");
        String tmp = Dispatch.get(this.cursor, "Text").getString();
        //System.out.println(".." + tmp);
        if (tmp.length() > 2)
        {
            return tmp.substring(0, tmp.length() - 2);
        }
        else
            return "";
    }

    /**
     * 用指定的字符串代替当前表格中指定的单元格
     * @param row
     * @param col
     * @param str
     * @return
     * @throws java.lang.Exception
     */
    public boolean replaceCell(int row, int col, String str) throws Exception
    {
        Dispatch cell = Dispatch.call(table,"Cell", Integer.toString(row), Integer.toString(col)).toDispatch();
        Dispatch.call(cell, "Select");
        Dispatch.put(this.cursor, "Text", str);
        return true;
    }
}