xfire+spring+权限

一般常用的配置方式有两种（转载+补充）：

方式1.使用org.codehaus.xfire.spring.XFireSpringServlet与ServiceBean来发布webService

导入jar包：XmlSchema-1.1.jar，xfire-all-1.2.6.jar，wsdl4j-1.6.1.jar，org.springframework.web-3.1.1.RELEASE.jar，org.springframework.web.servlet-3.1.1.RELEASE.jar，org.springframework.expression-3.1.1.RELEASE.jar，org.springframework.core-3.1.1.RELEASE.jar，org.springframework.context-3.1.1.RELEASE.jar，org.springframework.beans-3.1.1.RELEASE.jar，org.springframework.asm-3.1.1.RELEASE.jar，org.springframework.aop-3.1.1.RELEASE.jar，jdom-1.0.jar，commons-logging-1.1.1.jar，commons-httpclient-3.0.jar，commons-codec-1.3.jar   

3.配置web.xml文件：一般是配置spring配置文件的位置，spring的监听器，配置核心控制器

<!--配置spring配置文件的路径，后面还会配置一个spring的监听器，在服务器开启的时会自动加载spring的配置文件。   -->

classpath指的是classes目录下：

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
classpath:applicationContext_two.xml
</param-value>
</context-param>   

<!-- spring的监听器 -->

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<!-- XFire的核心servlet -->
<servlet>
<servlet-name>XFireServlet</servlet-name>
<servlet-class>org.codehaus.xfire.spring.XFireSpringServlet</servlet-class>
</servlet>

<servlet-mapping>
<servlet-name>XFireServlet</servlet-name>
<url-pattern>/services/*</url-pattern>
</servlet-mapping>

在src下配置applicationContext_two.xml的配置文件：（记得放到spring下管理）

<?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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
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/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
<import resource="classpath:org/codehaus/xfire/spring/xfire.xml"/>

<bean name="userService" class="org.codehaus.xfire.spring.ServiceBean">
<!-- 提供服务接口的实现类 -->
<property name="serviceBean" ref="userServiceImpl"/>
<!-- 提供服务的接口，这个接口是向客户端进行暴露，里面的方法都可以被客户端所访问 -->
<property name="serviceClass" value="com.union.sx.service.UserService"/>

<!--以下是可进行权限控制等操作配置，可以不配置 ，客户端的out对应服务端的in -->
<property name="outHandlers">
   <list>
    <ref bean="domOutHandler"/>
   </list>
</property>
<property name="inHandlers">
            <list>
                <ref bean="domInHandler"/>
            </list>
        </property>

</bean>
<bean id="domInHandler" class="ceshi.ServerInHandler2" />
<bean id="domOutHandler" class="ceshi.ServerInHandler" />


<bean id="userServiceImpl" class="com.union.sx.service.impl.UserServiceImpl"/>
</beans>

然后开启服务器就可以访问这个网站了

http://localhost:8080/项目名/services/userService 然后选择wsdl

调用方法1：（UserService 这个是服务端的接口，复制到客户端即可）

 Service serviceModel = new ObjectServiceFactory().create(UserService.class);  
          UserService service;
            service = (UserService) new XFireProxyFactory().create(  
                 serviceModel,  
                 "http://localhost:8080/TWRS/services/UserService");
        Map maps =new HashMap();
        maps.put("同一个世界", "同一个梦想");
            Map str = service.thisMap(maps);  
            System.out.println(str);

调用方法2：

Service serviceModel = new ObjectServiceFactory().create(UserService.class);   
        XFire xfire = XFireFactory.newInstance().getXFire();   
        XFireProxyFactory factory = new XFireProxyFactory(xfire);   
        String serviceUrl = "http://localhost:8080/TWRS/services/UserService";   
        UserService client = null;   
        client = (UserService) factory.create(serviceModel, serviceUrl);   

//添加权限控制       

// Client client1 = Client.getInstance(service);
       //         client1.addOutHandler(new ServerInHandler3("test","test"));
    String name=    client.sayHello("dd");
        System.out.println(name);

客户端：

/**
*
* @author ZHANGCHI
*  创建时间：2018年8月15日
* 类说明 ：客户端构造验证信息
 */
