如果大家看jquery的sourcecode就知道一开始就有两对小括号,

是什么意思呢! 真的是比较困惑, 这么神奇的代码,什么意思啊?

我们先看看jQuery一开始是怎么写的:

(function(){

// jquery 代码

})();

它是由什么组成呢? 有一个匿名函数(函数没有名字),

此匿名函数被一对小括号包裹着,这对小括号右边还有一对小括号.

我们再看常用一般函数定义方式.

//函数定义

function func1(){

alert("hello,world");

}

//调用函数

func1();

那么这两句话目的很明显就是要弹出一个"helloworld"的对话框,

那么我们可不可以合并成一句话, 也同样能达到这样的效果

当然是可以的.

(function (){

alert("hello,world"

); })();

函数名称func1都去掉了, 在函数外面加了一对小括号.

这和jquery是一样的啊! 可以看出最后面一对小括号语义就是"调用此匿名函数",

那么包裹在匿名函数外面的一对小括号可以去掉吗?

变成如下的样子

function (){

alert("hello,world");

}();

要回答这个问题,先看看javascript对表达式的评估.

dd= aa+ cc*bb javascript会先评估cc*bb,

然后才会评估aa+,这是因为地球人都知道的事情,

乘运算(*)符优先级高于加(+) 同样如果去掉这对小括号的话,

我们可以假想一下其表达式的评估过程,

javascript会先评估最后面小括号,而不是先评估匿名函数了,

那么最后面的小括号是什么语义呢! 仅当作一般运算符去处理,

并不是"此处存在函数调用"的这样一个语义,

因为在这之前并不知道有匿名函数存在(还没有评估呢),

所以在匿名函数外面加上一对小括号的话,javascript对其评估的顺序就变了,

所以答案很明显,不可以去掉匿名函数外面的一对小括号,否则其评估就会失败,

导致语法错误. 看到这里是不是豁然开朗了,呵呵! 如果讲的有错误,还请大侠们给指出来,在此谢谢了.

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 快来参加7月17日在成都举行的SOA中国技术论坛

• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

资源准备:

mysql5.0

spring-2.5

hibernate-3.2.5

junit-4.4.jar

创建表

