使用CXF发布WebService

这里普及一下WebService和cxf的知识、关于webservice和cxf：

 

WebService:  简单来说是一种远端方法调用（暴露本地的方法接口给外部，客户端可以通过远端调用的方式调用）
SOA (面向服务架构)： IBM提倡面向服务的架构， 希望以-组装电脑-的形式开发软件
SOA：1、各种提供服务的组件
     2、企业总线、通讯总线（ESB）
CXF：是一个SOA框架，Axis和XFire是原生态的WebService框架，由此可见，CXF是优秀与后两者的
SOAP（简单对象访问协议）：包含了两个标签，header和body，header是由程序员添加的，可以没有，
    但是body标签是必须的。
    body标签分为两种情况：1.当WebService调用成功的时候，由WSDL控制。
                        2.当WebService调用失败的时候，会生成fault元素，而fault元素又
                            包含两个部分：2.1错误码；2.2错误信息
    html+xml脚本片段
-------------------------------------------------------------------------------
CXF环境变量配置
将CXF的bin目录放到path环境变量
wsdl2java   --检测cxf环境配置是否成功
cxf对jdk的要求是1.6.17或以上
-------------------------------------------------------------------------------
WebService之间至少需要两个部分：接口和实现类
CXF自动携带了一个Jetty web Server，但是实际中并不使用它，多数使用Tomcat或WebLogic
-------------------------------------------------------------------------------
使用XCF开发WebService的服务端
1.开发一个WebService的业务接口，并且该接口使用@WebService修饰
2.开发接口的实现类，该实现类也需要采用@WebService修饰
3.发布WebService并且对外暴露WSDL，采用EndPoint类的静态方法publish发布，该类由java提供
-------------------------------------------------------------------------------
客户端调用WebService服务
1.使用CXF提供的wsdl2java命令生成远端代理
2.找到生成的代理类中的一个继承了service的类可以作为工厂使用，调用service子类中的一个叫getXXXport的方法
    得到远端接口服务代理对象
3.远端代理调用
使用wsdl2java http://127.0.0.1/firstcxf?wsdl执行远端代码，生成java文件，生成的java文件会有错误，
    原因是：javax.xml.ws.Service类中没有Service(wsdlLocation,SERVICE,features); 构造器。
    解决方法是：导入一个geronimo-javax_2.2_spec-1.1.jar提供最新版本的Service类，但是这个方法不建议（移植性差）
    可以使用：wsdl2java -frontend http://127.0.0.1/firstcxf?wsdl 

 

 

 

 

实际上，webservice就相当与云计算的概念，暴露一个本地的方法接口到web上，就可以给任何人调用，只要提供相应的wsdl。而客户端只需要传递相应的参数就可以实现对webservice的调用，最终可以对返回的结果进行相应的处理。

 

服务端的代码实现如下：

1.首先创建一个供外界访问的接口：

 

package com.ws;
import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebService;
/**
 * interface
 * 
 * @author Administrator
 *
 */
@WebService
public interface HelloWorld {
    @WebMethod(operationName="sayHi")
    public String sayHi(@WebParam(name="name")String name);
}
 
 
2.然后，设计一个类实现该接口，注意头部要添加@WebService注解，其中，endpointInterface的值为接口的完整名称，serviceName为暴露给外界访问的服务名称。
 
 
package com.ws.impl;
import javax.jws.WebService;
import com.ws.HelloWorld;
/**
 * endpointInterface:实现接口的完全路径
 * serviceName：server名称
 * 
 * @author Administrator
 * 
 * WebService 的目的是便于其他的编程语言调用
 *
 */
@WebService(endpointInterface="com.ws.HelloWorld",serviceName="Hello")
public class HelloWorldImpl implements HelloWorld {
    @Override
    public String sayHi(String name) {
        System.out.println("client called webservice...");
        if(name == null){
            return "Who are you?";
        }
        return "Hello , "+name;
    }
}
 
3.使用Endpoint.publish方法发布WebService到互联网
 
 
package com.srv;
import javax.xml.ws.Endpoint;
import com.ws.HelloWorld;
import com.ws.impl.HelloWorldImpl;
public class ServerMain {
    
    /**
     * 发布webservice
     * 
     * @param args
     */
    public static void main(String[] args) {
//第一种方式：非CXF方法
        HelloWorld hw = new HelloWorldImpl();
        Endpoint.publish("http://127.0.0.1:8888/firstcxf", hw);
        System.out.println("webservice publish successed!");
        
        //System.exit(0);
 
 
 
            
    //第二种方法（CXF发布），需要导入cxf 的jar包
        HelloWorldImpl impl = new HelloWorldImpl();  
        JaxWsServerFactoryBean factoryBean = new             JaxWsServerFactoryBean();  
        factoryBean.setAddress("http://127.0.0.1:8888/firstcxf");//发布地址  
        factoryBean.setServiceClass(HelloWorld.class);//接口类  
        factoryBean.setServiceBean(impl);//发布接口的实现类的实例  
        factoryBean.create();  
        System.out.println("WS发布成功！");    
    }
}

 

 

 

 

 

创建一个WebService客户端的步骤如下：有两种方式：

 

