有一段时间没有来更新文章了,呵呵,最近在研究系统的架构,为下一期系统做前期准备.准备采用spring+ibatis+JSF的架构.我个人目前只了解spring+ibatis这两层,因此这里也只讨论关于这两层的结合.
下图为工程目录:

(1)首先是spring的配置文件: applicationContext.xml

<?xmlversion="1.0"encoding="UTF-8"?>

<!DOCTYPEbeansPUBLIC"-//SPRING//DTD BEAN 2.0//EN""http://www.springframework.org/dtd/spring-beans-2.0.dtd">

<beans>

    <beanid="propertyConfigurer"class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

       <propertyname="locations">

           <list>

              <value>com/conf/jdbc.properties</value><!—数据库配置-->

           </list>

       </property>

    </bean>

    <beanid="dataSource"class="org.springframework.jndi.JndiObjectFactoryBean">

       <propertyname="jndiName"value="${dataSource}"/>

    </bean>   

    <beanid="sqlMapClient"class="org.springframework.orm.ibatis.SqlMapClientFactoryBean">

       <propertyname="configLocation"value="com/ibatis/sql-map-config.xml"/>

    </bean>

    <beanid="sqlMapDAO"class="com.doone.database.SqlMapClientDAO">

       <propertyname="dataSource"ref="dataSource"/>

       <propertyname="sqlMapClient"ref="sqlMapClient"/>

    </bean>

    <beanid="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

       <propertyname="dataSource"ref="dataSource"/>

    </bean>

</beans>

(2) jdbc.properties配置文件(配置数据源dataSource)

dataSource=test

(3) IbatisDAO接口

package com.doone.database;

import java.util.HashMap;

import java.util.List;

publicinterface IbatisDAO {

     /**

       *查询数据库转换成List

       *@paramsqlMapIdString

       *@returnList

       */

     public List ibatisQueryForList(String sqlMapId, Object parameter);

     public List ibatisQueryForList(String sqlMapId);

     //类似在这里实现删除,更新的方法.

}

(4) SqlMapClientDAO类

package com.doone.database;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Vector;

import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;

public class SqlMapClientDAO extends SqlMapClientDaoSupport implements IbatisDAO{

        /**

          * 查询数据库转换成List

          * @param sqlMapId String

          * @param parameter Object

          * @return List

          */

        public List ibatisQueryForList(String sqlMapId, Object parameter) {

           List list = null;

           try {

                  list = (List) getSqlMapClientTemplate().queryForList(sqlMapId, parameter);

           }

           catch (Exception er) {

             //log4j.log4jInfo("Ibatis操作出错,原因:", er.getMessage());

           }

           if (list == null)

             list = new ArrayList();

           return list;

        }

        /**

          * 查询数据库转换成List

          * @param sqlMapId String

          * @return List

          */

        public List ibatisQueryForList(String sqlMapId) {

           return ibatisQueryForList(sqlMapId, null);

        }

}

(5)sql-map-config.xml配置文件

<?xmlversion="1.0"encoding="UTF-8"?>

<!DOCTYPEsqlMapConfigPUBLIC"-//iBATIS.com//DTD SQL Map Config 2.0//EN"

    "http://www.ibatis.com/dtd/sql-map-config-2.dtd">

<sqlMapConfig>

    <sqlMapresource="com/ibatis/Account.xml"/>

</sqlMapConfig>

(5) Account.xml配置文件

<?xmlversion="1.0"encoding="UTF-8"?>

<!DOCTYPEsqlMapPUBLIC"-//iBATIS.com//DTD SQL Map 2.0//EN""http://www.ibatis.com/dtd/sql-map-2.dtd">

<sqlMapnamespace="Account">

 <selectid="getList"parameterClass="java.util.HashMap"resultClass="java.util.HashMap">

    select username as value from signon

 </select>

</sqlMap>

Signon为数据库的一张表

(6)测试类Main.java

package com.main;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.doone.database.IbatisDAO;

import java.util.*;

public class Main {

       private ApplicationContext context;

       public void run()