package ceshi;

import org.codehaus.xfire.MessageContext;
import org.codehaus.xfire.handler.AbstractHandler;
import org.jdom.Element;

/*
* @version 创建时间：2018年8月15日 上午10:26:11 
* 类说明 ：
*/
public class ServerInHandler3 extends AbstractHandler {  
	 private String username = null;   
     private String password = null;   
	
	
	public ServerInHandler(String username,String password) {
		  this.username = username;   
	         this.password = password;   
	}

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	@Override
	public void invoke(MessageContext context) throws Exception {
        //为SOAP Header构造验证信息  
        Element el = new Element("header");   
        context.getOutMessage().setHeader(el);   
        Element auth = new Element("AuthenticationToken");   
        Element username_el = new Element("Username");   
        username_el.addContent(username);   
        Element password_el = new Element("Password");   
        password_el.addContent(password);   
        auth.addContent(username_el);   
        auth.addContent(password_el);   
        el.addContent(auth);  
	}  
}

服务端：

/**
*
* @author ZHANGCHI
*  创建时间：2018年8月15日
* 类说明 ：服务端进行验证
 */
package ceshi;

import org.codehaus.xfire.MessageContext;
import org.codehaus.xfire.handler.AbstractHandler;
import org.jdom.Element;

/*
* @version 创建时间：2018年8月15日 上午10:26:11 
* 类说明 ：
*/
public class ServerInHandler2 extends AbstractHandler {  
	@Override
	public void invoke(MessageContext cfx) throws Exception {
	    if(cfx.getInMessage().getHeader() == null)  
        {  
             throw new org.codehaus.xfire.fault.XFireFault("请求必须包含验证信息",org.codehaus.xfire.fault.XFireFault.SENDER);  
         }  
         Element token=cfx.getInMessage().getHeader().getChild("AuthenticationToken");  
         if (token == null)   
        {   
          throw new org.codehaus.xfire.fault.XFireFault("请求必须包含身份验证信息", org.codehaus.xfire.fault.XFireFault.SENDER);   
         }   
            String username = token.getChild("Username").getValue();   
            String password = token.getChild("Password").getValue();   
            try   
           {   
                //进行身份验证 ，只有test@test的用户为授权用户  
               if(username.equals("test") && password.equals("test"))                
                System.out.println("身份验证通过");  
               else throw new Exception();  
            }   
            catch (Exception e)   
           {   
                throw new   org.codehaus.xfire.fault.XFireFault("非法的用户名和密码",   org.codehaus.xfire.fault.XFireFault.SENDER);   
            }   
	}  
}

方式2：直接集成Spring（通过Spring的org.springframework.web.servlet.DispatcherServlet）

流程：

导包：还需要另外加入spring的aop的jar文件，不止一个哦

web.xml配置：

