在本文中，我们将为您详细介绍WebService-RESTful和SOAP笔记的相关知识，并且为您解答关于soaprestfulwebservice区别的疑问，此外，我们还会提供一些关于CXF结合sp

在本文中，我们将为您详细介绍Web Service - RESTful 和 SOAP 笔记的相关知识，并且为您解答关于soap restful webservice 区别的疑问，此外，我们还会提供一些关于CXF 结合 spring 发布 WS 服务，含 SOAP services、RESTful services、java – SOAP webservice和RESTFUL webservice之间的区别、restful webservice SOAP webservice、RESTful Webservice 和 SOAP Webserivce 对比及区别的有用信息。

本文目录一览：

• Web Service - RESTful 和 SOAP 笔记（soap restful webservice 区别）
• CXF 结合 spring 发布 WS 服务，含 SOAP services、RESTful services
• java – SOAP webservice和RESTFUL webservice之间的区别
• restful webservice SOAP webservice
• RESTful Webservice 和 SOAP Webserivce 对比及区别

Web Service - RESTful 和 SOAP 笔记（soap restful webservice 区别）

1.什么是Web Service（Web服务）

从表面上看，Web Service就是一个应用程序，它向外界暴露出一个能够通过Web进行调用的API。

这就是说，你能够用编程的方法透明的调用这个应用程序，不需要了解 它的任何细节，

跟你使用的编程语言也没有关系。

例如可以创建一个提供天气预报的Web Service，那么无论你用哪种编程语言开发的应用，都可以通过调用它的API并传入城市信息来获得该城市的天气预报。

之所以称之为Web Service，是因为它基于HTTP协议传输数据，

这使得运行在不同机器上的不同应用无须借助附加的、专门的第三方软件或硬件，

就可相互交换数据或集 成。

2.SOA（Service-Oriented Architecture，面向服务的架构）

SOA是一种思想，它将应用程序的不同功能单元通过中立的契约联系起来，

    独立于硬件平台、操作系统和编程语言，使得各种形式的功能单元能够更好的集成。

    显然，Web Service是SOA的一种较好的解决方案，它更多的是一种标准，而不是一种具体的技术。

3.概念解释：SOAP、WSDL、UDDI

SOAP	简单对象访问协议（Simple   Object Access Protocol）， 是Web   Service中交换数据的一种协议规范。
WSDL	Web服务描述语言（Web   Service Description Language）， 它描述了Web服务的公共接口。 这是一个基于XML的关于如何与Web服务通讯和使用的服务描述； 也就是描述与目录中列出的Web服 务进行交互时需要绑定的协议和信息格式。 通常采用抽象语言描述该服务支持的操作和信息， 使用的时候再将实际的网络协议和信息格式绑定给该服务。
UDDI	统一描述、发现和集成（Universal   Description, Discovery and Integration）， 它是一个基于XML的跨平台的描述规范， 可以使世界范围内的企业在互联网上发布自己所提供的服务。 简单的说，UDDI是访问各 种WSDL的一个门面（可以参考设计模式中的门面模式）。

4.Java规范中和Web Service相关的规范有哪些

Java规范中和Web Service相关的有三个

JAX-WS(JSR 224)	这个规范是早期的基于SOAP的Web   Service规范JAX-RPC的替代版本， 它并不提供向下兼容性， 因为RPC样式的WSDL以及相关的API已经在Java   EE5中被移除了。 WS-MetaData是JAX-WS的依赖规范， 提供了基于注解配置Web   Service和SOAP消息的相关API。
JAXM(JSR 67)	定义了发送和接收消息所需的API,相当于Web   Service的服务器端
JAX-RS(JSR 311 & JSR 339 & JSR 370)	是针对REST（Representation   State Transfer）架构风格制定的一套Web Service规范。   REST是一种软件架构模式，是一种风格，           它不像SOAP那样本身承载着一种消息协议，           可以将REST视为基于HTTP协议的软件架构。 REST中最重要的两个概念是资源定位和资源操作，           而HTTP协议恰好完整的提供了这两个点。           HTTP协议中的URI可以完成资源定位，           而GET、POST、OPTION、DELETE方法可以完成资源操作。   因此REST完全依赖HTTP协议就可以完成Web   Service，           而不像SOAP协议那样只利用了HTTP的传输特性，           定位和操作都是由SOAP协议自身完成的，           也正是由于SOAP消息的存在使得基于SOAP的Web   Service显得笨重逐渐被淘汰。

5.REST和SOAP Web Service的比较

