<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://xfire.codehaus.org/config/1.0">

 <service>
  <name>UserService</name>
  <serviceClass>com.semovy.service.IUserService</serviceClass>
  <implementationClass>
   com.semovy.service.impl.UserServiceImpl
  </implementationClass>
  <style>wrapped</style>
  <use>literal</use>
  <scope>application</scope>
 </service>
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.4" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee   http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
  <servlet>
    <servlet-name>XFireServlet</servlet-name>
    <servlet-class>org.codehaus.xfire.transport.http.XFireConfigurableServlet</servlet-class>
    <load-on-startup>0</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>XFireServlet</servlet-name>
    <url-pattern>/services/*</url-pattern>
  </servlet-mapping>
</web-app>

 3.com.semovy.beans下建立测试类User

User.java

package com.semovy.beans;

public class User {

 private String id = "";

 private String name = "";

 private String remark = "";

 public User() {
 }

 public User(String id, String name, String remark) {
  this.id = id;
  this.name = name;
  this.remark = remark;
 }

 public String getId() {
  return id;
 }

 public void setId(String id) {
  this.id = id;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public String getRemark() {
  return remark;
 }

 public void setRemark(String remark) {
  this.remark = remark;
 }

 public String toString() {
  return "Id: " + id + " , name: " + name + " , remark: " + remark + "\n";
 }

 @Override
 public int hashCode() {
  final int PRIME = 31;
  int result = 1;
  result = PRIME * result + ((id == null) ? 0 : id.hashCode());
  result = PRIME * result + ((name == null) ? 0 : name.hashCode());
  result = PRIME * result + ((remark == null) ? 0 : remark.hashCode());
  return result;
 }

 @Override
 public boolean equals(Object obj) {
  if (this == obj)
   return true;
  if (obj == null)
   return false;
  if (getClass() != obj.getClass())
   return false;
  final User other = (User) obj;
  if (id == null) {
   if (other.id != null)
    return false;
  } else if (!id.equals(other.id))
   return false;
  if (name == null) {
   if (other.name != null)
    return false;
  } else if (!name.equals(other.name))
   return false;
  if (remark == null) {
   if (other.remark != null)
    return false;
  } else if (!remark.equals(other.remark))
   return false;
  return true;
 }
 
}

package com.semovy.service;

import java.util.List;

import com.semovy.beans.User;

public interface IUserService {
 public abstract String getStringTest(String msg1,String msg2);
 public abstract List getStringList();
 public abstract List getUsersList();
 public abstract User[] getUsersArray();
 public abstract String[] getUsersStringArray();
 public abstract User getUserById(String id);
 public abstract void addUser(User user);
}
这在接口包下建立.与服务接口相同名称的IUserService.aegis.xml


<?xml version="1.0" encoding="UTF-8"?>
<mappings>
  <mapping><!-- 返回类型是String ,String[]的,参数是String类型的方法不用定义 -->
    <method name="getStringList">
       <return-type  componentType="java.lang.String" /><!-- 返回类型对应集合Collection,数组中的元素的类型 -->
    </method>
    <method name="getUsersList">
     <return-type componentType="com.semovy.beans.User"/>
    </method>
    <method name="getUsersArray">
     <return-type componentType="com.semovy.beans.User"/>
    </method>
    <method name="getUserById">
     <return-type componentType="com.semovy.beans.User"/>
    </method> 
   </mapping>
</mappings>

package com.semovy.service.impl;

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

import com.semovy.beans.User;
import com.semovy.service.IUserService;

/**
 *
 * @author semovy
 * @version 1.0
 * the user service class implemente the IUserService implementation for testing
 */
public class UserServiceImpl implements IUserService {

 private List<User> users;
 public UserServiceImpl()
 {
  users = new ArrayList<User>();
  users.add(new User("1","semovy","semovy's remark"));
  users.add(new User("2","韦善茂","韦善茂的备注"));
  users.add(new User("3","superman_wshm","superman_wshm's remark"));
 }
 /**
  * @param msg1 the string msg1
  * @param msg2 the string msg2
  *
  */
 public String getStringTest(String msg1,String msg2) {

  return "Hello :" + msg1 + " : "  + msg2;
 }
 /**
  * @return list the list Collection with some String element
  */
 public List getStringList()
 {
  List<String> list = new ArrayList<String>();
  list.add("string1");
  list.add("字符串2");
  list.add("字符串3");
  list.add("string4");
  return list;
 }
 /**
  * @return all users
  */
 public List getUsersList() {
  return users;
 }
 /**
  * @param id the id of user
  * @return the user by specifical id
  */
 public User getUserById(String id) {
  Iterator it = users.iterator();
  while(it.hasNext())
  {
   User user = (User)it.next();
   if(user.getId().equals(id))
   {
    return user;
   }
  }
  return null;
 }
 /**
  * @return return all users of array form with type User.
  */
 public User[] getUsersArray() {
  
  return users.toArray(new User[]{new User()});
 }
 /**
  * @return return all users of array form with type String
  */
 public String[] getUsersStringArray() {
  
  User[] users_arr = (User[])users.toArray(new User[]{});
  String[] tempUser_arr = new String[users_arr.length];
  for(int i=0;i<users_arr.length;i++)
  {
   tempUser_arr[i] = users_arr[i].toString();
   System.out.println(tempUser_arr[i]);
  }
  return tempUser_arr;
 }
 public void addUser(User user) {
  users.add(user);
 }
 
}

