网络应用程序,分为前端和后端两个部分。当前的发展趋势,就是前端设备层出不穷(手机、平板、桌面电脑、其他专用设备......)。
因此,必须有一种统一的机制,方便不同的前端设备与后端进行通信。这导致API构架的流行,甚至出现"API First"的设计思想。RESTful API是目前比较成熟的一套互联网应用程序的API设计理论。我以前写过一篇《理解RESTful架构》,探讨如何理解这个概念。
今天,我将介绍RESTful API的设计细节,探讨如何设计一套合理、好用的API。我的主要参考了两篇文章(1,2)。
一、协议
API与用户的通信协议,总是使用HTTPs协议。
二、域名
应该尽量将API部署在专用域名之下。
https://api.example.com
如果确定API很简单,不会有进一步扩展,可以考虑放在主域名下。
https://example.org/api/
三、版本(Versioning)
应该将API的版本号放入URL。
https://api.example.com/v1/
另一种做法是,将版本号放在HTTP头信息中,但不如放入URL方便和直观。Github采用这种做法。
四、路径(Endpoint)
路径又称"终点"(endpoint),表示API的具体网址。
在RESTful架构中,每个网址代表一种资源(resource),所以网址中不能有动词,只能有名词,而且所用的名词往往与数据库的表格名对应。一般来说,数据库中的表都是同种记录的"集合"(collection),所以API中的名词也应该使用复数。
举例来说,有一个API提供动物园(zoo)的信息,还包括各种动物和雇员的信息,则它的路径应该设计成下面这样。
- https://api.example.com/v1/zoos
- https://api.example.com/v1/animals
- https://api.example.com/v1/employees
五、HTTP动词
对于资源的具体操作类型,由HTTP动词表示。
常用的HTTP动词有下面五个(括号里是对应的SQL命令)。
- GET(SELECT):从服务器取出资源(一项或多项)。
- POST(CREATE):在服务器新建一个资源。
- PUT(UPDATE):在服务器更新资源(客户端提供改变后的完整资源)。
- PATCH(UPDATE):在服务器更新资源(客户端提供改变的属性)。
- DELETE(DELETE):从服务器删除资源。
还有两个不常用的HTTP动词。
- HEAD:获取资源的元数据。
- OPTIONS:获取信息,关于资源的哪些属性是客户端可以改变的。
下面是一些例子。
- GET /zoos:列出所有动物园
- POST /zoos:新建一个动物园
- GET /zoos/ID:获取某个指定动物园的信息
- PUT /zoos/ID:更新某个指定动物园的信息(提供该动物园的全部信息)
- PATCH /zoos/ID:更新某个指定动物园的信息(提供该动物园的部分信息)
- DELETE /zoos/ID:删除某个动物园
- GET /zoos/ID/animals:列出某个指定动物园的所有动物
- DELETE /zoos/ID/animals/ID:删除某个指定动物园的指定动物
六、过滤信息(Filtering)
如果记录数量很多,服务器不可能都将它们返回给用户。API应该提供参数,过滤返回结果。
下面是一些常见的参数。
- ?limit=10:指定返回记录的数量
- ?offset=10:指定返回记录的开始位置。
- ?page=2&per_page=100:指定第几页,以及每页的记录数。
- ?sortby=name&order=asc:指定返回结果按照哪个属性排序,以及排序顺序。
- ?animal_type_id=1:指定筛选条件
参数的设计允许存在冗余,即允许API路径和URL参数偶尔有重复。比如,GET /zoo/ID/animals 与 GET /animals?zoo_id=ID 的含义是相同的。
七、状态码(Status Codes)
服务器向用户返回的状态码和提示信息,常见的有以下一些(方括号中是该状态码对应的HTTP动词)。
- 200 OK - [GET]:服务器成功返回用户请求的数据,该操作是幂等的(Idempotent)。
- 201 CREATED - [POST/PUT/PATCH]:用户新建或修改数据成功。
- 202 Accepted - [*]:表示一个请求已经进入后台排队(异步任务)
- 204 NO CONTENT - [DELETE]:用户删除数据成功。
- 400 INVALID REQUEST - [POST/PUT/PATCH]:用户发出的请求有错误,服务器没有进行新建或修改数据的操作,该操作是幂等的。
- 401 Unauthorized - [*]:表示用户没有权限(令牌、用户名、密码错误)。
- 403 Forbidden - [*] 表示用户得到授权(与401错误相对),但是访问是被禁止的。
- 404 NOT FOUND - [*]:用户发出的请求针对的是不存在的记录,服务器没有进行操作,该操作是幂等的。
- 406 Not Acceptable - [GET]:用户请求的格式不可得(比如用户请求JSON格式,但是只有XML格式)。
- 410 Gone -[GET]:用户请求的资源被永久删除,且不会再得到的。
- 422 Unprocesable entity - [POST/PUT/PATCH] 当创建一个对象时,发生一个验证错误。
- 500 INTERNAL SERVER ERROR - [*]:服务器发生错误,用户将无法判断发出的请求是否成功。
状态码的完全列表参见这里。
八、错误处理(Error handling)
如果状态码是4xx,就应该向用户返回出错信息。一般来说,返回的信息中将error作为键名,出错信息作为键值即可。
{ error: "Invalid API key" }
九、返回结果
针对不同操作,服务器向用户返回的结果应该符合以下规范。
- GET /collection:返回资源对象的列表(数组)
- GET /collection/resource:返回单个资源对象
- POST /collection:返回新生成的资源对象
- PUT /collection/resource:返回完整的资源对象
- PATCH /collection/resource:返回完整的资源对象
- DELETE /collection/resource:返回一个空文档
十、Hypermedia API
RESTful API最好做到Hypermedia,即返回结果中提供链接,连向其他API方法,使得用户不查文档,也知道下一步应该做什么。
比如,当用户向api.example.com的根目录发出请求,会得到这样一个文档。
{"link": { "rel": "collection https://www.example.com/zoos", "href": "https://api.example.com/zoos", "title": "List of zoos", "type": "application/vnd.yourformat+json" }}
上面代码表示,文档中有一个link属性,用户读取这个属性就知道下一步该调用什么API了。rel表示这个API与当前网址的关系(collection关系,并给出该collection的网址),href表示API的路径,title表示API的标题,type表示返回类型。
Hypermedia API的设计被称为HATEOAS。Github的API就是这种设计,访问api.github.com会得到一个所有可用API的网址列表。
{ "current_user_url": "https://api.github.com/user", "authorizations_url": "https://api.github.com/authorizations", // ... }
从上面可以看到,如果想获取当前用户的信息,应该去访问api.github.com/user,然后就得到了下面结果。
{ "message": "Requires authentication", "documentation_url": "https://developer.github.com/v3" }
上面代码表示,服务器给出了提示信息,以及文档的网址。
十一、其他
(1)API的身份认证应该使用OAuth 2.0框架。
(2)服务器返回的数据格式,应该尽量使用JSON,避免使用XML。
REST 从资源的角度来观察整个网络,分布在各处的资源由URI确定,而客户端的应用通过URI来获取资源的表示方式。获得这些表徵致使这些应用程序转变了其状态。随着不断获取资源的表示方式,客户端应用不断地在转变着其状态,所谓表述性状态转移(Representational State Transfer)。
这一观点不是凭空臆造的,而是通过观察当前Web互联网的运作方式而抽象出来的。Roy Fielding 认为,
“设计良好的网络应用表现为一系列的网页,这些网页可以看作的虚拟的状态机,用户选择这些链接导致下一网页传输到用户端展现给使用的人,而这正代表了状态的转变。”
REST是设计风格而不是标准。REST通常基于使用HTTP,URI,和XML以及HTML这些现有的广泛流行的协议和标准。
- 资源是由URI来指定。
- 对资源的操作包括获取、创建、修改和删除资源,这些操作正好对应HTTP协议提供的GET、POST、PUT和DELETE方法。
- 通过操作资源的表现形式来操作资源。
- 资源的表现形式则是XML或者HTML,取决于读者是机器还是人,是消费web服务的客户软件还是web浏览器。当然也可以是任何其他的格式。
REST的要求
- 客户端和服务器结构
- 连接协议具有无状态性
- 能够利用Cache机制增进性能
- 层次化的系统
- 隨需代碼 - Javascript (可選)
RESTful Web 服务
RESTful Web 服务(也称为 RESTful Web API)是一个使用HTTP并遵循REST原则的Web服务。它从以下三个方面资源进行定义:URI,比如:http://example.com/resources/。
§ Web服务接受与返回的互联网媒体类型,比如:JSON,XML ,YAML 等。
§ Web服务在该资源上所支持的一系列请求方法(比如:POST,GET,PUT或DELETE)。
该表列出了在实现RESTful Web 服务时HTTP请求方法的典型用途。
HTTP 请求方法在RESTful Web 服务中的典型应用
资源 | GET | PUT | POST | DELETE |
一组资源的URI,比如http://example.com/resources/ | 列出 URI,以及该资源组中每个资源的详细信息(后者可选)。 | 使用给定的一组资源替换当前整组资源。 | 在本组资源中创建/追加一个新的资源。 该操作往往返回新资源的URL。 | 删除整组资源。 |
单个资源的URI,比如http://example.com/resources/142 | 获取 指定的资源的详细信息,格式可以自选一个合适的网络媒体类型(比如:XML、JSON等) | 替换/创建 指定的资源。并将其追加到相应的资源组中。 | 把指定的资源当做一个资源组,并在其下创建/追加一个新的元素,使其隶属于当前资源。 | 删除指定的元素。 |
PUT 和 DELETE 方法是幂等方法。GET方法是安全方法 (不会对服务器端有修改,因此也是幂等的)。
不像基于SOAP的Web服务,RESTful Web服务并没有的“正式”标准。 这是因为REST是一种架构,而SOAP只是一个协议。虽然REST不是一个标准,但在实现RESTful Web服务时可以使用其他各种标准(比如HTTP,URL,XML,PNG等)。
REST的优点
- 可以利用缓存Cache来提高响应速度
- 通讯本身的无状态性可以让不同的服务器的处理一系列请求中的不同请求,提高服务器的扩展性
- 浏览器即可作为客户端,简化软件需求
- 相对于其他叠加在HTTP协议之上的机制,REST的软件依赖性更小
- 不需要额外的资源发现机制
- 在软件技术演进中的长期的兼容性更好
Rest 开发
首先先定义接口IRestHandler:
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
|
/// <summary>
/// The IRestHandler is an interface which provides Delete,Get,Post and Put methods.
/// </summary>
public
interface
IRestHandler : ICloneable
{
/// <summary>
/// Delete method for RestHandler
/// </summary>
/// <param name="processor">The rest processor.</param>
/// <param name="authenticated">if set to <c>true</c> [authenticated].</param>
/// <returns>The http response</returns>
RestHandlerResponse Delete(IRestProcessor processor,
bool
authenticated);
/// <summary>
/// Get method for RestHandler
/// </summary>
/// <param name="processor">The rest processor.</param>
/// <param name="authenticated">if set to <c>true</c> [authenticated].</param>
/// <returns>The http response</returns>
RestHandlerResponse Get(IRestProcessor processor,
bool
authenticated);
/// <summary>
/// Post method for RestHandler
/// </summary>
/// <param name="processor">The rest processor.</param>
/// <param name="authenticated">if set to <c>true</c> [authenticated].</param>
/// <returns>The http response</returns>
RestHandlerResponse Post(IRestProcessor processor,
bool
authenticated);
/// <summary>
/// Put method for RestHandler
/// </summary>
/// <param name="processor">The rest processor.</param>
/// <param name="authenticated">if set to <c>true</c> [authenticated].</param>
/// <returns>The http response</returns>
RestHandlerResponse Put(IRestProcessor processor,
bool
authenticated);
}
|
我们要定义一个HttpListener,先定义一个接口IRestListener:
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
|
/// <summary>
/// Listen an ip point and accept connection.
/// </summary>
public
interface
IRestListener : IDisposable
{
/// <summary>
/// Gets or sets the max allowed connections to this listener.
/// </summary>
int
MaxConnections {
get
;
set
; }
/// <summary>
/// Gets or sets desktop rest manager.
/// </summary>
DesktopRestManager DesktopRestManager {
get
;
set
; }
/// <summary>
/// Gets a value that indicate if it is listening.
/// </summary>
bool
IsRunning {
get
; }
/// <summary>
/// Gets or sets the server address information.
/// </summary>
IPEndPoint ServerAddress {
get
;
set
; }
string
Protocol {
get
;
set
; }
/// <summary>
/// Start a listener.
/// </summary>
/// <returns>The ip end point to listen.</returns>
bool
Start(TcpListener listener, IPEndPoint address);
/// <summary>
/// Stop the listener.
/// </summary>
/// <returns>True if successfully, else false.</returns>
bool
Stop();
}
|
接下来实现
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
public
class
HttpListener : IRestListener
{
public
HttpListener(DesktopRestManager drm)
{
this
.desktopRestManager = drm;
this
.isRunning =
false
;
MaxConnections = 50;
this
.serverAddress =
new
IPEndPoint(
new
IPAddress(
new
byte
[] { 127, 0, 0, 1 }), 10000);
this
.Protocol =
"Http"
;
}
#region IRestServer Members
//public event ServerStatusChangedHandler ServerStatusChanged;
public
DesktopRestManager DesktopRestManager
{
get
{
return
this
.desktopRestManager; }
set
{
this
.desktopRestManager = value; }
}
public
bool
IsRunning
{
get
{
return
this
.isRunning; }
}
public
IPEndPoint ServerAddress
{
get
{
return
this
.serverAddress; }
set
{
this
.serverAddress = value; }
}
public
int
MaxConnections
{
get
;
set
;
}
public
string
Protocol
{
get
;
set
;
}
public
bool
Start(TcpListener tcpListener, IPEndPoint address)
{
this
.ServerAddress = address;
this
.listener = tcpListener;
this
.isRunning =
true
;
Thread th =
new
Thread(
new
ThreadStart(
this
.Listening));
th.Start();
return
true
;
}
public
bool
Stop()
{
bool
success =
true
; ;
if
(
this
.isRunning ==
true
)
{
try
{
this
.isRunning =
false
;
if
(listener !=
null
)
{
listener.Stop();
}
}
catch
(SocketException socketEx)
{
_traceLog.InfoFormat(
"Stop http rest server: {0}"
, socketEx.Message);
success =
false
;
}
}
return
success;
}
#endregion
#region IDisposable Members
public
void
Dispose()
{
this
.Stop();
}
#endregion
#region Private Methods
private
void
Listening()
{
while
(
this
.isRunning)
{
TcpClient tcpClient =
null
;
try
{
tcpClient = listener.AcceptTcpClient();
HttpConnection connection =
new
HttpConnection(tcpClient);
RestProcessor rh =
new
RestProcessor(
this
.desktopRestManager);
Thread processThread =
new
Thread(
new
ParameterizedThreadStart(req => connection.SendResponse(rh.HandleRequest(req
as
RestHandlerRequest))));
processThread.Name =
"RestManager_Http_ProcessRequest"
;
processThread.Start(connection.GetRequest());
}
catch
(SocketException socketEx)
{
if
(
this
.isRunning)
{
_traceLog.InfoFormat(
"Socket exception: {0}"
, socketEx.Message);
}
else
{
_traceLog.Info(
"The use stop the http listener."
);
}
if
(tcpClient !=
null
&& tcpClient.Connected)
{
tcpClient.Close();
}
}
catch
(System.ArgumentNullException ex)
{
_traceLog.ErrorFormat(
"Error occured: {0}"
, ex.Message);
}
catch
(System.OutOfMemoryException ex)
{
_traceLog.ErrorFormat(
"Error occured: {0}"
, ex.Message);
}
catch
(System.Threading.ThreadStateException ex)
{
_traceLog.ErrorFormat(
"Error occured: {0}"
, ex.Message);
}
catch
(System.InvalidOperationException ex)
{
_traceLog.ErrorFormat(
"Error occured: {0}"
, ex.Message);
}
catch
(ApplicationException ex)
{
_traceLog.ErrorFormat(
"Error occured: {0}"
, ex.Message);
}
}
this
.Stop();
}
#endregion
#region Private Members
private
DesktopRestManager desktopRestManager;
private
bool
isRunning;
private
IPEndPoint serverAddress;
private
TcpListener listener;
private
static
LogManager _traceLog =
new
LogManager(
"RestManager-HttpListener"
);
#endregion
}
|
接下来处理HandleRequest:
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
|
/// <summary>
/// Handles an http request for an Api call.
/// </summary>
public
RestHandlerResponse HandleRequest(RestHandlerRequest rhr)
{
RestHandlerResponse res;
// 50 Requests in maximum
if
(!
this
.restProcessorSemaphore.WaitOne(0))
{
res =
new
RestHandlerResponse(503);
}
else
{
try
{
// There is no need decode the url here, since the address will be decoded when it is parsed.
//rhr.Address = System.Web.HttpUtility.UrlDecode(rhr.Address);
res =
this
.process(rhr);
}
catch
(RestManagerException ex)
{
traceLog.ErrorFormat(
"Error happened while processing request\n{1}.\nException info:\n{0} "
,ex.Message);
res =
new
RestHandlerResponse(500);
}
try
{
this
.restProcessorSemaphore.Release();
}
catch
(System.Threading.SemaphoreFullException)
{
traceLog.ErrorFormat(
"Error happened while processing Semaphore.Release"
);
}
catch
(System.IO.IOException)
{
traceLog.ErrorFormat(
"Error happened while processing Semaphore.Release"
);
}
catch
(System.UnauthorizedAccessException)
{
traceLog.ErrorFormat(
"Error happened while processing Semaphore.Release"
);
}
}
return
res;
}
|
接下来我们写发送请求代码:
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
|
private
JObject MakeRequest(
string
url)
{
var
subsequentRequest = WebRequest.Create(url)
as
HttpWebRequest;
subsequentRequest.Timeout = 30000;
subsequentRequest.Headers.Add(
"Authorization"
,
"OAuth "
+ TestToken);
subsequentRequest.Headers.Add(
"App-User"
, TestUserName);
WebResponse subsequentResponse;
try
{
subsequentResponse = subsequentRequest.GetResponse();
Stream stream = subsequentResponse.GetResponseStream();
StreamReader sr =
new
StreamReader(stream);
string
output = sr.ReadToEnd();
JObject jsonStr = JObject.Parse(output);
return
jsonStr;
}
catch
(WebException ex)
{
if
(ex.Response !=
null
)
{
HttpWebResponse errorResponse = (HttpWebResponse)ex.Response;
StreamReader reader =
new
StreamReader(errorResponse.GetResponseStream());
string
output = reader.ReadToEnd();
JObject jsonStr = JObject.Parse(output);
return
jsonStr;
}
else
{
return
null
;
}
}
}
|
涉及项目的原因,代码只能提供这么多了,仅供参考
Json的返回结果格式如下,:
1
|
[{
"CreatedDate"
:
"//Date(1299687080328+0800)//"
,
"Detail"
:
"Do Something 1"
,
"Title"
:
"Task1"
},{
"CreatedDate"
:
"//Date(1299687080328+0800)//"
,
"Detail"
:
"Do Something 5"
,
"Title"
:
"Task5"
}]
|
REST vs SOAP
成熟度:
SOAP虽然发展到现在已经脱离了初衷,但是对于异构环境服务发布和调用,以及厂商的支持都已经达到了较为成熟的情况。不同平台,开发语言之间通过SOAP来交互的web service都能够较好的互通(在部分复杂和特殊的参数和返回对象解析上,协议没有作很细致的规定,导致还是需要作部分修正)
REST国外很多大网站都发布了自己的开发API,很多都提供了SOAP和REST两种Web Service,根据调查部分网站的REST风格的使用情况要高于SOAP。但是由于REST只是一种基于Http协议实现资源操作的思想,因此各个网站的REST实现都自有一套,在后面会讲诉各个大网站的REST API的风格。也正是因为这种各自实现的情况,在性能和可用性上会大大高于SOAP发布的web service,但统一通用方面远远不及SOAP。由于这些大网站的SP往往专注于此网站的API开发,因此通用性要求不高。
由于没有类似于SOAP的权威性协议作为规范,REST实现的各种协议仅仅只能算是私有协议,当然需要遵循REST的思想,但是这样细节方面有太多没有约束的地方。REST日后的发展所走向规范也会直接影响到这部分的设计是否能够有很好的生命力。
总的来说SOAP在成熟度上优于REST。
效率和易用性:
SOAP协议对于消息体和消息头都有定义,同时消息头的可扩展性为各种互联网的标准提供了扩展的基础,WS-*系列就是较为成功的规范。但是也由于SOAP由于各种需求不断扩充其本身协议的内容,导致在SOAP处理方面的性能有所下降。同时在易用性方面以及学习成本上也有所增加。
REST被人们的重视,其实很大一方面也是因为其高效以及简洁易用的特性。这种高效一方面源于其面向资源接口设计以及操作抽象简化了开发者的不良设计,同时也最大限度的利用了Http最初的应用协议设计理念。同时,在我看来REST还有一个很吸引开发者的就是能够很好的融合当前Web2.0的很多前端技术来提高开发效率。例如很多大型网站开放的REST风格的API都会有多种返回形式,除了传统的xml作为数据承载,还有(JSON,RSS,ATOM)等形式,这对很多网站前端开发人员来说就能够很好的mashup各种资源信息。
因此在效率和易用性上来说,REST更胜一筹。
安全性:
这点其实可以放入到成熟度中,不过在当前的互联网应用和平台开发设计过程中,安全已经被提到了很高的高度,特别是作为外部接口给第三方调用,安全性可能会高过业务逻辑本身。
SOAP在安全方面是通过使用XML-Security和XML-Signature两个规范组成了WS-Security来实现安全控制的,当前已经得到了各个厂商的支持,.net ,php ,java 都已经对其有了很好的支持(虽然在一些细节上还是有不兼容的问题,但是互通基本上是可以的)。
REST没有任何规范对于安全方面作说明,同时现在开放REST风格API的网站主要分成两种,一种是自定义了安全信息封装在消息中(其实这和SOAP没有什么区别),另外一种就是靠硬件SSL来保障,但是这只能够保证点到点的安全,如果是需要多点传输的话SSL就无能为力了。安全这块其实也是一个很大的问题,今年在BEA峰会上看到有演示采用SAML2实现的网站间SSO,其实是直接采用了XML-Security和XML-Signature,效率看起来也不是很高。未来REST规范化和通用化过程中的安全是否也会采用这两种规范,是未知的,但是加入的越多,REST失去它高效性的优势越多。
应用设计与改造:
我们的系统要么就是已经有了那些需要被发布出去的服务,要么就是刚刚设计好的服务,但是开发人员的传统设计思想让REST的形式被接受还需要一点时间。同时在资源型数据服务接口设计上来说按照REST的思想来设计相对来说要容易一些,而对于一些复杂的服务接口来说,可能强要去按照REST的风格来设计会有些牵强。这一点其实可以看看各大网站的接口就可以知道,很多网站还要传入function的名称作为参数,这就明显已经违背了REST本身的设计思路。
而SOAP本身就是面向RPC来设计的,开发人员十分容易接受,所以不存在什么适应的过程。
总的来说,其实还是一个老观念,适合的才是最好的
技术没有好坏,只有是不是合适,一种好的技术和思想被误用了,那么就会得到反效果。REST和SOAP各自都有自己的优点,同时如果在一些场景下如果去改造REST,其实就会走向SOAP(例如安全)。
REST对于资源型服务接口来说很合适,同时特别适合对于效率要求很高,但是对于安全要求不高的场景。而SOAP的成熟性可以给需要提供给多开发语言的,对于安全性要求较高的接口设计带来便利。所以我觉得纯粹说什么设计模式将会占据主导地位没有什么意义,关键还是看应用场景。
同时很重要一点就是不要扭曲了REST现在很多网站都跟风去开发REST风格的接口,其实都是在学其形,不知其心,最后弄得不伦不类,性能上不去,安全又保证不了,徒有一个看似象摸象样的皮囊。
参考文献:
http://blog.csdn.net/terryzero/article/details/6295855
http://zh.wikipedia.org/wiki/REST