DROP TABLE IF EXISTS `myproject`.`boys`;
CREATE TABLE  `myproject`.`boys` (
  `id` bigint(20) NOT NULL auto_increment,
  `phone` varchar(20) default NULL,
  `sex` varchar(2) default NULL,
  `address` varchar(255) default NULL,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

创建相关配置文件:

(1)applicationContext-resources.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:p="http://www.springframework.org/schema/p"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:jee="http://www.springframework.org/schema/jee"
 xmlns:tx="http://www.springframework.org/schema/tx"
 xsi:schemaLocation="
   http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
   http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
   http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd
   http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
   http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
 
 
 <!--<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  <property name="locations">
  <list>
  <value>classpath:jdbc.properties</value>
  </list>
  </property>
  </bean>
 -->
 <context:property-placeholder location="classpath:jdbc.properties" />
 <!-- =====使用dbcp 连接池 -->
 <bean id="dataSource"
  class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"
  p:driverClassName="${jdbc.driverClassName}" p:url="${jdbc.url}"
  p:username="${jdbc.username}" p:password="${jdbc.password}" />
 <!-- Hibernate SessionFactory -->
 <bean id="sessionFactory"
  class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"
  p:dataSource-ref="dataSource"
  p:mappingResources="testHibernate.hbm.xml">
  <property name="hibernateProperties">
   <props>
    <prop key="hibernate.dialect">
     ${hibernate.dialect}
    </prop>
    <prop key="hibernate.show_sql">
     ${hibernate.show_sql}
    </prop>
    <!--<prop key="hibernate.generate_statistics">
     ${hibernate.generate_statistics}
     </prop>
    -->
   </props>
  </property>
 </bean>
 <bean id="transactionManager"
  class="org.springframework.orm.hibernate3.HibernateTransactionManager"
  p:sessionFactory-ref="sessionFactory" />
 <tx:advice id="txAdvice" transaction-manager="transactionManager">
  <tx:attributes>
   <tx:method name="find*" read-only="true" />
   <tx:method name="get*" read-only="true" />
   <!-- 所有抛出异常都要回滚 -->
   <tx:method name="*" rollback-for="Throwable" />
  </tx:attributes>
 </tx:advice>

<!-- com.jmesa.test.service包下面(包括子包)后缀为Service的所有bean -->
 <aop:config>
  <aop:pointcut id="serviceOperation"
   expression="execution(* com.jmesa.test.service..*Service.*(..))" />
  <aop:advisor pointcut-ref="serviceOperation"
   advice-ref="txAdvice"/>
 </aop:config>
</beans>

(2) applicationContext-dao.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:p="http://www.springframework.org/schema/p"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:jee="http://www.springframework.org/schema/jee"
 xmlns:tx="http://www.springframework.org/schema/tx"
 xsi:schemaLocation="
   http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
   http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
   http://www.springframework.org/schema/jee htp://www.springframework.org/schema/jee/spring-jee-2.5.xsd
   http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
 
 
 <bean name="boysDAO" class="com.jmesa.test.dao.hibernate.BoysDAOImpl" autowire="byName"></bean>
</beans>

(3)jdbc.properties

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost/myproject?createDatabaseIfNotExist=true&amp;useUnicode=true&amp;characterEncoding=utf-8
jdbc.username=root
jdbc.password=root
hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
hibernate.show_sql=true

(4) boys 实体的hibernate配置文件:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"
  "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping auto-import="true" default-lazy="false">
 <class name="com.jmesa.test.model.Boy" table="boys">
  <id name="id" column="id" type="long">
   <generator class="identity"></generator>
  </id>
  <property name="phone" column="phone"></property>
  <property name="sex" column="sex"></property>
  <property name="address"></property>
 </class>
</hibernate-mapping>

创建BoysDAO 接口

package com.jmesa.test.dao;

import java.util.List;

import com.jmesa.test.common.EntityFilters;
import com.jmesa.test.common.EntitySorts;
import com.jmesa.test.model.Boy;

public interface BoysDAO {
 /**
  *
  * @param boy
  *            域对象
  */
 public void save(Boy boy);

 /**
  * 更新boy数据
  *
  * @param boy
  */
 public void update(Boy boy);

 /**
  * 依据id值获得boy域对象
  *
  * @param id
  * @return
  */
 public Boy get(String id);

 /**
  * 获得所有boy域对象
  *
  * @return
  */
 public List<Boy> getAll();

/**
  * 依据boy 属性条件查询boy列表
  *
  * @param phone
  *            空或者null值将不作为查询条件
  * @param sex
  *            空或者null值将不作为查询条件
  * @return
  */
 public List<Boy> queryBoys(String phone, String sex);

}

BoysDAO 接口实现类:

package com.jmesa.test.dao.hibernate;

import java.sql.SQLException;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Property;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import com.jmesa.test.dao.BoysDAO;
import com.jmesa.test.model.Boy;

public class BoysDAOImpl extends HibernateDaoSupport implements BoysDAO {

 public Boy get(String id) {
  return (Boy) this.getHibernateTemplate().load(Boy.class, id);
 }

 public List<Boy> getAll() {
  return queryBoys(null, null);
 }

 public List<Boy> queryBoys(String phone, String sex) {
  DetachedCriteria query = DetachedCriteria.forClass(Boy.class);
  if (phone != null && !phone.equals("")) {
   query.add(Property.forName("phone").eq(phone));
  }
  if (sex != null && !sex.equals("")) {
   query.add(Property.forName("sex").eq(sex));
  }
  return this.getHibernateTemplate().findByCriteria(query);
 }

public void save(Boy boy) {
  this.getHibernateTemplate().save(boy);

 }

public void update(Boy boy) {
  this.getHibernateTemplate().update(boy);
 }

}

开始测试:

基于AbstractTransactionalDataSourceSpringContextTests 创建测试基类:

package com.jmesa.test.integrateTest;

import org.springframework.test.AbstractTransactionalDataSourceSpringContextTests;

public class BaseDataSourceSpringContextIntegrationTest extends
  AbstractTransactionalDataSourceSpringContextTests {

//加载spring配置文件,其路径在classpath的根目录下
 private static final String[] configFiles = new String[] {
   "applicationContext-resources.xml", "applicationContext-dao.xml" };

//设置dao类的注入方式,默认为类型注入,此处改为名称注入

public BaseDataSourceSpringContextIntegrationTest() {
  this.setAutowireMode(AUTOWIRE_BY_NAME);
 }

//通过此方法提供spring配置文件

protected String[] getConfigLocations() {
  return configFiles;
 }
}

BoysDAO的测试类:

package com.jmesa.test.integrateTest;

import java.util.List;

import org.junit.Assert;
import org.junit.Test;

import com.jmesa.test.common.EntityFilters;
import com.jmesa.test.common.EntitySorts;
import com.jmesa.test.dao.BoysDAO;
import com.jmesa.test.model.Boy;

/**
 * @author   jack
 */
public class BoyDAOTest extends BaseDataSourceSpringContextIntegrationTest {
 private BoysDAO boysDAO;

public BoyDAOTest(){
 }
 /**
  * 必须要提供变量boysDAO的setter方法,这样注入才会成功
  */
 public void setBoysDAO(BoysDAO boysDAO) {
  this.boysDAO = boysDAO;
 }

@before

 public void initialize(){

 }

@after

public void destroy(){

}

@Test
 public void testGetAll(){
  int count = this.countRowsInTable("boys");
  Assert.assertEquals(boysDAO.getAll().size(),count);
 }
 @Test
 public void testQueryBoys(){
  Assert.assertEquals(0,boysDAO.queryBoys("www", "wwww").size());
  Assert.assertEquals(1,boysDAO.queryBoys("eee", "33").size());
 }
 @Test
 public void testSave(){
  int boysCount = this.countRowsInTable("boys");
  String phone ="13401108995";
  String sex = "1";
  String address = "南京路";
  Boy boy = new Boy();
  boy.setPhone(phone);
  boy.setSex(sex);
  boy.setAddress(address);
  boysDAO.save(boy);
  Assert.assertEquals(boysCount+1, this.countRowsInTable("boys")); 
 }
 @Test
 public void testGetBoysCountWithFilter(){
  EntityFilters entityFilters = new EntityFilters();
  int count = boysDAO.getBoysCountWithFilter(entityFilters);
  Assert.assertEquals(20, count);
  EntityFilters entityFilters1 = new EntityFilters();
  entityFilters1.addFilter("phone", "342432");
  int size = entityFilters1.filterSize();
  int count1 = boysDAO.getBoysCountWithFilter(entityFilters1);
  Assert.assertEquals(1, count1);
 }
 @Test
 public void testGetBoysWithFilterAndSort(){
  EntityFilters entityFilters = new EntityFilters();
  //entityFilters.addFilter("phone", "342432");
  EntitySorts entitySorts = new EntitySorts();
  entitySorts.addSort("phone", "desc");
  List<Boy> boysList = boysDAO.getBoysWithFilterAndSort(entityFilters, entitySorts, 0, 10);
  Assert.assertEquals(10, boysList.size());
  Boy boy = boysList.get(0);
  Assert.assertEquals("ww",boy.getPhone() );
  
 }
} 

此处测试用到了 AbstractTransactionalDataSourceSpringContextTests 的四方面的功能:

1. 加载spring的资源配置文件

2. dao bean 引入测试类

3. 简便的函数使用,如:countRowsInTable

4. 事务自动回滚.

请注意此BoyDAOTest测试类中使用@before,@after修饰的方法在测试中没有被执行, 可能原因是BoyDAOTest 间接继承了TestCase类,要想执行此类方法,必须沿用以前版本的junit的setUp,tearDown

方法,然而AbstractTransactionalDataSourceSpringContextTests 类已经overide此方法,并且加了final修饰,其子类不可以在overide了. 所以加入类似before,after这样的方法,目前还没有想出比较好的办法? 还请大侠们赐教.

参考文献:http://www.infoq.com/articles/testing-in-spring

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 快来参加7月17日在成都举行的SOA中国技术论坛

      当你使用struts2开发一个user实体的"增删改查"应用时，你或许是这样

来配置action

   <action name="createUser"    
             class="com.mycompany.webapp.user.UserAction" 
             method="create">
     <result name="success">/user/userCreate.jsp</result>
     <result name="input">/user/userEdit.jsp</result>
     <result name="home">/user/home.jsp</result>
  </action>

........

其所对应的url可能是这样：/app/createUser.action,/app/retrieveUser.action,

/app/updateUser.action,/app/deleteUser.action

依次类推，一个实体的"增删改查"需要重复4次这样的工作。一个实体类已有如此多配置信息。多个实体又如何呢？

那么我们可以使用struts2的另一个功能：在action标签中的name属性里指定wildcard（通配符）。

struts2提供星号(*)的通配符，以上应用我们可以这样配置：

<action name="*_*" class="com.mycompany.webapp.user.{2}Action" method="{1}">
    <result name="success">/{2}/{1}.jsp</result>
    <result name="input">/{2}/edit.jsp</result>
    <result name="home">/{2}/home.jsp</result>
</action>

其所对应的user实体的url可能是：/app/create_User.action,/app/retrieve_User.action,

/app/update_User.action,/app/delete_User.action

这样的话其它的实体也可以使用这种convention。

请注意在name属性中的分隔符显然是要有的，不然就无法区分两个星号所配置的部分

现在大概来总结一下此应用的convention：

1 action类的命名为：实体名称（大写）+Action

2 action标签中name属性的值为：方法名称＋实体名称（大写）

3 实体所对应的jsp文件放在实体名称所对应的目录里面
4 初始jsp页面文件名称定义为"home",

validatation返回页面(也就是input所定义的页面)文件名称定义为edit 
5 在success中定义的jsp文件名称为：方法名称

• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

程序测试环境：

windowsXP sp2

office2003

jacob_1.11-pre1.zip jacob开发包

package com.langchaoauto.eimip.common;

import java.util.HashMap;

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

/**
 *
 * @author zhuzhen_hua@yahoo.com.cn
 *
 */

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

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

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

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

 private boolean saveOnExit = true;

 public MSWordManager() {
  if (word == null) {
   word = new ActiveXComponent("Word.Application");
   word.setProperty("Visible", new Variant(false));
  }
  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));
 }

 /**
  * 从选定内容或插入点开始查找文本
  *
  * @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 pasteExcelSheet(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
  *            被拷贝的表格在另一格文档中的位置
  * @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(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");
  }
 }

 /**
  * 在指定行前面增加行
  *
  * @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       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       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.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[]) {
  MSWordManager msWordManager = new MSWordManager();
  try {
   msWordManager.openDocument("D:\\SUPERADMIN20061121100.doc");
   msWordManager.callWordMacro();
   
  } catch (Exception e) {
   e.printStackTrace();
  }
  msWordManager.close();
 }

}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！