Web Service探索

发表于 | 更新于 | 分类于 | 阅读次数：
本文字数： 17k | 阅读时长 ≈ 16 分钟

概念

Web Service也称作XMl Web Service.XML是Web Service的基础.是应用程序组件,是独立的并可以自我描述的,它是使用的开放协议进行通信,可通过使用UDDI来发现,可以被其他应用程序使用.

如何工作

通过SOAP在Web上提供的软件服务，使用WSDL文件进行说明，并通过UDDI进行注册。

web service三要素

SOAP、WSDL(WebServicesDescriptionLanguage)、UDDI(UniversalDescriptionDiscovery andIntegration);
soap用来描述传递信息的格式,WSDL 用来描述如何访问具体的接口， uddi用来管理，分发，查询webService 。

XML：(Extensible Markup Language)扩展型可标记语言。面向短期的临时数据处理、面向万维网络，是Soap的基础。

Soap：(Simple Object Access Protocol)简单对象存取协议。是XML Web Service 的通信协议。当用户通过UDDI找到你的WSDL描述文档后，他通过可以SOAP调用你建立的Web服务中的一个或多个操作。SOAP是XML文档形式的调用方法的规范，它可以支持不同的底层接口，像HTTP(S)或者SMTP. SOAP 可以和现存的许多因特网协议和格式结合使用，包括超文本传输协议（HTTP），简单邮件传输协议（SMTP），多用途网际邮件扩充协议（MIME）。它还支持从消息系统到远程过程调用（RPC）等大量的应用程序。SOAP使用基于XML的数据结构和超文本传输协议(HTTP)的组合定义了一个标准的方法来使用Internet上各种不同操作环境中的分布式对象。

WSDL：(Web Services Description Language) WSDL 文件是一个 XML 文档，用于说明一组 SOAP 消息以及如何交换这些消息。大多数情况下由软件自动生成和使用。

UDDI (Universal Description, Discovery, and Integration) 是一个主要针对Web服务供应商和使用者的新项目。在用户能够调用Web服务之前，必须确定这个服务内包含哪些商务方法，找到被调用的接口定义，还要在服务端来编制软件，UDDI是一种根据描述文档来引导系统查找相应服务的机制。UDDI利用SOAP消息机制（标准的XML/HTTP）来发布，编辑，浏览以及查找注册信息。它采用XML格式来封装各种不同类型的数据，并且发送到注册中心或者由注册中心来返回需要的数据。

webservice现在应用的非常广泛,概念的东西这里就不在赘述了,闲话少说,我喜欢用代码来进行学习,现在开始我们的第一步.

使用java进行发布

这里定义了一个接口与一个实现类，用来进行发布。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
**接口**
/**
 * 使用java发布接口
 * Created by wsylp on 2017/10/17.
 */
@WebService
public interface JavaPublish {
     void publish(String name);
}

**实现**
/**
 * 实现接口
 * Created by wsylp on 2017/10/17.
 */
@WebService(
    serviceName = "JavaPublish",
    portName = "JavaPublishPort",
    endpointInterface = "wsylp.ws.jdkPub.JavaPublish"
)
public class JavaPublishImpl implements JavaPublish {

    @Override
    public void publish(String name) {
        System.out.println("我们使用java进行发布:" + name);
    }
}
@WebService用来定义该类是一个webservice


**服务端**
这里简单的使用java main方法进行发布上面的接口与实现
import javax.xml.ws.Endpoint;

/**
 * 用来发布WebService的服务端
 * Created by wsylp on 2017/10/17.
 */
public class Server {

    public static void main(String[] args) {
        //ws的服务地址,可以在浏览器中直接输入该地址,http://localhost/ismg/wsylp/javaPub/javaPub?wsdl
        String adress = "http://localhost/ismg/wsylp/javaPub/javaPub";
        JavaPublish javaPublish = new JavaPublishImpl();

        Endpoint.publish(adress,javaPublish);
        System.out.println("webservice 已经发布.....");
    }
}

我们运行Server的main方法就可以输入地址,进行查看,这个就是wsdl的xml文件,中间有方法名,参数等,大家可以进行仔细看下.

使用wsimport命令

我们进行调用的时候，可以使用java 自带的wsimport将wsdl大包为jar包，依赖后就可以进行调用。