5.1什么是SOAP?

                SOAP (Simple Object Access Protocol) 顾名思义，是一个严格定义的信息交换协议，

用于在Web Service中，把远程调用和返回封装成机器可读的格式化数据。

事实上SOAP数据使用XML数据格式，

定义了一整套复杂的标签，以描述调用的远程过程、参数、返回值和出错信息等等。

而且随着需要的增长，又不得增加协议以支持安全性，

这使SOAP变得异常庞大，背离了简单的初衷。
另一方面，各个服务器都可以基于这个协议推出自己的API，

即使它们提供的服务及其相似，定义的API也不尽相同，这又导致了WSDL的诞生。

WSDL (Web Service Description Language) 也遵循XML格式，

用来描述哪个服务器提供什么服务，怎样找到它，以及该服务使用怎样的接口规范，

简言之，服务发现。

现在，使用Web Service的过程变成，

获得该服务的WSDL描述，

根据WSDL构造一条格式化的SOAP请求发送给服务器，

然后接收一条同样SOAP格式的应答，

最后根据先前的WSDL解码数据。

绝大多数情况下，请求和应答使用HTTP协议传输，那么发送请求就使用HTTP的POST方法。

5.2什么是REST？

REST (REpresentational State Transfort)，

形式上应该表述为客户端通过申请资源来实现状态的转换，

在这个角度，系统可以看成一台虚拟的状态机。

REST应该满足这样的特点：

1)客户端和服务器结构；

2)连接协议具有无状态性；

3)能够利用Cache机制增进性能；

4)层次化的系统；

5)按需代码。

说到底，REST只是一种架构风格，而不是协议或标准。

但这种风格对现有的以SOAP为代表的Web Service造成的冲击也是革命性的，

因为它面向资源，甚至连服务也抽象成资源，

因为它和HTTP紧密结合，因为它服务器无状态。

5.3REST与SOAP的区别？

即使绝大多数SOAP是运行在HTTP上，使用URI标识服务，

SOAP也仅仅使用POST方法发送请求，用一个唯一的URI标识服务的入口。
      对于SOAP，delete操作也要用POST方法来发送，

而其实HTTP协议有更合逻辑的DELETE方法可用。

REST为每一个资源指定一个唯一的URI，
                而用HTTP的4种方法GET、POST、PUT、DELETE直观地表示
                                获取、创建、更新和删除图书。

REST的优点?
                REST简单而直观，把HTTP协议利用到了极限。
                                1. 它用HTTP请求的头信息来指明资源的表示形式，
                                2. 用HTTP的错误机制来返回访问资源的错误。
                                                由此带来的直接好处是构建的成本减少了，
                                                例如用URI定位每一个资源可以利用通用成熟的技术，
                                                而不用再在服务器端开发一套资源访问机制。
                                3. 只需简单配置服务器就能规定资源的访问权限，
                                                例如通过禁止非GET访问把资源设成只读。
                                4. 服务器无状态带来了更多额外好处，
                                                因为每次请求都包含响应需要的所有信息，所有状态信息都存储在客户端，
                                                服务器的内存从庞大的状态信息中解放出来。
                                                而且现在即使一台服务器突然死机对客户的影响也微乎其微，
                                                因为另一台服务器可以马上代替它的位置，而不需要考虑恢复状态信息。
                                5. 更多的缓存也变成可能，
                                                而之前由于服务器有状态，对同一个URI的请求可能导致完全不同的响应。
                总体结果是，网络的容错性和延展性都增强了，这些本来是WEB设计的初衷，
                                日趋复杂和定制的WEB把它们破坏了，现在REST又返璞归真，
                                试图把Web Service带回简单的原则中来。
REST的不足之处？
                无状态带来了巨大的优势，同时也带来了难以解决的问题，
                                例如，怎样授权特定用户才能使用的服务？怎样验证用户身份？
                                如果坚持服务器无状态，也就是不记录用户登录状态，
                                势必要求每一次服务请求都包含完整的用户身份和验证信息。
                                在这种情况下，怎样避免冒认？怎样避免用户信息泄漏？
                                事实上，构建REST附属的安 全机制已经在讨论中，
                                其结果无非导致另一个SOAP：复杂的需求摧残了易用性。
      REST在面向资源的应用中左右逢源，但在面向事务的应用中却未如人意。
            面向资源的应用操作简单，无非创建、读取、改变、删除几项，
                                但是面向事务的应用不允许用户直接操作资源，
                                用户只需向系统提交一个事务说明要求，然后等待事 务的完成，
                                                就如一个网上银行的用户不直接修改账户和存款，
                                                而是提交一个事务告诉银行自己要转账。
                                                如果把这样的服务看成一种资源，
                                                                通过向资源发送POST请 求完成事务，那不过是SOAP的翻版而已。
                                                无论是这样，还是通过PUT来创建事务，
                                                                都改变了系统的状态（资源本身未改变，此处是改变了用户的余额），
                                                                显然 违背了REST直观的初衷。