<!--自动加载spring -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:spring-config.xml
	</param-value>
	</context-param>
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>

	<listener>
		<listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
	</listener>

 <servlet>  
        <servlet-name>myxfire</servlet-name>  
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
    </servlet>  
    <servlet-mapping>  
        <servlet-name>myxfire</servlet-name>  
        <url-pattern>/*</url-pattern>  
    </servlet-mapping>    

然后是applicationContext.xml文件：（该文件随便建，要的就是那个bean，也可以直接放入管理bean的其他xml文件，只要保证被spring管理就行）

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">  
      
    <!-- 配置对应的bean -->  
    <bean id="HelloServiceBean" class="com.jadyer.server.HelloServiceImpl" />  
</beans>

在WEB-INF下配置myxfire-servlet.xml文件（自动查找改文件）：

<?xml version="1.0" encoding="UTF-8"?>  
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">  
<beans>  
    <!-- 引入XFire预配置信息 -->  
    <!-- 在XFire核心JAR包中拥有一个预定义的Spring配置文件，即xfire.xml文件 -->  
    <!-- 它定义了XFire在Spring中必须用到的一些Bean和资源 -->  
    <import resource="classpath:org/codehaus/xfire/spring/xfire.xml"/>  
      
    <!-- 定义访问的URL -->  
    <!-- 注意：在Spring2.5中，此时需要额外引入spring-webmvc.jar -->  
     <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">  
        <property name="urlMap">  
            <map>  
             <!--    定义WebService的访问路径，有几个路径就需要配置几个<entry>信息   -->
       <!--          本例中，WSDL访问地址为http://127.0.0.1:8080/XFire_Spring_02/XFireServer.ws?wsdl   -->
                <entry key="/XFireServer.ws">  
                    <ref bean="HelloService"/>  
                </entry>  
            </map>  
        </property>  
    </bean>  
      
    <!-- 使用XFire导出器 -->  
    <!-- XFire为Spring提供了方便易用的导出器XFireExporter -->  
    <!-- 借助XFireExporter的支持，我们可以在Spring容器中将一个业务类导出为WebService -->  
    <!-- 并且，按照标准的配置，对于任何导出器，都需要引入XFire环境，即serviceFactory和xfire属性 -->  
    <!-- 其中ServiceFactory是XFire的核心类，它可以将一个POJO生成为一个WebService -->  
    <!-- 本例中，这里通过定义一个baseWebService，其余的WebService配置可以将该bean作为父bean -->  
    <!-- 这样可以简化Spring的配置，不需要多次引入serviceFactory和xfire属性 -->  
    <bean id="baseWebService" class="org.codehaus.xfire.spring.remoting.XFireExporter" lazy-init="false" abstract="true">  
        <!-- 引用xfire.xml中定义的工厂   -->
        <property name="serviceFactory" ref="xfire.serviceFactory"/>  
        <!-- 引用xfire.xml中的xfire实例   -->
        <property name="xfire" ref="xfire"/>  
    </bean>  
      
    <!-- 定义暴露的WebService -->  
    <bean id="HelloService" parent="baseWebService">  
        <!-- 业务服务bean -->  
        <property name="serviceBean" ref="HelloServiceBean"/>  
        <!-- 业务服务bean的窄接口类 -->  
        <!-- 实际应用中，当某个类有很多的方法时，如果其中有几个方法不需要开放为WebService时 -->  
        <!-- 那么此时我们可以定义一个窄接口，该接口中只需定义那些开放为WebService的业务方法 -->  
        <!-- 窄接口中的方法在真实的系统中可能需要引用其它的业务类或DAO获取数据库中的真实数据 -->  
        <!-- 其实，将一个业务类所有需要开放为WebService的方法通过一个窄接口来描述是值得推荐的 -->  
        <!-- 这会让WebService的接口显得很干净 -->  
        <!-- 并且XFire的导出器也需要服务接口的支持，因为它采用了基于接口的动态代理技术 -->  
        <property name="serviceClass" value="ceshi.UserService"/>  
<!--     
         权限控制，大同小异
        <property name="outHandlers">
   <list>
    <ref bean="domOutHandler"/>
   </list>
</property>
 ->  
   </bean>  
 <!--    执行控制的具体类
<bean id="domOutHandler" class="ceshi.ServerInHandler" /> ->
    
</beans>  

客户端代码：（使用方法基本类似，只是url改变）

public void ss6(){
        try {
          Service serviceModel = new ObjectServiceFactory().create(UserService.class);  
          UserService service;
            service = (UserService) new XFireProxyFactory().create(  
                 serviceModel,  
                 "http://localhost:8080/TWRS/XFireServer.ws")；
            String str = service.sayHello("世界");  
            System.out.println(str);  
        } catch (MalformedURLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }  
    }