package com.semovy.test;

import java.net.MalformedURLException;
import java.util.Iterator;
import java.util.List;

import org.codehaus.xfire.XFireFactory;
import org.codehaus.xfire.client.XFireProxyFactory;
import org.codehaus.xfire.service.Service;
import org.codehaus.xfire.service.binding.ObjectServiceFactory;

import com.semovy.beans.User;
import com.semovy.service.IUserService;

public class UserServiceWSTest {
 public static void main(String[] args) {
  // 创建服务实例
  Service srvcModel = new ObjectServiceFactory()
    .create(IUserService.class);
  XFireProxyFactory factory = // 创建代理工厂实例
  new XFireProxyFactory(XFireFactory.newInstance().getXFire());
  String helloWorldURL = "http://localhost:8000/webServiceTest/services/UserService";
  IUserService srvc = null;
  try { // 获取指定位置的web服务对象
   srvc = (IUserService) factory.create(srvcModel, helloWorldURL);
  } catch (MalformedURLException e) {
   e.printStackTrace();
  }
  
  //调用只返回String的方法.在接口名.aegis.xml中不用设置方法名
  String result = srvc.getStringTest("msg1", "msg2");
  System.out.println(result);
  //调用返回String[]数组的方法,在接口名.aegis.xml中不用设置方法名.
  String[] userInfo_str_arr = srvc.getUsersStringArray();
  for(String aUserInfo:userInfo_str_arr)
   System.out.println(aUserInfo);
  //调用返回List类型值的方法,需要定义,List容器中的元素类型为String
  List strList = srvc.getStringList();
  Iterator str_it = strList.iterator();
  while (str_it.hasNext()) {
   String str = (String) str_it.next();
   System.out.println(str);
  }
  //调用返回User[]数组
  User[] user_arr = srvc.getUsersArray();
  for (User a_user : user_arr)
   System.out.print(a_user.toString());
  
  //调用返回User类型值的方法.方法参数是字符串.
  User a_user = srvc.getUserById("2");
  System.out.print(a_user.toString());
  
  //调用参数为User的方法,没有返回值,不用配置方法
  srvc.addUser(new User("4","添加的名称","添加的备注"));
  
  //调用返回List类型值的方法,需要定义,List容器中的元素类型为User
  List userList = srvc.getUsersList();
  Iterator userList_it = userList.iterator();
  while (userList_it.hasNext()) {
   User user = (User) userList_it.next();
   System.out.print(user.toString());
  }
 }

}
5.结果:
Hello :msg1 : msg2
Id: 1 , name: semovy , remark: semovy's remark
Id: 2 , name: 韦善茂 , remark: 韦善茂的备注
Id: 3 , name: superman_wshm , remark: superman_wshm's remark
string1
字符串2
字符串3
string4
Id: 1 , name: semovy , remark: semovy's remark
Id: 2 , name: 韦善茂 , remark: 韦善茂的备注
Id: 3 , name: superman_wshm , remark: superman_wshm's remark
Id: 2 , name: 韦善茂 , remark: 韦善茂的备注
Id: 1 , name: semovy , remark: semovy's remark
Id: 2 , name: 韦善茂 , remark: 韦善茂的备注
Id: 3 , name: superman_wshm , remark: superman_wshm's remark
Id: 4 , name: 添加的名称 , remark: 添加的备注

1. HTTP Authentication
2. SOAP Header authentication with JSR181
3. SOAP authentication with handlers
4. WS-Security

// Create your client

Client client = ....;



// Or get it from your proxy

Client client = ((XFireProxy) Proxy.getInvocationHandler(myClientProxy)).getClient(); 



client.setProperty(Channel.USERNAME, "username");

client.setProperty(Channel.PASSWORD, "pass");

去忘了写服务端应该怎么做，这个username和password该在那里验证呢？？我翻遍了文档也没找着

来看第二条SOAP header authentication with JSR181，看起来倒是很简单

但是在Service的代码中每个方法里都要写一个UserToken验证的参数，虽然似乎权限粒度能控制得很细，但是这严重污染了业务逻辑的代码，非常的不优雅，放弃！