第一种：

    先在客户端编译wsdl，生成对应的java文件，然后根据生成的java通过远端调用的方式调用WebService。

    第一步：

    进入工程的src目录，执行wsdl2java  http://127.0.0.1/firstcxf?wsdl 命令，

生成对应的java文件。

    第二步：然后可以根据生成的java文件通过远端调用的方式调用WebService。

 

下面是第一种方式调用的几种常用方法：

 

package com.client;
import java.net.MalformedURLException;
import java.net.URL;
import javax.xml.namespace.QName;
import javax.xml.ws.Service;
import javax.xml.ws.soap.SOAPBinding;
import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
import com.ws.HelloWorld;
import com.ws.impl.Hello;
public class ClientMain {
    /**
     * 远端调用WebService
     * 
     * @param args
     */
    public static void main(String[] args) {
//        第一种方式，不需要导入cxf包
//        // 注意。此处http://impl.ws.com/ 来源于wsdl文件中targetNamespace 
//        QName qName = new QName("http://impl.ws.com/", "Hello");
//        Hello hello;
//        try {
//            hello = new Hello(new URL("http://127.0.0.1:8888/firstcxf?wsdl"),
//                    qName);
//            HelloWorld service = hello.getPort(HelloWorld.class);
//            System.out.println(service.sayHi("niha"));
//        } catch (MalformedURLException e) {
//            e.printStackTrace();
//        }
        
        
        // 第二种方法   （无需导入cxf包）
        // Hello service = new Hello();
        // //service.getXXXPort返回的是远端接口代理对象
        // HelloWorld hw = service.getHelloWorldImplPort();
        // //远端调用
        // System.out.println(hw.sayHi("Handle"));
        
        
        // //第三种方法：采用CXF方法  (需要导入cxf包)
        // JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
        // //1.设置WebService接口
        // factory.setServiceClass(HelloWorld.class);
        // //2.设置wsdl的暴露地址
        // factory.setAddress("http://127.0.0.1:8888/firstcxf");
        //
        // HelloWorld hw = (HelloWorld) factory.create();
        // System.out.println(hw.sayHi(null));
        
//        
//        (不可用)
//        String endpointAddress = "http://127.0.0.1:8888/firstcxf";
//        Service service = Service.create(Hello.SERVICE);
//        service.addPort(Hello.HelloWorldImplPort,
//                SOAPBinding.SOAP11HTTP_BINDING, endpointAddress);
//        HelloWorld helloS = service.getPort(HelloWorld.class);
//        helloS.sayHi("nihao");
    }
}

 

 

这种方式由于需要显式调用暴露方法的接口来生成一个实例，因此该方法适用于服务器端与客户端处于同一个应用的相同服务下的应用程序。

 

 

第二种方式：

 

    可以隐式的调用远端方法，只需要提供相应的字符串参数

 

package com.test;
import javax.xml.namespace.QName;
import org.apache.cxf.endpoint.Client;
import org.apache.cxf.endpoint.Endpoint;
import org.apache.cxf.jaxws.endpoint.dynamic.JaxWsDynamicClientFactory;
import org.apache.cxf.service.model.BindingInfo;
import org.apache.cxf.service.model.BindingOperationInfo;
public class Test3 {
    public static void main(String[] args) {
        //第一种，知道方法名一定存在直接调用
        JaxWsDynamicClientFactory dcf = JaxWsDynamicClientFactory.newInstance();
        Client client = dcf.createClient("http://127.0.0.1:8888/firstcxf?wsdl");
        try {
            QName opName = new QName("http://ws.com/", "sayHi");//设置限定名
            Object[] result = client.invoke(opName, "lisi");
            System.out.println(result[0].toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        
        //第二种方法，较为动态的查找需要调用的方法
        
//        String wsdl = "http://127.0.0.1:8888/firstcxf?wsdl";
//        String operation  = "sayHi";
//        
//        JaxWsDynamicClientFactory factory = JaxWsDynamicClientFactory.newInstance();  
//        Client client = factory.createClient(wsdl);  
//          
//        // 下面一段处理 WebService接口和实现类namespace不同的情况  
//        // CXF动态客户端在处理此问题时，会报No operation was found with the name的异常  
//        Endpoint endpoint = client.getEndpoint();  
//        QName opName = new QName(endpoint.getService().getName().getNamespaceURI(), operation);  
//        BindingInfo bindingInfo = endpoint.getEndpointInfo().getBinding();  
//        if (bindingInfo.getOperation(opName) == null) {  
//            for (BindingOperationInfo operationInfo : bindingInfo.getOperations()) {  
//                if (operation.equals(operationInfo.getName().getLocalPart())) {  
//                    opName = operationInfo.getName();  
//                    break;  
//                }  
//            }  
//        }  
//          
//        String realParams = "Li si";
//        try {
//            Object[] res = client.invoke(opName, realParams);
//            System.out.println(res[0].toString());
//        } catch (Exception e) {
//            e.printStackTrace();
//        }  
    }
}

 

 

这种方法的好处是只需要知道相关的暴露接口中的方法名，既可以隐式调用，适合于发布的服务器和调用的客户端不处于同一应用，同一服务下的应用程序。

注意：

http://localhost:8080/WSCXF/helloService   //为暴露的接口的名称

 ?wsdl 必须要添加，这个是接口解析成的xml文件