CXF 结合 spring 发布 WS 服务，含 SOAP services、RESTful services

CXF 结合 spring 发布 WS 服务，含 SOAP services、RESTful services

1、访问：http://localhost:8088/sniperWS/services/
查看有哪些服务，包含 Available SOAP services、Available RESTful services

2、客户端调用 RESTful services：
http://localhost:8088/sniperWS/services/address/getSuggestions.query

调用示例：
$.ajax({
    url: "http://ip:port/sniperWS/services/address/getSuggestions.query",

    dataType: "json",
    data : {
        "address" : '' 罗湖 '',
        "max":10,
        "_type":"json"
    },
    cache : false,
    success: function(data) {
        var items = data.addressVO;
        for(var index in items) {
            alert(items[index].address);
        }
    },
    error : function(error) {
        alert(error);
    }
});

ws-services-context.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:jaxws="http://cxf.apache.org/jaxws" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:jaxrs="http://cxf.apache.org/jaxrs"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd
    http://cxf.apache.org/jaxrs http://cxf.apache.org/schemas/jaxrs.xsd" default-autowire="byName">
 <!--spring发布web服务配置 --> 
<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="addressService" class="cn.sniper.ws.service.AddressServiceImpl" />
<!-- 方式一：发布SOAP services -->
<!-- <jaxws:endpoint id="addressWS" implementor="#addressService" address="/addressWS" /> -->
<!-- 方式二：发布SOAP services -->
<jaxws:server id="addressWS" address="/addressWS"> 
     <jaxws:serviceBean> 
         <ref bean="addressService" /> 
     </jaxws:serviceBean> 
     
     <!-- <jaxws:inInterceptors>
  <bean ></bean>
  </jaxws:inInterceptors> -->
</jaxws:server>
<!-- 发布RESTful services-->
<jaxrs:server id="addressServiceWS" address="/address">
 <jaxrs:extensionMappings>
  <entry key="json" value="application/json" />
  <entry key="xml" value="application/xml" />
 </jaxrs:extensionMappings>
 
    <jaxrs:serviceBeans> 
        <ref bean="addressService" /> 
    </jaxrs:serviceBeans> 
    
    <!-- <jaxrs:inInterceptors>
  <bean ></bean>
 </jaxrs:inInterceptors> -->
</jaxrs:server>
</beans>

beans.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns=
 xmlns:xsi=
 xmlns:context=
 xmlns:aop=
 xmlns:tx=
 xsi:schemaLocation="http://www.springframework.org/schema/beans            http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

 <context:component-scan base-package="cn.sniper.ws.service"></context:component-scan>

 <import resource="ws-services-context.xml"/>
</beans>

AddressService

package cn.sniper.ws.service;
import java.util.List;
import javax.jws.WebParam;
import javax.jws.WebService;
import javax.jws.soap.SOAPBinding;
import javax.jws.soap.SOAPBinding.Style;
import cn.sniper.ws.po.Address;
@SOAPBinding(style = Style.DOCUMENT)
@WebService(targetNamespace = "http://cn.sniper.ws.service")
public interface AddressService {
 
 public List<Address> getSuggestions(@WebParam(name="address")String address, @WebParam(name="max")int max);
 
}

AddressServiceImpl

package cn.sniper.ws.service;
import java.util.ArrayList;
import java.util.List;
import javax.jws.WebService;
import javax.jws.soap.SOAPBinding;
import javax.jws.soap.SOAPBinding.Style;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.QueryParam;
import cn.sniper.ws.po.Address;
@Path(value="/")
@SOAPBinding(style = Style.DOCUMENT)
@WebService(
  serviceName = "address",
     portName = "address",
     targetNamespace = "http://cn.sniper.ws.service",
     endpointInterface = "cn.sniper.ws.service.AddressService")
public class AddressServiceImpl implements AddressService {
 
 @GET
    @Path("getSuggestions.query")
 public List<Address> getSuggestions(@QueryParam("address")String address, @QueryParam("max")int max) {
  List<Address> addressList = new ArrayList<Address>();
  addressList.add(new Address(1L, "admin-1"));
  addressList.add(new Address(2L, "admin-2"));
  
  return addressList;
 }
 
}

