WebService入门学习二

1、CXF框架的深入使用，CXF的拦截器，为什么设计CXF拦截器？

　　答：为了在webservice请求过程中，能动态操作请求和响应数据,，CXF设计了拦截器。

2、CXF的拦截器分类：

　　1）、按所处的位置分：服务器端拦截器，客户端拦截器。
　　2）、按消息的方向分：入拦截器，出拦截器。
　　3）、按定义者分：系统拦截器，自定义拦截器。

3、使用拦截器就可以不适用tcp/ip监控的工具了，因为此监控工具还需要将wsdl文件下载到本地，然后修改端口才能进行监控。

将apache-cxf-2.5.9lib里面的包导入到项目中，然后编写SEI(Service Endpoint Interface)，SEI在webservice中称为portType，在java中就是普通接口。

package com.bie.webservice.sei;

import javax.jws.WebMethod;
import javax.jws.WebService;

/**
 * 
 * @author
 *         编写SEI(Service Endpoint Interface)，SEI在webservice中称为portType，在java中就是普通接口 。        
 * 
 *         1、第一步，开发服务器端，Web Service编码。
 *            –@WebService(SEI和SEI的实现类)，该注解用来定义SEI和SEI的实现类。
 *         –@WebMethod(SEI中的所有方法)，该注解用来定义SEI里面的方法。
 *         2、第二步，发布Web Service，–Endpoint(终端, 发布webservice)。
 */
@WebService
public interface HelloWebServiceSEI {

    @WebMethod
    public String sayHello(String name);

}

然后编写SEI实现类，如下所示：

package com.bie.webservice.sei.impl;

import javax.jws.WebService;

import com.bie.webservice.sei.HelloWebServiceSEI;

/**
 * 
 * @author
 * 
 *         1、SEI实现类
 *
 * 
 */
@WebService // SEI实现类也要使用此注解
public class HelloWebServiceSEIImpl implements HelloWebServiceSEI {

    @Override
    public String sayHello(String name) {
        System.out.println("Service server sayHello() : " + name);
        return "hello " + name;
    }

}

发布WebService，Endpoint(终端, 发布webservice)，可以在服务器端编写拦截器，此拦截器可以替换掉tcp/ip监控工具。

package com.bie.webservice.endpoint;

import java.util.List;

import javax.xml.ws.Endpoint;

import org.apache.cxf.interceptor.Interceptor;
import org.apache.cxf.interceptor.LoggingInInterceptor;
import org.apache.cxf.interceptor.LoggingOutInterceptor;
import org.apache.cxf.jaxws22.EndpointImpl;
import org.apache.cxf.message.Message;

import com.bie.webservice.sei.HelloWebServiceSEI;
import com.bie.webservice.sei.impl.HelloWebServiceSEIImpl;

/**
 * 
 * @author 1、发布WebService，Endpoint(终端, 发布webservice)。
 *
 */
public class WebServiceEndpoint {

    public static void main(String[] args) {
        // 使用Endpoint发布webservice
        // 参数一，url地址
        String address = "http://localhost:8888/webservice/hello";
        // 参数二，是SEI实现类对象
        HelloWebServiceSEI implementor = new HelloWebServiceSEIImpl();
        // 终端
        Endpoint endpoint = Endpoint.publish(address, implementor);
        System.out.println(endpoint.toString());

        // 将Endpoint转换为EndpointImpl，使用更多的实现方法
        EndpointImpl endpointImpl = (EndpointImpl) endpoint;
        // 如果要添加拦截器，是使用终端Endpoint来添加拦截器的，这里使用EndpointImpl来添加拦截器
        // 添加服务器端的入拦截器
        List<Interceptor<? extends Message>> inInterceptors = endpointImpl.getInInterceptors();
        // 向拦截器集合中添加拦截器，添加服务器端的日志入拦截器
        inInterceptors.add(new LoggingInInterceptor());

        // 添加服务器端的日志出拦截器
        List<Interceptor<? extends Message>> outInterceptors = endpointImpl.getOutInterceptors();
        // 向拦截器集合中添加拦截器，添加服务器端的日志出拦截器
        outInterceptors.add(new LoggingOutInterceptor());
            
        System.out.println("使用Endpoint发布webservice,发布成功Success......");
    }

}

可以使用eclipse的web service浏览器进行测试，查看入拦截器和出拦截器的请求和相应参数是什么，如下所示：

