jacob 操纵Microsoft Word 进行转移、拆分、合并、插入等操作 结合Freemarker将无所不能

1.FreeMarker   word模板转换flt（xml）文件直接数据写入生成doc

public class ExportQualityWordHandler {
	
	private Configuration configuration = null;
	
	public ExportQualityWordHandler() {        
		configuration = new Configuration();        
		configuration.setDefaultEncoding("utf-8");  
		configuration.setClassicCompatible(true);
	}  
	
	public String createDoc(List list){    
		//Doc 子文件路径记载
		List<File> files = new ArrayList<File>();
		
		//输出文档路径        
		String savePath = Constants.FCKEDITOR_UPLOAD_FILE_DIR;
		if(savePath.endsWith("\\upfiles\\")){
			savePath = savePath.substring(0, savePath.lastIndexOf("\\upfiles\\"));
		}
		
		for(int i=0;i<list.size();i++){
			Map map = (HashMap)list.get(i);
			
			String partsType = map.get("partsType").toString();
			String sfpName = map.get("sfpName").toString();
			if(sfpName.indexOf("/") > -1){
				sfpName.replaceAll("\\/", "-");
			}
			
			Template t=null;
			try {
				configuration.setClassForTemplateLoading(this.getClass(), "");
				t = configuration.getTemplate("xx计划 -xx模板.flt");//1.直接获取模板文件
			} catch (IOException e) {
				e.printStackTrace();
			}
			//输出子文件名称
			String filePath = "/upfiles/SMI/x计划 -"+sfpName+".doc";
			
			File outFile = new File(savePath+filePath);
			System.out.println("File path:---------------" + savePath+filePath);
			
			//记录该输出子文件
			files.add(outFile);
			
			
			Writer out = null;
			try {
				out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(outFile),"UTF-8"));
			} catch (FileNotFoundException e1) {
					e1.printStackTrace();
			} catch (Exception e) {
				// TODO: handle exception
			} 
			
			try {
				t.process(map, out);
				out.close();
			} catch (TemplateException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();     
			}
		}
		
		return "";
	}

2.jacob 对于更复杂的word将多个由Freemarker生成的doc再次合成

package  com.test; 

import  java.sql.Connection; 
import  java.sql.DriverManager; 
import  java.sql.ResultSet; 
import  java.sql.Statement; 
import  java.util.ArrayList; 
import  java.util.List; 

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

public   class  MSWordManager { 
         // word文档 
         private  Dispatch doc; 

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

         // 所有word文档集合 
         private  Dispatch documents; 

         // 选定的范围或插入点 
         private  Dispatch selection; 

         private   boolean  saveOnExit =  true ; 

         /** *//** 
         *     
         * @param visible 为true表示word应用程序可见 
         */  
         public  MSWordManager( boolean  visible) { 
                 if  (word ==  null ) { 
                        word =  new  ActiveXComponent( "Word.Application" ); 
                        word.setProperty( "Visible" ,  new  Variant(visible)); 
                } 
                 if  (documents ==  null ) 
                        documents = word.getProperty( "Documents" ).toDispatch(); 
        } 

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

         /** *//** 
         * 创建一个新的word文档 
         *     
         */  
         public   void  createNewDocument() { 
                doc = Dispatch.call(documents,  "Add" ).toDispatch(); 
                selection = Dispatch.get(word,  "Selection" ).toDispatch(); 
        } 