简单说明下wsimport(在java bin目录下)的命令
wsimport wsdlAdress 默认为当前路径下进行解
-d 表示输出的目录，目录必须事先存在，否则导出失败。
-keep表示导出webservice的class文件时是否也导出源代码java文件。
-verbose表示详细信息。
例如:
wsimport -d folder wsdladress
wsimport -d folder -keep wsdladress
wsimport -d folder -keep -verbose wsdlAdress

1
2
3
4
5
6
现在我们使用命令进行打包:
wsimport -d webservice -keep -verbose http://localhost/ismg/wsylp/javaPub/javaPub?wsdl
现在进行打包:
jar  -cvf javaPub.jar wsylp/*  : 将webservice目录下的所有文件压缩为jar文件
等价于
jar -cvf javaPub.jar  * -c wsylp

客户端调用

引用jar进行测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import wsylp.ws.jdkpub.JavaPublish;
import wsylp.ws.jdkpub.JavaPublish_Service;

/**
 * 测试引用的jar,进行webservice测试
 * @author wsylp
 *
 */
public class Client {

    public static void main(String[] args) {

        JavaPublish_Service ws = new JavaPublish_Service();
        JavaPublish jp = ws.getJavaPublishPort();
        jp.publish("哈哈");

    }
}

结果:

1
2
webservice 已经发布.....
我们使用java进行发布:哈哈

如果你不想进行打包,你也可以进行这样操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.net.URL;

import javax.xml.namespace.QName;
import javax.xml.ws.Service;

import wsylp.ws.jdkpub.JavaPublish;

public class DyClient {