输入请求参数之后，就可以在控制台查看请求信息和响应信息，如下所示：

同样，在客户端也可以进行入拦截器和出拦截器的配置，客户端的代码可以使用java的工具脚本wsimport自动生成的，这里省略了，同样，需要将apache-cxf-2.5.9lib里面的包导入到客户端项目中，如下所示：

package com.bie.webservice.sei.client;

import java.util.List;

import org.apache.cxf.endpoint.Client;
import org.apache.cxf.frontend.ClientProxy;
import org.apache.cxf.interceptor.Interceptor;
import org.apache.cxf.interceptor.LoggingInInterceptor;
import org.apache.cxf.interceptor.LoggingOutInterceptor;
import org.apache.cxf.message.Message;

import com.bie.webservice.sei.HelloWebServiceSEI;
import com.bie.webservice.sei.impl.HelloWebServiceSEIImplService;

public class WebServiceCxfClient {

    public static void main(String[] args) {
        // 根据标签进行创建类<wsdl:service name="HelloWebServiceSEIImplService">
        HelloWebServiceSEIImplService factory = new HelloWebServiceSEIImplService();
        // 根据绑定的type为返回类型，<wsdl:binding name="HelloWebServiceSEIImplServiceSoapBinding"
        // type="ns1:HelloWebServiceSEI">
        HelloWebServiceSEI helloWebServiceSEI = factory.getHelloWebServiceSEIImplPort();

        // 服务器端使用的是终端EndPoint来进行添加拦截器的
        // 客户端是是使用的ClientProxy来获取到Client，Client即发送请求的客户端对象
        Client client = ClientProxy.getClient(helloWebServiceSEI);
        // 客户端的日志出拦截器
        List<Interceptor<? extends Message>> outInterceptors = client.getOutInterceptors();
        // 向集合中添加出拦截器
        outInterceptors.add(new LoggingOutInterceptor());

        // 客户端的日志入拦截器
        List<Interceptor<? extends Message>> inInterceptors = client.getInInterceptors();
        // 向集合中添加入拦截器
        inInterceptors.add(new LoggingInInterceptor());

        // 调用业务方法
        String sayHello = helloWebServiceSEI.sayHello("张姗姗");
        System.out.println("client : " + sayHello);
    }

}

客户端请求，入拦截器和出拦截器，已经请求方法返回信息打印的结果，如下所示：

4、CXF的拦截器API。

　　1）、Interceptor(拦截器接口)。
　　2）、AbstractPhaseInterceptor(自定义拦截器从此继承)。
　　3）、LoggingInInterceptor(系统日志入拦截器类)。使用日志拦截器，可以实现日志记录，日志拦截器有LoggingInInterceptor，LoggingOutInterceptor。
　　4）、LoggingOutInterceptor(系统日志出拦截器类)。使用日志拦截器，可以实现日志记录，日志拦截器有LoggingInInterceptor，LoggingOutInterceptor。

5、使用自定义拦截器，实现用户名与密码的检验，对于客户端的出拦截器，入拦截器，服务器端的入拦截器，出拦截器如何进行添加拦截器进行账号密码校验呢？

　　答：需要在服务器端的in拦截器，客户端的out拦截器添加拦截器进行校验。

首先搞一个客户端的出拦截器，进行拦截，如下所示：

package com.bie.webservice.sei.interceptor;

import java.util.List;

import javax.xml.namespace.QName;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.apache.cxf.binding.soap.SoapMessage;
import org.apache.cxf.headers.Header;
import org.apache.cxf.interceptor.Fault;
import org.apache.cxf.phase.AbstractPhaseInterceptor;
import org.apache.cxf.phase.Phase;
import org.apache.xml.utils.DOMHelper;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

/**
 * 
 * @author 拦截的是某一个消息，所以泛型是SoapMessage
 *
 */
public class ClientValidateUserInterceptor extends AbstractPhaseInterceptor<SoapMessage> {

    private String name;// 账号
    private String password;// 密码

    /**
     * 此构造器是关键点，决定了什么时候拦截器会拦截到消息
     * 
     * @param phase
     */
    public ClientValidateUserInterceptor(String name, String password) {
        // 准备协议化的时候进行拦截调用
        super(Phase.PRE_PROTOCOL);
        this.name = name;
        this.password = password;
    }