         /** *//** 
         * 打开一个已存在的文档 
         *     
         * @param docPath 
         */  
         public   void  openDocument(String docPath) { 
                closeDocument(); 
                doc = Dispatch.call(documents,  "Open" , docPath).toDispatch(); 
                selection = Dispatch.get(word,  "Selection" ).toDispatch(); 
        } 

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

        } 

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

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

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

         /** *//** 
         * 把插入点移动到文件首位置 
         *     
         */  
         public   void  moveStart() { 
                 if  (selection ==  null ) 
                        selection = Dispatch.get(word,  "Selection" ).toDispatch(); 
                Dispatch.call(selection,  "HomeKey" ,  new  Variant(6)); 
        } 
         
         public   void  moveEnd() { 
                 if  (selection ==  null ) 
                        selection = Dispatch.get(word,  "Selection" ).toDispatch(); 
                Dispatch.call(selection,  "EndKey" ,  new  Variant(6)); 
        } 

         /** *//** 
         * 从选定内容或插入点开始查找文本 
         *     
         * @param toFindText 要查找的文本 
         * @return boolean true-查找到并选中该文本，false-未查找到文本 
         */  
         public   boolean  find(String toFindText) { 
                 if  (toFindText ==  null  || toFindText.equals("")) 
                         return   false ; 
                 // 从selection所在位置开始查询 
                Dispatch find = word.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 toFindText 查找字符串 
         * @param newText 要替换的内容 
         * @return 
         */  
         public   boolean  replaceText(String toFindText, String newText) { 
                 if  (!find(toFindText)) 
                         return   false ; 
                Dispatch.put(selection,  "Text" , newText); 
                 return   true ; 
        } 

         /** *//** 
         * 全局替换文本 
         *     
         * @param toFindText 查找字符串 
         * @param newText 要替换的内容 
         */  
         public   void  replaceAllText(String toFindText, String newText) { 
                 while  (find(toFindText)) { 
                        Dispatch.put(selection,  "Text" , newText); 
                        Dispatch.call(selection,  "MoveRight" ); 
                } 
        } 

         /** *//** 
         * 在当前插入点插入字符串 
         *     
         * @param newText 要插入的新字符串 
         */  
         public   void  insertText(String newText) { 
                Dispatch.put(selection,  "Text" , newText); 
        } 

         /** *//** 
         *     
         * @param toFindText 要查找的字符串 
         * @param imagePath 图片路径 
         * @return 
         */  
         public   boolean  replaceImage(String toFindText, String imagePath) { 
                 if  (!find(toFindText)) 
                         return   false ; 
                Dispatch.call(Dispatch.get(selection,  "InLineShapes" ).toDispatch(), 
                                 "AddPicture" , imagePath); 
                 return   true ; 
        } 

         /** *//** 
         * 全局替换图片 
         *     
         * @param toFindText 查找字符串 
         * @param imagePath 图片路径 
         */  
         public   void  replaceAllImage(String toFindText, String imagePath) { 
                 while  (find(toFindText)) { 
                        Dispatch.call(Dispatch.get(selection,  "InLineShapes" ).toDispatch(), 
                                         "AddPicture" , imagePath); 
                        Dispatch.call(selection,  "MoveRight" ); 
                } 
        } 

         /** *//** 
         * 在当前插入点插入图片 
         *     
         * @param imagePath 图片路径 
         */  
         public   void  insertImage(String imagePath) { 
                Dispatch.call(Dispatch.get(selection,  "InLineShapes" ).toDispatch(), 
                                 "AddPicture" , imagePath); 
        } 

         /** *//** 
         * 合并单元格 
         *     
         * @param tableIndex 
         * @param fstCellRowIdx 
         * @param fstCellColIdx 
         * @param secCellRowIdx 
         * @param secCellColIdx 
         */  
         public   void  mergeCell( int  tableIndex,  int  fstCellRowIdx,  int  fstCellColIdx, 
                         int  secCellRowIdx,  int  secCellColIdx) { 
                 // 所有表格 
                Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch(); 
                 // 要填充的表格 
                Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex)) 
                                .toDispatch(); 
                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); 
        } 

         /** *//** 
         * 在指定的单元格里填写数据 
         *     
         * @param tableIndex 
         * @param cellRowIdx 
         * @param cellColIdx 
         * @param txt 
         */  
         public   void  putTxtToCell( int  tableIndex,  int  cellRowIdx,  int  cellColIdx, 
                        String txt) { 
                 // 所有表格 
                Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch(); 
                 // 要填充的表格 
                Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex)) 
                                .toDispatch(); 
                Dispatch cell = Dispatch.call(table,  "Cell" ,  new  Variant(cellRowIdx), 
                                 new  Variant(cellColIdx)).toDispatch(); 
                Dispatch.call(cell,  "Select" ); 
                Dispatch.put(selection,  "Text" , txt); 
        } 

         /** *//** 
         * 在当前文档拷贝数据 
         *     
         * @param pos 
         */  
         public   void  copy(String toCopyText) { 
                moveStart(); 
                 if  ( this .find(toCopyText)) { 
                        Dispatch textRange = Dispatch.get(selection,  "Range" ).toDispatch(); 
                        Dispatch.call(textRange,  "Copy" ); 
                } 
        } 

         /** *//** 
         * 在当前文档粘帖剪贴板数据 
         *     
         * @param pos 
         */  
         public   void  paste(String pos) { 
                moveStart(); 
                 if  ( this .find(pos)) { 
                        Dispatch textRange = Dispatch.get(selection,  "Range" ).toDispatch(); 
                        Dispatch.call(textRange,  "Paste" ); 
                } 
        } 

         /** *//** 
         * 在当前文档指定的位置拷贝表格 
         *     
         * @param pos 当前文档指定的位置 
         * @param tableIndex 被拷贝的表格在word文档中所处的位置 
         */  
         public   void  copyTable(String pos, int  tableIndex) { 
                Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch(); 
                Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex)) 
                                .toDispatch(); 
                Dispatch range = Dispatch.get(table,  "Range" ).toDispatch(); 
                Dispatch.call(range,  "Copy" ); 
                 if  ( this .find(pos)) { 
                        Dispatch textRange = Dispatch.get(selection,  "Range" ).toDispatch(); 
                        Dispatch.call(textRange,  "Paste" ); 
                } 
        } 

         /** *//** 
         * 在当前文档末尾拷贝来自另一个文档中的段落 
         *     
         * @param anotherDocPath 另一个文档的磁盘路径 
         * @param tableIndex 被拷贝的段落在另一格文档中的序号(从1开始) 
         */  
         public   void  copyParagraphFromAnotherDoc(String anotherDocPath, 
                         int  paragraphIndex) { 
                Dispatch wordContent = Dispatch.get(doc,  "Content" ).toDispatch();  // 取得当前文档的内容 
                Dispatch.call(wordContent,  "InsertAfter" ,  "$selection$" ); // 插入特殊符定位插入点 
                copyParagraphFromAnotherDoc(anotherDocPath, paragraphIndex, 
                                 "$selection$" ); 
        } 

         /** *//** 
         * 在当前文档指定的位置拷贝来自另一个文档中的段落 
         *     
         * @param anotherDocPath 另一个文档的磁盘路径 
         * @param tableIndex 被拷贝的段落在另一格文档中的序号(从1开始) 
         * @param pos 当前文档指定的位置 
         */  
         public   void  copyParagraphFromAnotherDoc(String anotherDocPath, 
                         int  paragraphIndex, String pos) { 
                Dispatch doc2 =  null ; 
                 try  { 
                        doc2 = Dispatch.call(documents,  "Open" , anotherDocPath) 
                                        .toDispatch(); 
                        Dispatch paragraphs = Dispatch.get(doc2,  "Paragraphs" ).toDispatch(); 

                        Dispatch paragraph = Dispatch.call(paragraphs,  "Item" , 
                                         new  Variant(paragraphIndex)).toDispatch(); 
                        Dispatch range = Dispatch.get(paragraph,  "Range" ).toDispatch(); 
                        Dispatch.call(range,  "Copy" ); 
                         if  ( this .find(pos)) { 
                                Dispatch textRange = Dispatch.get(selection,  "Range" ) 
                                                .toDispatch(); 
                                Dispatch.call(textRange,  "Paste" ); 
                        } 
                }  catch  (Exception e) { 
                        e.printStackTrace(); 
                }  finally  { 
                         if  (doc2 !=  null ) { 
                                Dispatch.call(doc2,  "Close" ,  new  Variant(saveOnExit)); 
                                doc2 =  null ; 
                        } 
                } 
        } 

         /** *//** 
         * 在当前文档指定的位置拷贝来自另一个文档中的表格 
         *     
         * @param anotherDocPath 另一个文档的磁盘路径 
         * @param tableIndex 被拷贝的表格在另一格文档中的序号(从1开始) 
         * @param pos 当前文档指定的位置 
         */  
         public   void  copyTableFromAnotherDoc(String anotherDocPath,  int  tableIndex, 
                        String pos) { 
                Dispatch doc2 =  null ; 
                 try  { 
                        doc2 = Dispatch.call(documents,  "Open" , anotherDocPath) 
                                        .toDispatch(); 
                        Dispatch tables = Dispatch.get(doc2,  "Tables" ).toDispatch(); 
                        Dispatch table = Dispatch.call(tables,  "Item" , 
                                         new  Variant(tableIndex)).toDispatch(); 
                        Dispatch range = Dispatch.get(table,  "Range" ).toDispatch(); 
                        Dispatch.call(range,  "Copy" ); 
                         if  ( this .find(pos)) { 
                                Dispatch textRange = Dispatch.get(selection,  "Range" ) 
                                                .toDispatch(); 
                                Dispatch.call(textRange,  "Paste" ); 
                        } 
                }  catch  (Exception e) { 
                        e.printStackTrace(); 
                }  finally  { 
                         if  (doc2 !=  null ) { 
                                Dispatch.call(doc2,  "Close" ,  new  Variant(saveOnExit)); 
                                doc2 =  null ; 
                        } 
                } 
        } 

         /** *//** 
         * 在当前文档指定的位置拷贝来自另一个文档中的图片 
         *     
         * @param anotherDocPath 另一个文档的磁盘路径 
         * @param shapeIndex 被拷贝的图片在另一格文档中的位置 
         * @param pos 当前文档指定的位置 
         */  
         public   void  copyImageFromAnotherDoc(String anotherDocPath,  int  shapeIndex, 
                        String pos) { 
                Dispatch doc2 =  null ; 
                 try  { 
                        doc2 = Dispatch.call(documents,  "Open" , anotherDocPath) 
                                        .toDispatch(); 
                        Dispatch shapes = Dispatch.get(doc2,  "InLineShapes" ).toDispatch(); 
                        Dispatch shape = Dispatch.call(shapes,  "Item" , 
                                         new  Variant(shapeIndex)).toDispatch(); 
                        Dispatch imageRange = Dispatch.get(shape,  "Range" ).toDispatch(); 
                        Dispatch.call(imageRange,  "Copy" ); 
                         if  ( this .find(pos)) { 
                                Dispatch textRange = Dispatch.get(selection,  "Range" ) 
                                                .toDispatch(); 
                                Dispatch.call(textRange,  "Paste" ); 
                        } 
                }  catch  (Exception e) { 
                        e.printStackTrace(); 
                }  finally  { 
                         if  (doc2 !=  null ) { 
                                Dispatch.call(doc2,  "Close" ,  new  Variant(saveOnExit)); 
                                doc2 =  null ; 
                        } 
                } 
        } 

         /** *//** 
         * 创建表格 
         *     
         * @param pos    位置 
         * @param cols 列数 
         * @param rows 行数 
         */  
         public   void  createTable( int  numCols,  int  numRows){ //(String pos, int numCols, int numRows) { 
//                if (!find(pos)) { 
                        Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch(); 
                        Dispatch range = Dispatch.get(selection,  "Range" ).toDispatch(); 
                        Dispatch newTable = Dispatch.call(tables,  "Add" , range, 
                                         new  Variant(numRows),  new  Variant(numCols)).toDispatch(); 
                        Dispatch.call(selection,  "MoveRight" ); 
                        moveEnd(); 
//                } 
        } 

         /** *//** 
         * 在指定行前面增加行 
         *     
         * @param tableIndex word文件中的第N张表(从1开始) 
         * @param rowIndex 指定行的序号(从1开始) 
         */  
         public   void  addTableRow( int  tableIndex,  int  rowIndex) { 
                 // 所有表格 
                Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch(); 
                 // 要填充的表格 
                Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex)) 
                                .toDispatch(); 
                 // 表格的所有行 
                Dispatch rows = Dispatch.get(table,  "Rows" ).toDispatch(); 
                Dispatch row = Dispatch.call(rows,  "Item" ,  new  Variant(rowIndex)) 
                                .toDispatch(); 
                Dispatch.call(rows,  "Add" ,  new  Variant(row)); 
        } 

         /** *//** 
         * 在第1行前增加一行 
         *     
         * @param tableIndex word文档中的第N张表(从1开始) 
         */  
         public   void  addFirstTableRow( int  tableIndex) { 
                 // 所有表格 
                Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch(); 
                 // 要填充的表格 
                Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex)) 
                                .toDispatch(); 
                 // 表格的所有行 
                Dispatch rows = Dispatch.get(table,  "Rows" ).toDispatch(); 
                Dispatch row = Dispatch.get(rows,  "First" ).toDispatch(); 
                Dispatch.call(rows,  "Add" ,  new  Variant(row)); 
        } 

         /** *//** 
         * 在最后1行前增加一行 
         *     
         * @param tableIndex 
         *                        word文档中的第N张表(从1开始) 
         */  
         public   void  addLastTableRow( int  tableIndex) { 
                 // 所有表格 
                Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch(); 
                 // 要填充的表格 
                Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex)) 
                                .toDispatch(); 
                 // 表格的所有行 
                Dispatch rows = Dispatch.get(table,  "Rows" ).toDispatch(); 
                Dispatch row = Dispatch.get(rows,  "Last" ).toDispatch(); 
                Dispatch.call(rows,  "Add" ,  new  Variant(row)); 
        } 

         /** *//** 
         * 增加一行 
         *     
         * @param tableIndex word文档中的第N张表(从1开始) 
         */  
         public   void  addRow( int  tableIndex) { 
                Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch(); 
                 // 要填充的表格 
                Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex)) 
                                .toDispatch(); 
                 // 表格的所有行 
                Dispatch rows = Dispatch.get(table,  "Rows" ).toDispatch(); 
                Dispatch.call(rows,  "Add" ); 
        } 

         /** *//** 
         * 增加一列 
         *     
         * @param tableIndex word文档中的第N张表(从1开始) 
         */  
         public   void  addCol( int  tableIndex) { 
                 // 所有表格 
                Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch(); 
                 // 要填充的表格 
                Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex)) 
                                .toDispatch(); 
                 // 表格的所有行 
                Dispatch cols = Dispatch.get(table,  "Columns" ).toDispatch(); 
                Dispatch.call(cols,  "Add" ).toDispatch(); 
                Dispatch.call(cols,  "AutoFit" ); 
        } 

         /** *//** 
         * 在指定列前面增加表格的列 
         *     
         * @param tableIndex word文档中的第N张表(从1开始) 
         * @param colIndex    指定列的序号 (从1开始) 
         */  
         public   void  addTableCol( int  tableIndex,  int  colIndex) { 
                 // 所有表格 
                Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch(); 
                 // 要填充的表格 
                Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex)) 
                                .toDispatch(); 
                 // 表格的所有行 
                Dispatch cols = Dispatch.get(table,  "Columns" ).toDispatch(); 
                System.out.println(Dispatch.get(cols,  "Count" )); 
                Dispatch col = Dispatch.call(cols,  "Item" ,  new  Variant(colIndex)) 
                                .toDispatch(); 
                 // Dispatch col = Dispatch.get(cols, "First").toDispatch(); 
                Dispatch.call(cols,  "Add" , col).toDispatch(); 
                Dispatch.call(cols,  "AutoFit" ); 
        } 

         /** *//** 
         * 在第1列前增加一列 
         *     
         * @param tableIndex word文档中的第N张表(从1开始) 
         */  
         public   void  addFirstTableCol( int  tableIndex) { 
                Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch(); 
                 // 要填充的表格 
                Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex)) 
                                .toDispatch(); 
                 // 表格的所有行 
                Dispatch cols = Dispatch.get(table,  "Columns" ).toDispatch(); 
                Dispatch col = Dispatch.get(cols,  "First" ).toDispatch(); 
                Dispatch.call(cols,  "Add" , col).toDispatch(); 
                Dispatch.call(cols,  "AutoFit" ); 
        } 

         /** *//** 
         * 在最后一列前增加一列 
         *     
         * @param tableIndex word文档中的第N张表(从1开始) 
         */  
         public   void  addLastTableCol( int  tableIndex) { 
                Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch(); 
                 // 要填充的表格 
                Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex)) 
                                .toDispatch(); 
                 // 表格的所有行 
                Dispatch cols = Dispatch.get(table,  "Columns" ).toDispatch(); 
                Dispatch col = Dispatch.get(cols,  "Last" ).toDispatch(); 
                Dispatch.call(cols,  "Add" , col).toDispatch(); 
                Dispatch.call(cols,  "AutoFit" ); 
        } 

         /** *//** 
         * 自动调整表格 
         *     
         */  
         public   void  autoFitTable() { 
                Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch(); 
                 int  count = Dispatch.get(tables,  "Count" ).toInt(); 
                 for  ( int  i = 0; i < count; i++) { 
                        Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(i + 1)) 
                                        .toDispatch(); 
                        Dispatch cols = Dispatch.get(table,  "Columns" ).toDispatch(); 
                        Dispatch.call(cols,  "AutoFit" ); 
                } 
        } 

         /** *//** 
         * 调用word里的宏以调整表格的宽度,其中宏保存在document下 
         *     
         */  
         public   void  callWordMacro() { 
                Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch(); 
                 int  count = Dispatch.get(tables,  "Count" ).toInt(); 
                Variant vMacroName =  new  Variant( "Normal.NewMacros.tableFit" ); 
                Variant vParam =  new  Variant( "param1" ); 
                Variant para[] =  new  Variant[] { vMacroName }; 
                 for  ( int  i = 0; i < para.length; i++) { 
                        Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(i + 1)) 
                                        .toDispatch(); 
                        Dispatch.call(table,  "Select" ); 
                        Dispatch.call(word,  "Run" ,  "tableFitContent" ); 
                } 
        } 

         /** *//** 
         * 设置当前选定内容的字体 
         *     
         * @param boldSize 
         * @param italicSize 
         * @param underLineSize 下划线 
         * @param colorSize 字体颜色 
         * @param size 字体大小 
         * @param name 字体名称 
         */  
         public   void  setFont( boolean  bold,  boolean  italic,  boolean  underLine, 
                        String colorSize, String size, String name) { 
                Dispatch font = Dispatch.get(selection,  "Font" ).toDispatch(); 
                Dispatch.put(font,  "Name" ,  new  Variant(name)); 
                Dispatch.put(font,  "Bold" ,  new  Variant(bold)); 
                Dispatch.put(font,  "Italic" ,  new  Variant(italic)); 
                Dispatch.put(font,  "Underline" ,  new  Variant(underLine)); 
                Dispatch.put(font,  "Color" , colorSize); 
                Dispatch.put(font,  "Size" , size); 
        } 

         /** *//** 
         * 文件保存或另存为 
         *     
         * @param savePath 保存或另存为路径 
         */  
         public   void  save(String savePath) { 
                Dispatch.call( 
                                (Dispatch) Dispatch.call(word,  "WordBasic" ).getDispatch(), 
                                 "FileSaveAs" , savePath); 
        } 

         /** *//** 
         * 关闭当前word文档 
         *     
         */  
         public   void  closeDocument() { 
                 if  (doc !=  null ) { 
                        Dispatch.call(doc,  "Save" ); 
                        Dispatch.call(doc,  "Close" ,  new  Variant(saveOnExit)); 
                        doc =  null ; 
                } 
        } 

         /** *//** 
         * 关闭全部应用 
         *     
         */  
         public   void  close() { 
                closeDocument(); 
                 if  (word !=  null ) { 
                        Dispatch.call(word,  "Quit" ); 
                        word =  null ; 
                } 
                selection =  null ; 
                documents =  null ; 
        } 

         /** *//** 
         * 打印当前word文档 
         *     
         */  
         public   void  printFile() { 
                 if  (doc !=  null ) { 
                        Dispatch.call(doc,  "PrintOut" ); 
                } 
        } 

         public   static   void  main(String args[]) throws  Exception { 
     
     

                MSWordManager msWordManager =  new  MSWordManager( true ); 
                msWordManager.createNewDocument(); 

                 
                 
                msWordManager.insertText( "aaaaaaaaaaaaaaaaaaaaa" ); 
                msWordManager.moveEnd(); 

             
                 
             
                msWordManager.close(); 

        } 
         
         
}

