基于CXF的WebServie技术应用

基于CXF的WebServie技术应用

1   概述

面向服务的体系结构（service-oriented architecture，SOA）是一种思想，它将应用程序的不同功能单元通过中立的契约（独立于硬件平台、操作系统、编程语言）联系起来，使各个形式的功能单元更好的集成。WebService是SOA思想的一种较好实现方式，它和普通的web程序一样（如JSP，ASP）采用HTTP协议进行通讯，但是它只用POST方式通讯，它的数据是基于XML格式的，采用SOAP（Simple Object Access Protocol）协议。SOAP协议实际上就是基于XML编码规范的文本协议，它是WebService特有的应用协议。

1.1      WebService体系架构

 

 

1.2      CXF说明

JAVA平台上对WebService支持的成熟框架很多，如CXF、AXIS1&2、XFire等，本文使用CXF。

Apache CXF = Celtix + XFire，前身叫 Apache CeltiXfire，已经正式更名为 Apache CXF 了，以下简称为 CXF。CXF 继承了 Celtix 和 XFire 两大开源项目的精华，是Apache基金会组织下的一个顶级项目，简化了WebService服务端的创建过程。

CXF实现了JAX-WS2.0规范，并通过了JAX-WS2.0 TCK；

CXF可以和Spring无缝集成；

CXF支持多种传输协议（HTTP， JMS， Corba等）；

CXF支持多种Binding数据格式（SOAP，XML，JSON等）；

CXF 支持多种DataBinding数据类型（JAXB， Aegis) 。

CXF基于Interceptor的架构，使得整个框架非常易于扩展。本次我主要讨论CXF在HTTP/SOAP模式下的处理机制。

CXF的下载地址为：http://cxf.apache.org/download.html，下载后解压压缩包，从lib中至少要拿出如下jar到应用：

cxf-2.2.5.jar

antlr-2.7.7.jar

commons-codec-1.3.jar

commons-collections-3.2.1.jar

commons-lang-2.4.jar 

commons-logging-1.1.1.jar

commons-pool-1.5.2.jar 

geronimo-annotation_1.0_spec-1.1.1.jar

geronimo-jaxws_2.1_spec-1.0.jar 

geronimo-ws-metadata_2.0_spec-1.1.2.jar

jaxb-api-2.1.jar

xalan-2.7.1.jar

wsdl4j-1.6.2.jar 

XmlSchema-1.4.5.jar

2      构建服务端

2.1      Servlet构建的简单服务端

1)         定义webservice接口和实现类

publicinterface IHelloWorld {

             public String sayHello(String name);

}

publicclass HelloWorldImpl implements IHelloWorld {

            public String sayHello(String name) {

                 return"Hello " + name + ".";

            }

}

 

2)         定义webservice

publicclass HelloWorldServlet extends CXFNonSpringServlet {

privatestaticfinallongserialVersionUID = 1L;

@Override

protectedvoid loadBus(ServletConfig sc) {

    super.loadBus(sc);

     Bus bus = getBus();

     //如果我们要发布多个WebService，仅仅需要修改WebService的接口定义、发布地址、实现类，然后不断重复下面的代码即可

     ServerFactoryBean factory = new ServerFactoryBean();

     factory.setBus(bus);

     factory.setServiceClass(IHelloWorld.class);

     factory.setAddress("/HelloWorld");

     factory.setServiceBean(new HelloWorldImpl());

     factory.create();

}

}

         首先CXF的内部上下文对象Bus，然后我再使用CXF提供的ServerFactoryBean工具类把自己写的一个普通的JavaBean发布成WebService。

ServerFactoryBean需要以下参数：

1) Bus。也就是上面我们所得到的Bus对象。

2) WebService的接口定义，也就是指自己的WebService实现了哪个Java Interface。

3) WebService的发布地址，也就是访问WebService的URL地址。

4) WebService的实现类。

web.xml中配置HelloWorldServlet

<servlet>    

<servlet-name> HelloWorldServlet </servlet-name>

<servlet-class> HelloWorldServlet</servlet-class>

<load-on-startup>1</load-on-startup>

       </servlet> 

<servlet-mapping>

<servlet-name>HelloWorldServlet</servlet-name>