Address

package cn.sniper.ws.po;
import java.io.Serializable;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
/**
 * 注意，@XmlRootElement(name="addressVO")的name不要和属性的name重复，
 * 否则会导xml解析过程报错
 * @author audaque
 *
 */
@XmlRootElement(name="addressVO")
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(propOrder = {"id","address"})
public class Address implements Serializable {
 
 private static final long serialVersionUID = -1704617795954765535L;
 @XmlElement(name="id")
 private Long id;
 
 @XmlElement(name="address")
 private String address;
 public Address() {
 }
 
 public Address(Long id, String address) {
  this.id = id;
  this.address = address;
 }
 
 public Long getId() {
  return id;
 }
 public void setId(Long id) {
  this.id = id;
 }
 public String getAddress() {
  return address;
 }
 public void setAddress(String address) {
  this.address = address;
 }
 
}

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" 
 xmlns="http://java.sun.com/xml/ns/j2ee" 
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee 
 http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
 
 <!-- 通过上下文参数指定spring配置文件的位置 -->
 <context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>classpath:spring/beans.xml</param-value>
 </context-param>
  
   <!-- spring上下文载入器监听器,确保web服务器启动时,完成spring容器的初始化 ,放在了application范围中-->
 <listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 </listener>
 
 <!-- cxf -->
 <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>/services/*</url-pattern>
 </servlet-mapping>
</web-app>

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>cn.sniper.ws</groupId>
  <artifactId>sniperWS</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>sniperWS Maven Webapp</name>
  <url>http://maven.apache.org</url>
  
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 <spring.version>3.1.1.RELEASE</spring.version>
 <struts.version>2.3.4.1</struts.version>
 <hibernate.version>3.6.9.Final</hibernate.version>
 <junit.version>4.8.1</junit.version>
  </properties>
  <dependencies>
   
   <!-- spring配置 -->
   <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-core</artifactId>
  <version>${spring.version}</version>
 </dependency>
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-beans</artifactId>
  <version>${spring.version}</version>
 </dependency>
 
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>${spring.version}</version>
 </dependency>
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context-support</artifactId>
  <version>${spring.version}</version>
 </dependency>
 
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-oxm</artifactId>
  <version>${spring.version}</version>
 </dependency>
 
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-web</artifactId>
  <version>${spring.version}</version>
 </dependency>
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>${spring.version}</version>
 </dependency>
 
 <!-- 注解拦截，需要引入spring aop相关jar包 -->
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aop</artifactId>
  <version>${spring.version}</version>
 </dependency>
 
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aspects</artifactId>
  <version>${spring.version}</version>
 </dependency>
 
 <!-- spring jdbc -->
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-jdbc</artifactId>
  <version>${spring.version}</version>
 </dependency>
 
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-orm</artifactId>
  <version>${spring.version}</version>
 </dependency>
 
 <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-hibernate3</artifactId>
  <version>2.0.8</version>
 </dependency>
 
 <dependency>
  <groupId>cglib</groupId>
     <artifactId>cglib</artifactId>
     <version>2.2.2</version>
 </dependency>
 
 <!-- aspectj -->
 <dependency>  
  <groupId>org.aspectj</groupId>  
  <artifactId>aspectjrt</artifactId>  
  <version>1.7.4</version>  
 </dependency>
  
 <dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.7.4</version>
 </dependency>
 
 <dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjlib</artifactId>
  <version>1.6.2</version>
 </dependency>
 
 <!-- @ResponseBody 将数据转换成json的依赖包，如果没有依赖包，即使能够访问action，返回的时候也会报错 -->
 <!-- 解决：Could not find acceptable representation报错； 客户端报错：ajax not acceptable -->
 <!-- <dependency>
        <groupId>org.codehaus.jackson</groupId>
        <artifactId>jackson-core-asl</artifactId>
        <version>1.9.13</version>
    </dependency>
 <dependency>
  <groupId>org.codehaus.jackson</groupId>
  <artifactId>jackson-mapper-asl</artifactId>
  <version>1.9.13</version>
 </dependency> -->
 
 <!-- cxf -->
 <dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>apache-cxf</artifactId>
    <version>2.6.1</version>
    <type>pom</type>
   </dependency>
   <dependency>  
        <groupId>javax.ws.rs</groupId>  
        <artifactId>jsr311-api</artifactId>  
        <version>1.1.1</version>  
    </dependency>  
 
 <dependency>
  <groupId>net.sf.json-lib</groupId>
  <artifactId>json-lib</artifactId>
  <version>2.2.3</version>
  <classifier>jdk15</classifier>
 </dependency>
 
 <dependency>
  <groupId>commons-io</groupId>
     <artifactId>commons-io</artifactId>
     <version>2.3</version>
 </dependency>
 
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
  
  <build>
    <finalName>sniperWS</finalName>
  </build>
</project>

java – SOAP webservice和RESTFUL webservice之间的区别

restful webservice SOAP webservice

为了说明这个问题，必须的纠正一下我们对 HTTP 的认识。

首先回顾一下 OSI 七层模型

OSI（Open System Interconnection，开放系统互连）七层模型

7 应用层 

6 表示层 

5 会话层 

4 传输层 

3 网络层 

2 数据链路层 

1 物理层 

HTTP 并不是一种传输层的 “传输协议”（第四层），而是一种应用层的 “转移协议”（最高层）。

SOAP 类型的 WebService 就是最好的例子，SOAP 消息完全就是将 Http 协议作为消息承载，

以至于对于 Http 协议中的各种参数（例如编码，错误码等）都置之不顾。
 其实，它有着非常丰富的语义，Http 协议所抽象的 get,post,put,delete 就好比数据库中最基本的增删改查，而互联网上的各种资源就好比数据库中的记录。

restful webservice

Rest(Representional state transfer)
WEB 的在世界范围类的普及和成功，人们从技术角度对它的总结，既 -- 分布式架构，注意强调的是架构风格 - architectural style.
是一种全新的 Web 开发思维方式， 一种基于 Http 协议来资源操作的思想，是基于 URI 来设计系统的架构。
那么它的特点主要由以下五点
1. 面向资源（resource）
2. 每个资源都对应唯一的 URI uniform resource identifier
3. 抽象资源的操作，使用通用连接接口来操作资源 （generic connector interface）
4. 对资源的操作不会改变 URI
5. 所有的操作无状态 （stateless）
可以看出 REST 抽象资源的操作跟 HTTP 不谋而合，将 Http 协议的设计初衷作了诠释。

SOAP/WSDL webservice 

为了包装 RPC (Remote Procedure Call) 的请求信息，推出了 XML-RPC，但 XML-RPC 只能使用有限的数据类型种类和一些简单的数据结构。
于是就出现了 SOAP
SOAP（Simple Object Access Protocol） 是基于 XML 的结构化数据交换。SOAP 可以和多种传输协议绑定（Binding），如包括超文本传输协议（ HTTP），简单邮件传输协议（SMTP），多用途网际邮件扩充协议（MIME）使用底层协议交换信息，如： HTTP。

理论上，SOAP 就是一段 xml，你可以通过 HTTP，SMTP 等发送它 (复制到软盘上，叫快递公司送去也行)。

SOAP 跟 HTTP 的关系

SOAP 在 HTTP 协议的基础之上，一个基于 XML 的协议。即 HTTP + XML = SOAP 或者说 SOAP 方式是一个遵照 SOAP 编码规则的 HTTP 请求 / 响应。

WSDL

WSDL 是基于 SOAP 通信时的描述语言，WSDL 是用来描述 SOAP 的，也是一段 xml。

那么，我们可以从以下几个方面去比较它们的优劣

1. 成熟，规范

SOAP 比 REST 成熟，规范，受到很多厂商的支持，REST 只是提供了思想，所以大家还处在各自为战的局面。

2. 伸缩性

 REST 是基于 HTTP 协议实现资源操作，大大的降低了开发复杂度和伸缩性。

3. 效率，易用

SOAP 根据需求在不断的扩展协议的内容，导致处理性能下降，学习成本上升。而 REST 采用 ROA（Resource-Oriented Architecture，面向资源的体系架构）进行设计并且融合 WEB2.0 前端技术，提高了开发效率。

4. 安全性

SOAP 采用 XML-Security 和 XML-Signature 两个规范组成了 WS-Security 来实现安全控制，REST 目前没有任何说明。

RESTful Webservice 和 SOAP Webserivce 对比及区别

关于Web Service - RESTful 和 SOAP 笔记和soap restful webservice 区别的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于CXF 结合 spring 发布 WS 服务，含 SOAP services、RESTful services、java – SOAP webservice和RESTFUL webservice之间的区别、restful webservice SOAP webservice、RESTful Webservice 和 SOAP Webserivce 对比及区别的相关知识，请在本站寻找。

本文标签：

• web_service
• RESTful
• SOAP
• Webservice区别