3.对于复杂但是内容不多的还有种方式，代码结合freemarker来更灵活的处理，我尝试失败了因为string等装载不了，用byte数组装经过测试服务器负荷太大。但此方法可行。

/**  
* @Title: DocumentWordHandler.java
* @Package cn.com.c**h.business.s**ip.common
* @Description: TODO()
* @author TravisTang 
* @eMail t**@***.com.cn  
* @date Nov 20, 2013 7:53:03 PM
* @version V1.0  
*/

package cn.com.c**sh.business.s**ip.common;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import java.util.Map;

import cn.com.ch***s*.portal.Constants;
import freemarker.template.Configuration;
import freemarker.template.Template;
import freemarker.template.TemplateException;

/**
 * @ClassName: DocumentWordHandler
 * @Description: TODO(//2014.01.03 废弃的XML替换方案,不删除作为参考和后续可能使用的方案)
 * @author TravisTang
 * @date Nov 20, 2013 7:53:03 PM
 *
 */

public class DocumentWordHandler {
	
	private Configuration configuration = null;     
	private String templateName = "XX计划 -总装模板.xml";
	private String ZZHeadName = "总装头部.txt";
	private String ZZOffalName = "总装尾部.txt";
	private String ZZReplaceName = "总装替换.txt";
	
	private static final freemarker.template.Configuration fmConfig=new freemarker.template.Configuration();
	static {
		fmConfig.setDefaultEncoding("GBK");
	}
	