       {

              System.out.println("初始化环境.....");

              context=new ClassPathXmlApplicationContext("com/conf/applicationContext.xml");

              System.out.println("获取 sqlMapDAO.....");

              IbatisDAO sqlMapDAO=(IbatisDAO)context.getBean("sqlMapDAO");

              list=sqlMapDAO.ibatisQueryForList("getList");

              System.out.println("查询结果为:"+list);

       }

       public static void main(String[] args)

       {

              new Main().run();

       }

}

package com.proxy;

import java.lang.reflect.*;
import java.util.logging.Logger;
import java.util.logging.Level;
import org.springframework.aop.AfterReturningAdvice;

public class LogAfterAdvice  implements AfterReturningAdvice{

 private Logger logger=Logger.getLogger(this.getClass().getName());
 public void afterReturning(Object object,Method method,Object[] args,Object target) throws Throwable
 {
  logger.log(Level.INFO,"LogAfterAdvice mehtod ends "+method);
 }

}
(2)advice-config.xml修改如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
 <bean id="logBeforeAdvice" class="com.proxy.LogBeforeAdvice" />
    <bean id="logAfterAdvice" class="com.proxy.LogAfterAdvice" />
 <bean id="helloSpeaker" class="com.proxy.HelloSpeaker" />
 
 <bean id="helloProxy"
  class="org.springframework.aop.framework.ProxyFactoryBean"><!--建立代理对象-->
  <property name="proxyInterfaces"><!--代理接口-->
   <value>com.proxy.IHello</value>
  </property>
  <property name="target"><!--代理目标-->
   <ref bean="helloSpeaker"/>
  </property>
  <property name="interceptorNames"><!--代理实现类-->
   <list>
    <value>logBeforeAdvice</value>
    <value>logAfterAdvice</value>
   </list>
  </property>
 </bean>
 
</beans>

这样就实现了目标对象的方法在执行之后被调用。


同样，在方法执行前后调用目标对象的方法也可以不通过上面的这种方式(毕竟实现两个接口比较麻烦)，可以直接通过实现MethodInterceptor接口，达到目的。
如LogInterceptor类便实现了这样的接口，如下
(3)LogInterceptor.java

package com.proxy;

import java.util.logging.Logger;
import java.util.logging.Level;
import org.aopalliance.intercept.*;

public class LogInterceptor  implements MethodInterceptor{

 private Logger logger=Logger.getLogger(this.getClass().getName());

 public Object invoke(MethodInvocation Invocation) throws Throwable {
  
  logger.log(Level.INFO,"LogInterceptor method starts..."+Invocation.getMethod());
  
  Object result=null;
  
  try
  {
   result=Invocation.proceed();
  }
  finally
  {
   logger.log(Level.INFO,"LogInterceptor method ends..."+Invocation.getMethod());
  }
  return result;
 }

}

(4)advice-config.xml 配置文件修改如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
 <bean id="logInterceptor" class="com.proxy.LogInterceptor" />
 <bean id="helloSpeaker" class="com.proxy.HelloSpeaker" />
 
 <bean id="helloProxy"
  class="org.springframework.aop.framework.ProxyFactoryBean"><!--建立代理对象-->
  <property name="proxyInterfaces"><!--代理接口-->
   <value>com.proxy.IHello</value>
  </property>
  <property name="target"><!--代理目标-->
   <ref bean="helloSpeaker"/>
  </property>
  <property name="interceptorNames"><!--代理实现类-->
   <list>
    <value>logInterceptor</value>
   </list>
  </property>
 </bean>
 
</beans>

通过实现MethodInterceptor接口，同样实现了这样的功能。

package com.proxy;

import java.lang.reflect.*;
import java.util.logging.Logger;
import java.util.logging.Level;
import org.springframework.aop.MethodBeforeAdvice;;

public class LogBeforeAdvice  implements MethodBeforeAdvice{

 private Logger logger=Logger.getLogger(this.getClass().getName());
 public void before(Method method,Object[] args,Object target) throws Throwable
 {
  logger.log(Level.INFO,"mehtod starts "+method);
 }
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
 <bean id="logBeforeAdvice" class="com.proxy.LogBeforeAdvice" />
 <bean id="helloSpeaker" class="com.proxy.HelloSpeaker" />
 