public void someOperation(String data, @WebParam(header=true) UserToken token) {
authenticate(token)

// do your normal request here
}

再看WS-Security，这是webservice的安全标准，但实在太复杂了，并且需要配置Service.xml，我们项目是Java1.5，Service.xml根本就没有写，是自动生成的，我是实在找不到Service.xml该在那配置？只好作罢

AuthenticationHandler需要修改一下，其他不用变：

AuthenticationHandler.java

import org.apache.log4j.Logger;
import org.codehaus.xfire.MessageContext;
import org.codehaus.xfire.handler.AbstractHandler;
import org.codehaus.xfire.fault.*;
import org.jdom.*;

public class AuthenticationHandler extends AbstractHandler {
    private static final Logger log = Logger.getLogger(AuthenticationHandler.class);
   
    public void invoke(MessageContext context) throws Exception {
        log.info("authentication handler is invoked");
        if (context.getInMessage().getHeader() == null)
        {
            throw new XFireFault("Request must include company authentication token.",
                                 XFireFault.SENDER);
        }
        Element header = context.getInMessage().getHeader();
        Element token = header.getChild("AuthenticationToken");
       
        if (token == null)
        {
            throw new XFireFault("Request must include authentication token.",
                                 XFireFault.SENDER);
        }

        String username = token.getChild("Username").getText();
        String password = token.getChild("Password").getText();

        try {
            // 现在你已经得到了客户端传来的username和password，那就验证它吧（可以交给acegi来验证）
            }

        }catch(Exception e) {
            log.warn(e);
            throw new XFireFault("Authentication Failed.",
                    XFireFault.SENDER);
        }
    }
}

客户端代码：

SpringSide中关于Web服务的配置是在

WEB-IBF/classes文件下的applicationContext-webservice.xml中配置的：

第一步，引入xfire.xml文件

<import resource="classpath:org/codehaus/xfire/spring/xfire.xml"/>。这样，我们就不必在web.xml中配置了,这种语法在Spring参考手册（2.0-M3）3.18节中有介绍，3.19节介绍了在web.xml配置bean定义文件的方法，就是上一节使用的方法。

第二步，处理映射，将/BookService URL和bookService这个bean联系起来。当然，这里bookService又继承了baseWebService，这样做挺巧妙，这样如果有多个Web服务bean，就继承baseWebService就可以了，这种面向对象的概念还是值得我们提倡的，Spring参考手册3.5节介绍了相关的知识。

在bookService的定义中，serviceBean也就是接口实现类为bookManager bean，这个bean实际是在WEB-INF/classes/applicationContext-manager.xml文件中所定义，类名为org.springside.bookstore.service.logic.BookManager：

serviceClass也就是接口类为

org.springside.bookstore.service.webservice.BookService：

事实上，SpringSide既是一个Web服务的提供者，又是一个Web服务的消费者。它在WEB-INF/classes/applicationContext-webservice-client.xml文件中定义了消费这个Web服务的bean：

这个消费Web服务的bean定义为BookServiceClient，它是采用Groovy脚本语言定义了。在Spring参考手册(2.0-M3)中的第25章专门介绍在Spring中脚本语言的使用，脚本语言支持是Spring 2.0新增的内容,目前可以支持Groovy、BeanShell、Jruby三种脚本语言。

这个BookServiceClient最终是在dwr中使用，可以

plugins"org.springside.ajax.dwr"webapp"WEB-INF"dwr.xml中的定义。

在SpringSide,采用Aegis的binding方式，在

plugins"org.springside.webservice.xfire"src"org"springside"bookstore"service"webservice"BookService.aegis.xml中定义了返回值的类型：

XFire在SpringSide中的应用就介绍到这里为止。

当使用JDK1.4时，或者对JDK1.5的范型和注释不是很熟悉的情况下，当遇到需要映射POJO或配置WebService接口方法返回类型(如集合类型)时，需要进行绑定，此时aegis的绑定为建立.aegis.xml的文件。

1.当封装的接口类中，某方法返回集合类型时，aegis的绑定方式：

例如，需要将以下接口封装

代码

1. public interface UserInfo {   
2.   
3.     public User findUserInfosByUserID(String userUniqueID);   
4.     public String test();   
5.     public Collection findRoleInfosByUserID(String userUniqueID);   
6.     }   
7.   

观察此接口，受限我们看findRoleInfosByUserID方法，此方法传入String,返回类型为Collection，此时，我们即需要配置findRoleInfosByUserID方法。

配置步骤，在接口类的同一包下建立和接口名相同的aegis.xml文件，即UserInfo.aegis.xml文件。

UserInfo.aegis.xml

