javatoword.java

jacob的一个例子

package word.sp;

/*************************************
 *
 *作用：利用jacob插件根据模板word生成word 文件！
 *
 *传入数据为HashMap对象，对象中的Key代表word模板中要替换的字段，Value代表用来替换的值。
 * word模板中所有要替换的字段（即HashMap中的Key）以特殊字符开头和结尾，如：$code$、$date$……，以免执行错误的替换。
 * 所有要替换为图片的字段，Key中需包含image或者Value为图片的全路径（目前只判断文件后缀名为：.bmp、.jpg、.gif）。
 * 要替换表格中的数据时，HashMap中的Key格式为“table$R@N”，其中：R代表从表格的第R行开始替换，N代表word模板中的第N张表格；
 * Value为ArrayList对象，ArrayList中包含的对象统一为String[]，一条String[]代表一行数据，ArrayList中第一条记录为特殊记录，
 * 记录的是表格中要替换的列号，如：要替换第一列、第三列、第五列的数据，则第一条记录为String[3] {“1”,”3”,”5”}。
 *
 *2008-9-26
 *
 ************************************/

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.HashMap;

import com.jacob.activeX.ActiveXComponent;
import com.jacob.com.ComThread;
import com.jacob.com.Dispatch;
import com.jacob.com.Variant;

public class JavaToWord {
	private boolean saveOnExit;

	/**
	 * word文档
	 */
	private Dispatch doc = null;

	/**
	 * word运行程序对象
	 */
	private ActiveXComponent word;

	/**
	 * 所有word文档
	 */
	private Dispatch documents;

	private static Object appLock = new Object();
	
	/**
	 * 构造函数
	 */
	public JavaToWord() {
		saveOnExit = false;
		//word = new ActiveXComponent("Word.Application");
		if (word == null) {
			synchronized (appLock) {
				if (word == null) {
					word = new ActiveXComponent("Word.Application");
				}
			}
		}
		word.setProperty("Visible", new Variant(false));
		documents = word.getProperty("Documents").toDispatch();
	}

	/**
	 * 设置参数：退出时是否保存
	 * 
	 * @param saveOnExit
	 *            true-退出时保存文件，false-退出时不保存文件
	 */
	public void setSaveOnExit(boolean saveOnExit) {
		this.saveOnExit = saveOnExit;
	}

	/**
	 * 得到参数：退出时是否保存
	 * 
	 * @return boolean true-退出时保存文件，false-退出时不保存文件
	 */
	public boolean getSaveOnExit() {
		return saveOnExit;
	}

	/**
	 * 打开文件
	 * 
	 * @param inputDoc
	 *            要打开的文件，全路径
	 * @return Dispatch 打开的文件
	 */
	public Dispatch open(String inputDoc) {
		return Dispatch.call(documents, "Open", inputDoc).toDispatch();	
	}

	/**
	 * 选定内容
	 * 
	 * @return Dispatch 选定的范围或插入点
	 */
	public Dispatch select() {
		return word.getProperty("Selection").toDispatch();
	}

	/**
	 * 把选定内容或插入点向上移动
	 * 
	 * @param selection
	 *            要移动的内容
	 * @param count
	 *            移动的距离
	 */
	public void moveUp(Dispatch selection, int count) {
		for (int i = 0; i < count; i++)
			Dispatch.call(selection, "MoveUp");
	}

	/**
	 * 把选定内容或插入点向下移动
	 * 
	 * @param selection
	 *            要移动的内容
	 * @param count
	 *            移动的距离
	 */
	public void moveDown(Dispatch selection, int count) {
		for (int i = 0; i < count; i++)
			Dispatch.call(selection, "MoveDown");
	}

	/**
	 * 把选定内容或插入点向左移动
	 * 
	 * @param selection
	 *            要移动的内容
	 * @param count
	 *            移动的距离
	 */
	public void moveLeft(Dispatch selection, int count) {
		for (int i = 0; i < count; i++)
			Dispatch.call(selection, "MoveLeft");
	}

	/**
	 * 把选定内容或插入点向右移动
	 * 
	 * @param selection
	 *            要移动的内容
	 * @param count
	 *            移动的距离
	 */
	public void moveRight(Dispatch selection, int count) {
		for (int i = 0; i < count; i++)
			Dispatch.call(selection, "MoveRight");
	}