    /**
     * 请求体
     * 
     * <soap:Envelope> 
     *     <head>
     *         <zhangsansan>
     *             <name>zhangsansan</name>
     *             <password>123456</password>
     *         </zhangsansan>
     *  </head>
     *     <Body> 
     *         <sayHello> 
     *             <arg0>张姗姗</arg0> 
     *         </sayHello> 
     *     </Body>
     * </soap:Envelope>
     */
    @Override
    public void handleMessage(SoapMessage soapMessage) throws Fault {
        // 获取到头信息，向头部信息设置值
        List<Header> headers = soapMessage.getHeaders();
        // 此时需要构造这种结构的数据
//        <zhangsansan>
//            <name>zhangsansan</name>
//            <password>123456</password>
//        </zhangsansan>
        
        // 第一步：初始化一个XML解析工厂
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        // 第二步：创建一个DocumentBuilder实例
        DocumentBuilder builder = null;
        try {
            builder = factory.newDocumentBuilder();
        } catch (ParserConfigurationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        // 第三步：构建一个Document实例
        Document doc = builder.newDocument();
        // standalone用来表示该文件是否呼叫其它外部的文件。若值是 ”yes” 表示没有呼叫外部文件
        doc.setXmlStandalone(true);
        // 第四步：创建一个根节点，名称为root，并设置一些基本属性，创建标签
        Element rootElement = doc.createElement("zhangsansan");
        // 设置节点属性
        // rootElement.setAttribute("attr", "root");
        // 设置标签之间的内容
        // rootElement.setTextContent("root attr");
        
        // 开始设置<zhangsansan>下面的标签<name>zhangsansan</name>
        Element nameElement = doc.createElement("name");
        nameElement.setTextContent(this.name);
        // 第五步：把节点添加到Document中，再创建一些子节点加入，将子标签添加到父标签中
        rootElement.appendChild(nameElement);
        
        // 开始设置<zhangsansan>下面的标签<name>zhangsansan</name>
        Element passwordElement = doc.createElement("password");
        passwordElement.setTextContent(this.password);
        // 第五步：把节点添加到Document中，再创建一些子节点加入，将子标签添加到父标签中
        rootElement.appendChild(passwordElement);
        
        // 第六步：把构造的XML结构，写入到具体的文件中
        // 参数一QName起一个唯一的名字，这个名称必须和rootElement标签的值必须一样
        // 参数二就是rootElement根节点
        Header header = new Header(new QName("zhangsansan"), rootElement);
        // 将此请求体和构建的请求头发送给服务器端
        headers.add(header);
        
        System.out.println("Client handleMessage Interceptor......");
        
        // DOMHelper.createDocument()方法过期了
        // Document createDocument = DOMHelper.createDocument();
    }

}

然后在客户端新增自定义的出拦截器，验证账号密码信息，如下所示：

package com.bie.webservice.sei.client;

import java.util.List;

import org.apache.cxf.endpoint.Client;
import org.apache.cxf.frontend.ClientProxy;
import org.apache.cxf.interceptor.Interceptor;
import org.apache.cxf.message.Message;

import com.bie.webservice.sei.HelloWebServiceSEI;
import com.bie.webservice.sei.impl.HelloWebServiceSEIImplService;
import com.bie.webservice.sei.interceptor.ClientValidateUserInterceptor;

public class WebServiceCxfClient2 {

    public static void main(String[] args) {
        // 根据标签进行创建类<wsdl:service name="HelloWebServiceSEIImplService">
        HelloWebServiceSEIImplService factory = new HelloWebServiceSEIImplService();
        // 根据绑定的type为返回类型，<wsdl:binding name="HelloWebServiceSEIImplServiceSoapBinding"
        // type="ns1:HelloWebServiceSEI">
        HelloWebServiceSEI helloWebServiceSEI = factory.getHelloWebServiceSEIImplPort();

        // 服务器端使用的是终端EndPoint来进行添加拦截器的
        // 客户端是是使用的ClientProxy来获取到Client，Client即发送请求的客户端对象
        Client client = ClientProxy.getClient(helloWebServiceSEI);
        // 账号密码的校验，要使用的是客户端的出拦截器
        List<Interceptor<? extends Message>> outInterceptors = client.getOutInterceptors();
        // 向集合中添加自定义的出拦截器
        String name = "张姗姗";
        String password = "123456";
        outInterceptors.add(new ClientValidateUserInterceptor(name, password));

        // 调用业务方法
        String sayHello = helloWebServiceSEI.sayHello("张姗姗");
        System.out.println("client : " + sayHello);
    }

}

然后搞一个服务器端的入拦截器，验证账号密码是否正常，如下所示：

package com.bie.webservice.interceptor;

import javax.xml.namespace.QName;

import org.apache.cxf.binding.soap.SoapMessage;
import org.apache.cxf.headers.Header;
import org.apache.cxf.interceptor.Fault;
import org.apache.cxf.phase.AbstractPhaseInterceptor;
import org.apache.cxf.phase.Phase;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

/**
 * 
 * @author 服务器端的自定义入拦截器
 *
 */
public class ServerValidateUserInterceptor extends AbstractPhaseInterceptor<SoapMessage> {