 <bean id="helloProxy"
  class="org.springframework.aop.framework.ProxyFactoryBean"><!--建立代理对象-->
  <property name="proxyInterfaces"><!--代理接口-->
   <value>com.proxy.IHello</value>
  </property>
  <property name="target"><!--代理目标-->
   <ref bean="helloSpeaker" />
  </property>
  <property name="interceptorNames"><!--代理实现类-->
   <list>
    <value>logBeforeAdvice</value>
   </list>
  </property>
 </bean>
 
</beans>
(3)测试类SpringAOPDemo

package com.proxy;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class SpringAOPDemo {
 public static void main(String[] args)
 {
  //读取配置文件
  ApplicationContext context=new FileSystemXmlApplicationContext("advice-config.xml");
  IHello helloProxy=(IHello)context.getBean("helloProxy");
  helloProxy.hello("ducklyl");
  
 }
}

运行测试类，结果如下：
Hello,ducklyl

package com.proxy;
/**
 * 接口
 *
 * **/
public interface IHello {
 public void hello(String name);

}
(2)实现类HelloSpeaker

package com.proxy;

public class HelloSpeaker implements IHello{

 public void hello(String name) {
  System.out.println("Hello,"+name);
  
 }

}
(3)代理类HelloProxy

package com.proxy;
import java.util.logging.*;
/**
 * 静态代理类,代理真正的实现类HelloSpeaker来执行
 *
 * */
public class HelloProxy implements IHello{

 private Logger logger=Logger.getLogger(this.getClass().getName());
 
 private IHello helloObject;//接口声明

 //构造函数
 public HelloProxy(IHello helloObject)
 {
  this.helloObject=helloObject;
 }
 //接口实现方法
 public void hello(String name)
 {
  log("hello methods starts...");
  helloObject.hello(name);
  log("hello methods ends...");
 }
 private void log(String msg)
 {
  logger.log(Level.INFO,msg);
 }

}

(4)测试类ProxyDemo

package com.proxy;

public class ProxyDemo {
 public static void main(String[] args)
 {
  //静态代理模式
  HelloProxy proxy=new HelloProxy(new HelloSpeaker());
  proxy.hello("ducklyl");
 }

}
运行测试类，结果为：
Hello,ducklyl
2007-10-28 10:52:26 com.proxy.HelloProxy log
信息: hello methods starts...
2007-10-28 10:52:27 com.proxy.HelloProxy log
信息: hello methods ends...



接下来介绍动态代理
(1)创建动态代理类LogHandler

package com.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.logging.*;
/**
 *
 * 动态代理类
 * **/

public class LogHandler implements InvocationHandler {

 private Logger logger = Logger.getLogger(this.getClass().getName());

 private Object delegate;

 public LogHandler()
 {
 }
 
 public Object bind(Object delegate) {
  this.delegate = delegate;
  log("bind starts...");
  return Proxy.newProxyInstance(delegate.getClass().getClassLoader(),
    delegate.getClass().getInterfaces(), this);
 }

 public Object invoke(Object proxy, Method method, Object[] args)
   throws Throwable {
  Object result = null;
  try {
   log("method starts..." + method);
   result = method.invoke(delegate, args);
   log("method ends..." + method);
  } catch (Exception e) {
   log(e.toString());
  }
  return null;
 }