	/**
	 * 把插入点移动到文件首位置
	 * 
	 * @param selection
	 *            插入点
	 */
	public void moveStart(Dispatch selection) {
		Dispatch.call(selection, "HomeKey", new Variant(6));
	}

	/**
	 * 从选定内容或插入点开始查找文本
	 * 
	 * @param selection
	 *            选定内容
	 * @param toFindText
	 *            要查找的文本
	 * @return boolean true-查找到并选中该文本，false-未查找到文本
	 */
	public boolean find(Dispatch selection, String toFindText) {
		// 从selection所在位置开始查询
		Dispatch find = Dispatch.call(selection, "Find").toDispatch();
		// 设置要查找的内容
		Dispatch.put(find, "Text", toFindText);
		// 向前查找
		Dispatch.put(find, "Forward", "True");
		// 设置格式
		Dispatch.put(find, "Format", "True");
		// 大小写匹配
		Dispatch.put(find, "MatchCase", "True");
		// 全字匹配
		Dispatch.put(find, "MatchWholeWord", "True");
		// 查找并选中
		return Dispatch.call(find, "Execute").getBoolean();
	}

	/**
	 * 把选定内容替换为设定文本
	 * 
	 * @param selection
	 *            选定内容
	 * @param newText
	 *            替换为文本
	 */
	public void replace(Dispatch selection, String newText) {
		// 设置替换文本
		Dispatch.put(selection, "Text", newText);
	}

	/**
	 * 全局替换
	 * 
	 * @param selection
	 *            选定内容或起始插入点
	 * @param oldText
	 *            要替换的文本
	 * @param newText
	 *            替换为文本
	 */
	public void replaceAll(Dispatch selection, String oldText, Object replaceObj) {
		// 移动到文件开头
		moveStart(selection);
		if (oldText.startsWith("table") || replaceObj instanceof List) {
			replaceTable(selection, oldText, (List) replaceObj);
		} else {
			String newText = (String) replaceObj;
			if (oldText.indexOf("image") != -1
					|| newText.lastIndexOf(".bmp") != -1
					|| newText.lastIndexOf(".jpg") != -1
					|| newText.lastIndexOf(".gif") != -1)
				while (find(selection, oldText)) {
					replaceImage(selection, newText);
					Dispatch.call(selection, "MoveRight");
				}
			else
				while (find(selection, oldText)) {
					replace(selection, newText);
					Dispatch.call(selection, "MoveRight");
				}
		}
	}

	/**
	 * 替换图片
	 * 
	 * @param selection
	 *            图片的插入点
	 * @param imagePath
	 *            图片文件（全路径）
	 */
	public void replaceImage(Dispatch selection, String imagePath) {
		Dispatch.call(Dispatch.get(selection, "InLineShapes").toDispatch(),
				"AddPicture", imagePath);
	}

	/**
	 * 替换表格
	 * 
	 * @param selection
	 *            插入点
	 * @param tableName
	 *            表格名称，形如table$1@1、table$2@1...table$R@N，R代表从表格中的第R行开始填充，
	 *            N代表word文件中的第N张表
	 * @param fields
	 *            表格中要替换的字段与数据的对应表
	 */
	public void replaceTable(Dispatch selection, String tableName, List dataList) {
		if (dataList.size() <= 1) {
			System.out.println("Empty table!");
			return;
		}
		// 要填充的列
		String[] cols = (String[]) dataList.get(0);
		// 表格序号
		String tbIndex = tableName.substring(tableName.lastIndexOf("@") + 1);
		// 从第几行开始填充
		int fromRow = Integer.parseInt(tableName.substring(tableName
				.lastIndexOf("$") + 1, tableName.lastIndexOf("@")));
		// 所有表格
		Dispatch tables = Dispatch.get(doc, "Tables").toDispatch();
		// 要填充的表格
		Dispatch table = Dispatch.call(tables, "Item", new Variant(tbIndex))
				.toDispatch();
		// 表格的所有行
		Dispatch rows = Dispatch.get(table, "Rows").toDispatch();
		// 填充表格
		for (int i = 1; i < dataList.size(); i++) {
			// 某一行数据
			String[] datas = (String[]) dataList.get(i);
			// 在表格中添加一行
			if (Dispatch.get(rows, "Count").getInt() < fromRow + i - 1)
				Dispatch.call(rows, "Add");
			// 填充该行的相关列
			for (int j = 0; j < datas.length; j++) {
				// 得到单元格
				Dispatch cell = Dispatch.call(table, "Cell",
						Integer.toString(fromRow + i - 1), cols[j])
						.toDispatch();
				// 选中单元格
				Dispatch.call(cell, "Select");
				// 设置格式
				Dispatch font = Dispatch.get(selection, "Font").toDispatch();
				Dispatch.put(font, "Bold", "0");
				Dispatch.put(font, "Italic", "0");
				// 输入数据
				Dispatch.put(selection, "Text", datas[j]);
			}
		}
	}