	public String createDoc(Map map){       
		
		//要填入模本的数据文件        
		getData(map);  
		
		//获取组装完毕的文件的路径
		File file = jointXML();
		
		Template t=null;   
		try {
//			configuration.setClassForTemplateLoading(this.getClass(), "");  //1.直接获取模板文件
			configuration.setDirectoryForTemplateLoading(file);//3.生成File获取模板
			t = configuration.getTemplate("prepareDate.xml");//3.
//			t = configuration.getTemplate(prepareNmae);//1.直接获取模板文件
//			t = createTemplateByContent(newTemplate);//2.根据重写加载器获取变量模板   由于文件字节过大,摒弃,备用
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		//输出文档路径及名称        
		String filePath = "/upfiles/SXP/X计划 -总装导出.doc";
//		String filePath = "/upfiles/SXP/Qua1_"+
//			(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())).replaceAll(":","-")+".doc";
		String savePath = Constants.FCKEDITOR_UPLOAD_FILE_DIR;
		if(savePath.endsWith("\\upfiles\\")){
			savePath = savePath.substring(0, savePath.lastIndexOf("\\upfiles\\"));
		}
		File outFile = new File(savePath+filePath);
		System.out.println("File path:---------------" + savePath+filePath);
		
		Writer out = null;
		try {
			out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(outFile),"UTF-8"));
		} catch (FileNotFoundException e1) {
				e1.printStackTrace();
		} catch (Exception e) {
			// TODO: handle exception
		} 
		