 private void log(String msg) {
  logger.log(Level.INFO, msg);
 }

}
(2)创建测试类ProxyTest

package com.proxy;

public class ProxyTest {
 public static void main(String[] args)
 {
  LogHandler logHandler=new LogHandler();
  //logHandler代理HelloSpeaker实例，调用hello
  IHello helloProxy=(IHello)logHandler.bind(new HelloSpeaker());
  helloProxy.hello("ducklyl");
 }

}

运行测试类，结果为：
Hello,ducklyl
2007-10-28 11:24:59 com.proxy.LogHandler log
信息: bind starts...
2007-10-28 11:24:59 com.proxy.LogHandler log
信息: method starts...public abstract void com.proxy.IHello.hello(java.lang.String)
2007-10-28 11:24:59 com.proxy.LogHandler log
信息: method ends...public abstract void com.proxy.IHello.hello(java.lang.String)

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
 <property name="basename">
    <value>duck</value> <!-- 资源文件名前缀 -->
 </property>
</bean>

</beans>
(2)创建资源文件duck_en_US.properties,duck_zh_CN.properties两个文件
duck_en_US.properties内容为：
ducklyl=User {0} login at {1}

duck_zh_CN.properties内容(经过JDK工具native2ascii)编码转换为:
ducklyl=\u7528\u6237 {0} \u4e8e {1} \u767b\u9646

(3)创建测试类

package com.resource;

import java.util.*;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class SpringTest {
 public static void main(String[] args)
 {
 //读取配置文件
 ApplicationContext context=new FileSystemXmlApplicationContext("src/com/resource/resource-config.xml");
 
 //传入两个参数,替换资源文件{0},{1}
 String[] para=new String[]{"王生生",Calendar.getInstance().getTime().toString()};
 
 System.out.println(context.getMessage("ducklyl", para,Locale.US));
 System.out.println(context.getMessage("ducklyl", para,Locale.CHINA));
 
}
}

如果以上配置正确，运行结果为：

User 王生生 login at Thu Oct 25 19:15:59 CST 2007
用户 王生生 于 Thu Oct 25 19:15:59 CST 2007 登陆

package com.editor;

public class User {
 private String name;
 private int number;
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getNumber() {
  return number;
 }
 public void setNumber(int number) {
  this.number = number;
 }

}

package com.editor;

public class HelloBean {
 private String helloWord;
 private User user;
 public String getHelloWord() {
  return helloWord;
 }
 public void setHelloWord(String helloWord) {
  this.helloWord = helloWord;
 }
 public User getUser() {
  return user;
 }
 public void setUser(User user) {
  this.user = user;
 }

}
(3)创建UserEditor 类

package com.editor;
import java.beans.PropertyEditorSupport;

public class UserEditor extends PropertyEditorSupport{
 public void setAsText(String text)
 {
  String[] strs=text.split(",");
  int number=Integer.parseInt(strs[1]);
  
  User user=new User();
  user.setName(strs[0]);
  user.setNumber(number);
  
  setValue(user);
 }

}

(4)在类路径下创建property-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
 <bean id="EditorConfigBean"
  class="org.springframework.beans.factory.config.CustomEditorConfigurer">
  <property name="customEditors"><!--CustomEditorConfigurer类会加载"customEditors"属性设定的map-->
   <map>
    <entry key="com.editor.User">
     <bean id="userEditor" class="com.editor.UserEditor" />
    </entry>
   </map>
  </property>
 </bean>