    public static void main(String[] args) {
        try {
            URL wsdl = new URL("http://localhost/ismg/wsylp/javaPub/javaPub?wsdl");
            QName serviceName = new QName("http://jdkPub.ws.wsylp/", "JavaPublish");
            QName portName = new QName("http://jdkPub.ws.wsylp/", "JavaPublishPort");
            Service service = Service.create(wsdl, serviceName);

            JavaPublish jp = service.getPort(portName, JavaPublish.class);
            jp.publish("哈哈");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

使用CXF框架

简单介绍下CXF(引用百度百科)
CXF：Apache CXF = Celtix + XFire，开始叫 Apache CeltiXfire，后来更名为 Apache CXF 。

CXF 继承了 Celtix 和 XFire 两大开源项目的精华，提供了对 JAX-WS 全面的支持，并且提供了多种 Binding 、DataBinding、Transport 以及各种 Format 的支持，并且可以根据实际项目的需要，采用代码优先（Code First）或者 WSDL 优先（WSDL First）来轻松地实现 Web Services 的发布和使用。
Apache CXF 是一个开源的 Services 框架，CXF 帮助您利用 Frontend 编程 API 来构建和开发 Services ，像 JAX-WS 。这些 Services 可以支持多种协议，比如：SOAP、XML/HTTP、RESTful HTTP 或者 CORBA ，并且可以在多种传输协议上运行，比如：HTTP、JMS 或者 JBI，CXF 大大简化了 Services 的创建，同时它继承了 XFire 传统，一样可以天然地和 Spring 进行无缝集成。

在项目中我们不可能频繁的打包,在者使用java发布的方式的确比较繁琐,目前用的最多的就是CXF了.
在这里我使用ssm框架与CXf进行整合:
首先我说下使用的jar包:注意:本人使用的是gradle进行依赖的.

1
2
3
4
compile group: 'org.apache.cxf', name: 'apache-cxf', version: '3.2.0', ext: 'pom'
compile group: 'org.apache.cxf', name: 'cxf-rt-frontend-jaxws', version: '3.2.0'
compile group: 'org.apache.cxf', name: 'cxf-rt-transports-http-jetty', version: '3.2.0'
compile group: 'org.apache.cxf', name: 'cxf-rt-transports-http', version: '3.2.0'

java代码

接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package wsylp.ws.spring_cxf;

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

/**
 * Created by wsylp on 2017/10/19.
 */


@WebService
public interface SpringCxfService {
    @WebMethod
    void useSpringCxfService(String name);
}

实现接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package wsylp.ws.spring_cxf;

import javax.jws.WebService;
import org.springframework.stereotype.Component;

/**
 - Created by wsylp on 2017/10/19.
 */
@WebService
@Component
public class SpringCxfServiceImpl implements SpringCxfService {

    @Override
    public void useSpringCxfService(String name) {
        System.out.println("使用spring与cxf进行使用wenservice:" + name);
    }
}

配置文件

在这里我将CXF的配置文件进行单独编写(spring-cxf.xml)
一定要在context中加载配置文件，不然后报错。
在web.xml进行配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring-m*.xml,classpath*:spring-cxf.xml</param-value>
  </context-param>

<servlet>
    <servlet-name>CXFServlet</servlet-name>
    <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
    <load-on-startup>2</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>CXFServlet</servlet-name>
    <url-pattern>/ws/*</url-pattern>
  </servlet-mapping>

spring-cxf.xml配置
这里采用的简单的配置,还有另外两种方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<jaxws:endpoint id="springCxfService" implementor="#springCxfServiceImpl" address="/mywebservice" >
  </jaxws:endpoint>

<!--  <jaxws:server id="springCxfService" address="/mywebservice">
    <jaxws:serviceBean>
      <ref bean="springCxfServiceImpl"/>
    </jaxws:serviceBean>
  </jaxws:server>-->

  <!--simple方式进行发布-->
 <!-- <simple:server id="springCxfService" serviceClass="#springCxfService" address="/mywebservice">
    <simple:serviceBean>
      <ref bean="#springCxfServiceImpl"/>
    </simple:serviceBean>
  </simple:server>-->

启动tomcat-

我们可以输入项目http://localhost:8080/ismg/ws进行查看

输入http://localhost:8080/ismg/ws/mywebservice?wsdl

1
2
3
4
5
<wsdl:definitions name="SpringCxfServiceImplService" targetNamespace="http://spring_cxf.ws.wsylp/"><wsdl:types><xs:schema elementFormDefault="unqualified" targetNamespace="http://spring_cxf.ws.wsylp/" version="1.0"><xs:element name="useSpringCxfService" type="tns:useSpringCxfService"/><xs:element name="useSpringCxfServiceResponse" type="tns:useSpringCxfServiceResponse"/><xs:complexType name="useSpringCxfService"><xs:sequence><xs:element minOccurs="0" name="arg0" type="xs:string"/></xs:sequence></xs:complexType><xs:complexType name="useSpringCxfServiceResponse"><xs:sequence/></xs:complexType></xs:schema></wsdl:types><wsdl:message name="useSpringCxfService"><wsdl:part element="tns:useSpringCxfService" name="parameters">
    </wsdl:part></wsdl:message><wsdl:message name="useSpringCxfServiceResponse"><wsdl:part element="tns:useSpringCxfServiceResponse" name="parameters">
    </wsdl:part></wsdl:message><wsdl:portType name="SpringCxfService"><wsdl:operation name="useSpringCxfService"><wsdl:input message="tns:useSpringCxfService" name="useSpringCxfService">
    </wsdl:input><wsdl:output message="tns:useSpringCxfServiceResponse" name="useSpringCxfServiceResponse">
    </wsdl:output></wsdl:operation></wsdl:portType><wsdl:binding name="SpringCxfServiceImplServiceSoapBinding" type="tns:SpringCxfService"><soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/><wsdl:operation name="useSpringCxfService"><soap:operation soapAction="" style="document"/><wsdl:input name="useSpringCxfService"><soap:body use="literal"/></wsdl:input><wsdl:output name="useSpringCxfServiceResponse"><soap:body use="literal"/></wsdl:output></wsdl:operation></wsdl:binding><wsdl:service name="SpringCxfServiceImplService"><wsdl:port binding="tns:SpringCxfServiceImplServiceSoapBinding" name="SpringCxfServiceImplPort"><soap:address location="http://localhost:8080/ismg/ws/mywebservice"/></wsdl:port></wsdl:service></wsdl:definitions>

调用webservice

这里首先我们先测试一下,使用单元测试

1
2
3
4
5
6
7
8
9
10
11
12
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath*:spring-*.xml"})
public class WsTest {

    @Autowired
    private SpringCxfService springCxfService;

    @Test
    public void testWs() {
        springCxfService.useSpringCxfService("我在测试.....");
    }
}

测试结果

1
2
[21:53:01:290] [DEBUG] - org.apache.ibatis.logging.LogFactory.setImplementation(LogFactory.java:135) - Logging initialized using 'class org.apache.ibatis.logging.log4j2.Log4j2Impl' adapter.
使用spring与cxf进行使用wenservice:我在测试.....

在实际的项目中我们可以采取生成客户端的方式
在eclipse中选中项目,new->other->搜索client->选中webservice client
生成文件如下

1
2
3
4
5
SpringCxfService.java
SpringCxfServiceImplService.java
SpringCxfServiceImplServiceLocator.java
SpringCxfServiceImplServiceSoapBindingStub.java
SpringCxfServiceProxy.java

将生成的客户端当做service进行使用即可.

REST与CXF

REST是继SOAP之后有一种广泛使用的Web服务，但是REST没有WSDL,。
rest，即REST（RepresentationalStateTransfer表述性状态转移）是一种针对网络应用的设计和开发方式，可以降低开发的复杂性，提高系统的可伸缩性。现如今在三种主流的Web服务实现方案中，因为REST模式的Web服务与复杂的SOAP和XML-RPC对比来讲明显的更加简洁，越来越多的web服务开始采用REST风格设计和实现。例如，Amazon.com提供接近REST风格的Web服务进行图书查找；雅虎提供的Web服务也是REST风格的。 (来自搜狗百科)
REST 本质上是使用 URL 来访问资源的一种方式。
请求方式：GET（查）、POST（增）、PUT（改）、DELETE（删）、HEAD、OPTIONS；
GET用来获取资源，
POST用来新建资源（也可以用于更新资源），
PUT用来更新资源，
DELETE用来删除资源。

接口以及实现类

用来发布的接口以及实现
接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
package wsylp.ws.rest;

import java.util.List;
import java.util.Map;
import javax.jws.WebService;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.FormParam;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import wsylp.po.User;

/**
 * rest方式进行webservice
 * Created by wsylp on 2017/10/22.
 *
 *
 * 请求方式注解，包括：@GET、@POST、@PUT、@DELETE
 * 请求路径注解，包括：@Path，其中包括一个路径参数
 * 数据格式注解，包括：@Consumes（输入）、@Produces（输出），可使用 MediaType 常量
 * 相关参数注解，包括：@PathParam（路径参数）、@FormParam（表单参数），此外还有 @QueryParam（请求参数）
 * GET用来获取资源，
 * POST用来新建资源（也可以用于更新资源），
 * PUT用来更新资源，
 * DELETE用来删除资源。
 */
public interface UserWebservice {

    @GET
    @Path("/user")
    @Produces(MediaType.APPLICATION_JSON)
    List<User> getUser();

    @GET
    @Path("/user/{id}")
    @Produces(MediaType.APPLICATION_JSON)
    User getUserById(@PathParam("id") long id);

    @POST
    @Path("/user")
    @Consumes(MediaType.APPLICATION_FORM_URLENCODED)
    @Produces(MediaType.APPLICATION_JSON)
    User updateUserByLoginName(@FormParam("loginName") String name);

    @POST
    @Path("/user")
    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(MediaType.APPLICATION_JSON)
    User createUser(User user);

    @PUT
    @Path("/user/{id}")
    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(MediaType.APPLICATION_JSON)
    User updateUserById(@PathParam("id") long id, Map<String, Object> fieldMap);

    @DELETE
    @Path("/user/{id}")
    @Produces(MediaType.APPLICATION_JSON)
    User deleteUserById(@PathParam("id") long id);
}

实现（这里没有写实现方法的内部处理）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
package wsylp.ws.rest;

import java.util.List;
import java.util.Map;
import javax.jws.WebService;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.FormParam;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import wsylp.po.User;

@Component
public class UserWebserviceImpl implements UserWebservice {

    @Override
    public List<User> getUser() {
        return null;
    }

    @Override
    public User getUserById(long id) {
        return null;
    }

    @Override
    public User updateUserByLoginName(String name) {
        return null;
    }


    @Override
    public User createUser(User user) {
        return null;
    }

    @Override
    public User updateUserById(long id, Map<String, Object> fieldMap) {
        return null;
    }

    @Override
    public User deleteUserById(long id) {
        return null;
    }
}

配置web.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<context-param>
    <param-name>contextConfigLocation</param-name>
   <!-- ,classpath*:spring-cxf-rest.xml-->
    <param-value>classpath:spring-m*.xml,classpath*:spring-cxf-rest.xml</param-value>
  </context-param>

<servlet>
    <servlet-name>CXFServlet</servlet-name>
    <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
    <load-on-startup>2</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>CXFServlet</servlet-name>
    <url-pattern>/ws/*</url-pattern>
  </servlet-mapping>

配置spring-cxf-rest.xml

1
2
3
4
5
6
7
8
9
<bean id="jsonProvider" class="com.fasterxml.jackson.jaxrs.json.JacksonJsonProvider"/>
  <jaxrs:server address="/rest">
    <jaxrs:serviceBeans>
      <ref bean="userWebserviceImpl"/>
    </jaxrs:serviceBeans>
    <jaxrs:providers>
      <ref bean="jsonProvider"/>
    </jaxrs:providers>
  </jaxrs:server>

启动tomcat并调用

1
2
3
4
5
6
7
8
9
10
$(function() {
    $.ajax({
      type: 'get',
      url: 'http://localhost:8080/ismg/ws/rest/user',
      dataType: 'json',
      success: function(data) {
       console.log(data);
      }
    });
  });

由于没有写内部的代码，这里进行调用打断点的时候可以看到进入方法。

后话
实际的开发当中webservice都是给别的项目进行调用的，不在本项目中使用，因此一般会跨域。
这部分没有测试（具体结果不清楚）

使用 JSONP 解决 AJAX 跨域问题
JSONP 的全称是 JSON with Padding，实际上是在需要返回的 JSON 数据外，用一个 JS 函数进行封装。

可以这样来理解，服务器返回一个 JS 函数，参数是一个 JSON 数据，例如：callback({您的 JSON 数据})，虽然 AJAX 不能跨域访问，但 JS 脚本是可以跨域执行的，因此客户端将执行这个 callback 函数，并获取其中的 JSON 数据。

配置文件在上面已经介绍过了，下面直接进行使用：
spring-cxf-rest.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<bean id="jsonProvider" class="com.fasterxml.jackson.jaxrs.json.JacksonJsonProvider"/>

 <!--jsonp使用-->
 <bean id="jsonpInInterceptor" class="org.apache.cxf.jaxrs.provider.jsonp.JsonpInInterceptor"/>
 <bean id="jsonpPreStreamInterceptor" class="org.apache.cxf.jaxrs.provider.jsonp.JsonpPreStreamInterceptor"/>
 <bean id="jsonpPostStreamInterceptor" class="org.apache.cxf.jaxrs.provider.jsonp.JsonpPostStreamInterceptor"/>

<jaxrs:server address="/rest">
   <jaxrs:serviceBeans>
     <ref bean="userWebserviceImpl"/>
   </jaxrs:serviceBeans>
   <jaxrs:providers>
     <ref bean="jsonProvider"/>
     <ref bean="jsonpPreStreamInterceptor"/>
   </jaxrs:providers>
   <jaxrs:inInterceptors>
     <ref bean="jsonpInInterceptor"/>
   </jaxrs:inInterceptors>
   <jaxrs:outInterceptors>
     <ref bean="jsonpPostStreamInterceptor"/>
   </jaxrs:outInterceptors>
 </jaxrs:server>

使用 CORS 解决 AJAX 跨域问题
在 IE8 中使用 jQuery 发送 AJAX 请求时，需要配置 $.support.cors = true，才能开启 CORS 特性

1
2
3
4
5
6
7
8
9
10
11
12
<!--使用 CORS 解决 AJAX 跨域问题-->
 <jaxrs:server address="/rest">
   <jaxrs:serviceBeans>
     <ref bean="userWebserviceImpl"/>
   </jaxrs:serviceBeans>
   <jaxrs:providers>
     <bean class="com.fasterxml.jackson.jaxrs.json.JacksonJsonProvider"/>
     <bean class="org.apache.cxf.rs.security.cors.CrossOriginResourceSharingFilter">
       <property name="allowOrigins" value="http://localhost"/>
     </bean>
   </jaxrs:providers>
 </jaxrs:server>

本文参考了这里写链接内容

本文标题:Web Service探索

文章作者:wsylp

发布时间:2018年06月01日 - 13:06

最后更新:2020年01月02日 - 10:01

原始链接:http://wsylp.github.io/2018/06/01/Web-Service探索/

许可协议: 本文为 wsylp 版权所有 转载请保留原文链接及作者。

-------------本文结束感谢阅读-------------