		try {
			t.process(map, out);
			out.close();
		} catch (TemplateException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();     
		}
		
		return savePath+filePath;
	}
	
	/**
	 * @Title: jointXML 
	 * @Description: TODO(组装XML)
	 * @author TravisTang
	 * @date Dec 18, 2013 9:31:03 PM
	 */
	public File jointXML(){
		String filePath = "/upfiles/SXP/prepareDate.xml";
		String savePath = Constants.FCKEDITOR_UPLOAD_FILE_DIR;
		if(savePath.endsWith("\\upfiles\\")){
			savePath = savePath.substring(0, savePath.lastIndexOf("\\upfiles\\"));
		}
		//创建XML
		File file = null;
		try {
			file = createXmlFile(savePath+filePath);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		/******   文件读写开始   ******/
		System.out.println("【Start to write All XML】");
		long t1 = System.currentTimeMillis();
		//读取XML头部并写入文件
		readXML(ZZHeadName,file);
		
		//获取已替换的XML中部
		Long tx1 = System.currentTimeMillis();
		String XMLContent = EditXML(ZZReplaceName);
		//给予一分钟读写时间再开始下一段读写
		for(int i=tx1.intValue();i<tx1.intValue()+60;i++){}
		//将中部写入XML
		readXML(ZZReplaceName,file);
		writeDoc(file, XMLContent);
		
		//读取XML尾部并写入文件
		readXML(ZZOffalName,file);
		long t2 = System.currentTimeMillis();
		System.out.println("【End to write All XML, time:" + (t2 - t1) + "(ms)】");
		/******   文件读写完毕   ******/
		
		return file;
	}
	
	/**
	 * @Title: EditXML 
	 * @Description: TODO(根据数据编辑XML替换部分)
	 * @author TravisTang
	 * @date Dec 18, 2013 6:42:47 PM
	 */
	public String EditXML(String replaceName){
		BufferedReader br = null;
		try {
			 br = new BufferedReader(
					new InputStreamReader(this.getClass().getResourceAsStream(replaceName),"UTF-8"));
		} catch (UnsupportedEncodingException e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		
		StringBuilder sbu = new StringBuilder();
		String line;
		
		try {
			while ((line = br.readLine()) != null) {
				sbu.append(line);
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} 
		String afterReplace = sbu.toString().replace("${No}", "${No1}")
											.replace("${executableUnit}", "${executableUnit1}")
											.replace("${operationDesc}", "${operationDesc1}")
											.replace("${fileNo}", "${fileNo1}")
											.replace("${fileVersion}", "${fileVersion1}")
											.replace("${operationContent}", "${operationContent1}")
											.replace("${qualityGradeAndDate}", "${qualityGradeAndDate1}")
											.replace("${controlPoint1}", "${controlPoint11}")
											.replace("${controlPoint2}", "${controlPoint21}")
											.replace("${controlPoint3}", "${controlPoint31}")
											.replace("${remark}", "${remark1}");
		return afterReplace;
	}
	
	/**
	 * @Title: readXML 
	 * @Description: TODO(Read XML for generate Doc.)
	 * @author TravisTang
	 * @date Dec 18, 2013 4:49:52 PM
	 */
	public void readXML(String fileName,File file){
		System.out.println("【Start to readXML】");
		long t1 = System.currentTimeMillis();
		BufferedReader br = null;
		try {
			 br = new BufferedReader(
					new InputStreamReader(this.getClass().getResourceAsStream(fileName),"UTF-8"));
		} catch (UnsupportedEncodingException e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		
		StringBuilder sbu = new StringBuilder();
		String line;
		
		OutputStream out = null;
		try {
			out = new FileOutputStream(file);
			
			try {
				while ((line = br.readLine()) != null) {
					//按行读取文件并写入XML
					out.write(line.getBytes("UTF-8"));
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} catch (Exception ex) {
			//
			ex.printStackTrace();
		} finally {
			if (out != null) {
				try {
					out.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		long t2 = System.currentTimeMillis();
		System.out.println("【End to readXML, time:" + (t2 - t1) + "(ms)】");
	}
	
	
	/**
	 * 将内容写入文件 
	 * @param file
	 * @param str
	 */
	private void writeDoc(File file, String str) {
		System.out.println("【Start to writeDoc】");
		long t1 = System.currentTimeMillis();
		OutputStream out = null;
		try {
			out = new FileOutputStream(file);
			out.write(str.getBytes("UTF-8"));
		} catch (Exception ex) {
			//
			ex.printStackTrace();
		} finally {
			if (out != null) {
				try {
					out.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		long t2 = System.currentTimeMillis();
		System.out.println("【End to writeDoc, time:" + (t2 - t1) + "(ms)】");
	}

	/**
	 *  创建文件
	 * @param path
	 * @return
	 * @throws IOException
	 */
	private File createXmlFile(String path) throws IOException {
		File file = new File(path);
		if (!file.exists()) {
			file.createNewFile();
		}
		return file;
	}
	
	
	/**     
	 * 注意dataMap里存放的数据Key值要与模板中的参数相对应     
	 * @param dataMap     */    
	private void getData(Map dataMap){
		dataMap.put("sfpName", "a18"); 
		dataMap.put("quNum", "a1");        
		dataMap.put("workorderNo", "a2");        
		dataMap.put("deviceName", "a3");        
		dataMap.put("tagNum", "a4");        
		dataMap.put("qualityClass", "a5");        
		dataMap.put("version", "a6");        
		dataMap.put("No", "a7");        
		dataMap.put("executableUnit", "a8");        
		dataMap.put("operationDesc", "a9"); 
		dataMap.put("fileNo", "a10"); 
		dataMap.put("fileVersion", "a11"); 
		dataMap.put("operationContent", "a12"); 
		dataMap.put("qualityGradeAndDate", "a13"); 
		dataMap.put("controlPoint1", "a14"); 
		dataMap.put("controlPoint2", "a15"); 
		dataMap.put("controlPoint3", "a16"); 
		dataMap.put("remark", "a17"); 
		dataMap.put("No1", "a71");        
		dataMap.put("executableUnit1", "a81");        
		dataMap.put("operationDesc1", "a91"); 
		dataMap.put("fileNo1", "a101"); 
		dataMap.put("fileVersion1", "a111"); 
		dataMap.put("operationContent1", "a121"); 
		dataMap.put("qualityGradeAndDate1", "a131"); 
		dataMap.put("controlPoint11", "a141"); 
		dataMap.put("controlPoint21", "a151"); 
		dataMap.put("controlPoint31", "a161"); 
		dataMap.put("remark1", "a171"); 
	}
	
	public static Template createTemplateByContent(String content) throws IOException 
	{ 
		Configuration configuration = new Configuration(); 
		configuration.setTemplateLoader(new StringFreemarkerTemplateLoader(content)); 
		configuration.setDefaultEncoding("UTF-8"); 
		return configuration.getTemplate("");  
	} 

}