 <bean id="helloBean" class="com.editor.HelloBean">
  <property name="helloWord">
   <value>Hello!</value>
  </property>
  <property name="user">
   <value>ducklyl,123456</value>
  </property>
 </bean>

</beans>
(5)创建测试类

package com.editor;

import org.springframework.context.*;
import org.springframework.context.support.*;

public class SpirngTest {
 public static void main(String[] args)
 {
  //读取配置文件
  ApplicationContext context=new FileSystemXmlApplicationContext("property-config.xml");
  //获取id="helloBean"对象
  HelloBean hello=(HelloBean)context.getBean("helloBean");
  //调用helloBean对象getHelloWord()方法
  System.out.println(hello.getHelloWord());
  System.out.println("Name:"+hello.getUser().getName());
  System.out.println("Number:"+hello.getUser().getNumber());
 }

}
如果以上正确设置，运行结果为：
Hello!
Name:ducklyl
Number:123456

public class ObjectSet {
 private String name;

 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public String toString()
 {
  return name;
 }
}
(2)创建SomeBean类
package com.set;

import java.util.List;
import java.util.Map;

public class SomeBean {
 private String[] someStrArray;
 private ObjectSet[] someObjArray;
 private List someList;
 private Map someMap;
 public SomeBean()
 {}
 public List getSomeList() {
  return someList;
 }
 public void setSomeList(List someList) {
  this.someList = someList;
 }
 public Map getSomeMap() {
  return someMap;
 }
 public void setSomeMap(Map someMap) {
  this.someMap = someMap;
 }
 public ObjectSet[] getSomeObjArray() {
  return someObjArray;
 }
 public void setSomeObjArray(ObjectSet[] someObjArray) {
  this.someObjArray = someObjArray;
 }
 public String[] getSomeStrArray() {
  return someStrArray;
 }
 public void setSomeStrArray(String[] someStrArray) {
  this.someStrArray = someStrArray;
 }
}
(3)在类路径下，创建set-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="first_object" class="com.set.ObjectSet" >
 <property name="name">
    <value>ducklyl</value>
 </property>
</bean>
<bean id="second_object" class="com.set.ObjectSet" >
 <property name="name">
    <value>wangsp</value>
 </property>
</bean>

<bean id="someBean" class="com.set.SomeBean" >
 <property name="someStrArray">
    <list>
     <value>Hello</value>
     <value>Welcome</value>
    </list>
 </property>
 <property name="someObjArray">
  <list>
   <ref bean="first_object"/>
   <ref bean="second_object"/>
  </list>
 </property>
 <property name="someList">
  <list>
   <value>ListTest</value>
   <ref bean="first_object"/>
   <ref bean="second_object"/>
  </list>
 </property>
 <property name="someMap">
  <map>
   <entry key="first">
    <value>Hello,ducklyl!</value>
   </entry>
   <entry key="second">
    <ref bean="first_object"/>
   </entry>
  </map>
 </property>
</bean>
</beans>
(4)创建测试类SpringTest

package com.set;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import java.util.*;

public class SpringTest {
 public static void main(String[] args)
 {
 //读取配置文件
 ApplicationContext context=new FileSystemXmlApplicationContext("set-config.xml");
 //获取id="setBean"对象
 SomeBean someBean=(SomeBean)context.getBean("someBean");
 
    //获取someStrArray,someObjArray
 String[] strs=someBean.getSomeStrArray();
 ObjectSet[] some=someBean.getSomeObjArray();
 
 for(int i=0;i<strs.length;i++)
 System.out.println(strs[i]+","+some[i]);
 
    //获取someList
 List someList=(List)someBean.getSomeList();
 for(int i=0;i<someList.size();i++)
  System.out.println(someList.get(i));
 
 //获取someMap
 Map someMap=someBean.getSomeMap();
 System.out.println(someMap);
 
}
}

如果以上配置正确，运行测试程序，结果如下：
Hello,ducklyl
Welcome,wangsp
ListTest
ducklyl
wangsp
{first=Hello,ducklyl!, second=ducklyl}

package example;

public interface Basic {
   public String hello(); //与服务端的hello方法对应
}
(2)服务端实现类

package example;

public class BasicService implements Basic {
  private String _greeting = "Hello,ducklyl!";

  public void setGreeting(String greeting)
  {
    _greeting = greeting;
  }

  public String hello()
  {
    return _greeting;
  }
}

package example;

import com.caucho.hessian.client.HessianProxyFactory;
/**  
 * <p>Title: hessian实现远程调用</p>  
 * <p>Copyright: Copyright (c) 2007</p>  
 * @author ducklyl  
 * @version 1.0  
 */  
public class BasicClient {
  public static void main(String []args)
    throws Exception
  {
    String url = "http://127.0.0.1:8080/Hessian/ducklyl";
    //创建factory实例
    HessianProxyFactory factory = new HessianProxyFactory();
    //客户端需实现Basic接口
    Basic basic = (Basic) factory.create(Basic.class, url);

    System.out.println("Hessian: " + basic.hello());
  }
}

(4) web.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app
    PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
    "http://java.sun.com/dtd/web-app_2_3.dtd">
 <web-app>
  <servlet>
   <servlet-name>ducklyl</servlet-name>
   <servlet-class>com.caucho.hessian.server.HessianServlet</servlet-class>
    <init-param>
      <param-name>home-class</param-name>
      <param-value>example.BasicService</param-value>
    </init-param>
    <init-param>
      <param-name>home-api</param-name>
      <param-value>example.Basic</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
 <servlet-name>ducklyl</servlet-name>
    <url-pattern>/ducklyl</url-pattern>
  </servlet-mapping>
</web-app>