代码

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <mappings>  
3.     <mapping>  
4.         <method name="findRoleInfosByUserID">  
5.             <return-type  
6.                 componentType="com.tongtech.bjvsp.sysmng.entity.Role" />  
7.         </method>  
8.     </mapping>  
9. </mappings>  
10.   

其中，method代表需要配置的方法名，由于XFire可以支持基本类型，针对集合类型时，需要配置，返回类型或参数类型为基本类型时不需要特殊配置。

<return-type/>为配置返回类型，componentType属性代表返回的集合中所包含的类，此类可以是自定义的对象，也可以是基本类型,例如java.lang.String

此时，findRoleInfosByUserID方法配置完毕

PS，还拿此接口举例，如接口中，findRoleInfosByUserID接受的参数也为集合类型，那么需要在<method></method>之间再加入以下代码

代码

1. <parameter index="0" componentType="java.lang.String"/>   

index="0"代表方法的参数的序号，0即第一个参数。

componentType代表集合参数内包含的类型，也可以为自定义对象，例如User

注意，如果findRoleInfosByUserID方法有两个参数，一个比如为String，一个为集合，那么只需要配置集合参数即可。

二。映射POJO

比如还是上面的UserInfo接口，第一个方法

public User findUserInfosByUserID(String userUniqueID);

此时，返回类型为User

如果User中仅为基本类型，例如String，int等基本类型，无需配置User

但如果User中还包含有其他类型，比如包含有Set，List，那么需要对其进行配置

比如User代码如下：

代码

1. public class User  implements java.io.Serializable {   
2.   
3.     // Fields       
4.   
5.      private Integer userId;   
6.      private String loginName;   
7.      private String userPassword;   
8.      private Integer SOrder;   
9.      private String userCa;   
10.      private String userName;   
11.      private String userTel;   
12.      private String userEmail;   
13.      private String ZNote;   
14.      private String userCode;   
15.      private DicSystemAuth SDicSystemAuth;   
16.      private Set SGroupUsers = new HashSet(0);   
17.      private Set SUserDepts = new HashSet(0);   
18. }   

此时User中还包含有SDicSystemAuth的对象，以及SUserDepts等Set集合

这种情况主要可能会出现在使用Hibernate，映射一对一，一对多表时

这里要特别注意

那么此时我们需要对User进行aegis绑定，控制POJO和XML的映射

配置方法：

在User对象所在包内建立User.aegis.xml

由于User中包含Set，那么只需要对集合做设置即可，DicSystemAuth下面单独讨论

我们可以分两次来配置，分别讲解

1,

代码

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <mappings xmlns:my="http://my.bjvsp.tongtech.com">  
3. <mapping name="my:User">  
4. <property name="SGroupUsers" componentType="com.tongtech.bjvsp.sysmng.entity.GroupUser"/>  
5. <property name="SUserDepts" componentType="com.tongtech.bjvsp.sysmng.entity.UserDept"/>  
6. </mapping>  
7. </mappings>  

此时，配置文件中配置了两个Set集合，componentType明确定义了Set集合内包含的内容

此时，DicSystemAuth即便是自定义的对象类，由于不是集合，XFire也可以对其正确映射。

2

代码

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <mappings xmlns:my="http://my.bjvsp.tongtech.com">  
3. <mapping name="my:User">  
4.   
5. <property name="SGroupUsers" ignore="true"/>  
6. <property name="SUserDepts" ignore="true"/>  
7. <property name="SDicSystemAuth" ignore="true"/>  
8. </mapping>  
9. </mappings>  

第二种方式，定义了三个字段，并使用了ignore属性，表示这三个属性不能被序列化。

那么，何时会遇到类似于User中Set集合，不被序列化呢？

当客户端访问本地代理时，如果User表内包含有其他表的关联时，如果基于hibernate的持久层，由于hibernate的惰性加载机制，加载User时仅会将User中的属性值加载而不会加载关联表中的值，比如set和SDicSystemAuth对象等，当客户端访问本地代理，序列化User对象时，如果没有设置关联字段是否序列化，那么它会将其全部序列化，但当序列化时，由于hibernate的惰性加载，此时Session已经关闭，那么在序列化关联字段的时候，就会出现session was close的异常。因此解决办法是在aegis绑定时制定关联字段的ignore属性设置为true。

还有一种解决办法，就是仍然按照第一种配置方式，明确指明关联的Set集合内的对象，但在执行序列化前，session关闭之前，提前将关联字段内的值初始化。

用Hibernate.initialize初始化

最后补充一小句

XFire对于自定义的对象可以聪明的找到，前提是它不包含集合

例如你的方法返回一个User对象

User中都是基本类型，或者User中包含有Dept对象的引用，都没有问题。

但如果你不希望加载user时序列化Dept出问题，就乖乖把dept初始化或将dept的ignore属性设置为true