<url-pattern>/services/*</url-pattern>

</servlet-mapping>

启动服务器，访问http://127.0.0.1:8080/CXFDemo/services/?wsdl，可以看到服务列表，http://127.0.0.1:8080/CXFDemo/services/HelloWorld?wsdl就是我们的服务地址。

2.2      java注解的简单服务端

为webservice实现类加上注解

@WebService

public class HelloWorldImpl implements IHelloWorld {

public String sayHello(@WebParam(name = "text") String name) {

           return "Hello " + name + ".";

}

}

构建服务端

public class SimpleServer {

public SimpleServer() {

           System.out.println("Starting Server");

           IHelloWorld helloService = new HelloWorldImpl();

           String address = "http://localhost:9000/helloWorld";

           Endpoint.publish(address, helloService);

}

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

          

           //System.out.println(System.getProperty("java.endorsed.dirs"));

           new SimpleServer();

           System.out.println("Server ready...");

           Thread.sleep(6000000);

           System.out.println("Server exiting");

           System.exit(0);

}

}

           运行应用程序，访问http://localhost:9000/helloWorld?wsdl，已经发布成功，可以看到服务没有在web服务器中发布，这是因为CXF内置了Jetty应用服务器，可以直接在Jetty上发布。

2.3      结合spring构建web服务

1)         声明实体

@XmlType(name = "User")

@XmlAccessorType(XmlAccessType.FIELD)

publicclass User implements Serializable {

    privatestaticfinallongserialVersionUID = 1L;

    private String username;

    private String password;

 

    public String getUsername() {

        returnusername;

    }

    publicvoid setUsername(String username) {

        this.username = username;

    }

    public String getPassword() {

        returnpassword;

    }

    publicvoid setPassword(String password) {

        this.password = password;

    }

}

2)         声明接口

import javax.jws.WebService;

import javax.jws.soap.SOAPBinding;

import javax.jws.soap.SOAPBinding.Style;

 

@WebService

@SOAPBinding(style = Style.RPC)

publicinterface IHelloService {

  User saveUser(User user);

  User getMaxLongNameUser(User u1, User u2);

}

 

3)         声明实现

import javax.jws.WebService;

import javax.jws.soap.SOAPBinding;

import javax.jws.soap.SOAPBinding.Style;

import org.apache.log4j.Logger;

 

@WebService

@SOAPBinding(style = Style.RPC)

publicclass HelloServiceImpl implements IHelloService {

    privatestatic Logger log = Logger.getRootLogger();

    public User saveUser(User user) {

        log.debug("saveUser is called!");

        return user;

    }

    public User getMaxLongNameUser(User u1, User u2) {

        log.debug("getMaxLongNameUser is called!");

        return u1;

    }

}

4)         spring配置

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"

    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:jaxws="http://cxf.apache.org/jaxws"

    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd

    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd

    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd

    http://cxf.apache.org/jaxws

    http://cxf.apache.org/schemas/jaxws.xsd">

 

    <!-- 还需要引入以下3个关于CXF的资源文件，这三个文件在cxf.jar中 -->

    <import resource="classpath:META-INF/cxf/cxf.xml" />

    <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />

    <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />

 

    <bean id="inInter" class="org.apache.cxf.interceptor.LoggingInInterceptor" />

    <bean id="outInter" class="org.apache.cxf.interceptor.LoggingOutInterceptor" />

    <jaxws:endpoint id="userManager" address="/UserManager"

        implementorClass="com.pgw.test.webservice.IHelloService">

        <jaxws:implementor>

            <bean id="userServiceImpl" class="com.pgw.test.webservice.HelloServiceImpl">

            </bean>

        </jaxws:implementor>

        <!-- 加入拦截器 -->

        <jaxws:inInterceptors>

            <ref bean="inInter" />

            <ref bean="outInter" />

        </jaxws:inInterceptors>

    </jaxws:endpoint>

</beans>

5)         web.xml配置

    <context-param>

        <param-name>contextConfigLocation</param-name>

        <param-value>/WEB-INF/config/*.xml</param-value>

    </context-param>

    <listener>

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

    </listener>

    <listener>

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

    </listener>

    <servlet>

        <servlet-name>CXFService</servlet-name>

        <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>

    </servlet>

    <servlet-mapping>

        <servlet-name>CXFService</servlet-name>

        <url-pattern>/*</url-pattern>

    </servlet-mapping>

完成上述操作后发布web程序，在浏览器中输入

http://127.0.0.1:8080/CXFDemo/UserManager?wsdl查看服务。另外在部署中可能会遇到JAXB 2.0 API is being loaded from the bootstrap classloader这个错误，这是因为cxf2.2.5需要jaxb-api-2.1.jar支持，而低版本的jdk1.6默认的是jaxb-api-2.0.jar，解决办法如下：

重新构建一个相同类型的项目(不同的项目类型，输出的结果不一样)，在项目中打印输出System.getProperty("java.endorsed.dirs")，如果文件系统中不存在输出的目录则创建，把jaxb-api-2.1.jar放置到该目录下，问题解决。

3      构建客户端

3.1      WSDL2Java构建客户端

WSDL2Java位于cxf的bin目录下，可以根据wsdl生成java客户端代码。在命令行中输入 WSDL2JAVA –help 可以获取该指令的帮助。

如下所示：

wsdl2java -frontend jaxws21

-p com.ailk.demo.webservice.client.wsdl2Java

-d D:\workspace\olcom5\CXFDemo\src\ http://localhost:8080/CXFDemo/services/HelloWorld?wsdl

 

客户端生成后进行调用：

publicclass ClientMain {

 

publicstaticvoid main(String[] args) {

     IHelloWorld helloWorld = new IHelloWorld();

     IHelloWorldPortType client = helloWorld.getIHelloWorldPort();

     String resultStr = client.sayHello("test");

     System.out.println("HelloWorld webService response :" + resultStr);

}

}

3.2      JAX-WS Proxy构建客户端

import java.net.MalformedURLException;

import java.net.URL;

import javax.xml.namespace.QName;

import javax.xml.ws.Service;

import com.ailk.demo.service.IHelloWorld;

 

publicclass ClientMain {

publicstaticvoid main(String[] args) throws MalformedURLException {

     URL wsdlURL = new URL("http://localhost:9000/helloWorld?wsdl");

     QName SERVICE_NAME = new QName("http://impl.service.demo.ailk.com/", "HelloWorldImplService");

     QName PORT_NAME = new QName("http://impl.service.demo.ailk.com/", "HelloWorldImplPort");

     Service service = Service.create(wsdlURL, SERVICE_NAME);

     IHelloWorld client = service.getPort(PORT_NAME, IHelloWorld.class);

     String result = client.sayHello("test");

     System.out.println("HelloWorld webService response :" + result);

}

}

3.3      JaxWsProxyFactoryBean构建客户端

JaxWsProxyFactoryBean简化了Proxy

publicclass ClientMain {

publicstaticvoid main(String[] args) {

     JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();

     factory.setServiceClass(IHelloWorld.class);

     factory.setAddress("http://localhost:9000/helloWorld?wsdl");

     IHelloWorld client = (IHelloWorld) factory.create();

     String result = client.sayHello("test");

     System.out.println("HelloWorld webService response :" + result);

}

}

3.4      JaxWsClientProxy动态客户端

DynamicClientFactory factory = DynamicClientFactory.newInstance();

     Client client = factory.

createClient("http://localhost:8080/CXFDemo/services/HelloWorld?wsdl");

     try {

         Object[] objs = client.invoke("sayHello",

new Object[] { "test" });

         System.out.println("HelloWorld webService response :" + objs[0]);

     } catch (Exception e) {

         e.printStackTrace();

}

3.5      JaxWsDynamicClientFactory动态客户端

 

import org.apache.cxf.endpoint.Client;

import org.apache.cxf.endpoint.ConduitSelector;

import org.apache.cxf.endpoint.Endpoint;

import org.apache.cxf.endpoint.UpfrontConduitSelector;

import org.apache.cxf.jaxws.endpoint.dynamic.JaxWsDynamicClientFactory;

import org.apache.cxf.transport.http.HTTPConduit;

import org.apache.cxf.transports.http.configuration.HTTPClientPolicy;

 

publicclass ClientMain {

 

publicstaticvoid main(String[] args) throws Exception {

     JaxWsDynamicClientFactory dcf = JaxWsDynamicClientFactory.newInstance();

     Client client = dcf.createClient("http://localhost:8080/CXFDemo/services/HelloWorld?wsdl");

     // sayHello 为接口中定义的方法名称 test为传递的参数返回一个Object数组

     Object[] objects = client.invoke("sayHello", "test");

     // 输出调用结果

     System.out.println("HelloWorld webService response :" + objects[0]);

     // 动态设置Address

     Endpoint ep = client.getEndpoint();

ep.getEndpointInfo().setAddress("http://localhost:8080/CXFDemo/services/HelloWorld");

     ConduitSelector cs = new UpfrontConduitSelector();

     cs.setEndpoint(ep);

     client.setConduitSelector(cs);

 

     // 设置连接超时时间、相应超时时间

     HTTPConduit http = (HTTPConduit) client.getConduit();

     HTTPClientPolicy httpClientPolicy = new HTTPClientPolicy();

     httpClientPolicy.setConnectionTimeout(60000);

     httpClientPolicy.setAllowChunking(false);

     httpClientPolicy.setReceiveTimeout(600000);

     http.setClient(httpClientPolicy);

 

     objects = client.invoke("sayHello", "test");

     // 输出调用结果

     System.out.println("HelloWorld webService response :" + objects[0]);

}

}

客户端创建的过程中，生产服务下所有的方法类、参数类、返回值类，耗时比较惊人，建议在实际应用中预先初始化。

 

在实际的项目应用中，有这样的场景，提供的服务是相同的，但是服务地址会随着业务的需求动态的变化，就需要我们动态的设置服务地址。