Web Service探索

概念

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.top/2018/06/01/Web-Service探索/

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

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