	/**
	 * 保存文件
	 * 
	 * @param outputPath
	 *            输出文件（包含路径）
	 */
	public void save(String outputPath) {
		//Dispatch.call(Dispatch.call(word, "WordBasic").getDispatch(),"FileSaveAs", outputPath);
		Dispatch.call(doc, "SaveAS", outputPath);
	}
	
	/**
	 * 关闭文件
	 * 
	 * @param document
	 *            要关闭的文件
	 */
	public void close(Dispatch doc) {
		Dispatch.call(doc, "Close", new Variant(saveOnExit));
		closeApp();
	}

	public void closeApp() {
		Dispatch.call(word, "Quit");
		word = null;
		doc = null;
	}
	
	/**
	 * 退出程序
	 */
	public void quit() {
		word.invoke("Quit", new Variant[0]);
		ComThread.Release();
	}

	/**
	 * 根据模板、数据生成word文件
	 * @param inputPath 模板文件（包含路径）
	 * @param outPath 输出文件（包含路径）
	 * @param data 数据包（包含要填充的字段、对应的数据）
	 */
	public void toWord(String inputPath, String outPath, HashMap data) {
		String oldText;
		Object newValue;
		try {
			doc = open(inputPath);
			Dispatch selection = select();
			Iterator keys = data.keySet().iterator();
			while (keys.hasNext()) {
				oldText = (String) keys.next();
				newValue = data.get(oldText);
				//replaceAll(selection, oldText, newValue);
				//replace(selection, "xxxdd");

				ArrayList<String[]> alist=new ArrayList<String[]>();
				int col=3;
				String str[]=new String[col];
				int x=0;
				for(int i=0;i<4;i++){
					for(int j=0;j<col;j++) {
						x++;
						str[j]=x+"";
					}
					//str=new String[]{"1","2","3"};
					alist.add(i, str);
					str=new String[col];
				}
	
			/*
				String str0[]={"1","2","3"};//特殊行表示要替换的列标
				String str1[]={"11","12","13"};//从第一行开始替换
				String str2[]={"21","22","23"};
				String str3[]={"31","32","33"};
				String str4[]={"41","42","43"};
				String str5[]={"51","52","53"};
				String str6[]={"61","62","63"};
				alist.add(0, str0);
				alist.add(1, str1);
				alist.add(2, str2);
				alist.add(3, str3);
				alist.add(4, str4);
				alist.add(5, str5);
				alist.add(6, str6);
				*/
				replaceTable(selection,"table$1@1",alist);
				replaceTable(selection,"table$1@2",alist);
				
			}
			save(outPath);
		} catch (Exception e) {
			System.out.println("操作word文件失败！"+e.getMessage());
			// debug.println("toword[JavaToWord]------------操作word文件失败！"+e.getMessage(),true);

		} finally {
			if (doc != null)
				close(doc);
		}
	}
	
	public static void main(String[] args){
		System.out.println("begin");
		HashMap data= new HashMap();
		data.put("{v0}", "中国一定强xxx");
		data.put("{v1}", "OKKKKK");
		JavaToWord jw=new JavaToWord();
		jw.toWord("c:\\org.doc","c:\\des.doc",data);
		System.out.println("end");
	}
	

}