    private static final String name = "张姗姗";
    private static final String password = "123456";
    
    public ServerValidateUserInterceptor() {
        // 准备协议化的时候进行拦截调用
        super(Phase.PRE_PROTOCOL);
    }

    /**
     * 请求体，服务器端需要解析请求头信息
     * 
     * <soap:Envelope> 
     *     <head>
     *         <zhangsansan>
     *             <name>zhangsansan</name>
     *             <password>123456</password>
     *         </zhangsansan>
     *  </head>
     *     <Body> 
     *         <sayHello> 
     *             <arg0>张姗姗</arg0> 
     *         </sayHello> 
     *     </Body>
     * </soap:Envelope>
     */
    @Override
    public void handleMessage(SoapMessage soapMessage) throws Fault {
        // 获取到请求头的信息
        QName qName = QName.valueOf("zhangsansan");
        // 获取到请求头
        Header header = soapMessage.getHeader(qName);
        // 判断是否为空
        if(header != null) {
            // 获取到对象，强转为w3c的元素标签
            Element element = (Element) header.getObject();
            // 获取到name标签的值
            Node nameNode = element.getElementsByTagName("name").item(0);
            // 获取到name的值
            String nameValue = nameNode.getTextContent();
            // 获取到pasword标签的值
            Node passwordNode = element.getElementsByTagName("password").item(0);
            // 获取到pasword的值
            String paswordValue = passwordNode.getTextContent();
            // 开始进行判断
            if(ServerValidateUserInterceptor.name.equals(nameValue) && ServerValidateUserInterceptor.password.equals(paswordValue)) {
                System.out.println("Server 通过拦截器......");
                return;
            }
        }
        // 如果不能通过
        System.out.println("Sorry Server 不通过拦截器......");
        // 抛出异常信息
        throw new Fault(new RuntimeException("账号密码错误......"));
    }

}

然后在服务器端添加自定义的入拦截器，如下所示：

package com.bie.webservice.endpoint;

import java.util.List;

import javax.xml.ws.Endpoint;

import org.apache.cxf.interceptor.Interceptor;
import org.apache.cxf.jaxws22.EndpointImpl;
import org.apache.cxf.message.Message;

import com.bie.webservice.interceptor.ServerValidateUserInterceptor;
import com.bie.webservice.sei.HelloWebServiceSEI;
import com.bie.webservice.sei.impl.HelloWebServiceSEIImpl;

/**
 * 
 * @author 1、发布WebService，Endpoint(终端, 发布webservice)。
 *
 */
public class WebServiceEndpoint2 {

    public static void main(String[] args) {
        // 使用Endpoint发布webservice
        // 参数一，url地址
        String address = "http://localhost:8888/webservice/hello";
        // 参数二，是SEI实现类对象
        HelloWebServiceSEI implementor = new HelloWebServiceSEIImpl();
        // 终端
        Endpoint endpoint = Endpoint.publish(address, implementor);
        System.out.println(endpoint.toString());

        // 将Endpoint转换为EndpointImpl，使用更多的实现方法
        EndpointImpl endpointImpl = (EndpointImpl) endpoint;
        // 如果要添加拦截器，是使用终端Endpoint来添加拦截器的，这里使用EndpointImpl来添加拦截器
        // 添加服务器端的入拦截器
        List<Interceptor<? extends Message>> inInterceptors = endpointImpl.getInInterceptors();
        // 向拦截器集合中添加拦截器，添加服务器端的账号密码验证的入拦截器
        inInterceptors.add(new ServerValidateUserInterceptor());

        System.out.println("使用Endpoint发布webservice,发布成功Success......");
    }

}

启动服务器端服务，然后启动客户端服务，分别输入正确的账号密码，和错误的账号密码进行验证。