 运行客户端程序BasicClient ，如果以下配置没问题，输出结果为：

package com.ducklyl;

public class HelloBean {
 private String helloWord;

 public String getHelloWord() {
  return helloWord;
 }

 public void setHelloWord(String helloWord) {
  this.helloWord = helloWord;
 }

}

(2)创建Spring配置文件：beans-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
<bean id="helloBean" class="com.ducklyl.HelloBean">
 <property name="helloWord">
    <value>Hello,ducklyl!</value>
 </property>
</bean>

</beans>

(3)导入Spring所需的包：commons-logging.jar，spring.jar 。(日志包和Spring包)
包下载地址：
http://www.blogjava.net/Files/ducklyl/Spring.rar
(4)创建测试类：SpringDemo.java

package com.ducklyl;

import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.*;

public class SpringDemo{
 public static void main(String[] args)
 {
  //读取配置文件
  Resource rs=new FileSystemResource("beans-config.xml");
  //实例化Bean工厂
  BeanFactory factory=new XmlBeanFactory(rs);
  
  //获取id="helloBean"对象
  HelloBean hello=(HelloBean)factory.getBean("helloBean");
  //调用helloBean对象getHelloWord()方法
  System.out.println(hello.getHelloWord());
 }

}

如果以上配置正确的话，运行SpringDemo.java，可以看到输出结果：Hello,ducklyl！

　　从技术的角度来说，有必要提一下我们的调试环境。我们使用的是Windows XP操作系统，安装有JAVA 2 SDK 1.4.1，Apache SOAP 2.3.1，JAF 1.0.2，JAVAMAIL 1.3.1和Xerces 2.6.0。上面所提及的都能在Tcomcat 4.1.29 JSP/Servlet容器中正常运行。所有的软件都是免费自由软件，因此你能够很容易的下载它们并自己在任何你喜欢的平台如Windows或UNIX上安装它们。Java SDK，JAF和JAVAMAIL位于SUN的官方网站(http://java.sun.com)，其他的软件在Jakarta项目组的官方网站(http://jakarta.apache.org)上有down的。

　　可能你在看到我们需要这么多不同的包(package)时已经有点担心和不安了，但是实际上你不应该担心这些的。一旦你懂了基础，那么对你将相当容易。安装不是一件很难的事情，你只需要在设置环境变量的时候仔细些，比如CATALINA_HOME, CLASSPATH, JAVA_HOME 等等，所有这些步骤都是手工的。由于我仅仅是想将你的注意力再次集中到它们身上，所以你能很快的就完成以上配置过程。我只是添加下面的一些字符串到Tomcat的bin/setclasspath.bat文件中:

set CATALINA_HOME=C:\Tomcat4.1.29
set CLASSPATH=%JAVA_HOME%\lib\tools.jar
set CLASSPATH=%JAVA_HOME%\soap-2.3.1\lib\soap.jar
set CLASSPATH=%CLASSPATH%;%JAVA_HOME%\javamail-1.3.1\mail.jar
set CLASSPATH=%CLASSPATH%;%JAVA_HOME%\jaf-1.0.2\activation.jar
set CLASSPATH=%CLASSPATH%;%JAVA_HOME%\xerces-2_6_0\xercesImpl.jar
set CLASSPATH=%CLASSPATH%;%JAVA_HOME%\xerces-2_6_0\xercesSamples.jar
set CLASSPATH=%CLASSPATH%;%JAVA_HOME%\xerces-2_6_0\xml-apis.jar
set CLASSPATH=%CLASSPATH%;%JAVA_HOME%\xerces-2_6_0\xmlParserAPIs.jar
set CLASSPATH=%CLASSPATH%;%CATALINA_HOME%\common\lib\servlet.jar
set CLASSPATH=%CLASSPATH%;%CATALINA_HOME%\common\lib\tools.jar
 

　　SOAP意思是简单对象访问协议(Simple Object Access Protocol)。的确如它的名字一样，SOAP是很简单的。它是一个基于XML的协议，允许程序组件和应用程序彼此使用一种标准的Internet协议--HTTP来通讯。SOAP是一种独立的平台，它不依赖程序语言，它是简单的，弹性的，很容易扩展的。目前，应用程序能够彼此使用一种基于DCOM和CORBA技术的远程过程调用(RPC)来进行相互通讯，但HTTP不被设计为这个目的。RPC在Internet上应用是非常困难的，它们会出现许多兼容性和安全性的问题，因为防火墙和代理服务器通常都会阻断(block)这些类型的流量。应用程序之间最好的通讯方式是通过HTTP协议，因为HTTP是支持所有Internet浏览器和服务器的。基于这个目的，SOAP协议被创建出来。
那么，它们是如何运作的呢?比如，一个应用程序(A)需要和另一个应用程序(B)在SOAP的帮助下进行彼此通讯。它们将使用下面的框架图来完成这个过程:

　　这个SOAP信封(SOAP envelope)是一个包含以下内容的XML文档:

　　正如你看到的，它是非常简单的。它看起来确实就象一个普通的信封或者你的email。你想看看它们是如何动作的吗?下面跟我们一起来吧。其实我们有很多方法是不用SOAP来在创建和运行我们自己的“Hello World”应用程序的，但是因为我们要保持它的简单性，我会给你一个它运作方式的框架图(scheme)。

　　我们的“Hello World”范例会包含一个SOAP Service。我们的SOAP Client将发送它们的名字到该SOAP Service，并试图得到一些答复或响应。这个SOAP Service需要部署到一个SOAP Admin的工具，以至重定位所有请求的SOAP(Proxy) RPC Router能够知道它们应该使用哪种服务来运作。总而言之，这个是以下面的方式来运作的:

现在，我们来一步步的看看到底发生了什么。在Step 1里，HelloWorldClient将连接一个SOAP RPC Router，请求我们的SOAP Service并将包含我们名字的一个字符串传递给它。该SOAP RPC Router会检查是否它已经部署了这个SOAP Service。如果它被发现是被部署的，那么它将传递数据到这个SOAP Service并调用特定的方法，这个是Step 2。然后SOAP Service方法会被执行，将返回某个字符串值(该值就是SOAP Client的答复或者响应)(Step 3)。在Step4中，SOAP RPC Router将仅仅只是重定向这个数据到SOAP Client。所有在Step1和Step4里传输的数据是通过SOAP Envelope来完成的。正如你所看到的，算法是相当简单的，因此我们只准备关心实际的代码。

　　首先，我们要创建一个SOAP Service。下面是它的代码，请不要忘记将它放入HelloWorld/ 目录中(必须被包含在你的CLASSPATH中):

// SOAPService.java 
　　package HelloWorld; 
　　public class SOAPService { 
　　    public String sayHi(String x) { 
　　    return("Hello my friend, " + x + "! Glad to see you!"); 
　　} 
　　}

　　Java Provider - Static? No

一些注释:ID是我们要从SOAP Client标识我们的SOAP Service的唯一名字。Method包含SOAP Service提供的一系列方法。JAVA Provider-Provider Class是SOAP Service Java类的名字。

　　现在，点击Deploy 按钮，那么你的服务会被部署。再次强调，请注意正确设置CLASSPATH环境变量。然后，你的HelloWorld.SOAPService类能够被找到，并且所有必需的jar包也能被找到。这是个几乎每个人都会犯的普通错误。现在，你能够点击 List ，将会看见你的服务已经被部署进来。恭喜!

　　最后，让我们来创建一个SOAP Client。代码看起来有点复杂，但是在现实中不会只有这么点长。

1: // HelloWorldClient.java 
　　2: import java.io.*; 
　　3: import java.net.*; 
　　4: import java.util.*; 
　　5: import org.apache.soap.*; 
　　6: import org.apache.soap.rpc.*; 
　　7: public class HelloWorldClient { 
　　8: public static void main(String[] arg) throws Exception { 
　　9: Call c = null; 
　　10: URL url = null; 
　　11: Vector params = null; 
　　12: Response rep = null; 
　　13: String ourName = "Superman"; 
　　14: String ourUrn = "urn:HelloWorld_SOAPService"; 
　　15: String ourMethod = "sayHi"; 
　　16: url = new URL("http://localhost:8080/soap/servlet/ 
　　rpcrouter"); 
　　17: System.out.println("Passing to our deployed "+ourUrn+" 
　　our name ("+ourName+"): "); 
　　18: c = new Call(); 
　　19: c.setTargetObjectURI(ourUrn); 
　　20: c.setMethodName(ourMethod); 
　　21: c.setEncodingStyleURI(Constants.NS_URI_SOAP_ENC); 
　　22: params = new Vector(); 
　　23: params.addElement(new Parameter("ourName", String.class, 
　　ourName, null)); 
　　24: c.setParams(params); 
　　25: System.out.print("and its answer is: "); 
　　26: rep = c.invoke(url, ""); 
　　27: if (rep.generatedFault()) { 
　　28: Fault fault = rep.getFault(); 
　　29: System.out.println("\nCall failed!"); 
　　30: System.out.println("Code = " + fault.getFaultCode()); 
　　31: System.out.println("String = " + fault.getFaultString()); 
　　32: } else { 
　　33: Parameter result = rep.getReturnValue(); 
　　34: System.out.print(result.getValue()); 
　　35: System.out.println(); 
　　36: } 
　　37: } 
　　38:}

下面我要做一些解释。在第13行，我们设置了我们的名字，这个名字将会传递给SOAP Service。在第14行，我们设置了我们将要调用的服务的ID(service ID)，和第15行里设置的服务方法(service method)。有了这个ID，服务能够被部署到SOAP服务管理器(SOAP Service Manager)中。我们没有设置任何其他值，仅仅只用刚才那些基础值就可以正常运作了。你能从SOAP的官方文档上得到相关信息，该文档来自SOAP包中，它们的解释超出了本文的范围。

　　用以下方式编译这个SOAP Client:

　　javac HelloWorldClient.java

　　为了圆满完成它，让我们检查一下针对我们的测试，是否所有事情都准备就绪。Tomcat正在运行，所有的环境变量都正确，SOAP Service被编译和部署，SOAP Client被成功编译。OK，让我们运行它，你将看到这个屏幕:

　　正如你所看到的，我们的SOAP Client使用SOAP协议成功发送它的名字和接收了一个答复。正如前面所说的，SOAP Service发送和接收的是SOAP envelope。这个是SOAP envelope的源代码。

　　被发送到SOAP Service的SOAP Envelope

＜?xml version=1.0 encoding=UTF-8?＞
＜SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/
soap/envelope/"
xmlns:xsi="http://www.w3.org/2001/
XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"＞
＜SOAP-ENV:Body＞
＜ns1:sayHi xmlns:ns1="urn:HelloWorld_SOAPService"
SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/
soap/encoding/"＞
＜ourName xsi:type="xsd:string"＞Superman＜/ourName＞
＜/ns1:sayHi＞
＜/SOAP-ENV:Body＞
＜/SOAP-ENV:Envelope＞: 

从SOAP Service接收的SOAP Envelope

＜?xml version=1.0 encoding=UTF-8?＞
＜SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/
soap/envelope/"
xmlns:xsi="http://www.w3.org/2001/
XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"＞
＜SOAP-ENV:Body＞
＜ns1:sayHiResponse xmlns:ns1="urn:HelloWorld_SOAPService"
SOAP-ENV:encodingStyle="http://schemas.xmlsoap.
org/soap/encoding/"＞
＜return xsi:type="xsd:string"＞Hello my friend, Superman!
Glad to see you!＜/return＞
＜/ns1:sayHiResponse＞
＜/SOAP-ENV:Body＞
＜/SOAP-ENV:Envelope＞ 

      
      要理解SOAP Envelope中的所有标签的含义，我建议你花一点时间阅读 http://www.w3.org/2001/06/soap-envelope 命名空间规范。

　　我希望本文能够在你理解SOAP技术上有一定帮助。这个技术是简单的，有趣的，强大的，弹性的。它被用在许多Web应用中，这些应用的数量也在不断增加。学习SOAP是值得的，至少你要知道它是什么和它是怎么运作的。