stfu

是一样的，因为OGC标准是统一的，他下面的服务必须是一样的，不然这个行业就没有办法使用了。ArcGIS server发布的WMS服务，用openjs都可以调用的！

Jersey更符合JAVA规范，Spring MVC自成一派。我个人用的Spring MVC 能体会到的好处就是和Spring 其他玩意儿结合方便Spring MVC Spring Data Spring Security

trustful表示"可相信的"的意思.例如一个人说的话是否可信.而reliable指的是"可靠的"的意思,就是一个人是否可靠.包括语言和行动.例如有任务时,大家都愿意交给小张,因为他为人可靠.这时候就不能用trustful了.望采纳谢谢~~

trusful 可信任的 reliable 可依赖的

meteor 前端restful api 怎么传递数组指针 指针是C语言中广泛使用的一种数据类型。运用指针编程是C语言最主要的风格之一。利用指针变量可以表示各种数据结构；能很方便地使用数组和字符串；并能象汇编语言一样处理内存地址，从而编出精练而高效的程序。指针极大地丰富了C语言的功能。学习指针是学习C语言中最重要的一环，能否正确理解和使用指针是我们是否掌握C语言的一个标志。同时，指针也是C语言中最为困难的一部分，在学习中除了要正确理解基本概念，还必须要多编程，上机调试。只要作到这些，指针也是不难掌握的。10.1 地址指针的基本概念在计算机中，所有的数据都是存放在存储器中的。一般把存储器中的一个字节称为一个内存单元，不同的数据类型所占用的内存单元数不等，如整型量占2个单元，字符量占1个单元等，在前面已有详细的介绍。为了正确地访问这些内存单元，必须为每个内存单元编上号。根据一个内存单元的编号即可准确地找到该内存单元。内存单元的编号也叫做地址。 既然根据内存单元的编号或地址就可以找到所需的内存单元，所以通常也把这个地址称为指针。 内存单元的指针和内存单元的内容是两个不同的概念。 可以用一个通俗的例子来说明它们之间的关系。我们到银行去存取款时， 银行工作人员将根据我们的帐号去找我们的存款单， 找到之后在存单上写入存款、取款的金额。在这里，帐号就是存单的指针， 存款数是存单的内容。对于一个内存单元来说，单元的地址即为指针，其中存放的数据才是该单元的内容。在C语言中，允许用一个变量来存放指针，这种变量称为指针变量。因此，一个指针变量的值就是某个内存单元的地址或称为某内存单元的指针。图中，设有字符变量C，其内容为“K”(ASCII码为十进制数 75)，C占用了011A号单元(地址用十六进数表示)。设有指针变量P，内容为011A，这种情况我们称为P指向变量C，或说P是指向变量C的指针。严格地说，一个指针是一个地址，是一个常量。而一个指针变量却可以被赋予不同的指针值，是变量。但常把指针变量简称为指针。为了避免混淆，我们中约定：“指针”是指地址，是常量，“指针变量”是指取值为地址的变量。定义指针的目的是为了通过指针去访问内存单元。 既然指针变量的值是一个地址，那么这个地址不仅可以是变量的地址，也可以是其它数据结构的地址。在一个指针变量中存放一个数组或一个函数的首地址有何意义呢？ 因为数组或函数都是连续存放的。通过访问指针变量取得了数组或函数的首地址，也就找到了该数组或函数。这样一来，凡是出现数组，函数的地方都可以用一个指针变量来表示，只要该指针变量中赋予数组或函数的首地址即可。这样做，将会使程序的概念十分清楚，程序本身也精练，高效。在C语言中，一种数据类型或数据结构往往都占有一组连续的内存单元。 用“地址”这个概念并不能很好地描述一种数据类型或数据结构，而“指针”虽然实际上也是一个地址，但它却是一个数据结构的首地址，它是“指向”一个数据结构的，因而概念更为清楚，表示更为明确。 这也是引入“指针”概念的一个重要原因。10.2 变量的指针和指向变量的指针变量

首先解释幂等，幂等是数学的一个用语，对于单个输入或者无输入的运算方法，如果每次都是同样的结果，则称其是幂等的对于两个参数，如果传入值相等，结果也等于每个传入值，则称其为幂等的，如min(a,b)POST用于提交请求，可以更新或者创建资源，是非幂等的举个例子，在我们的支付系统中，一个api的功能是创建收款金额二维码，它和金额相关，每个用户可以有多个二维码，如果连续调用则会创建新的二维码，这个时候就用POSTPUT用于向指定的URI传送更新资源，是幂等的还是那个例子，用户的账户二维码只和用户关联，而且是一一对应的关系，此时这个api就可以用PUT，因为每次调用它，都将刷新用户账户二维码比如一个接口用于用户生成，接收的数据是用户名、密码等相关信息，则用POSTRESTful建议所有的URI都是对应资源，所以创建用户不应该理解为一个行为，在此将此接口命名为:/user/creation每次调用它都会新建一个用户（假定用户名可以重复）而PUT方法更加关心一个具体资源对应的URI，比如更新当前用户信息，这里可以用PUT/user/me/update这里用me来指代当前用户，如果是针对更多用户适用的接口，可以考虑/user/{uid}/update注意多次调用同一接口，只要提交的数据一致，用户信息每次结果就会一致，即产生同样的结果：服务器端某个具体的资源得到了更新当需要以更新的形式来修改某一具体资源的时候，如何判断用PUT还是POST呢？很简单，如果该更新对应的URI多次调用的结果一致，则PUT比如更新某个blog文章，因为该文章具有单一的具体URI，所以每次更新提交相同的内容，结果都一致/blog/{document_id}/update在每次更新提交相同的内容，最终的结果不一致的时候，用POST举个很常见的例子，一个接口的功能是将当前余额减一个值，每次提交指定该值为100，接口如下/amount/deduction调用一次，你的余额-100，调用两次，余额-200这个时候就用POSTRESTful的4种层次Representational status transfer个人理解为：表现形式的状态传递1、只有一个接口交换xml来实现整个服务目前我们的移动站点的服务就是类似的结构，我们有两个URI接口/mapp/lead和/msdk/safepay2、每一个资源对应一个具体的URI，比1好维护，但是问题依然很明显，资源版本更新会引入时间戳维护，资源的获取和更新修改必须对应不同的URI目前PC主站和移动站点的静态内容（包括html文件）都是这种形式3、在2的基础上使用了http verb，每个URI可以有不同的动作，充分利用了http协议，所以自然居然http协议的完整优势，比如缓存和健壮性HTML4.0只支持POST和GET，所以无论DELETE还是PUT操作，都用POST去模拟了在WEB开发者看来，就是如果有数据变动，就用POST，如果没有，就用GET所以目前中国用户来看，PC端实现RESTful很困难，只有移动端支持Html5的浏览器，才能让前端做出尝试4、现在似乎更加无法实际应用，Hypemedia control，也就是RESTful的本意，合理的架构原理和以网络为基础的设计相结合，带来一个更加方便、功能强大的通信架构

REST 可以看成一种服务器接口设计的模式pattern。它的全称是 RE presentational S tate T ransfer。它的意思就是说，服务器根据前端的请求，返回给可展示的资源状态。例如你请求了Weibo一个用户的信息，那么服务器就应该返回给你一个user，包含了姓名，账号，关注人数等信息。 Resource：资源可以是前端想要获取的任何东西，一张图片，一个文件，一个用户的信息等等。 Collection：一系列的用户。 URL：Uniform Resource Locator，指向一个资源的路径。 如果在完全没有系统学习过接口设计的情况下，让你去设计一系列接口，你会怎么设计？我想大部分人都会做出如下的设计： 你或许会觉得这样的设计很readable啊，一看就知道是什么意思了。是的，可读性或许确实是它的一个优点，但同时不容易去维护你的接口。原因是你需要想方设法去像一个这种名字，接口少的时候还好，多了呢？如何解决接口重名的问题。 解决的方法就是舍弃这种依靠命名来分辨接口的办法。REST提出了一个很好的解决办法，依靠资源定位符和request方法来分辨要请求的资源以及要进行的操作（CRUD）。 这类Code代表操作成功。 These status codes represent that the client has raised a faulty request.

安全是恒久的话题，对于基于WSDL和SOAP的Web Service，我们有WS-Security这样的安全规范来指导实现认证、授权、身份管理等安全需求。那么，RESTful API有无成熟可用规范或实现框架呢？如何保证RESTful API的安全性呢？如何对RESTful API进行版本控制，请分享您认为实用的做法？HTTP1.1规范中给出的动词对于设计RESTful API够用吗？您在实际项目中会扩展自己的动词吗？在什么情况下需要扩展？今年5月份发布的JAX-RS 2.0规范对于RSTfulAPI的设计最有价值的特性是哪个（些）? 它（们）用于解决什么问题？能否为InfoQ的读者们推荐一款实用的RESTful API开发框架，并说明您的推介理由。HTTP2.0规范正在制定当中，您对它的期待是什么？InfoQ：什么是好的RESTful API？相信每个人都有自己的评判标准。那么，您认为一个好的RESTful API应该具有哪些特征呢？李锟：一个好的RESTful API，应该具备以下特征：这个API应该是对浏览器友好的，能够很好地融入Web，而不是与Web格格不入。浏览器是最常见和最通用的REST客户端。好的RESTful API应该能够使用浏览器+HTML完成所有的测试（不需要使用编程语言）。这样的API还可以很方便地使用各种自动化的Web功能测试、性能测试工具来做测试。Web前端应用（基于浏览器的RIA应用、移动App等等）也可以很方便地将多个RESTful API的功能组合起来，建造Mashup类的应用。这个API中所包含的资源和对于资源的操作，应该是直观和容易理解的，并且符合HTTP协议的要求。REST开发又被称作“面向资源的开发”，这说明对于资源的抽象，是设计RESTful API的核心内容。RESTful API建模的过程与面向对象建模类似，是以名词为核心的。这些名词就是资源，任何可命名的抽象概念都可以定义为一个资源。而HTTP协议并不是一种传输协议，它实际提供了一个操作资源的统一接口。对于资源的任何操作，都应该映射到HTTP的几个有限的方法（常用的有GET/POST/PUT/DELETE四个方法，还有不常用的PATCH/HEAD/OPTIONS方法）上面。所以RESTful API建模的过程，可以看作是具有统一接口约束的面向对象建模过程。按照HTTP协议的规定，GET方法是安全且幂等的，POST方法是既不安全也不幂等的（可以用来作为所有写操作的通配方法），PUT、DELETE方法都是不安全但幂等的。将对资源的操作合理映射到这四个方法上面，既不过度使用某个方法（例如过度使用GET方法或POST方法），也不添加过多的操作以至于HTTP的四个方法不够用。如果发现资源上的操作过多，以至于HTTP的方法不够用，应该考虑设计出更多的资源。设计出更多资源（以及相应的URI）对于RESTful API来说并没有什么害处。这个API应该是松耦合的。RESTful API的设计包括了三个循序渐进、由低到高的层次：资源抽象、统一接口、超文本驱动。正是这三个层次确保了RESTful API的松耦合性。当设计面向互联网的API时，松耦合变成了一种“必须有”的强需求。紧耦合的API非常脆弱，一旦公布出去，服务器端和客户端都无法持续进化。尤其是服务器端，公布出去的接口根本不敢改，改了之后，几乎所有客户端应用立即无法正常工作。REST这种架构风格就是紧耦合API的解毒剂，这个话题可以谈的很深，这里就不展开了。感兴趣的读者可以参考《REST实战》。这个API中所使用的表述格式应该是常见的通用格式在RESTful API中，对于资源的操作，是通过在服务器端-客户端之间传递资源的表述来间接完成的。资源的表述可以有很多种格式，并且在响应和请求中的资源表述格式也会有所不同。GET/POST响应中的资源表述格式，常见的有HTML、XML、JSON；POST/PUT请求中的资源表述格式，常见的有标准的HTML表单参数、XML、JSON。这些常见表述格式，处理起来非常容易，有大量的框架和库提供支持。所以除非有很合理的要求，通常不需要使用自定义的私有格式。使用HTTP响应状态代码来表达各种出错情况HTTP响应状态代码，是HTTP协议这个统一接口中用来表达出错情况的标准机制。响应状态代码分成两部分：status code和reason phase。两部分都是可定制的，也可以使用标准的status code，只定制reason phase。如果一个所谓的“RESTful API”对于任何请求都返回200 OK响应，在响应的消息体中返回出错情况信息，这种做法显然不符合“确保操作语义的可见性”这个REST架构风格的基本要求。这个API应该对于HTTP缓存是友好的充分利用好HTTP缓存是RESTful API可伸缩性的根本。HTTP协议是一个分层的架构，从两端的user agent到origin server之间，可以插入很多中间组件。而在整个HTTP通信链条的很多位置，都可以设置缓存。HTTP协议内建有很好的缓存机制，可以分成过期模型和验证模型两套缓存机制。如果API设计者完全没有考虑过如何利用HTTP缓存，那么这个API的可伸缩性会有很多问题。李建业：首先说明一下，对REST这个概念，我一般把它理解为REST风格的架构，但是现在实践中最为广泛认知的是HTTP，而它是REST的一个实现，所以RESTful API也可以不太严格的指基于HTTP的API——当然，即使是不严格的时候，API本身也应该力求遵循REST架构风格。我认为，一个RESTful API最重要的一点应该是——“尽可能少的先验信息”，这一条也同时是我判断一个好的RESTful API的标准。比如HTTP动词，在实践中，大家可能会常常纠结于有效利用 HTTP 动词，但这却并不是特别重要的事情——除非你理解这么做的价值。HTTP 动词最重要的地方在于它是标准阐明了的行为，也就是说，如果我们的“客户端”遵循约定，那么就不必要发明新的动词，也就不必增加“先验信息”；但是，所谓“先验信息”，针对的是客户端——对API来说就是调用者，对于一些企业内部系统，或者一些传统系统，由于“资源”很稳定，对资源的操作也很稳定，这些系统的“调用客户端”不是浏览器而是另一个系统，此时如果强制对应到HTTP动词，反而会变成额外的“先验信息”，这时我就不会太拘泥HTTP动词，自己制定一套动词放在参数中也可以接受——只要动词不变化，这个系统依然是REST风格的。再比如Response里面的Content-Type，这个有时会被新手忽略，但这其实很重要，因为一般涉及到系统间协同的API，往往不会使用普通的文本，比较常见的是使用json表达复杂结构，而这与通常的缺省理解不同（缺省一般会认为是text/plain和text/html），所以如果在API中忘记用Content-Type进行区分的话，后续对多种类型的客户端接入的支持就会变成陷阱（我们多次遇到过这个问题）。而如果一开始就检查是否增加先验知识（缺省Content-Type为plain或者允许指定Content-Type），那这一困难就可以避免了。丁雪丰：首先，应该正确地使用HTTP的统一接口，比如HTTP的动词，如果不分青红皂白清一色POST那显然还有改进的余地；其次，资源有合适的粒度，可以从三个方面来评判资源的粒度是否合理——网络的效率、表述的大小以及客户端使用时的易用程度；最后，是表述的设计，除了表述的正文内容，还有其中的URI和链接，这些都是评判一个RESTful API好坏的标准。马钧：在我看来，一个好的API标准，就是能尽量利用到HTTP协议的特性，将HTTP当成一种转移协议，而不是传输协议。包括但不限于：利用HTTP的各种动词来明确操作；包含有内容协商，可以根据请求头提供的参数选择一个资源最合适的媒体类型、语言、字符集和编码的表现；使用不同的返回代码来描述各种状态。但实际上见到过的很多声称RESTful API，包括国内的和国外的，能符合这些条件的并不多。parse.com提供的API是我见到过的较为不错的RESTful API，可以作为范例参考。InfoQ：安全是恒久的话题，对于基于WSDL和SOAP的Web Service，我们有WS-Security这样的安全规范来指导实现认证、授权、身份管理等安全需求。那么，RESTful API有无成熟可用规范或实现框架呢？如何保证RESTful API的安全性呢？李锟：保证RESTful API的安全性，主要包括三大方面：a) 对客户端做身份认证b) 对敏感的数据做加密，并且防止篡改c) 身份认证之后的授权对客户端做身份认证，有几种常见的做法：在请求中加签名参数为每个接入方分配一个密钥，并且规定一种签名的计算方法。要求接入方的请求中必须加上签名参数。这个做法是最简单的，但是需要确保接入方密钥的安全保存，另外还要注意防范replay攻击。其优点是容易理解与实现，缺点是需要承担安全保存密钥和定期更新密钥的负担，而且不够灵活，更新密钥和升级签名算法很困难。使用标准的HTTP身份认证机制HTTP Basic身份认证安全性较低，必须与HTTPS配合使用。HTTP Digest身份认证可以单独使用，具备中等程度的安全性。HTTP Digest身份认证机制还支持插入用户自定义的加密算法，这样可以进一步提高API的安全性。不过插入自定义加密算法在面向互联网的API中用的不是很多。这个做法需要确保接入方“安全域-用户名-密码”三元组信息的安全保存，另外还要注意防范replay攻击。优点：基于标准，得到了广泛的支持（大量HTTP服务器端、客户端库）。在服务器端做HTTP身份认证的职责可以由Web Server（例如Nginx）、App Server（例如Tomcat）、安全框架（例如Spring Security）来承担，对应用开发者来说是透明的。HTTP身份认证机制（RFC 2617）非常好地体现了“分离关注点”的设计原则，而且保持了操作语义的可见性。缺点：这类基于简单用户名+密码机制的安全性不可能高于基于非对称密钥的机制（例如数字证书）。使用OAuth协议做身份认证OAuth协议适用于为外部应用授权访问本站资源的情况。其中的加密机制与HTTP Digest身份认证相比，安全性更高。需要注意，OAuth身份认证与HTTP Digest身份认证之间并不是相互取代的关系，它们的适用场景是不同的。OAuth协议更适合于为面向最终用户维度的API提供授权，例如获取隶属于用户的微博信息等等。如果API并不是面向最终用户维度的，例如像七牛云存储这样的存储服务，这并非是OAuth协议的典型适用场景。对敏感的数据做加密，并且防止篡改，常见的做法有：部署SSL基础设施（即HTTPS），敏感数据的传输全部基于SSL。仅对部分敏感数据做加密（例如预付费卡的卡号+密码），并加入某种随机数作为加密盐，以防范数据被篡改。身份认证之后的授权，主要是由应用来控制。通常应该实现某种基于角色+用户组的授权机制，这方面的框架有不少（例如Spring Security），不过大多数开发团队还是喜欢自己来实现相关功能。李建业：我不认为安全是RESTful API需要考虑的问题，事实上我觉得这是两个正交的问题。当然，如果使用RESTful API来提供认证、授权和身份管理，那也算是双方有关系，但是这和其它风格的API设计所要考虑的问题似乎没什么区别，不值得特别注意。但是在具体设计层面，这两者的“正交点”上似乎确实有些问题，因为REST是一个推崇状态无关原则的架构风格，而认证和授权通常基于第三方解决方案，所以往往会出现违背有状态约束的问题，这个地方我也没有特别的想法，当然这个困难和原问题关系不大。至于WS-族的协议，我不太了解，不太能参与讨论。丁雪丰：对于RESTful API，常见的安全措施都是可以继续使用的。例如，为了防篡改，可以对全部参数进行签名；为了防范重放攻击可以在请求中增加一次性的Token，或者短时间内有效的Token；对内容加密可以实现数据防泄露……；对于DDoS攻击，各种HTTP流量清洗策略，都可以继续发挥作用，因为这就是基本的HTTP请求。在授权和认证方面，OAuth 2.0已经基本成熟了，并且得到了广泛地应用。如果可以，接入第三方账户体系是个不错的选择，比如Google和Facebook的，国内的当然也有几个候选。马钧：个人认为RESTful的安全性分为几个层次，在安全要求较高的场合，可以通过HTTPs这样的加密协议来保证网络层的安全，应用层的安全可以通过OAuth实现认证，而对于资源的访问授权，则只能依靠应用程序来实现了。InfoQ：如何对RESTful API进行版本控制，请分享您认为实用的做法？李锟：一个比较简单实用的做法是直接在URI中插入版本号，这样做允许多个版本的API并行运行。另一个做法是在HTTP请求中加入自定义头信息，标明使用的版本号。不过这个做法其实对浏览器不够友好，简单地使用浏览器+HTML无法测试。李建业：目前比较好的方式还是在uri设计中添加版本信息，其它方法都不如这个实用。丁雪丰：个人认为最好的版本化，就是没有明显的版本。在对已发布的服务进行变更时，要尽量做到兼容，其中包括URI、链接和各种不同的表述的兼容，最关键的就是在扩展时不能破坏现有的客户端。例如，要变更一个参数，可以选择同时兼容新旧两种输入，或者保持老参数不动，提供一个新的参数，在文档中必须做出说明，不推荐新用户再继续使用之前的参数。如果必须要进行不兼容的变更，那么可以选择标记不同的版本号，这时可以选择在路径或参数中增加版本信息。也有做法是增加HTTP标头，只是在调用时会稍有不便，推荐前两种方法。马钧：RESTfulAPI的版本升级，尽量兼容之前的版本，保证原有的API都能正常工作，可以通过HTTP 301转跳到新的资源。另外一种实用的做法就是在url中保留版本号，同时提供多个版本供客户端使用，如 v1.rest.com 或者 rest.com/v1/ 这样。InfoQ：HTTP1.1规范中给出的动词对于设计RESTful API够用吗？您在实际项目中会扩展自己的动词吗？在什么情况下需要扩展？李锟：这个问题取决于设计者如何看待和设计资源。如果资源抽象做的很好，对于某个资源的任何操作，通常都能够映射到CRUD四个类别中。CRUD四个类别对于操作资源来说，绝大多数情况下是完备的。HTTP的GET/POST/PUT/DELETE四个方法，对于CRUD四个类别的操作来说是足够的，映射关系是Create-POST/Retrieve-GET/Update-PUT/Delete-DELETE。我们通常不会选择创建自己的动词，这样做对于客户端开发者来说，需要更多的学习成本。如果在资源上定义的操作过多，我们会选择拆分出更多的资源。李建业：一般是够用的，有时一些“不够用”的场景是由于我们没有设计出合理的资源，比如批量操作。但是，正如之前所说的那样，对于某些内部的、传统的（因此模型稳定且已知）系统，API提供者和调用者会有自已的固定动词表，此时没必要拘泥。另外，我不建议扩展动词，一旦扩展了动词，其实已经破坏了我之前说的*“尽可能少的先验信息”*，那么，扩展动词和重新设计动词的成本差别不大。基于这个考虑，我建议尽可能保持动词不变，除非你想重新设计动词表。丁雪丰：一般情况下，常用的HTTP动词是够用的，并没有出现一定要自己扩展动词的情况。其实，最常用的也就是GET、POST、DELETE和PUT，而HEAD、OPTIONS、TRACE则基本用不太到。如果出现一时找不到合适的动词，安全幂等的操作用GET，其他都可以用POST，在设计资源时稍加考虑即可。马钧：在我的实际项目中，只用到了POST，PUT，DELETE，GET这四个动词。InfoQ：今年5月份发布的JAX-RS 2.0规范对于RSTfulAPI的设计最有价值的特性是哪个（些）? 它（们）用于解决什么问题？李锟：REST开发框架RESTEasy项目负责人Bill Burke，去年写了一篇文章介绍JAX-RS 2.0。我同意Bill在文章中的观点，在JAX-RS 2.0增加的内容中，最重要的三部分为：a) Client API——用来规范化JAX-RS客户端的开发方式。b) Server-side Asynchronous HTTP——用来实现服务器端推送功能，而不需要依靠低效的轮询方式。c) Filters and Interceptors——用来分离关注点，将鉴权、日志等逻辑与业务逻辑分离开，更好地实现代码重用。这三部分的内容对于开发者来说都很有用。遵循JAX-RS规范做开发，可以确保服务器端以及客户端代码的可移植性。李建业：我个人关注异步API这部分，主要是因为流式服务将会越来越多，那将大量需要这类支持。InfoQ：能否为InfoQ的读者推荐一款实用的RESTful API开发框架，并说明您的推介理由。李锟：这个问题我就不详细回答了。不同的编程语言有不同的REST开发框架，对于REST的支持程度也不同。开发RESTful API的需求范围很广，可选择的开发框架的范围也很广。保持多样性是繁荣生态环境的基础。像Java就有支持JAX-RS规范的Jersey、RESTEasy、Restlet、Apache CXF，和不支持JAX-RS规范的Spring MVC等等很多框架。这些框架目前都做的不错。我对框架的选择没有倾向性。RESTful API设计的最佳实践应该是通用的，而不是必须依赖某种特定的开发框架。李建业：不好意思，这个我不太重视，没法推荐，不过我可以解释一下为什么对RESTful API框架不感冒的原因。REST作为一个架构风格，对我们的系统开发有很大影响，但是这些影响一般是针对架构（例如状态无关）或者设计（例如资源识别）上的，所以一旦涉及到具体实现，主要工作就基本结束了，此时开发框架能做的事也就只有简化编程了（相较而言，有的框架还能起到引导设计的作用），而由于RESTful会抽象动词，所以实现层面中和API规范相关的工作本来就不多，那么框架的价值就更小了。当然，我们也不可能直接基于servlet/rakc/wsgi来开发，不过一般的编程语言都会提供一些简单的url route/match策略，我们使用这些就足够了。另外，有些框架能帮我们生成全部的动词支持，但这也未必是好事，我一般倾向于按需实现——用到了再支持，这就更不需要太关注开发框架对RESTful的支持了。丁雪丰：由于本人是Spring的拥护者，工作中也一直在使用Spring，所以在选择框架时会更多地倾向Spring MVC（并不是说别的框架不好，这里有些个人主观的成份）。如果一定要选择其他框架，也要选择能够方便与Spring集成的框架。如果在项目中已经使用了Spring，那么没有什么理由不选择Spring MVC，鉴于目前Spring在各种项目中的高出镜率，相信一般情况下都会选择Spring MVC。REST的成熟度模型中，第三层就是HATEOAS，Spring目前还提供了Spring Hateoas子项目，对链接、资源等方面的支持都做了一定的增强。马钧：我目前在实际项目中使用的是Spray，这是一个开源的 REST/HTTP 工具包和底层网络 IO 包，基于 Scala 和 Akka 构建。轻量级、异步、非堵塞、基于 actor 模式、模块化和可测试是Spray的特点。InfoQ：HTTP2.0规范正在制定当中，您对它的期待是什么？李锟：我的期待包括两个方面：应该做的和不应该做的。HTTP/2.0规范应该做的：与HTTP/1.1协议保持兼容。兼容的含义是说两者可以并存，客户端应用可以根据服务器端的能力，自由地选择使用HTTP/2.0还是HTTP/1.1，而且选择过程对应用来说是透明的。改进HTTP协议（作为资源的统一接口）之中操作语义表达方式的语法，提高网络传输效率。更好地模块化，这样HTTP/2.0协议的实现能够更好地模块化。应用程序可根据需要选择适当的模块，而不是要么全有、要么全无。废弃掉HTTP/1.1协议中一些很少有人用到的部分，例如采用管道（pipelining）方式发送请求。增加更多的动词，以适应除CRUD之外的其他场景。HTTP/2.0规范不应该做的：HTTP/2.0协议不应该把底层的数据加密机制（即SSL）作为必选项。HTTP/2.0协议不应该背离REST架构风格的约束，尤其是要确保操作语义对于中间组件的可见性。在上面这两个方面，Roy Fileidng曾经与SPDY协议设计者Mike Belshe发生过激烈争论，详情请看：Roy Fielding谈Google SPDY协议李建业：对此规范关注不多，不知道会不会有对于流的支持，目前我所知道的只有chunk方式进行简单的支持，但是真正的流需要区分数据通道和控制通道——哪怕是逻辑上的区分，这样就直接对REST风格产生了很大冲击，考虑到流式服务在未来的发展潜力，我特别期待业界在这方面有所进展。丁雪丰：HTTP 2.0很大程度上是借鉴了Google的SPDY，就我而言，首先，希望这个规范能做到与HTTP 1.1的兼容，使用者如果只认识1.1，那么2.0能优雅“降级”；其次，希望2.0能带来更好的性能，SPDY在这方面还是有所改进的，希望HTTP 2.0能再接再厉；最后，希望这个规范能在最终定稿时附带一个最佳实践，正确引导人们合理地使用HTTP 2.0。马钧：没研究过，估计即使出来，1.1还有很长的生命周期，不会很快被取代。

安全是恒久的话题，对于基于WSDL和SOAP的Web Service，我们有WS-Security这样的安全规范来指导实现认证、授权、身份管理等安全需求。那么，RESTful API有无成熟可用规范或实现框架呢？如何保证RESTful API的安全性呢？如何对RESTful API进行版本控制，请分享您认为实用的做法？HTTP1.1规范中给出的动词对于设计RESTful API够用吗？您在实际项目中会扩展自己的动词吗？在什么情况下需要扩展？今年5月份发布的JAX-RS 2.0规范对于RSTfulAPI的设计最有价值的特性是哪个（些）? 它（们）用于解决什么问题？能否为InfoQ的读者们推荐一款实用的RESTful API开发框架，并说明您的推介理由。HTTP2.0规范正在制定当中，您对它的期待是什么？InfoQ：什么是好的RESTful API？相信每个人都有自己的评判标准。那么，您认为一个好的RESTful API应该具有哪些特征呢？李锟：一个好的RESTful API，应该具备以下特征：这个API应该是对浏览器友好的，能够很好地融入Web，而不是与Web格格不入。浏览器是最常见和最通用的REST客户端。好的RESTful API应该能够使用浏览器+HTML完成所有的测试（不需要使用编程语言）。这样的API还可以很方便地使用各种自动化的Web功能测试、性能测试工具来做测试。Web前端应用（基于浏览器的RIA应用、移动App等等）也可以很方便地将多个RESTful API的功能组合起来，建造Mashup类的应用。这个API中所包含的资源和对于资源的操作，应该是直观和容易理解的，并且符合HTTP协议的要求。REST开发又被称作“面向资源的开发”，这说明对于资源的抽象，是设计RESTful API的核心内容。RESTful API建模的过程与面向对象建模类似，是以名词为核心的。这些名词就是资源，任何可命名的抽象概念都可以定义为一个资源。而HTTP协议并不是一种传输协议，它实际提供了一个操作资源的统一接口。对于资源的任何操作，都应该映射到HTTP的几个有限的方法（常用的有GET/POST/PUT/DELETE四个方法，还有不常用的PATCH/HEAD/OPTIONS方法）上面。所以RESTful API建模的过程，可以看作是具有统一接口约束的面向对象建模过程。按照HTTP协议的规定，GET方法是安全且幂等的，POST方法是既不安全也不幂等的（可以用来作为所有写操作的通配方法），PUT、DELETE方法都是不安全但幂等的。将对资源的操作合理映射到这四个方法上面，既不过度使用某个方法（例如过度使用GET方法或POST方法），也不添加过多的操作以至于HTTP的四个方法不够用。如果发现资源上的操作过多，以至于HTTP的方法不够用，应该考虑设计出更多的资源。设计出更多资源（以及相应的URI）对于RESTful API来说并没有什么害处。这个API应该是松耦合的。RESTful API的设计包括了三个循序渐进、由低到高的层次：资源抽象、统一接口、超文本驱动。正是这三个层次确保了RESTful API的松耦合性。当设计面向互联网的API时，松耦合变成了一种“必须有”的强需求。紧耦合的API非常脆弱，一旦公布出去，服务器端和客户端都无法持续进化。尤其是服务器端，公布出去的接口根本不敢改，改了之后，几乎所有客户端应用立即无法正常工作。REST这种架构风格就是紧耦合API的解毒剂，这个话题可以谈的很深，这里就不展开了。感兴趣的读者可以参考《REST实战》。这个API中所使用的表述格式应该是常见的通用格式在RESTful API中，对于资源的操作，是通过在服务器端-客户端之间传递资源的表述来间接完成的。资源的表述可以有很多种格式，并且在响应和请求中的资源表述格式也会有所不同。GET/POST响应中的资源表述格式，常见的有HTML、XML、JSON；POST/PUT请求中的资源表述格式，常见的有标准的HTML表单参数、XML、JSON。这些常见表述格式，处理起来非常容易，有大量的框架和库提供支持。所以除非有很合理的要求，通常不需要使用自定义的私有格式。使用HTTP响应状态代码来表达各种出错情况HTTP响应状态代码，是HTTP协议这个统一接口中用来表达出错情况的标准机制。响应状态代码分成两部分：status code和reason phase。两部分都是可定制的，也可以使用标准的status code，只定制reason phase。如果一个所谓的“RESTful API”对于任何请求都返回200 OK响应，在响应的消息体中返回出错情况信息，这种做法显然不符合“确保操作语义的可见性”这个REST架构风格的基本要求。这个API应该对于HTTP缓存是友好的充分利用好HTTP缓存是RESTful API可伸缩性的根本。HTTP协议是一个分层的架构，从两端的user agent到origin server之间，可以插入很多中间组件。而在整个HTTP通信链条的很多位置，都可以设置缓存。HTTP协议内建有很好的缓存机制，可以分成过期模型和验证模型两套缓存机制。如果API设计者完全没有考虑过如何利用HTTP缓存，那么这个API的可伸缩性会有很多问题。李建业：首先说明一下，对REST这个概念，我一般把它理解为REST风格的架构，但是现在实践中最为广泛认知的是HTTP，而它是REST的一个实现，所以RESTful API也可以不太严格的指基于HTTP的API——当然，即使是不严格的时候，API本身也应该力求遵循REST架构风格。我认为，一个RESTful API最重要的一点应该是——“尽可能少的先验信息”，这一条也同时是我判断一个好的RESTful API的标准。比如HTTP动词，在实践中，大家可能会常常纠结于有效利用 HTTP 动词，但这却并不是特别重要的事情——除非你理解这么做的价值。HTTP 动词最重要的地方在于它是标准阐明了的行为，也就是说，如果我们的“客户端”遵循约定，那么就不必要发明新的动词，也就不必增加“先验信息”；但是，所谓“先验信息”，针对的是客户端——对API来说就是调用者，对于一些企业内部系统，或者一些传统系统，由于“资源”很稳定，对资源的操作也很稳定，这些系统的“调用客户端”不是浏览器而是另一个系统，此时如果强制对应到HTTP动词，反而会变成额外的“先验信息”，这时我就不会太拘泥HTTP动词，自己制定一套动词放在参数中也可以接受——只要动词不变化，这个系统依然是REST风格的。再比如Response里面的Content-Type，这个有时会被新手忽略，但这其实很重要，因为一般涉及到系统间协同的API，往往不会使用普通的文本，比较常见的是使用json表达复杂结构，而这与通常的缺省理解不同（缺省一般会认为是text/plain和text/html），所以如果在API中忘记用Content-Type进行区分的话，后续对多种类型的客户端接入的支持就会变成陷阱（我们多次遇到过这个问题）。而如果一开始就检查是否增加先验知识（缺省Content-Type为plain或者允许指定Content-Type），那这一困难就可以避免了。丁雪丰：首先，应该正确地使用HTTP的统一接口，比如HTTP的动词，如果不分青红皂白清一色POST那显然还有改进的余地；其次，资源有合适的粒度，可以从三个方面来评判资源的粒度是否合理——网络的效率、表述的大小以及客户端使用时的易用程度；最后，是表述的设计，除了表述的正文内容，还有其中的URI和链接，这些都是评判一个RESTful API好坏的标准。马钧：在我看来，一个好的API标准，就是能尽量利用到HTTP协议的特性，将HTTP当成一种转移协议，而不是传输协议。包括但不限于：利用HTTP的各种动词来明确操作；包含有内容协商，可以根据请求头提供的参数选择一个资源最合适的媒体类型、语言、字符集和编码的表现；使用不同的返回代码来描述各种状态。但实际上见到过的很多声称RESTful API，包括国内的和国外的，能符合这些条件的并不多。parse.com提供的API是我见到过的较为不错的RESTful API，可以作为范例参考。InfoQ：安全是恒久的话题，对于基于WSDL和SOAP的Web Service，我们有WS-Security这样的安全规范来指导实现认证、授权、身份管理等安全需求。那么，RESTful API有无成熟可用规范或实现框架呢？如何保证RESTful API的安全性呢？李锟：保证RESTful API的安全性，主要包括三大方面：a) 对客户端做身份认证b) 对敏感的数据做加密，并且防止篡改c) 身份认证之后的授权对客户端做身份认证，有几种常见的做法：在请求中加签名参数为每个接入方分配一个密钥，并且规定一种签名的计算方法。要求接入方的请求中必须加上签名参数。这个做法是最简单的，但是需要确保接入方密钥的安全保存，另外还要注意防范replay攻击。其优点是容易理解与实现，缺点是需要承担安全保存密钥和定期更新密钥的负担，而且不够灵活，更新密钥和升级签名算法很困难。使用标准的HTTP身份认证机制HTTP Basic身份认证安全性较低，必须与HTTPS配合使用。HTTP Digest身份认证可以单独使用，具备中等程度的安全性。HTTP Digest身份认证机制还支持插入用户自定义的加密算法，这样可以进一步提高API的安全性。不过插入自定义加密算法在面向互联网的API中用的不是很多。这个做法需要确保接入方“安全域-用户名-密码”三元组信息的安全保存，另外还要注意防范replay攻击。优点：基于标准，得到了广泛的支持（大量HTTP服务器端、客户端库）。在服务器端做HTTP身份认证的职责可以由Web Server（例如Nginx）、App Server（例如Tomcat）、安全框架（例如Spring Security）来承担，对应用开发者来说是透明的。HTTP身份认证机制（RFC 2617）非常好地体现了“分离关注点”的设计原则，而且保持了操作语义的可见性。缺点：这类基于简单用户名+密码机制的安全性不可能高于基于非对称密钥的机制（例如数字证书）。使用OAuth协议做身份认证OAuth协议适用于为外部应用授权访问本站资源的情况。其中的加密机制与HTTP Digest身份认证相比，安全性更高。需要注意，OAuth身份认证与HTTP Digest身份认证之间并不是相互取代的关系，它们的适用场景是不同的。OAuth协议更适合于为面向最终用户维度的API提供授权，例如获取隶属于用户的微博信息等等。如果API并不是面向最终用户维度的，例如像七牛云存储这样的存储服务，这并非是OAuth协议的典型适用场景。对敏感的数据做加密，并且防止篡改，常见的做法有：部署SSL基础设施（即HTTPS），敏感数据的传输全部基于SSL。仅对部分敏感数据做加密（例如预付费卡的卡号+密码），并加入某种随机数作为加密盐，以防范数据被篡改。身份认证之后的授权，主要是由应用来控制。通常应该实现某种基于角色+用户组的授权机制，这方面的框架有不少（例如Spring Security），不过大多数开发团队还是喜欢自己来实现相关功能。李建业：我不认为安全是RESTful API需要考虑的问题，事实上我觉得这是两个正交的问题。当然，如果使用RESTful API来提供认证、授权和身份管理，那也算是双方有关系，但是这和其它风格的API设计所要考虑的问题似乎没什么区别，不值得特别注意。但是在具体设计层面，这两者的“正交点”上似乎确实有些问题，因为REST是一个推崇状态无关原则的架构风格，而认证和授权通常基于第三方解决方案，所以往往会出现违背有状态约束的问题，这个地方我也没有特别的想法，当然这个困难和原问题关系不大。至于WS-族的协议，我不太了解，不太能参与讨论。丁雪丰：对于RESTful API，常见的安全措施都是可以继续使用的。例如，为了防篡改，可以对全部参数进行签名；为了防范重放攻击可以在请求中增加一次性的Token，或者短时间内有效的Token；对内容加密可以实现数据防泄露……；对于DDoS攻击，各种HTTP流量清洗策略，都可以继续发挥作用，因为这就是基本的HTTP请求。在授权和认证方面，OAuth 2.0已经基本成熟了，并且得到了广泛地应用。如果可以，接入第三方账户体系是个不错的选择，比如Google和Facebook的，国内的当然也有几个候选。马钧：个人认为RESTful的安全性分为几个层次，在安全要求较高的场合，可以通过HTTPs这样的加密协议来保证网络层的安全，应用层的安全可以通过OAuth实现认证，而对于资源的访问授权，则只能依靠应用程序来实现了。InfoQ：如何对RESTful API进行版本控制，请分享您认为实用的做法？李锟：一个比较简单实用的做法是直接在URI中插入版本号，这样做允许多个版本的API并行运行。另一个做法是在HTTP请求中加入自定义头信息，标明使用的版本号。不过这个做法其实对浏览器不够友好，简单地使用浏览器+HTML无法测试。李建业：目前比较好的方式还是在uri设计中添加版本信息，其它方法都不如这个实用。丁雪丰：个人认为最好的版本化，就是没有明显的版本。在对已发布的服务进行变更时，要尽量做到兼容，其中包括URI、链接和各种不同的表述的兼容，最关键的就是在扩展时不能破坏现有的客户端。例如，要变更一个参数，可以选择同时兼容新旧两种输入，或者保持老参数不动，提供一个新的参数，在文档中必须做出说明，不推荐新用户再继续使用之前的参数。如果必须要进行不兼容的变更，那么可以选择标记不同的版本号，这时可以选择在路径或参数中增加版本信息。也有做法是增加HTTP标头，只是在调用时会稍有不便，推荐前两种方法。马钧：RESTfulAPI的版本升级，尽量兼容之前的版本，保证原有的API都能正常工作，可以通过HTTP 301转跳到新的资源。另外一种实用的做法就是在url中保留版本号，同时提供多个版本供客户端使用，如 v1.rest.com 或者 rest.com/v1/ 这样。InfoQ：HTTP1.1规范中给出的动词对于设计RESTful API够用吗？您在实际项目中会扩展自己的动词吗？在什么情况下需要扩展？李锟：这个问题取决于设计者如何看待和设计资源。如果资源抽象做的很好，对于某个资源的任何操作，通常都能够映射到CRUD四个类别中。CRUD四个类别对于操作资源来说，绝大多数情况下是完备的。HTTP的GET/POST/PUT/DELETE四个方法，对于CRUD四个类别的操作来说是足够的，映射关系是Create-POST/Retrieve-GET/Update-PUT/Delete-DELETE。我们通常不会选择创建自己的动词，这样做对于客户端开发者来说，需要更多的学习成本。如果在资源上定义的操作过多，我们会选择拆分出更多的资源。李建业：一般是够用的，有时一些“不够用”的场景是由于我们没有设计出合理的资源，比如批量操作。但是，正如之前所说的那样，对于某些内部的、传统的（因此模型稳定且已知）系统，API提供者和调用者会有自已的固定动词表，此时没必要拘泥。另外，我不建议扩展动词，一旦扩展了动词，其实已经破坏了我之前说的*“尽可能少的先验信息”*，那么，扩展动词和重新设计动词的成本差别不大。基于这个考虑，我建议尽可能保持动词不变，除非你想重新设计动词表。丁雪丰：一般情况下，常用的HTTP动词是够用的，并没有出现一定要自己扩展动词的情况。其实，最常用的也就是GET、POST、DELETE和PUT，而HEAD、OPTIONS、TRACE则基本用不太到。如果出现一时找不到合适的动词，安全幂等的操作用GET，其他都可以用POST，在设计资源时稍加考虑即可。马钧：在我的实际项目中，只用到了POST，PUT，DELETE，GET这四个动词。InfoQ：今年5月份发布的JAX-RS 2.0规范对于RSTfulAPI的设计最有价值的特性是哪个（些）? 它（们）用于解决什么问题？李锟：REST开发框架RESTEasy项目负责人Bill Burke，去年写了一篇文章介绍JAX-RS 2.0。我同意Bill在文章中的观点，在JAX-RS 2.0增加的内容中，最重要的三部分为：a) Client API——用来规范化JAX-RS客户端的开发方式。b) Server-side Asynchronous HTTP——用来实现服务器端推送功能，而不需要依靠低效的轮询方式。c) Filters and Interceptors——用来分离关注点，将鉴权、日志等逻辑与业务逻辑分离开，更好地实现代码重用。这三部分的内容对于开发者来说都很有用。遵循JAX-RS规范做开发，可以确保服务器端以及客户端代码的可移植性。李建业：我个人关注异步API这部分，主要是因为流式服务将会越来越多，那将大量需要这类支持。InfoQ：能否为InfoQ的读者推荐一款实用的RESTful API开发框架，并说明您的推介理由。李锟：这个问题我就不详细回答了。不同的编程语言有不同的REST开发框架，对于REST的支持程度也不同。开发RESTful API的需求范围很广，可选择的开发框架的范围也很广。保持多样性是繁荣生态环境的基础。像Java就有支持JAX-RS规范的Jersey、RESTEasy、Restlet、Apache CXF，和不支持JAX-RS规范的Spring MVC等等很多框架。这些框架目前都做的不错。我对框架的选择没有倾向性。RESTful API设计的最佳实践应该是通用的，而不是必须依赖某种特定的开发框架。李建业：不好意思，这个我不太重视，没法推荐，不过我可以解释一下为什么对RESTful API框架不感冒的原因。REST作为一个架构风格，对我们的系统开发有很大影响，但是这些影响一般是针对架构（例如状态无关）或者设计（例如资源识别）上的，所以一旦涉及到具体实现，主要工作就基本结束了，此时开发框架能做的事也就只有简化编程了（相较而言，有的框架还能起到引导设计的作用），而由于RESTful会抽象动词，所以实现层面中和API规范相关的工作本来就不多，那么框架的价值就更小了。当然，我们也不可能直接基于servlet/rakc/wsgi来开发，不过一般的编程语言都会提供一些简单的url route/match策略，我们使用这些就足够了。另外，有些框架能帮我们生成全部的动词支持，但这也未必是好事，我一般倾向于按需实现——用到了再支持，这就更不需要太关注开发框架对RESTful的支持了。丁雪丰：由于本人是Spring的拥护者，工作中也一直在使用Spring，所以在选择框架时会更多地倾向Spring MVC（并不是说别的框架不好，这里有些个人主观的成份）。如果一定要选择其他框架，也要选择能够方便与Spring集成的框架。如果在项目中已经使用了Spring，那么没有什么理由不选择Spring MVC，鉴于目前Spring在各种项目中的高出镜率，相信一般情况下都会选择Spring MVC。REST的成熟度模型中，第三层就是HATEOAS，Spring目前还提供了Spring Hateoas子项目，对链接、资源等方面的支持都做了一定的增强。马钧：我目前在实际项目中使用的是Spray，这是一个开源的 REST/HTTP 工具包和底层网络 IO 包，基于 Scala 和 Akka 构建。轻量级、异步、非堵塞、基于 actor 模式、模块化和可测试是Spray的特点。InfoQ：HTTP2.0规范正在制定当中，您对它的期待是什么？李锟：我的期待包括两个方面：应该做的和不应该做的。HTTP/2.0规范应该做的：与HTTP/1.1协议保持兼容。兼容的含义是说两者可以并存，客户端应用可以根据服务器端的能力，自由地选择使用HTTP/2.0还是HTTP/1.1，而且选择过程对应用来说是透明的。改进HTTP协议（作为资源的统一接口）之中操作语义表达方式的语法，提高网络传输效率。更好地模块化，这样HTTP/2.0协议的实现能够更好地模块化。应用程序可根据需要选择适当的模块，而不是要么全有、要么全无。废弃掉HTTP/1.1协议中一些很少有人用到的部分，例如采用管道（pipelining）方式发送请求。增加更多的动词，以适应除CRUD之外的其他场景。HTTP/2.0规范不应该做的：HTTP/2.0协议不应该把底层的数据加密机制（即SSL）作为必选项。HTTP/2.0协议不应该背离REST架构风格的约束，尤其是要确保操作语义对于中间组件的可见性。在上面这两个方面，Roy Fileidng曾经与SPDY协议设计者Mike Belshe发生过激烈争论，详情请看：Roy Fielding谈Google SPDY协议李建业：对此规范关注不多，不知道会不会有对于流的支持，目前我所知道的只有chunk方式进行简单的支持，但是真正的流需要区分数据通道和控制通道——哪怕是逻辑上的区分，这样就直接对REST风格产生了很大冲击，考虑到流式服务在未来的发展潜力，我特别期待业界在这方面有所进展。丁雪丰：HTTP 2.0很大程度上是借鉴了Google的SPDY，就我而言，首先，希望这个规范能做到与HTTP 1.1的兼容，使用者如果只认识1.1，那么2.0能优雅“降级”；其次，希望2.0能带来更好的性能，SPDY在这方面还是有所改进的，希望HTTP 2.0能再接再厉；最后，希望这个规范能在最终定稿时附带一个最佳实践，正确引导人们合理地使用HTTP 2.0。马钧：没研究过，估计即使出来，1.1还有很长的生命周期，不会很快被取代。

Justfun抓饭体育直播app是一款专注于提供全方位体育直播的手机应用。用户可以通过该app免费观看各种体育赛事直播，包括足球、篮球、网球等多个热门体育项目。Justfun抓饭体育直播app提供高清流畅的视频直播，让用户身临其境地感受比赛的激情。同时，该app还提供多语言解说和多视角切换功能，让用户享受更加个性化的观赛体验。想要下载justfun抓饭直播app的话就赶紧往下看吧!一、justfun抓饭直播app下载点击抓饭体育直播app抓饭体育直播app类别：影音播放下载抓饭体育直播app是一款为全球体育爱好者所设计的app。用户可以在其中观看包括NBA、足球、英超、西甲、意甲等各大体育赛事的直播。此外，该app还提供了实时比分、赛事预告、精彩集锦等功能，让用户随时得知最新最快的赛事动态。同时，抓饭体育直播的界面简单、操作便捷，且支持多屏同步观看，用户体验极佳。二、类似抓饭体育直播的软件1、鲸体育app官网版鲸体育app官网版类别：影音播放下载鲸体育app官网版是一款专为体育迷设计的应用软件，提供最新的体育资讯、赛事直播和比分数据。用户可以随时随地通过鲸体育app观看各类体育赛事的直播，包括足球、篮球、网球等，满足用户对体育赛事的热爱和追求。此外，鲸体育还提供详尽的赛事分析和数据统计，帮助用户更好地了解比赛形势和参与投注。2、泡泡体育直播nba泡泡体育直播nba类别：影音播放下载泡泡体育直播nba是专门为篮球爱好者设计的一款直播平台。该软件提供高清的NBA篮球赛事直播，包括常规赛、季后赛以及全明星赛等。用户可以轻松观看最新的赛事直播，体验到激烈的比赛场面和精彩瞬间。泡泡体育直播NBA软件还提供了赛事预告、赛程表、球队排名等实时更新的比赛信息，让用户随时掌握比赛动态。此外，软件还提供球员数据、赛事回放和专家解说等特色功能，让用户更加全面地了解球队和球员的表现。3、多米体育直播app多米体育直播app类别：影音播放下载多米体育直播app是一款专注于体育赛事的直播平台。用户可以在该app上观看各类体育赛事的直播视频，包括国内外足球、篮球、网球、游泳等多种项目。多米体育直播app提供高清流畅的观赛体验，让用户能够身临其境地感受体育盛事。多米体育直播app还提供了社交互动功能，用户可以与其他球迷进行交流和讨论。总之，多米体育直播app为体育迷提供了全方位的体育赛事体验和互动平台。4、奇异果体育app最新版奇异果体育app最新版类别：影音播放下载奇异果体育app最新版是一款最新版本的体育应用程序。它提供了全方位的体育资讯和内容，包括足球、篮球、网球、高尔夫等多种体育项目。用户可以通过奇异果体育app获取最新的赛事新闻、比赛结果和赛程安排，而且还可以观看赛事的直播和回放。此外，该应用还提供了专业的数据分析和统计，帮助用户更深入地了解比赛和运动员的表现。通过奇异果体育app，用户可以定制自己感兴趣的体育项目和球队，获取个性化的推送信息。5、百度体育直播百度体育直播类别：影音播放下载百度体育直播是一款提供全球体育赛事直播、赛程资讯和实时比分的应用程序。用户可以通过该app观看各类体育赛事，包括足球、篮球、网球、乒乓球等。该应用程序支持高清直播，用户可以实时观看比赛，同时还可以查看赛事新闻、战报和相关视频，了解最新的比赛动态。百度体育直播app界面简洁直观，操作简单，用户可以方便地找到自己感兴趣的比赛，并设置观看提醒，不会错过任何精彩时刻。6、jrs免费体育直播nbajrs免费体育直播nba类别：影音播放下载jrs免费体育直播nba是一款提供免费NBA比赛直播的应用程序。用户可以通过该软件观看NBA的各项赛事，包括常规赛、季后赛以及全明星赛等。该软件提供高质量的直播流，并支持多种清晰度选择，用户可以根据自己的网络条件选择适合的观看质量。除了直播功能，JRS免费体育直播NBA软件还提供比赛回放功能，用户可以在错过直播的情况下重新观看比赛。7、JRS直播无插件直播极速体育360JRS直播无插件直播极速体育360类别：影音播放下载JRS直播无插件直播极速体育360是一款专业的体育直播应用。用户无需安装插件，可通过该应用轻松观看各类体育比赛直播。应用提供了高速流畅的直播体验，让用户近乎实时地感受比赛的精彩。此外，应用还提供了360度全方位的视角，用户可选择自己感兴趣的视点观看比赛，仿佛置身于现场。应用界面简洁易用，操作简单，用户可以快速找到所需的比赛和信息。8、54体育直播jrs54体育直播jrs类别：影音播放下载54体育直播jrs是一款专为体育爱好者打造的直播应用。用户可以通过该应用实时观看各类体育比赛，包括足球、篮球、网球等。通过高清、流畅的直播画面，用户能够亲临现场感受到精彩的比赛场面。此外，该应用提供了多种功能，如实时比分、赛事预告、球队数据等，让用户全面了解比赛动态。9、劲爆体育直播nba劲爆体育直播nba类别：影音播放下载劲爆体育直播nba是一款专为篮球迷们设计的应用程序。该软件提供全方位的NBA赛事直播，包括常规赛、季后赛以及全明星赛等。用户可以通过劲爆体育直播NBA软件随时随地观看最新的比赛，不错过任何精彩瞬间。此外，该软件还提供赛前战略分析、赛后回顾以及球员数据统计等功能，让用户全面了解比赛情况。劲爆体育直播NBA软件界面简洁直观，操作简便，用户体验出色。10、山猫体育直播免费直播APP山猫体育直播免费直播APP类别：影音播放下载山猫体育直播免费直播APP是一款提供免费体育赛事直播的手机应用程序。用户可以通过该App观看各类热门体育赛事，包括足球、篮球、网球等。该应用提供高清流畅的视频直播，让用户能够身临其境地感受比赛的激情。山猫体育直播免费直播App还提供赛事预告、比分更新、赛事分析等功能，帮助用户及时了解最新的赛事动态。总结：以上就是小编本次带来的justfun抓饭直播app下载、抓饭体育直播官方最新版下载的所有内容，希望可以帮助到大家。

我也想知道啊

0收藏(1)1 用户登录 一般的写法 GET http://localhost:8080/Test/login.do?username=name&password=p REST的原则之一是：网络上的所有事物都被抽象为资源 这么说，所有的url都应该是名词形式的，不应该是动词或者动宾结构？ 对应的 RESTful: GET http://localhost:8080/Test/users/user?username=name&password=p ？？ 2 删除多个用户 页面表单中有checkbox，可以删除多个用户 一般的写法 POST http://localhost:8080/Test/deleteUser.do 传一个参数userIds，是删除用户的id的列表 改成RESTful DELETE http://localhost:8080/Test/users/user 还传参数userId? 这样写好么? 3 给用户分配设备，权限等操作 一般的写法 POST http://localhost:8080/Test/grantUserPrivilege.do?userId=id1&privilegeId=id2 典型的动宾形式,

出现超时问题的原因:1：网站方面的问题：服务器正在维修，可能网站正在维护，可以尝试打开别的网页判断是否是该网站的问题。如果别的网站正常打开，则说明是网站方面的问题；反之则不是。2：用户方面的问题：电脑问题：电脑用户可以换电脑重新访问该网页，以此判断网站是否可以使用。网速问题：可以打开别的网站来判断，以打开速度判断网速的快慢。

可以参照Rails中的标准的定义方式。如果定义这个资源的两个参数具有从属关系，那么生成的路由就是owner/1/property/1其中property从属于owner。比如用户1的编号为2的文章，就是users/1/articles/2如果两个资源是平等的，那么一般是作为路由中HTTP方法的参数，比如你提到的“要表示x轴为2,y轴为3的点”，就一般是用xxx.com/dot?x=2&y=3

App通常用restful api跟server打交道。Rest是stateless的，也就是app不需要像browser那样用cookie来保存session, 因此用session token来标示自己就够了，session/state由api server的逻辑处理。　　如果你的后端不是stateless的rest api, 那么你可能需要在app里保存session. 可以在app里嵌入webkit,用一个隐藏的browser来管理cookie session.　　session 和 oauth token 并不矛盾，作为身份认证 token 安全性比session好，因为每个请求都有签名还能防止监听以及重放攻击，而session就必须靠链路层来保障通讯安全了。如上所说，如果你需要实现有状态的会话，仍然可以增加session来在服务器端保存一些状态

您好！一下为个人看法，希望能对您有帮助，满意的麻烦给个采纳，谢谢了！从基本原理层次上说，REST 样式和 SOAP 样式 Web Service的区别取决于应用程序是面向资源的还是面向活动的。例如，在传统的WebService中，一个获得天气预报的webservice会暴露一个WebMethod：string GetCityWether（string city）。而RESTful WebService暴露的不是方法，而是对象（资源），通过Http GET, PUT, POST 或者 DELETE来对请求的资源进行操作。在 REST 的定义中，一个 Web Service总是使用固定的 URI 向外部世界呈现（或者说暴露）一个资源。可以说这是一种全新的思维模式：使用唯一资源定位地址 URI，加上 HTTP 请求方法从而达到对一个发布于互联网资源的唯一描述和操作。所以我理解为rest架构定义的webservice实际上定义了一个借口的规范。 REST其实并不是什么协议也不是什么标准，而是将Http协议的设计初衷作了诠释，在Http协议被广泛利用的今天，越来越多的是将其作为传输协议，而非原先设计者所考虑的应用协议。REST的思想归结以下有如下几个关键点：1．面向资源的接口设计所有的接口设计都是针对资源来设计的，也就很类似于我们的面向对象和面向过程的设计区别，只不过现在将网络上的操作实体都作为资源来看待，同时URI的设计也是体现了对于资源的定位设计。后面会提到有一些网站的API设计说是REST设计，其实是RPC-REST的混合体，并非是REST的思想。 2．抽象操作为基础的CRUD 这点很简单，Http中的get,put,www.hbbz08.com post,delete分别对应了read,update,create,delete四种操作，如果仅仅是作为对于资源的操作，抽象成为这四种已经足够了，但是对于现在的一些复杂的业务服务接口设计，可能这样的抽象未必能够满足。其实这也在后面的几个网站的API设计中暴露了这样的问题，如果要完全按照REST的思想来设计，那么适用的环境将会有限制，而非放之四海皆准的。 3．Http是应用协议而非传输协议 这点在后面各大网站的API分析中有很明显的体现，其实有些网站已经走到了SOAP的老路上，说是REST的理念设计，其实是作了一套私有的SOAP协议，因此称之为REST风格的自定义SOAP协议。4．无状态，自包含这点其实不仅仅是对于REST来说的，作为接口设计都需要能够做到这点，也是作为可扩展和高效性的最基本的保证，就算是使用SOAP的WebService也是一样。

参考借鉴： http://www.cnblogs.com/loveis715/p/4669091.html 一、定义 REST其实是一种组织Web服务的架构，而并不是我们想象的那样是实现Web服务的一种新的技术，更没有要求一定要使用HTTP。其目标是为了创建具有良好扩展性的分布式系统。与目前常见的web设计架构区别点在于，REST是以资源为中心，而常规web架构是以执行了什么任务为中心。 二、五大约束 1、使用客户/服务器模型。客户和服务器之间通过一个统一的接口来互相通讯。 2、层次化的系统。在一个REST系统中，客户端并不会固定地与一个服务器打交道。 3、无状态。在一个REST系统中，服务端并不会保存有关客户的任何状态。也就是说，客户端自身负责用户状态的维持，并在每次发送请求时都需要提供足够的信息。 4、可缓存。REST系统需要能够恰当地缓存请求，以尽量减少服务端和客户端之间的信息传输，以提高性能。 5、统一的接口。一个REST系统需要使用一个统一的接口来完成子系统之间以及服务与用户之间的交互。这使得REST系统中的各个子系统可以独自完成演化。（是REST服务设计的核心所在） 三、统一接口四个子约束 1、每个资源都拥有一个资源标识。每个资源的资源标识可以用来唯一地标明该资源。 2、消息的自描述性。在REST系统中所传递的消息需要能够提供自身如何被处理的足够信息。例如该消息所使用的MIME类型，是否可以被缓存等。 3、资源的自描述性。一个REST系统所返回的资源需要能够描述自身，并提供足够的用于操作该资源的信息，如如何对资源进行添加，删除以及修改等操作。也就是说，一个典型的REST服务不需要额外的文档对如何操作资源进行说明。 4、HATEOAS。即客户只可以通过服务端所返回各结果中所包含的信息来得到下一步操作所需要的信息(客户端仅可以决定资源ID)，如到底是向哪个URL发送请求等。也就是说，一个典型的REST服务不需要额外的文档标示通过哪些URL访问特定类型的资源，而是通过服务端返回的响应来标示到底能在该资源上执行什么样的操作。一个REST服务的客户端也不需要知道任何有关哪里有什么样的资源这种信息。 四、资源操作方式 1、GET 等幂且安全，读取资源 2、DELETE 等幂 ，删除资源 3、POST 不等幂，创建资源，ID由服务端创建 4、PUT 等幂，创建资源和更新整个资源，ID由客户端创建，一般通过GUID和UUID 5、PATCH 等幂，更新部分资源 注：等幂性，是指每次操作结果都一样 五、HTTP Code 参照：Hypermedia ControlsHypermedia Controlshttp://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml 100 Continue 101 Switching 102 Processing 103-199 Unassigned 200 OK 201 Created 202 Accepted 203 Non-Authoritative Information 204 No Content 205 Reset Content 206 Partial Content 207 Multi-Status 208 Already Reported 209-225 Unassigned 226 IM Used 227-299 Unassigned 300 Multiple Choices 301 Moved Permanently 302 Found 303 See Other 304 Not Modified 305 Use Proxy 306 (Unused) 307 Temporary Redirect 308 Permanent Redirect 309-399 Unassigned 400 Bad Request 401 Unauthorized 402 Payment Required 403 Forbidden 404 Not Found 405 Method Not Allowed 406 Not Acceptable 407 Proxy Authentication Required 408 Request Timeout 409 Conflict 410 Gone 411 Length Required 412 Precondition Failed 413 Payload Too Large 414 URI Too Long 415 Unsupported Media Type 416 Range Not Satisfiable 417 Expectation Failed 418-420 Unassigned 421 Misdirected Request 422 Unprocessable Entity 423 Locked 424 Failed Dependency 425 Unassigned 426 Upgrade Required 427 Unassigned 428 Precondition Required 429 Too Many Requests 430 Unassigned 431 Request Header Fields Too Large 432-450 Unassigned 451 Unavailable For Legal Reasons 452-499 Unassigned 500 Internal Server Error 501 Not Implemented 502 Bad Gateway 503 Service Unavailable 504 Gateway Timeout 505 HTTP Version Not Supported 506 Variant Also Negotiates 507 Insufficient Storage 508 Loop Detected 509 Unassigned 510 Not Extended 511 Network Authentication Required 512-599 Unassigned 六、开发注意 对于一个基于HTTP的REST服务而言，软件开发人员需要遵守如下的守则以保持API的后向兼容性（即兼容旧版本）： 1、不能在请求中添加新的必须的参数。 2、不能更改操作资源的动词。 3、不能更改响应的HTTP status。 七、性能优化 　　接下来我们就来简单地说说基于HTTP的REST服务中的性能问题。在基于HTTP的REST服务中，性能提升主要分为两个方面：REST架构本身在提高性能方面做出的努力，以及基于HTTP协议的优化。 首先要讨论的就是对登陆性能的优化。在前面我们已经介绍过，在一个基于HTTP的REST服务中，每次都将用户的用户名和密码发送到服务端并由服务端验证这些信息是否合法是一个非常消耗资源的流程。因此我们常常需要在登陆服务中使用一个缓存，或者是使用第三方单点登陆（SSO）类库。 除此之外，软件开发人员还可以通过为同一个资源提供不同的表现形式来减少在网络上传输的数据量，从而提高REST服务的性能。 而在集群内部服务之间，我们则可以不再使用JSON，XML等这种用户可以读懂的负载格式，而是使用二进制格式。这样可以大大地减少内部网络所需要传输的数据量。这在内部网络交换数据频繁并且所传输的数据量巨大时较为有效。 接下来就是REST系统的横向扩展。在REST的无状态约束的支持下，我们可以很容易地向REST系统中添加一个新的服务器。 除了这些和REST架构本身相关的性能提升之外，我们还可以在如何更高效地使用HTTP协议上努力。一个最常见的方法就是使用条件请求（Conditional Request）。简单地说，我们可以使用如下的HTTP头来有条件地存取资源： 1、ETag：一个对用户不透明的用来标示资源实例的哈希值 2、Data-Modified：资源被更改的时间 3、If-Modified-Since：根据资源的更改时间有条件地Get资源。这将允许客户端对4、未更改的资源使用本地缓存。 5、If-None-Match：根据ETag的值有条件地Get资源。 6、If-Unmodified-Since：根据资源的更改时间有条件地Put或Delete资源。 7、If-Match：根据ETag的值有条件地Put或Delete资源。 　　当然，这里所提到的一系列性能优化方案实际上仅仅是比较常见的，与基于HTTP的REST服务关联较大的方案。只是顾虑到过多地陈述和REST关联不大的话题一方面显得比较没有效率，另一方面也是因为通过写另一个系列博客可以将问题陈述得更加清楚，因此在这里我们将不再继续讨论性能相关的话题。

首先在Struts2工程中导入所需的jar包 ezmorph-1.0.3.jar json-lib-2.1-jdk15.jar struts2-convention-plugin-2.2.1.1.jar struts2-rest-plugin-2.2.1.1.jar xstream-1.2.2.jar配置和使用现在，我们配置struts2使它使用restful2actionmapper。在web项目中，修改struts.properties文件（它最终会发布到你的web应用的web-inf/classes目录中）：struts.mapper.class=org.apache.struts2.dispatcher.mapper.restful2actionmapperstruts.enable.slashesinactionnames=true当然，你也可以在struts.xml里进行配置，请参考struts2的相关文档。

Restful风格的API是一种软件架构风格，设计风格而不是标准，只是提供了一组设计原则和约束条件。它主要用于客户端和服务器交互类的软件。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。在Restful风格中，用户请求的url使用同一个url而用请求方式：get，post，delete，put...等方式对请求的处理方法进行区分，这样可以在前后台分离式的开发中使得前端开发人员不会对请求的资源地址产生混淆和大量的检查方法名的麻烦，形成一个统一的接口。在Restful风格中，现有规定如下：GET（SELECT）：从服务器查询，可以在服务器通过请求的参数区分查询的方式。POST（CREATE）：在服务器新建一个资源，调用insert操作。PUT（UPDATE）：在服务器更新资源，调用update操作。PATCH（UPDATE）：在服务器更新资源（客户端提供改变的属性）。(目前jdk7未实现，tomcat7也不行)。DELETE（DELETE）：从服务器删除资源，调用delete语句。了解这个风格定义以后，我们举个例子：如果当前url是 http://localhost:8080/User那么用户只要请求这样同一个URL就可以实现不同的增删改查操作，例如http://localhost:8080/User?_method=get&id=1001　　这样就可以通过get请求获取到数据库 user 表里面 id=1001 的用户信息http://localhost:8080/User?_method=post&id=1001&name=zhangsan　　这样可以向数据库 user 表里面插入一条记录http://localhost:8080/User?_method=put&id=1001&name=lisi　　这样可以将 user表里面 id=1001 的用户名改为lisihttp://localhost:8080/User?_method=delete&id=1001　　这样用于将数据库 user 表里面的id=1001 的信息删除这样定义的规范我们就可以称之为restful风格的API接口，我们可以通过同一个url来实现各种操作。

1、 WebService到底是什么？ 2、 Web service是什么？ 3、 什么是WEBService，实现WEBService有哪些框架，为什么WEBService经常被认为太重了，只有银行和大型国企才会使用的更多有一些？4、 理解RESTful架构 5、 WebService入门介绍

App通常用restfulapi跟server打交道。Rest是stateless的，也就是app不需要像browser那样用cookie来保存session,因此用sessiontoken来标示自己就够了，session/state由apiserver的逻辑处理。　　如果你的后端不是stateless的restapi,那么你可能需要在app里保存session.可以在app里嵌入webkit,用一个隐藏的browser来管理cookiesession.　　session和oauthtoken并不矛盾，作为身份认证token安全性比session好，因为每个请求都有签名还能防止监听以及重放攻击，而session就必须靠链路层来保障通讯安全了。如上所说，如果你需要实现有状态的会话，仍然可以增加session来在服务器端保存一些状态

REST 服务的安全，一般依赖于HTTP认证，HTTP认证有几种：basic，digest，token，这些都有标准的实现的开源包需要主要的是这个认证的帐号跟你业务的帐户实际是不一样的，REST属于webService一种，他的安全是后台服务的安全，因此不需要实际的业务帐号，通常是系统keyStore证书库里的账户.

这个就按照普通项目做呗，就是只要传值给app前端就可以了，http请求传呗，restful不是框架，它只是一种开发风格，如果网页需要推广的话尽量使用restful，不推广，用了也没啥屌用，例子：普通：list.html?id=10restful：list/10.html

首先，安装Flaskpip install flask阅读这篇文章之前我假设你已经了解RESTful API的相关概念，如果不清楚，可以阅读我之前写的这篇博客[Designing a RESTful Web APIFlask是一个使用Python开发的基于Werkzeug的Web框架。Flask非常适合于开发RESTful API，因为它具有以下特点：?使用Python进行开发，Python简洁易懂?容易上手?灵活?可以部署到不同的环境?支持RESTful请求分发我一般是用curl命令进行测试，除此之外，还可以使用Chrome浏览器的postman扩展。资源首先，我创建一个完整的应用，支持响应/, /articles以及/article/:id。from flask import Flask, url_forapp = Flask(__name__)@app.route("/")def api_root():return "Welcome"@app.route("/articles")def api_articles():return "List of " + url_for("api_articles")@app.route("/articles/<articleid>")def api_article(articleid):return "You are reading " + articleidif __name__ == "__main__":app.run()可以使用curl命令发送请求：响应结果分别如下所示：GET /WelcomeGET /articlesList of /articlesGET /articles/123You are reading 123路由中还可以使用类型定义:@app.route("/articles/<articleid>")上面的路由可以替换成下面的例子：@app.route("/articles/<int:articleid>")@app.route("/articles/<float:articleid>")@app.route("/articles/<path:articleid>")默认的类型为字符串。请求请求参数假设需要响应一个/hello请求，使用get方法，并传递参数namefrom flask import request@app.route("/hello")def api_hello():if "name" in request.args:return "Hello " + request.args["name"]else:return "Hello John Doe"服务器会返回如下响应信息：GET /helloHello John DoeGET /hello?name=LuisHello Luis请求方法Flask支持不同的请求方法：@app.route("/echo", methods = ["GET", "POST", "PATCH", "PUT", "DELETE"])def api_echo():if request.method == "GET":return "ECHO: GET "elif request.method == "POST":return "ECHO: POST "elif request.method == "PATCH":return "ECHO: PACTH "elif request.method == "PUT":return "ECHO: PUT "elif request.method == "DELETE":return "ECHO: DELETE"可以使用如下命令进行测试:curl -X PATCH :5000/echo不同请求方法的响应如下：GET /echoECHO: GETPOST /ECHOECHO: POST...请求数据和请求头通常使用POST方法和PATCH方法的时候，都会发送附加的数据，这些数据的格式可能如下：普通文本(plain text)， JSON，XML，二进制文件或者用户自定义格式。Flask中使用request.headers类字典对象来获取请求头信息，使用request.data 获取请求数据，如果发送类型是application/json，则可以使用request.get_json()来获取JSON数据。from flask import json@app.route("/messages", methods = ["POST"])def api_message():if request.headers["Content-Type"] == "text/plain":return "Text Message: " + request.dataelif request.headers["Content-Type"] == "application/json":return "JSON Message: " + json.dumps(request.json)elif request.headers["Content-Type"] == "application/octet-stream":f = open("./binary", "wb")f.write(request.data)f.close()return "Binary message written!"else:return "415 Unsupported Media Type ;)"使用如下命令指定请求数据类型进行测试：curl -H "Content-type: application/json" -X POST :5000/messages -d "{"message":"Hello Data"}"使用下面的curl命令来发送一个文件:curl -H "Content-type: application/octet-stream" -X POST :5000/messages --data-binary @message.bin不同数据类型的响应结果如下所示：POST /messages {"message": "Hello Data"}Content-type: application/jsonJSON Message: {"message": "Hello Data"}POST /message <message.bin>Content-type: application/octet-streamBinary message written!注意Flask可以通过request.files获取上传的文件，curl可以使用-F选项模拟上传文件的过程。响应Flask使用Response类处理响应。from flask import Response@app.route("/hello", methods = ["GET"])def api_hello():data = {"hello" : "world","number" : 3}js = json.dumps(data)resp = Response(js, status=200, mimetype="application/json")resp.headers["Link"] = "http://luisrei.com"return resp使用-i选项可以获取响应信息：curl -i :5000/hello返回的响应信息如下所示：GET /helloHTTP/1.0 200 OKContent-Type: application/jsonContent-Length: 31Link: http://luisrei.comServer: Werkzeug/0.8.2 Python/2.7.1Date: Wed, 25 Apr 2012 16:40:27 GMT{"hello": "world", "number": 3}mimetype指定了响应数据的类型。上面的过程可以使用Flask提供的一个简便方法实现：from flask import jsonify...# 将下面的代码替换成resp = Response(js, status=200, mimetype="application/json")# 这里的代码resp = jsonify(data)resp.status_code = 200状态码和错误处理如果成功响应的话，状态码为200。对于404错误我们可以这样处理：@app.errorhandler(404)def not_found(error=None):message = {"status": 404,"message": "Not Found: " + request.url,}resp = jsonify(message)resp.status_code = 404return resp@app.route("/users/<userid>", methods = ["GET"])def api_users(userid):users = {"1":"john", "2":"steve", "3":"bill"}if userid in users:return jsonify({userid:users[userid]})else:return not_found()测试上面的两个URL，结果如下：GET /users/2HTTP/1.0 200 OK{"2": "steve"}GET /users/4HTTP/1.0 404 NOT FOUND{"status": 404,"message": "Not Found: :5000/users/4"}默认的Flask错误处理可以使用@error_handler修饰器进行覆盖或者使用下面的方法：app.error_handler_spec[None][404] = not_found即使API不需要自定义错误信息，最好还是像上面这样做，因为Flask默认返回的错误信息是HTML格式的。认证使用下面的代码可以处理 HTTP Basic Authentication。from functools import wrapsdef check_auth(username, password):return username == "admin" and password == "secret"def authenticate():message = {"message": "Authenticate."}resp = jsonify(message)resp.status_code = 401resp.headers["WWW-Authenticate"] = "Basic realm="Example""return respdef requires_auth(f):@wraps(f)def decorated(*args, **kwargs):auth = request.authorizationif not auth:return authenticate()elif not check_auth(auth.username, auth.password):return authenticate()return f(*args, **kwargs)return decorated接下来只需要给路由增加@require_auth修饰器就可以在请求之前进行认证了：@app.route("/secrets")@requires_authdef api_hello():return "Shhh this is top secret spy stuff!"现在，如果没有通过认证的话，响应如下所示：GET /secretsHTTP/1.0 401 UNAUTHORIZEDWWW-Authenticate: Basic realm="Example"{"message": "Authenticate."}curl通过-u选项来指定HTTP basic authentication，使用-v选项打印请求头：curl -v -u "admin:secret"响应结果如下：GET /secrets Authorization: Basic YWRtaW46c2VjcmV0Shhh this is top secret spy stuff!Flask使用MultiDict来存储头部信息，为了给客户端展示不同的认证机制，可以给header添加更多的WWW-Autheticate。resp.headers["WWW-Authenticate"] = "Basic realm="Example""resp.headers.add("WWW-Authenticate", "Bearer realm="Example"")调试与日志通过设置debug=True来开启调试信息：app.run(debug=True)使用Python的logging模块可以设置日志信息：import loggingfile_handlewww.huashijixun.com?baiduzhidao.ogging.FileHandler("app.log")app.logger.addHandler(file_handler)app.logger.setLevel(logging.INFO)@app.route("/hello", methods = ["GET"])def api_hello():app.logger.info("informing")app.logger.warning("warning")app.logger.error("screaming bloody murder!")return "check your logs "CURL 命令参考选项作用-X 指定HTTP请求方法，如POST，GET-H 指定请求头，例如Content-type:application/json-d 指定请求数据--data-binary 指定发送的文件-i 显示响应头部信息-u 指定认证用户名与密码-v 输出请求头部信息

REST种架构风格其核面向资源REST专门针中国络应用设计发式降低发复杂性提高系统伸缩性REST提设计概念准则： 一.中国络所事物都抽象资源(resource) 二.每资源都唯资源标识(resource identifier)资源操作改变些标识 三.所操作都状态 REST简化发其架构遵循CRUD原则该原则告诉我于资源(包括中国络资源)需要四种行：创建获取更新删除完相关操作处理您通统资源标识符（Universal Resource IdentifierURI）识别定位资源并且针些资源执行操作通 HTTP 规范定义其核操作GET,PUT,POST,DELETE 由于REST强制所操作都必须stateless没文约束做布式集群都需要考虑文保持问题极提高系统伸缩性 于SOAP WebserviceRestful Webservice选择问题首先需要理解SOAP偏向于面向严格规范标准包括安全事务等各面内容同SOAP强调操作操作象离WSDL文件规范XSD文件别其定义REST强调面向资源要我要操作象抽象资源即使用REST架构风格 REST ful 应用问题 否使用REST需要考虑资源本身抽象识别否困难本身简单类似增删改查业务操作抽象资源比较容易于复杂业务抽象资源并简单事情比校验用户等级转账事务处理等些往往并容易简单抽象资源 其严格规范标准定义要求且前期规范标准需要指导业务系统集发候SOAP风格由于清晰规范标准定义明显优势我始实现前严格定义相关接口接口传输数据 简单数据操作事务处理发调用简单些使用REST架构风格优势于较复杂面向服务我使用REST候都仍传统面向思想通转换工具再转换REST服务种使用式没意义 效率易用性 SOAP协议于消息体消息都定义同消息扩展性各种互联中国标准提供扩展基础WS-*系列较功规范由于SOAP由于各种需求断扩充其本身协议内容导致SOAP处理面性能所降同易用性面及习本所增加 REST重视其实面其高效及简洁易用特性种高效面源于其面向资源接口设计及操作抽象简化发者良设计同限度利用Http初应用协议设计理念同我看REST吸引发者能够融合前Web二.0前端技术提高发效率例型中国站放REST风格API都种返形式除传统xml作数据承载（JSON,RSS,ATOM）等形式中国站前端发员说能够mashup各种资源信息 安全性 技术没坏合适种技术思想误用反效RESTSOAP各自都自优点同些场景改造REST其实走向SOAP（例安全） REST于资源型服务接口说合适同特别适合于效率要求高于安全要求高场景SOAP熟性给需要提供给发语言于安全性要求较高接口设计带便利所我觉纯粹说设计模式占据主导位没意义关键看应用场景 同重要点要扭曲REST现中国站都跟风发REST风格接口其实都其形知其弄伦类性能安全保证 熟度 SOAP虽发展现已经脱离初衷于异构环境服务发布调用及厂商支持都已经达较熟情况同平台发语言间通SOAP交互web service都能够较互通 由于没类似于SOAP权威性协议作规范REST实现各种协议仅仅能算私协议需要遵循REST思想细节面太没约束REST发展所走向规范直接影响部设计否能够命

现在有一个系统，他有两个接口并发量特别高，或者说比其他接口高出几个档次。那么如何针对这两个接口进行处理？目前我有几点疑惑。1、不少高并发网站在指出将模块服务化，这样可以对各个模块进行负载均衡，按需分配，那么他其实是代码层级上就是分开编写的还是只是部署在不同的机器上用nginx转发实现模块化？2、如果代码不是分开编写的，像这种个别接口访问量高的应该怎么处理。3、就算是分开编写，每个服务已经自成一个系统，那么如何处理该系统中极个别接口访问量特别高的情况？现在想到的方法是：使用nginx负载均衡，针对这两个接口给予专门的服务器集群做处理（代码还是那一套）。我不知道这样做是不是正确的？因为我为了这两个接口部署了整个系统，我感觉是有问题的。

restful是标准，webapi是.net的实现

一个好的RESTful API，应该具备以下特征：这个API应该是对浏览器友好的，能够很好地融入Web，而不是与Web格格不入。浏览器是最常见和最通用的REST客户端。好的RESTful API应该能够使用浏览器+HTML完成所有的测试（不需要使用编程语言）。这样的API还可以很方便地使用各种自动化的Web功能测试、性能测试工具来做测试。Web前端应用（基于浏览器的RIA应用、移动App等等）也可以很方便地将多个RESTful API的功能组合起来，建造Mashup类的应用。这个API中所包含的资源和对于资源的操作，应该是直观和容易理解的，并且符合HTTP协议的要求。REST开发又被称作“面向资源的开发”，这说明对于资源的抽象，是设计RESTful API的核心内容。RESTful API建模的过程与面向对象建模类似，是以名词为核心的。这些名词就是资源，任何可命名的抽象概念都可以定义为一个资源。而HTTP协议并不是一种传输协议，它实际提供了一个操作资源的统一接口。对于资源的任何操作，都应该映射到HTTP的几个有限的方法（常用的有GET/POST/PUT/DELETE四个方法，还有不常用的PATCH/HEAD/OPTIONS方法）上面。所以RESTful API建模的过程，可以看作是具有统一接口约束的面向对象建模过程。按照HTTP协议的规定，GET方法是安全且幂等的，POST方法是既不安全也不幂等的（可以用来作为所有写操作的通法），PUT、DELETE方法都是不安全但幂等的。将对资源的操作合理映射到这四个方法上面，既不过度使用某个方法（例如过度使用GET方法或POST方法），也不添加过多的操作以至于HTTP的四个方法不够用。2.如果发现资源上的操作过多，以至于HTTP的方法不够用，应该考虑设计出更多的资源。设计出更多资源（以及相应的URI）对于RESTful API来说并没有什么害处。这个API应该是松耦合的。RESTful API的设计包括了三个循序渐进、由低到高的层次：资源抽象、统一接口、超文本驱动。正是这三个层次确保了RESTful API的松耦合性。3.当设计面向互联网的API时，松耦合变成了一种“必须有”的强需求。紧耦合的API非常脆弱，一旦公布出去，服务器端和客户端都无法持续进化。尤其是服务器端，公布出去的接口根本不敢改，改了之后，几乎所有客户端应用立即无法正常工作。REST这种架构风格就是紧耦合API的解毒剂，这个话题可以谈的很深，这里就不展开了。感兴趣的读者可以参考《REST实战》。这个API中所使用的表述格式应该是常见的通用格式在RESTful API中，对于资源的操作，是通过在服务器端-客户端之间传递资源的表述来间接完成的。资源的表述可以有很多种格式，并且在响应和请求中的资源表述格式也会有所不同。GET/POST响应中的资源表述格式，常见的有HTML、XML、JSON；POST/PUT请求中的资源表述格式，常见的有标准的HTML表单参数、XML、JSON。4.这些常见表述格式，处理起来非常容易，有大量的框架和库提供支持。所以除非有很合理的要求，通常不需要使用自定义的私有格式。使用HTTP响应状态代码来表达各种出错情况HTTP响应状态代码，是HTTP协议这个统一接口中用来表达出错情况的标准机制。响应状态代码分成两部分：status code和reason phase。两部分都是可定制的，也可以使用标准的status code，只定制reason phase。5.如果一个所谓的“RESTful API”对于任何请求都返回200 OK响应，在响应的消息体中返回出错情况信息，这种做法显然不符合“确保操作语义的可见性”这个REST架构风格的基本要求。这个API应该对于HTTP缓存是友好的6.充分利用好HTTP缓存是RESTful API可伸缩性的根本。HTTP协议是一个分层的架构，从两端的user agent到origin server之间，可以插入很多中间组件。而在整个HTTP通信链条的很多位置，都可以设置缓存。HTTP协议内建有很好的缓存机制，可以分成过期模型和验证模型两套缓存机制。如果API设计者完全没有考虑过如何利用HTTP缓存，那么这个API的可伸缩性会有很多问题。

应该是http服务器的进程故障了。你可以尝试打开，设置中的控制面板，然后点击性能和维护，找到管理工具，找到Apache2.2点击禁用此服务就可以了。一般这样子操作进程就会停止了，然后再启用试试。

别折腾了，一般人根本就做不了RESTful。绝大部分人都理解RESTful是一种接口的设计形式，然后发现很多时候某些需求根本没法做成RESTful形式的，但就我看来RESTful是从底层架构就应该考虑的问题，或者说是一种架构设计思想，而不仅仅只针对于接口。比如题主的这个情况，如果要让我来做，我会设计两个接口POST /shop/1/query 新建一个商品的查询，返回idGET /shop/1/query/{id} 获取某个查询的结果为什么要这么设计？1.RESTful中，URI代表资源，html/图片这类文件是资源，query这类服务也是资源2.RESTful中，POST用来新建或者更新，GET用来获取资源但是很显然，这肯定不满足题主的需求，要这样做现有的架构肯定满足不了，所以，别折腾了

定义了RestFul Api，必须先做单元测试，确保Api可用，然后再交给别人去调用，这样才能确保工作进度（1）使用Apache的jmeter测试工具，很方便，可以批量测试Api，(2) 使用JerseyClient写测试程序。因为我们用的是jersey实现的RestFul。(3) 使用浏览器插件工具，我用的是火狐的插件RESTClient（4）使用curl命令行工具。使用工具测试Api，GET方法还好，如果是POST方法需要指定方法的Headers(数据格式),Body（请求参数），Api的url。Body请求参数，如何获取呢，在这里我使用了Gson，先用java组织参数对象，然后用Gson将参数对象转化为json串。Gson gson = new Gson(); String wqtString = gson.toJson(wqt);System.out.println(wqtString)举例说明：我们框架中封装了一个查询参数WebQueryTerm。我获取到它的json串格式为：{"page":{"number":1,"size":10,"total":0,"sorts":[{"field":"creationTime","type":"DESC"}]},"terms":[{"field":"appType","operator":"equal","value":"0"}]}其中page表示分页属性。number当前页，size一页显示多少条数据，sorts排序：field表示排序字段。type表示排序类型，是desc降序还是asc升序terms表示查询。field表示查询字段；operator表示是模糊查询Like还是精确查询Equal，value表示你输入的查询值。追答这里简单说一下，怎么使用火狐的RESTClient。(1)首先，在火狐浏览器菜单-附件组件-插件，中搜索RESTClient，并安装(2)打开RESTClient，点击菜单Headers。输入自定义Request Headers。例如Name = Content-Type Value=application/json 点击okay！（3）选择Method，我选择Post，因为我测试获取应用列表，带分页，带查询条件。（4）输入api资源的url：http://192.168.1.183:8080/osd/rest/app/get_app_list（5）输入上面的请求参数json串。(6)点击Send请求API。结果查看：Response Headers如果Status Code =200 ok则表明API没有异常再看Response Body返回数据，是否满足你的要求。测试工作完成！

几个必须的原则: REST的核心原则是将你的API拆分为逻辑上的资源。这些资源通过http被操作(GET ,POST,PUT,DELETE). 显然从API用户的角度来看，”资源“应该是个名词。即使你的内部数据模型和资源已经有了很好的对应，API设计的时候你仍然不需要把它们一对一的都暴露出来。这里的关键是隐藏内部资源，暴露必需的外部资源。 URL遵循动词+宾语的结构 宾语必须为名词且最好为复数，同时要避免多级URL，可通过参数来展示分类. 使用复数使得URL更加规整, 这让API使用者更加容易理解，对开发者来说也更容易实现. 一旦定义好了要暴露的资源，你可以定义资源上允许的操作，以及这些操作和你的API的对应关系： 可以看出使用REST的好处在于可以充分利用http的强大实现对资源的CURD功能。而这里只需要一个endpoint：/tickets, 再没有其他什么命名规则和url规则了. 如何处理关联？关于如何处理资源之间的管理REST原则也有相关的描述： 其中，如果这种关联和资源独立，那么可以在资源的输出表示中保存相应资源的endpoint。然后API的使用者就可以通过点击链接找到相关的资源。如果关联和资源联系紧密。资源的输出表示就应该直接保存相应资源信息。（例如这里如果message资源是独立存在的，那么上面 GET /tickets/12/messages就会返回相应message的链接；相反的如果message不独立存在，他和ticket依附存在，则上面的API调用返回直接返回message信息） 在API上加入版本信息可以有效的防止用户访问已经更新了的API，同时也能让不同主要版本之间平稳过渡。 版本化API的通常方式有： 这种方式通常在URI中增加一段用于标识版本，例如 /v1 、 /v2 等。例如： 这种方式的优势在于版本信息很容易明显的看出来，可以通过浏览器直接访问。 这种方式的版本信息会放在HTTP的请求头中，通常会利用 Accept 字段，或者自定义一个字段。例如： 这种方式的好处是当版本升级时，URI保持不变，并且仅用于表示资源定位。 版本化的目的是为了标识API的变化，如果API不会变化，或者每次都会重新扩展新的API，这种情况下，就可以标识版本信息。例如： 前面提到了三种版本化API的方式，通常情况下需要针对自己业务的特殊性来挑选其中的一种方式。但是，在实际应用场景中，情况会更加复杂，API的升级通常有两种情况： 因此，折中方案是基于URI中的大版本号和HTTP头中的小版本号整合的方式。下面通过一个简单的示例来解释。 用户管理平台 一个常用的用户管理平台，提供以下API，通过用户ID获取用户信息： 考虑以下两种变动情况：一种是用户id从数字变成了字符串，另一种是新增一个用户头像的值。 前者修改因为数据类型的变化，会导致客户端解析出现问题。因此这样的修改已经破坏了向下兼容性，此时就需要修改API的版本号。例如： 第二种情况，对于旧客户端来说，只是增加了不使用的字段，通常的JSON格式解析库都可以忽略这些不使用的字段。对于新客户端则可以读取新的字段。例如： 这种情况下，基本可以做到向下兼容，因此可以算是“小版本升级”。针对小版本升级，可以将小版本号放到HTTP头中。例如： 由于混合版本化的方式同时涉及到URI和HTTP头字段，前端代理（例如HAProxy、nginx）可以通过这些特定版本号字段将请求代理到对应的后端应用。 例如，前端使用HAProxy进行多版本分发，可以针对URI和HTTP头定制acl，然后再对这些acl进行组合，设置不同的backend。 这样可以将API版本化规则应用到不同的后端，以保证向下兼容性。 基于版本化API规则，将“大版本”应用在URI上，将“小版本”应用在HTTP头字段上。通常来说，如果API升级之后破坏了向下兼容性，就应该升级“大版本”号；如果API升级可以向下兼容，可以升级“小版本”号。 版本化API有很多不同的设计方式，实际应用时，还是要根据业务场景进行选择，包括API版本升级频率，API稳定性等。通过HAProxy、nginx等代理服务，可以在确保向下兼容的情况下，由业务方决定老版本API的保留时间。 URL遵循动词+宾语的结构 API不需要1xx状态码 API 返回的数据格式，不应该是纯文本，而应该是一个 JSON 对象，因为这样才能返回标准的结构化数据。所以服务端返回值的Content-Type属性应为application/json，同时客户端请求头ACCEPT属性应为application/json。 发生错误时，不要返回200状态码，这样相当于状态码失去了意义。应该用状态码表示发生的错误，然后在信息里写明错误详情 提供链接（这个看不懂）

RESTful API 和 JSON-RPC 都不好用。应该二者结合，用兼容 RESTful API 的 RPC 才对。我们 ThoughtWorks 的几个小伙伴最近开源的 ThoughtWorksInc/microbuilder ，让你直接写 RPC 接口，然后自动转换成 RESTful 调用。这有一个例子，摘自 Microbuilder的文档，类似这样定义：@:structuralFailure(userSdk.model.Models.Failure)interface IUserProfileService { @:route("GET", "users/{userId}") @:responseContentType("text/json") function getProfile(userId:String):Future<Profile>;@:requestHeader("Your-Custom-Header", "custom-header-value") @:route("PUT", "users/{userId}") @:requestContentType("text/json") function setProfile(userId:String, profile:Profile):Future<Void>;}然后 Microbuilder 会自动生成接口实现，你就可以直接调用 RPC 了。

restful list-keys翻译为中文意思是:restful列表键

在进行API接口设计时，不同的开发人员可能有不同的设计风格，风格迥异。 那是否存在一种统一的接口设计方式，被广大开发人员所接受呢？ 答: 这就是被普遍采用的RESTful API设计风格 。 路径又称"终点"（endpoint），表示API的具体网址，每个网址代表一种资源（resource）。 （1）URL地址尽量使用名词，不使用动词。 举例来说，以下是不好的例子: 对于一个简洁结构，应该始终用名词。 （2） API中的名词应该使用复数，无论单个资源或者所有资源 。 举例来说，获取产品的API可以这样定义： 访问同一个URL地址，采用不同的请求方式，代表要执行不同的操作 。 常用的HTTP请求方式有下面四个： 例如： 过滤参数可以放在查询字符串中 。 在访问API接口获取数据时，可能需要对数据进行过滤。 下面是一些常见的参数： 针对不同操作，服务器向用户返回的响应数据应该符合以下规范： 服务器返回的响应数据格式，应该尽量使用JSON。 服务器向客户端返回的状态码和提示信息，常见的状态码如下：

Spring MVC本身对Restful支持非常好。它的@RequestMapping、@RequestParam、@PathVariable、@ResponseBody注解很好的支持了REST。18.2 Creating RESTful services1. @RequestMappingSpring uses the @RequestMapping method annotation to define the URI Template for the request. 类似于struts的action-mapping。 可以指定POST或者GET。2. @PathVariableThe @PathVariable method parameter annotation is used to indicate that a method parameter should be bound to the value of a URI template variable. 用于抽取URL中的信息作为参数。（注意，不包括请求字符串，那是@RequestParam做的事情。）@RequestMapping("/owners/{ownerId}", method=RequestMethod.GET)public String findOwner(@PathVariable String ownerId, Model model) { // ...}如果变量名与pathVariable名不一致，那么需要指定：@RequestMapping("/owners/{ownerId}", method=RequestMethod.GET)public String findOwner(@PathVariable("ownerId") String theOwner, Model model) { // implementation omitted}Tipmethod parameters that are decorated with the @PathVariable annotation can be of any simple type such as int, long, Date... Spring automatically converts to the appropriate type and throws a TypeMismatchException if the type is not correct.3. @RequestParam官方文档居然没有对这个注解进行说明，估计是遗漏了（真不应该啊）。这个注解跟@PathVariable功能差不多，只是参数值的来源不一样而已。它的取值来源是请求参数（querystring或者post表单字段）。对了，因为它的来源可以是POST字段，所以它支持更丰富和复杂的类型信息。比如文件对象:@RequestMapping("/imageUpload")public String processImageUpload(@RequestParam("name") String name, @RequestParam("description") String description, @RequestParam("image") MultipartFile image) throws IOException { this.imageDatabase.storeImage(name, image.getInputStream(), (int) image.getSize(), description); return "redirect:imageList";}还可以设置defaultValue：@RequestMapping("/imageUpload")public String processImageUpload(@RequestParam(value="name", defaultValue="arganzheng") String name, @RequestParam("description") String description, @RequestParam("image") MultipartFile image) throws IOException { this.imageDatabase.storeImage(name, image.getInputStream(), (int) image.getSize(), description); return "redirect:imageList";}4. @RequestBody和@ResponseBody这两个注解其实用到了Spring的一个非常灵活的设计——HttpMessageConverter 18.3.2 HTTP Message Conversion与@RequestParam不同，@RequestBody和@ResponseBody是针对整个HTTP请求或者返回消息的。前者只是针对HTTP请求消息中的一个 name=value 键值对(名称很贴切)。HtppMessageConverter负责将HTTP请求消息(HTTP request message)转化为对象，或者将对象转化为HTTP响应体(HTTP response body)。public interface HttpMessageConverter<T> { // Indicate whether the given class is supported by this converter. boolean supports(Class<? extends T> clazz); // Return the list of MediaType objects supported by this converter. List<MediaType> getSupportedMediaTypes(); // Read an object of the given type form the given input message, and returns it. T read(Class<T> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException; // Write an given object to the given output message. void write(T t, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException;} Spring MVC对HttpMessageConverter有多种默认实现，基本上不需要自己再自定义HttpMessageConverterStringHttpMessageConverter - converts stringsFormHttpMessageConverter - converts form data to/from a MultiValueMap<String, String>ByteArrayMessageConverter - converts byte arraysSourceHttpMessageConverter - convert to/from a javax.xml.transform.SourceRssChannelHttpMessageConverter - convert to/from RSS feedsMappingJacksonHttpMessageConverter - convert to/from JSON using Jackson"s ObjectMapperetc...然而对于RESTful应用，用的最多的当然是MappingJacksonHttpMessageConverter。但是MappingJacksonHttpMessageConverter不是默认的HttpMessageConverter：public class AnnotationMethodHandlerAdapter extends WebContentGeneratorimplements HandlerAdapter, Ordered, BeanFactoryAware { ... public AnnotationMethodHandlerAdapter() { // no restriction of HTTP methods by default super(false); // See SPR-7316 StringHttpMessageConverter stringHttpMessageConverter = new StringHttpMessageConverter(); stringHttpMessageConverter.setWriteAcceptCharset(false); this.messageConverters = new HttpMessageConverter[]{new ByteArrayHttpMessageConverter(), stringHttpMessageConverter, new SourceHttpMessageConverter(), new XmlAwareFormHttpMessageConverter()}; }} 如上：默认的HttpMessageConverter是ByteArrayHttpMessageConverter、stringHttpMessageConverter、SourceHttpMessageConverter和XmlAwareFormHttpMessageConverter转换器。所以需要配置一下：<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"> <property name="messageConverters"> <list> <bean class="org.springframework.http.converter.StringHttpMessageConverter"> <property name="supportedMediaTypes"> <list> <value>text/plain;charset=GBK</value> </list> </property> </bean> <bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" /> </list> </property></bean>配置好了之后，就可以享受@Requestbody和@ResponseBody对JONS转换的便利之处了：@RequestMapping(value = "api", method = RequestMethod.POST)@ResponseBodypublic boolean addApi(@RequestBody Api api, @RequestParam(value = "afterApiId", required = false) Integer afterApiId) { Integer id = apiMetadataService.addApi(api); return id > 0;}@RequestMapping(value = "api/{apiId}", method = RequestMethod.GET)@ResponseBodypublic Api getApi(@PathVariable("apiId") int apiId) { return apiMetadataService.getApi(apiId, Version.primary);}一般情况下我们是不需要自定义HttpMessageConverter，不过对于Restful应用，有时候我们需要返回jsonp数据：package me.arganzheng.study.springmvc.util;import java.io.IOException;import java.io.PrintStream;import org.codehaus.jackson.map.ObjectMapper;import org.codehaus.jackson.map.annotate.JsonSerialize.Inclusion;import org.springframework.http.HttpOutputMessage;import org.springframework.http.converter.HttpMessageNotWritableException;import org.springframework.http.converter.json.MappingJacksonHttpMessageConverter;import org.springframework.web.context.request.RequestAttributes;import org.springframework.web.context.request.RequestContextHolder;import org.springframework.web.context.request.ServletRequestAttributes;public class MappingJsonpHttpMessageConverter extends MappingJacksonHttpMessageConverter { public MappingJsonpHttpMessageConverter() { ObjectMapper objectMapper = new ObjectMapper(); objectMapper.setSerializationConfig(objectMapper.getSerializationConfig().withSerializationInclusion(Inclusion.NON_NULL)); setObjectMapper(objectMapper); } @Override protected void writeInternal(Object o, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException { String jsonpCallback = null; RequestAttributes reqAttrs = RequestContextHolder.currentRequestAttributes(); if(reqAttrs instanceof ServletRequestAttributes){ jsonpCallback = ((ServletRequestAttributes)reqAttrs).getRequest().getParameter("jsonpCallback"); } if(jsonpCallback != null){ new PrintStream(outputMessage.getBody()).print(jsonpCallback + "("); } super.writeInternal(o, outputMessage); if(jsonpCallback != null){ new PrintStream(outputMessage.getBody()).println(");"); } }}

等幂性（Idempotence）等幂性简单点说就是一次请求和多次请求，资源的状态是一样。比如GET和HEAD，不论你请求多少次，资源还是在那里。请注意，DELETE和PUT也是等幂的，以为对同一个资源删除一次或者多次，结果是一样的，就是资源被删除了，不存在了。为什么说PUT也是等幂的？当你PUT一个新资源的时候，资源被创建，再次PUT这个URI的时候，资源还是没变。当你PUT一个存在的资源时，更新了资源，再次PUT的时候，还是更新成这个样子。在PUT更新的时候，不能做相对的更新（依赖资源现在的状态），比如每次对一个数加1，这样资源状态就会变化。应该每次更新成某个数，比如把某个数变成4，则无论多少次PUT，值都是4，这样就是等幂了。我们设计Restful WS的时候，GET，HEAD, PUT, DELETE一定要设计成等幂的。由于网络是不可靠的，安全性和等幂性就显得特别重要。如果一次请求，服务器收到处理以后，客户端没有收到相应，客户端会再次请求，如果没有等幂性保障，就会发生意想不到的问题。POST是不安全也不等幂的，还是拿weblog的例子，如果两次POST相同的博文，则会产生两个资源，URI可能是这样/weblogs/myweblog/entries/1和/weblogs/myweblog/entries/2，尽管他们的内容是一摸一样的。

幂等性原本是数学中的含义，表达的是N次变换与1次变换的结果相同。 而RESTFul API中的幂等性是指调用某个接口1次或N次，对所访问的资源产生的影响结果都是相同的，需要特别注意的是：这里幂等性指的是对资源产生的影响结果，而非调用HTTP请求的返回结果。 举个例子，RESTFul API中的GET方法是查询资源信息，不会对资源产生影响，所以它是符合幂等性的，但是每次调用GET方法返回的结果有可能不同（可能资源的某个属性在调用GET方法之前已经被其他方法修改了，例如在多次访问期间，接口返回对象的update_time字段被别的请求更新，但GET本身是幂等性的）。 实际上，在分布式架构中的API幂等性不仅仅针对RESTFul接口，而是对所有类型的接口适用，目的是为了确保调用1次或N次接口时对资源的影响结果都是相同的。 接口的幂等性确保了无论调用1次还是N次对资源的影响都是相同的，这在某些场合下是非常有用的。 举个业务场景：用户下单，银行从用户账户扣款。 有这样一个接口方法：pay(long account, int money)，该方法用于银行卡扣款支付，参数account为账户ID，money为需要扣除的钱数。 当用户从网页上点击支付按钮时，在该方法的实现逻辑中需要从指定账户中扣除对应的商品价钱。如果支付操作已经成功执行，但是响应消息因为某种原因未能及时返回给客户端，这时候给用户的体验是可能是未支付成功，如果此时再次点击支付按钮，那么将再一次执行该方法，结果可能会导致用户只买了一件商品却扣减了双份的钱，这当然是不合理的。整个流程如下图所示： 当然，就上述例子的场景，为了避免用户重复支付，是可以通过别的方式解决的，比如：分布式事务；或者根据支付状态提示给予用户进行提示等等。 但是，如果引入了分布式事务，那么将带来实现上的复杂性，而且会影响到接口性能；而采取提示信息的方式并不能百分之百确保用户不会重复支付，存在一定的风险。 而如果接口符合幂等性，即：对同一个订单无论是执行一次支付还是多次支付，在服务端都确保只会扣一次款，那么既不需要引入分布式事务的复杂性，也能从根本上解决重复支付的问题，这也就是接口符合幂等性的价值所在。 总而言之，接口符合幂等性在可以降低系统实现的复杂性，并能保证资源状态的一致性。 RESTFul风格的接口设计本质上使用的是HTTP协议的请求方法，因此，RESTFul接口方法的幂等性指的就是HTTP方法的幂等性。 常用的HTTP方法有： 那么，这些HTTP方法的幂等性又是什么样的呢？除了幂等性之外，HTTP方法的安全性是指不对资源产生修改。 如下是常用HTTP方法的幂等性和安全性总结： 从上述表格中可以看出，HTTP方法的幂等性和安全性并不是同一个概念，如下是对个各个方法的幂等性和安全性解释： 设计幂等性接口的关键在于保证接口不论是被调用1次还是N次，它对资源所产生的影响都是相同的。 从上述HTTP方法的幂等性总结中可以得知，HTTP协议的POST和PATCH方法都不是幂等性的（但是我们却经常会在RESTFul接口中使用到它们），那是否就意味中无法将POST和PATCH方法设计为幂等性接口了呢？答案显然是否定的。在上述例子中，可以将订单ID也作为方法参数之一，如：pay(long account, int money, long order)，这样在服务端确保一个订单只会被支付一次（订单号是全局唯一的），那么无论该方法被调用1次还是N次结果都是一样的，也就保证了接口的幂等性。当然，在哪些没有订单号的场景，可以为接口操作生成一个全局唯一的处理号ID，并把该处理号ID作为方法参数之一，这样在服务端确保一个处理号ID只会被执行一次就保证了接口的幂等性。 符合幂等性的接口调用流程描述如下图所示： 虽然说设计符合幂等性的接口在某些场合可以降低系统的复杂性（如：可以不用引入分布式事务），但是并非在所有场合的问题都能通过幂等性接口解决，在必要的时候依然需要引入分布式事务处理这样的框架。我们不要也不能把接口幂等性作为万能的解决办法，但是，我们在设计接口时尽量考虑符合幂等性处理是非常有价值的。 【参考】

前言 目前网站上已经有很多关于如何去写restful风格的api的文章，主要说明下我接下来写的关于api写法的连载文章的目的，一个是主要把自己在这方面的心得分享给大家，二是希望大家也能给出更好的意见、建议，欢迎在看文章后讨论。 本篇文章主要说下接口路径该怎么定义，一个URL地址的可读性对于调用者和维护者都是很重要的，当你规划好URL该怎么定义后，这也决定了java项目中你的controller类的划分，我们知道一个HTTP接口通常主要结构为： 协议://域名/应用content path/自定义路径?查询参数，例如： https://api.zhuma.com/zm-back/users?pageSize=10&pageNum=1 代表筑码网后台管理用户功能的API。 那我们到底该怎么定义我们的API URL会更好一些呢？下面给出几点建议。 若域名无法区分出是api还是页面功能的时候，api路径后面统一加/api用于区分是接口服务。 1. https://back.zhuma.com/api/login 2. https://api-back.zhuma.com/login 上面举例中back代表着后台管理的意思，所以想要进入后台管理页面路径应该为： https://back.zhuma.com 前台当然要留给 https://www.zhuma.com ，在域名使用中我们可以利用三级域名对我们整体系统大的功能或应用进行很好的划分，正是因此，我们看到举例中路径上并没有加上应用的content path。 ★ 备注 建议通过域名去区分api，也就是举例中2的方式 在开发中对于多环境开发我们也可以通过域名来区分，例如： https://fe-api-back.zhuma.com 为联调环境， https://qa-api-back.zhuma.com 为QA测试环境， https://stg-api-back.zhuma.com 为仿真环境， https://api-back.zhuma.com 为生产环境等。 定义自定义路径部分时，使用名词的复数形式定义一个资源，如若有动词词性在url中考虑以下划线区分。 基本操作 GET /users # 获取用户列表 GET /users/{userId} # 查看某个具体的用户信息 POST /users # 新建一个用户 PUT /users/{userId} # 全量更新某一个用户信息 PATCH /users/{userId} # 选择性更新某一个用户信息 DELETE /users/{userId} # 删除某一个用户 批量操作 POST /users/_mget # 批量获取多个用户 POST /users/_mcreate # 批量创建多个用户 POST /users/_mupdate # 批量更新多个用户 POST /users/_mdelete # 批量删除多个用户 POST /users/_bulk # 批量功能组装（后面会讲到） 动词词性加入url （原则上此种情况是不被推荐的） GET /users/_search # 搜索用户 POST /users/_init # 初化所有用户 ★ 备注 这里可能有人会纠结路径参数/users/{userId} 是使用userId还是id，毕竟当前资源只有一级，此处不必纠结，原因是：这仅仅是一个后端使用变量而已，不会影响前端的使用，所以我们统一使用userId这种形式定义变量 批量操作时，统一使用POST作为HTTP METHOD，原因是 批量操作参数的数据大小不可控，使用request param可能超过某些浏览器对参数的长度限制，实际上，URL不存在参数长度上限的问题，HTTP协议规范没有对URL长度进行限制，这个限制是特定的浏览器及服务器对它的限制。 这里注意一个小点，URL路径是对大小写敏感的，例如：/users 和 /Users 是两个接口哦，但是我们规定URL全部小写。 URL区分功能（管理、我的 功能） 上面我们提到的 关于/users 用户功能的举例，通常情况下，这其实是一个管理用户资源的功能的接口，用于表示对用户这个资源的增删改查等管理功能。 那 我的 功能是指的什么呢？ 通常来说，是对于前端用户下的某某资源的说明，我们通常定义为my-开头。 举例 GET /my-orders 我的订单列表 GET /users/{userId}/orders 管理查看某一个用户下的订单列表 1. 路径中多个单词时，使用中划线 - 来连接 2. 不允许在路径中出现大写字母（查询参数名称除外） 3. 接口后省略xxx.do（很多人愿意加上.do这种形式，注意我们的每一个url代表的是一个资源哦） 举例 GET /my-account/profile 获取我的账户的简要信息 GET /my-notifications 获取我的消息列表 ★ 备注 上面的举例我们看到，my-account是单数而不是复数形式，这里说明下，在系统中如果明确该信息就是单数，那我们在url定义时也应该使用单数表示。 参考： Restful Api写法心得之一《路径定义篇》

1.接口命名规则http://ip:端口/v1/接口名IP：服务器IP地址端口：Restful端口号V1：版本号(1)接口名：命名规则：现有接口方法去第一个单词后，全小写命名，如：城市信息查询， 原接口名：queryCityId (String id)Restful接口：http://ip:端口/v1/cityid2.参数规则参数提交方式：Application/www-form-urlencoded参数命名：单词采取小写，复合词采取下划线分开的全小写命名。参数规则：批量查询需有page_size以及page_num参数，避免一次性查询，部分参数需有默认值设定。Restful接口设计原则l 使用标准HTTP方法实现资源CURD操作；l 采用json作为API输入输出；l 以json输出错误信息。注：Http协议详解HTTP请求方法在 RESTfulAPI 中的典型应用一组资源的URI，比如http://ip:8080/v1/ user/列出 URI，以及该资源组中每个资源的详细信息（后者可选）。使用给定的一组资源替换当前整组资源。在本组资源中创建/追加一个新的资源。该操作往往返回新资源的URL。删除 整组资源。单个资源的URI，比如http://ip:8080/v1/user/1获取 指定的资源的详细信息，格式使用JSON替换/创建 指定的资源。并将其追加到相应的资源组中。把指定的资源当做一个资源组，并在其下创建/追加一个新的元素，使其隶属于当前资源。删除 指定的元素。PUT 和 DELETE 方法是幂等方法。GET方法是安全方法 （不会对服务器端有修改，因此当然也是幂等的）。支持的返回码列表：HTTP返回码实现举例例如，一个简单的客户管理应用:列举所有客户：URL: GET http:// ip: 8080/v1/crm/customer输入：无输出：略呈现某一位客户：URL: GET http:// ip: 8080/v1/crm/customer/[customer id]输入：无输出：略新增客户：URL: POST http:// ip: 8080/v1/crm/ customer输入：略输出：略更新用户：根据更新参数，需要更新哪些参数就选哪些参数。

我们现实生活中的协议是指相互遵守的规定，单方面违背，协议不成立。 而在互联网交互的过程中，也存在这许多协议，例如 FTP、HTTP、STMP、TCP/IP 等。 而 HTTP 协议则是 web 服务器 和 web 客户端 达成的一种可靠的数据传输协议，通过 HTTP 可以从遍布全世界的 Web 服务器上将 JPEG 图片，HTML 页面，文本文件，MPEG 电影，WAV 音频文件和其他资源信息块迅速、便捷、可靠地搬移到人们桌面上的 Web 浏览器上去。它能够确保数据在传输的过程当中不会损坏或者产生混乱。这样，对用户来说是个好事，同样对 Internet 应用的开发人员来说也是一件好事。因为我们在开发过程中也不需要担心自己的页面和数据会在传输过程中发生破坏和畸变了。 Web 内容都是 存储在 Web 服务器 上的。Web 服务器所使用的是 HTTP 协议，因此经常会被称为 HTTP 服务器。这些 HTTP 服务器存储了因特网中的数据，如果 HTTP 客户端发出请求的话，它们会提供数据。客户端向服务器发送 HTTP 请求，服务器会在 HTTP 响应中回送所请求的数据。 那么一次请求和响应的过程中发生了什么？ web 服务器是 web 资源的宿主 ，而 web 资源就是我们常见的 web 内容的源头，最简单的 web 资源就是我们服务器中的静态文件：文本文件，HTML 文档，JPEG 图片文件，AVI 文件等等。 当然 web 资源也可以是动态生成的，类似搜索引擎生成的页面，QQ 空间的动态等，总之，所有类型的内容来源都是资源。 因特网上有数千种不同类型的数据类型，HTTP 在传输的过程中为每个传输的数据都打上了名为 MIME 类型的数据类型标签，描述并标记多媒体内容。 web 浏览器请求一个网站的时候往往会发布 多个 HTTP 请求 ，比如我们在浏览一个具有丰富图片的的 web 页面的时候，浏览器会执行一次 HTTP 请求来获取描述页面布局的 HTML，然后发布另外的请求来获取每个嵌入式的图片，这些图片甚至可能位于不同的服务器上。因此，一个 web 页面通常不是单个资源，而是一组资源的集合。 web 服务器会为所有的 HTTP 对象数据附加一个 MIME 类型 ，当浏览器从服务器中取回一个对象的时候，会查看相关的 MIME 类型。看看它是否知道应该如何处理这个对象。对象的类型写在响应的 content-type 头 中；同样，请求的时候浏览器也会告知服务器请求数据类型。 常见的 MIME 类型： 以 application 开头的媒体格式类型： MIME 参考手册： W3school MINE类型 大部分 URL 都遵循一种标准格式， 这种格式包含三个部分。 URI = Uniform Resource Identifier 统一资源 标志符 URL = Uniform Resource Locator 统一资源 定位符 URN = Uniform Resource Name 统一资源 名称 翻译成人话: URI 是抽象的定义，不管用什么方法表示，只要能定位一个资源，就叫 URI，本来设想的的使用两种方法定位。 1）URL 用地址定位 2）URN 用名称定位 举个例子：去村子找个具体的人（URI）。如果用地址：某村多少号房子第几间房的主人就是 URL， 如果用身份证号 + 名字，去找就是 URN 了。 目前 WEB 上就 URL 流行开了，平常见得 URI 基本都是 URL。 1）HTTP 和 HTTPS 的相同点 2）HTTP 和 HTTPS 的不同之处 3）如何选择 HTTP 和 HTTPS 协议 HTTP 支持几种不同请求和命令，这些命令被称为 HTTP 方法，每条 HTTP 请求报文都包含一个方法。 这个方法会告诉服务器要执行什么动作（获取一个 Web 页面、发送一段信息、删除一个文件等）。 请求方法如下： 状态码分成如下几个系列： 常见的 HTTP 状态码： 从 Web 客户端发往 Web 服务器的 HTTP 报文称为请求报文（request message）。从服务器发往客户端的报文称为响应报文（response message）。 HTTP 报文包括以下三个部分: 以上内容复制自： http://www.cnblogs.com/Joans/p/3956490.html 使用火狐和 chrome 浏览器打开一个网页，找到其中一个网络请求查看报文。 1）协议 2）域名 3）接口版本控制规范 格式规范如下： 更新版本后可以使用 v2、v3 等依次递加。 4）接口路径规范 格式规范如下： 5）接口命名规范 格式规范如下： 6） HTTP 请求方法 格式规范如下： GET https://api.xxxxx.com/v1/zoos ：列出所有动物园 POST https://api.xxxxx.com/v1/zoos ：新建一个动物园 GET https://api.xxxxx.com/v1/zoos/ID ：获取某个指定动物园的信息 PUT https://api.xxxxx.com/v1/zoos/ID ：更新某个指定动物园的信息（提供该动物园的全部信息） PATCH https://api.xxxxx.com/v1/zoos/ID ：更新某个指定动物园的信息（提供该动物园的部分信息） DELETE https://api.xxxxx.com/v1/zoos/ID ：删除某个动物园 GET https://api.xxxxx.com/v1/zoos/ID/animals ：列出某个指定动物园的所有动物 DELETE https://api.xxxxx.com/v1/zoos/ID/animals/ID ：删除某个指定动物园的指定动物 注意：修改有两个方法 PUT 和 PATCH。 假设 URL 位置有一组数据 UserInfo，包括 UserID、UserName 等 20 个字段 需求：用户修改了 UserName，其他不变 u2022 采用 PATCH，仅向 URL 提交 UserName 的局部更新请求 u2022 采用 PUT，必须将所有 20 个字段一并提交到 URL，未提交字段被删除 PATCH 的最主要好处：节省网络带宽 7）接口信息过滤 格式规范如下： ?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 的含义是相同的。 8）请求参数规范 9）接口返回数据 格式规范如下： status:：接口的执行状态 data：接口的主数据 msg：返回成功或者失败的错误信息 返回数据中的状态码、状态信息，常指具体的业务状态，不建议和 HTTP 状态码混在一起。HTTP 状态，是用来体现 HTTP链路状态情况，如：404-Not Found。HTTP 状态码和 JSON 结果中的状态码，并存尚可，用于体现不同维度的状态。 简单的功能如下： 这里不牵扯到任何 Python 和 Pycharm 的教学，不会的童鞋挪步 Python 开发教程。 参考新浪开放平台 https://open.weibo.com ，基本是国内最为标准的 API 文档之一。

你好，restfull翻译成中文的意思是休息。希望能够帮到你。

在开发HTTP API的时候，我们一般会按照REST风格来设计，符合REST风格的API也称为RESTful API。 RESTful API的主要规则包括以下几点： 标准的RESTful API示例如下： 由于英语语法的特点和HTTP请求的方法数量的有限，可能存在一些无法覆盖到的部分，如下： 下面来谈谈上述未覆盖部分及其解决方案。 常规动作有GET,POST,PUT,PATCH和DELETE，也就是所谓的增删改查，但是现实中还有很多非前面提到的动作，如取消操作。 针对非常规动作，解决的方案有两种： 下面我们以取消订单为例，来看看针对该问题不同方案的实现。 该方案是GitHub在使用中的方案，在开放的API的可以看到。 针对实例的实现如下： 这个Google Could中Could API设计规范中定义的方案，语法为： 针对实例的实现如下： 该情况可按照英语语法使用对应的名词即可，如下: 使用可数名词来代替，如news可以用news-items来代替。 这种情况可以采用资源对应的名词的单数形式来表示获取一条数据, 该方案也适用于多对一的情况。 例如：用户的购物车数据，每个用户有一个购物车，可以表示如下：

SOAP(Simple Object Access Protocol)简单对象访问协议，是基于HTTP的一种异构系统通信的协议，说白了就是xml文档传输，之所以会有它，就是在于不同语言C,C++,JAVA等语言开发的系统进行通信，是WebService就是基于SOAP协议的，确实是一种比较传统的SOA解决方案。REST(Rerepresentational State Transfer)是外国一位博士提出的一种架构风格，从资源状态转换角度看待资源，但也是基于SOAP协议进行通信。rest 是一种风格 restful Webservice 和 soap的区别在于表现形式不一样，如果想深入了解 可以去开开 深入理解Webservice 这本书，restful Webservice 不只是可以用json 也可以用xml 更可以用html做消息返回， rest 风格的Webservice 和传统的soap 主要的表现在于 rest是将资源暴露 soap是暴露操作 。具体的流程其实和soap是一样的，但是rest更方便，更轻。

使用Node.js和npm安装CoffeeScript尽管有很多不借助Node来运行CoffeeScript代码的方法（附录2会谈到其中几种），然而我还是假定你在全书中用的是标准的coffee命令，专门运行在Node上的。但是只有在第6章才会明确需要使用Node和npm。请注意，使用Windows系统的用户，在继续之前你需要先安装Cygwin 。Cygwin基本上相当于一个Linux模拟器。虽然Node.js在0.6版本的蓝图中计划直接支持Windows，但是在写作本书之时，使用Cygwin是现有的最可靠的方法。Mac用户需要安装Xcode ，重点并不在于这个程序，而在于那些随它一起安装的命令行开发工具。尝试运行命令gcc（GNU编译器集合）来检测系统中是否已经安装了这些工具：

无状态是针对于“状态”来说的。 一个WEB应用协议中的“状态”指的是，为两个相互关联的用户交互操作保留某种公共信息，例如用户登录信息，工作流等。 这些信息具有不同作用域，如page，request，session，application等。通常由服务器负责保存这些信息。 “无状态” 的概念逐渐流行，得益于分布式系统的发展。首先，无状态请求易于实现负载均衡。在分布式web系统下，有多个可用服务器，每个服务器都可以处理客户端请求。传统的有状态请求，因为状态信息只保存在第一次发起请求的那台服务器上，之后的请求都只能由这台服务器来处理，服务器无法自由调度请求。无状态请求则完全没有这个限制。其次，无状态请求有较强的容错性和可伸缩性。如果一台服务器宕机，无状态请求可以透明地交由另一台可用服务器来处理，而有状态的请求则会因为存储请求状态信息的服务器宕机而承担状态丢失的风险。需要注意的是，“状态"指请求的状态，而不是资源的状态。Restful风格的无状态约束要求服务器不保存请求状态，如果确实需要维持用户状态，也应由客户端负责。传递user credentials 是Restful的，而传递sessionID是unRestful的,因为session信息保存在服务器端。

restful怎么返回多表查询可以通过BufferedReader 流的形式进行流缓存，之后通过readLine方法获取到缓存的内容。 BufferedReader bre = null;try {String file = "D:/test/test.txt";bre = new BufferedReader(new FileReader(file));//此时获取到的bre就是整个文件的缓存流while ((str = bre.readLine())!= null) // 判断最后一行不存在，为空结束循环{System.out.println(str);//原样输出读到的内容}；备注： 流用完之后必须close掉，如上面的就应该是：bre.close()，否则bre流会一直存在，直到程序运行结束。

两者可以同时使用，restful是一种设计风格，而hession是一种远程调用技术不同的东西

infoq：安全是恒久的话题，对于基于wsdl和soap的webservice，我们有ws-security这样的安全规范来指导实现认证、授权、身份管理等安全需求。那么，restfulapi有无成熟可用规范或实现框架呢？如何保证restfulapi的安全性呢？李锟：保证restfulapi的安全性，主要包括三大方面：a)对客户端做身份认证b)对敏感的数据做加密，并且防止篡改c)身份认证之后的授权对客户端做身份认证，有几种常见的做法：在请求中加签名参数1.为每个接入方分配一个密钥，并且规定一种签名的计算方法。要求接入方的请求中必须加上签名参数。这个做法是最简单的，但是需要确保接入方密钥的安全保存，另外还要注意防范replay攻击。其优点是容易理解与实现，缺点是需要承担安全保存密钥和定期更新密钥的负担，而且不够灵活，更新密钥和升级签名算法很困难。使用标准的http身份认证机制httpbasic身份认证安全性较低，必须与https配合使用。httpdigest身份认证可以单独使用，具备中等程度的安全性。httpdigest身份认证机制还支持插入用户自定义的加密算法，这样可以进一步提高api的安全性。不过插入自定义加密算法在面向互联网的api中用的不是很多。这个做法需要确保接入方“安全域-用户名-密码”三元组信息的安全保存，另外还要注意防范replay攻击。优点：基于标准，得到了广泛的支持（大量http服务器端、客户端库）。在服务器端做http身份认证的职责可以由webserver（例如nginx）、appserver（例如tomcat）、安全框架（例如springsecurity）来承担，对应用开发者来说是透明的。http身份认证机制（rfc2617）非常好地体现了“分离关注点”的设计原则，而且保持了操作语义的可见性。2.缺点：这类基于简单用户名+密码机制的安全性不可能高于基于非对称密钥的机制（例如数字证书）。使用oauth协议做身份认证oauth协议适用于为外部应用授权访问本站资源的情况。其中的加密机制与httpdigest身份认证相比，安全性更高。需要注意，oauth身份认证与httpdigest身份认证之间并不是相互取代的关系，它们的适用场景是不同的。oauth协议更适合于为面向最终用户维度的api提供授权，例如获取隶属于用户的微博信息等等。如果api并不是面向最终用户维度的，例如像七牛云存储这样的存储服务，这并非是oauth协议的典型适用场景。

一个好的RESTful API，应该具备以下特征：　　这个API应该是对浏览器友好的，能够很好地融入Web，而不是与Web格格不入。　　1.浏览器是最常见和最通用的REST客户端。好的RESTful API应该能够使用浏览器+HTML完成所有的测试（不需要使用编程语言）。这样的API还可以很方便地使用各种自动化的Web功能测试、性能测试工具来做测试。Web前端应用（基于浏览器的RIA应用、移动App等等）也可以很方便地将多个RESTful API的功能组合起来，建造Mashup类的应用。　　这个API中所包含的资源和对于资源的操作，应该是直观和容易理解的，并且符合HTTP协议的要求。　　REST开发又被称作“面向资源的开发”，这说明对于资源的抽象，是设计RESTful API的核心内容。RESTful API建模的过程与面向对象建模类似，是以名词为核心的。这些名词就是资源，任何可命名的抽象概念都可以定义为一个资源。而HTTP协议并不是一种传输协议，它实际提供了一个操作资源的统一接口。对于资源的任何操作，都应该映射到HTTP的几个有限的方法（常用的有GET/POST/PUT/DELETE四个方法，还有不常用的PATCH/HEAD/OPTIONS方法）上面。所以RESTful API建模的过程，可以看作是具有统一接口约束的面向对象建模过程。　　按照HTTP协议的规定，GET方法是安全且幂等的，POST方法是既不安全也不幂等的（可以用来作为所有写操作的通配方法），PUT、DELETE方法都是不安全但幂等的。将对资源的操作合理映射到这四个方法上面，既不过度使用某个方法（例如过度使用GET方法或POST方法），也不添加过多的操作以至于HTTP的四个方法不够用。　　2.如果发现资源上的操作过多，以至于HTTP的方法不够用，应该考虑设计出更多的资源。设计出更多资源（以及相应的URI）对于RESTful API来说并没有什么害处。　　这个API应该是松耦合的。　　RESTful API的设计包括了三个循序渐进、由低到高的层次：资源抽象、统一接口、超文本驱动。正是这三个层次确保了RESTful API的松耦合性。　　3.当设计面向互联网的API时，松耦合变成了一种“必须有”的强需求。紧耦合的API非常脆弱，一旦公布出去，服务器端和客户端都无法持续进化。

　　App通常用restful api跟server打交道。Rest是stateless的，也就是app不需要像browser那样用cookie来保存session, 因此用session token来标示自己就够了，session/state由api server的逻辑处理。　　如果你的后端不是stateless的rest api, 那么你可能需要在app里保存session. 可以在app里嵌入webkit,用一个隐藏的browser来管理cookie session.　　session 和 oauth token 并不矛盾，作为身份认证 token 安全性比session好，因为每个请求都有签名还能防止监听以及重放攻击，而session就必须靠链路层来保障通讯安全了。如上所说，如果你需要实现有状态的会话，仍然可以增加session来在服务器端保存一些状态

　　一个好的RESTful API，应该具备以下特征：　　这个API应该是对浏览器友好的，能够很好地融入Web，而不是与Web格格不入。　　1.浏览器是最常见和最通用的REST客户端。好的RESTful API应该能够使用浏览器+HTML完成所有的测试（不需要使用编程语言）。这样的API还可以很方便地使用各种自动化的Web功能测试、性能测试工具来做测试。Web前端应用（基于浏览器的RIA应用、移动App等等）也可以很方便地将多个RESTful API的功能组合起来，建造Mashup类的应用。　　这个API中所包含的资源和对于资源的操作，应该是直观和容易理解的，并且符合HTTP协议的要求。　　REST开发又被称作“面向资源的开发”，这说明对于资源的抽象，是设计RESTful API的核心内容。RESTful API建模的过程与面向对象建模类似，是以名词为核心的。这些名词就是资源，任何可命名的抽象概念都可以定义为一个资源。而HTTP协议并不是一种传输协议，它实际提供了一个操作资源的统一接口。对于资源的任何操作，都应该映射到HTTP的几个有限的方法（常用的有GET/POST/PUT/DELETE四个方法，还有不常用的PATCH/HEAD/OPTIONS方法）上面。所以RESTful API建模的过程，可以看作是具有统一接口约束的面向对象建模过程。　　按照HTTP协议的规定，GET方法是安全且幂等的，POST方法是既不安全也不幂等的（可以用来作为所有写操作的通配方法），PUT、DELETE方法都是不安全但幂等的。将对资源的操作合理映射到这四个方法上面，既不过度使用某个方法（例如过度使用GET方法或POST方法），也不添加过多的操作以至于HTTP的四个方法不够用。　　2.如果发现资源上的操作过多，以至于HTTP的方法不够用，应该考虑设计出更多的资源。设计出更多资源（以及相应的URI）对于RESTful API来说并没有什么害处。　　这个API应该是松耦合的。　　RESTful API的设计包括了三个循序渐进、由低到高的层次：资源抽象、统一接口、超文本驱动。正是这三个层次确保了RESTful API的松耦合性。　　3.当设计面向互联网的API时，松耦合变成了一种“必须有”的强需求。紧耦合的API非常脆弱，一旦公布出去，服务器端和客户端都无法持续进化。尤其是服务器端，公布出去的接口根本不敢改，改了之后，几乎所有客户端应用立即无法正常工作。REST这种架构风格就是紧耦合API的解毒剂，这个话题可以谈的很深，这里就不展开了。感兴趣的读者可以参考《REST实战》。　　这个API中所使用的表述格式应该是常见的通用格式　　在RESTful API中，对于资源的操作，是通过在服务器端-客户端之间传递资源的表述来间接完成的。资源的表述可以有很多种格式，并且在响应和请求中的资源表述格式也会有所不同。GET/POST响应中的资源表述格式，常见的有HTML、XML、JSON；POST/PUT请求中的资源表述格式，常见的有标准的HTML表单参数、XML、JSON。　　4.这些常见表述格式，处理起来非常容易，有大量的框架和库提供支持。所以除非有很合理的要求，通常不需要使用自定义的私有格式。　　使用HTTP响应状态代码来表达各种出错情况　　HTTP响应状态代码，是HTTP协议这个统一接口中用来表达出错情况的标准机制。响应状态代码分成两部分：status code和reason phase。两部分都是可定制的，也可以使用标准的status code，只定制reason phase。　　5.如果一个所谓的“RESTful API”对于任何请求都返回200 OK响应，在响应的消息体中返回出错情况信息，这种做法显然不符合“确保操作语义的可见性”这个REST架构风格的基本要求。　　这个API应该对于HTTP缓存是友好的　　6.充分利用好HTTP缓存是RESTful API可伸缩性的根本。HTTP协议是一个分层的架构，从两端的user agent到origin server之间，可以插入很多中间组件。而在整个HTTP通信链条的很多位置，都可以设置缓存。HTTP协议内建有很好的缓存机制，可以分成过期模型和验证模型两套缓存机制。如果API设计者完全没有考虑过如何利用HTTP缓存，那么这个API的可伸缩性会有很多问题。

一个好的RESTfulAPI，应该具备以下特征：这个API应该是对浏览器友好的，能够很好地融入Web，而不是与Web格格不入。1.浏览器是最常见和最通用的REST客户端。好的RESTfulAPI应该能够使用浏览器HTML完成所有的测试（不需要使用编程语言）。这样的API还可以很方便地使用各种自动化的Web功能测试、性能测试工具来做测试。Web前端应用（基于浏览器的RIA应用、移动App等等）也可以很方便地将多个RESTfulAPI的功能组合起来，建造Mashup类的应用。这个API中所包含的资源和对于资源的操作，应该是直观和容易理解的，并且符合HTTP协议的要求。REST开发又被称作“面向资源的开发”，这说明对于资源的抽象，是设计RESTfulAPI的核心内容。RESTfulAPI建模的过程与面向对象建模类似，是以名词为核心的。这些名词就是资源，任何可命名的抽象概念都可以定义为一个资源。而HTTP协议并不是一种传输协议，它实际提供了一个操作资源的统一接口。对于资源的任何操作，都应该映射到HTTP的几个有限的方法（常用的有GET/POST/PUT/DELETE四个方法，还有不常用的PATCH/HEAD/OPTIONS方法）上面。所以RESTfulAPI建模的过程，可以看作是具有统一接口约束的面向对象建模过程。按照HTTP协议的规定，GET方法是安全且幂等的，POST方法是既不安全也不幂等的（可以用来作为所有写操作的通配方法），PUT、DELETE方法都是不安全但幂等的。将对资源的操作合理映射到这四个方法上面，既不过度使用某个方法（例如过度使用GET方法或POST方法），也不添加过多的操作以至于HTTP的四个方法不够用。2.如果发现资源上的操作过多，以至于HTTP的方法不够用，应该考虑设计出更多的资源。设计出更多资源（以及相应的URI）对于RESTfulAPI来说并没有什么害处。这个API应该是松耦合的。RESTfulAPI的设计包括了三个循序渐进、由低到高的层次：资源抽象、统一接口、超文本驱动。正是这三个层次确保了RESTfulAPI的松耦合性。3.当设计面向互联网的API时，松耦合变成了一种“必须有”的强需求。紧耦合的API非常脆弱，一旦公布出去，服务器端和客户端都无法持续进化。尤其是服务器端，公布出去的接口根本不敢改，改了之后，几乎所有客户端应用立即无法正常工作。REST这种架构风格就是紧耦合API的解毒剂，这个话题可以谈的很深，这里就不展开了。感兴趣的读者可以参考《REST实战》。这个API中所使用的表述格式应该是常见的通用格式在RESTfulAPI中，对于资源的操作，是通过在服务器端-客户端之间传递资源的表述来间接完成的。资源的表述可以有很多种格式，并且在响应和请求中的资源表述格式也会有所不同。GET/POST响应中的资源表述格式，常见的有HTML、XML、JSON；POST/PUT请求中的资源表述格式，常见的有标准的HTML表单参数、XML、JSON。4.这些常见表述格式，处理起来非常容易，有大量的框架和库提供支持。所以除非有很合理的要求，通常不需要使用自定义的私有格式。使用HTTP响应状态代码来表达各种出错情况HTTP响应状态代码，是HTTP协议这个统一接口中用来表达出错情况的标准机制。响应状态代码分成两部分：statuscode和reasonphase。两部分都是可定制的，也可以使用标准的statuscode，只定制reasonphase。5.如果一个所谓的“RESTfulAPI”对于任何请求都返回200OK响应，在响应的消息体中返回出错情况信息，这种做法显然不符合“确保操作语义的可见性”这个REST架构风格的基本要求。这个API应该对于HTTP缓存是友好的6.充分利用好HTTP缓存是RESTfulAPI可伸缩性的根本。HTTP协议是一个分层的架构，从两端的useragent到originserver之间，可以插入很多中间组件。而在整个HTTP通信链条的很多位置，都可以设置缓存。HTTP协议内建有很好的缓存机制，可以分成过期模型和验证模型两套缓存机制。如果API设计者完全没有考虑过如何利用HTTP缓存，那么这个API的可伸缩性会有很多问题。

一个好的RESTful API，应该具备以下特征：　　这个API应该是对浏览器友好的，能够很好地融入Web，而不是与Web格格不入。　　1.浏览器是最常见和最通用的REST客户端。好的RESTful API应该能够使用浏览器+HTML完成所有的测试（不需要使用编程语言）。这样的API还可以很方便地使用各种自动化的Web功能测试、性能测试工具来做测试。Web前端应用（基于浏览器的RIA应用、移动App等等）也可以很方便地将多个RESTful API的功能组合起来，建造Mashup类的应用。　　这个API中所包含的资源和对于资源的操作，应该是直观和容易理解的，并且符合HTTP协议的要求。　　REST开发又被称作“面向资源的开发”，这说明对于资源的抽象，是设计RESTful API的核心内容。RESTful API建模的过程与面向对象建模类似，是以名词为核心的。这些名词就是资源，任何可命名的抽象概念都可以定义为一个资源。而HTTP协议并不是一种传输协议，它实际提供了一个操作资源的统一接口。对于资源的任何操作，都应该映射到HTTP的几个有限的方法（常用的有GET/POST/PUT/DELETE四个方法，还有不常用的PATCH/HEAD/OPTIONS方法）上面。所以RESTful API建模的过程，可以看作是具有统一接口约束的面向对象建模过程。　　按照HTTP协议的规定，GET方法是安全且幂等的，POST方法是既不安全也不幂等的（可以用来作为所有写操作的通配方法），PUT、DELETE方法都是不安全但幂等的。将对资源的操作合理映射到这四个方法上面，既不过度使用某个方法（例如过度使用GET方法或POST方法），也不添加过多的操作以至于HTTP的四个方法不够用。　　2.如果发现资源上的操作过多，以至于HTTP的方法不够用，应该考虑设计出更多的资源。设计出更多资源（以及相应的URI）对于RESTful API来说并没有什么害处。　　这个API应该是松耦合的。　　RESTful API的设计包括了三个循序渐进、由低到高的层次：资源抽象、统一接口、超文本驱动。正是这三个层次确保了RESTful API的松耦合性。　　3.当设计面向互联网的API时，松耦合变成了一种“必须有”的强需求。紧耦合的API非常脆弱，一旦公布出去，服务器端和客户端都无法持续进化。尤其是服务器端，公布出去的接口根本不敢改，改了之后，几乎所有客户端应用立即无法正常工作。REST这种架构风格就是紧耦合API的解毒剂，这个话题可以谈的很深，这里就不展开了。感兴趣的读者可以参考《REST实战》。　　这个API中所使用的表述格式应该是常见的通用格式　　在RESTful API中，对于资源的操作，是通过在服务器端-客户端之间传递资源的表述来间接完成的。资源的表述可以有很多种格式，并且在响应和请求中的资源表述格式也会有所不同。GET/POST响应中的资源表述格式，常见的有HTML、XML、JSON；POST/PUT请求中的资源表述格式，常见的有标准的HTML表单参数、XML、JSON。　　4.这些常见表述格式，处理起来非常容易，有大量的框架和库提供支持。所以除非有很合理的要求，通常不需要使用自定义的私有格式。　　使用HTTP响应状态代码来表达各种出错情况　　HTTP响应状态代码，是HTTP协议这个统一接口中用来表达出错情况的标准机制。响应状态代码分成两部分：status code和reason phase。两部分都是可定制的，也可以使用标准的status code，只定制reason phase。　　5.如果一个所谓的“RESTful API”对于任何请求都返回200 OK响应，在响应的消息体中返回出错情况信息，这种做法显然不符合“确保操作语义的可见性”这个REST架构风格的基本要求。　　这个API应该对于HTTP缓存是友好的

REST是一种架构风格，其核心是面向资源，REST专门针对网络应用设计和开发方式，以降低开发的复杂性，提高系统的可伸缩性。REST提出设计概念和准则为： 1.网络上的所有事物都可以被抽象为资源(resource) 2.每一个资源都有唯一的资源标识(resource identifier)，对资源的操作不会改变这些标识 3.所有的操作都是无状态的 REST简化开发，其架构遵循CRUD原则，该原则告诉我们对于资源(包括网络资源)只需要四种行为：创建，获取，更新和删除就可以完成相关的操作和处理。您可以通过统一资源标识符（Universal Resource Identifier，URI）来识别和定位资源，并且针对这些资源而执行的操作是通过 HTTP 规范定义的。其核心操作只有GET,PUT,POST,DELETE。 由于REST强制所有的操作都必须是stateless的，这就没有上下文的约束，如果做分布式，集群都不需要考虑上下文和会话保持的问题。极大的提高系统的可伸缩性。 对于SOAP Webservice和Restful Webservice的选择问题，首先需要理解就是SOAP偏向于面向活动，有严格的规范和标准，包括安全，事务等各个方面的内容，同时SOAP强调操作方法和操作对象的分离，有WSDL文件规范和XSD文件分别对其定义。而REST强调面向资源，只要我们要操作的对象可以抽象为资源即可以使用REST架构风格。REST ful 应用问题 是否使用REST就需要考虑资源本身的抽象和识别是否困难，如果本身就是简单的类似增删改查的业务操作，那么抽象资源就比较容易，而对于复杂的业务活动抽象资源并不是一个简单的事情。比如校验用户等级，转账，事务处理等，这些往往并不容易简单的抽象为资源。 其次如果有严格的规范和标准定义要求，而且前期规范标准需要指导多个业务系统集成和开发的时候，SOAP风格由于有清晰的规范标准定义是明显有优势的。我们可以在开始和实现之前就严格定义相关的接口方法和接口传输数据。 简单数据操作，无事务处理，开发和调用简单这些是使用REST架构风格的优势。而对于较为复杂的面向活动的服务，如果我们还是使用REST，很多时候都是仍然是传统的面向活动的思想通过转换工具再转换得到REST服务，这种使用方式是没有意义的。效率和易用性 SOAP协议对于消息体和消息头都有定义，同时消息头的可扩展性为各种互联网的标准提供了扩展的基础，WS-*系列就是较为成功的规范。但是也由于SOAP由于各种需求不断扩充其本身协议的内容，导致在SOAP处理方面的性能有所下降。同时在易用性方面以及学习成本上也有所增加。 REST被人们的重视，其实很大一方面也是因为其高效以及简洁易用的特性。这种高效一方面源于其面向资源接口设计以及操作抽象简化了开发者的不良设计，同时也最大限度的利用了Http最初的应用协议设计理念。同时，在我看来REST还有一个很吸引开发者的就是能够很好的融合当前Web2.0的很多前端技术来提高开发效率。例如很多大型网站开放的REST风格的API都会有多种返回形式，除了传统的xml作为数据承载，还有（JSON,RSS,ATOM）等形式，这对很多网站前端开发人员来说就能够很好的mashup各种资源信息安全性 技术没有好坏，只有是不是合适，一种好的技术和思想被误用了，那么就会得到反效果。REST和SOAP各自都有自己的优点，同时如果在一些场景下如果去改造REST，其实就会走向SOAP（例如安全）。 REST对于资源型服务接口来说很合适，同时特别适合对于效率要求很高，但是对于安全要求不高的场景。而SOAP的成熟性可以给需要提供给多开发语言的，对于安全性要求较高的接口设计带来便利。所以我觉得纯粹说什么设计模式将会占据主导地位没有什么意义，关键还是看应用场景。 同时很重要一点就是不要扭曲了REST现在很多网站都跟风去开发REST风格的接口，其实都是在学其形，不知其心，最后弄得不伦不类，性能上不去，安全又保证不了。成熟度 SOAP虽然发展到现在已经脱离了初衷，但是对于异构环境服务发布和调用，以及厂商的支持都已经达到了较为成熟的情况。不同平台，开发语言之间通过SOAP来交互的web service都能够较好的互通。 由于没有类似于SOAP的权威性协议作为规范，REST实现的各种协议仅仅只能算是私有协议，当然需要遵循REST的思想，但是这样细节方面有太多没有约束的地方。REST日后的发展所走向规范也会直接影响到这部分的设计是否能够有很好的生命力。

REST(REpresentationStateTransfer)描述了一个架构样式的网络系统，比如web应用程序。它首次出现在2000年RoyFielding的博士论文中，他是HTTP规范的主要编写者之一。REST指的是一组架构约束条件和原则。满足这些约束条件和原则的应用程序或设计就是RESTful。Web应用程序最重要的REST原则是，客户端和服务器之间的交互在请求之间是无状态的。从客户端到服务器的每个请求都必须包含理解请求所必需的信息。如果服务器在请求之间的任何时间点重启，客户端不会得到通知。此外，无状态请求可以由任何可用服务器回答，这十分适合云计算之类的环境。客户端可以缓存数据以改进性能。在服务器端，应用程序状态和功能可以分为各种资源。资源是一个有趣的概念实体，它向客户端公开。资源的例子有:应用程序对象、数据库记录、算法等等。每个资源都使用URI(UniversalResourceIdentifier)得到一个惟一的地址。所有资源都共享统一的界面，以便在客户端和服务器之间传输状态。使用的是标准的HTTP方法，比如GET、PUT、POST和DELETE。Hypermedia是应用程序状态的引擎，资源表示通过超链接互联。另一个重要的REST原则是分层系统，这表示组件无法了解它与之交互的中间层以外的组件。通过将系统知识限制在单个层，可以限制整个系统的复杂性，促进了底层的独立性。当REST架构的约束条件作为一个整体应用时，将生成一个可以扩展到大量客户端的应用程序。它还降低了客户端和服务器之间的交互延迟。统一界面简化了整个系统架构，改进了子系统之间交互的可见性。REST简化了客户端和服务器的实现。RESTful的实现:RESTfulWeb服务与RPC样式的Web服务了解了什么是什么是REST，我们再看看RESTful的实现。最近，使用RPC样式架构构建的基于SOAP的Web服务成为实现SOA最常用的方法。RPC样式的Web服务客户端将一个装满数据的信封(包括方法和参数信息)通过HTTP发送到服务器。服务器打开信封并使用传入参数执行指定的方法。方法的结果打包到一个信封并作为响应发回客户端。客户端收到响应并打开信封。每个对象都有自己独特的方法以及仅公开一个URI的RPC样式Web服务，URI表示单个端点。它忽略HTTP的大部分特性且仅支持POST方法。由于轻量级以及通过HTTP直接传输数据的特性，Web服务的RESTful方法已经成为最常见的替代方法。可以使用各种语言(比如Java程序、Perl、Ruby、Python、PHP和Javascript[包括Ajax])实现客户端。RESTfulWeb服务通常可以通过自动客户端或代表用户的应用程序访问。但是，这种服务的简便性让用户能够与之直接交互，使用它们的Web浏览器构建一个GETURL并读取返回的内容。在REST样式的Web服务中，每个资源都有一个地址。资源本身都是方法调用的目标，方法列表对所有资源都是一样的。这些方法都是标准方法，包括HTTPGET、POST、PUT、DELETE，还可能包括HEADER和OPTIONS。在RPC样式的架构中，关注点在于方法，而在REST样式的架构中，关注点在于资源--将使用标准方法检索并操作信息片段(使用表示的形式)。资源表示形式在表示形式中使用超链接互联。LeonardRichardson和SamRuby在他们的著作RESTfulWebServices中引入了术语REST-RPC混合架构。REST-RPC混合Web服务不使用信封包装方法、参数和数据，而是直接通过HTTP传输数据，这与REST样式的Web服务是类似的。但是它不使用标准的HTTP方法操作资源。它在HTTP请求的URI部分存储方法信息。好几个知名的Web服务，比如Yahoo的FlickrAPI和del.icio.usAPI都使用这种混合架构。RESTful的实现:RESTfulWeb服务的Java框架有两个Java框架可以帮助构建RESTfulWeb服务。eromeLouvel和DavePawson开发的Restlet(见参考资料)是轻量级的。它实现针对各种RESTful系统的资源、表示、连接器和媒体类型之类的概念，包括Web服务。在Restlet框架中，客户端和服务器都是组件。组件通过连接器互相通信。该框架最重要的类是抽象类Uniform及其具体的子类Restlet，该类的子类是专用类，比如Application、Filter、Finder、Router和Route。这些子类能够一起处理验证、过滤、安全、数据转换以及将传入请求路由到相应资源等操作。Resource类生成客户端的表示形式。JSR-311是SunMicrosystems的规范，可以为开发RESTfulWeb服务定义一组JavaAPI。Jersey是对JSR-311的参考实现。JSR-311提供一组注释，相关类和接口都可以用来将Java对象作为Web资源展示。该规范假定HTTP是底层网络协议。它使用注释提供URI和相应资源类之间的清晰映射，以及HTTP方法与Java对象方法之间的映射。API支持广泛的HTTP实体内容类型，包括HTML、XML、JSON、GIF、JPG等。它还将提供所需的插件功能，以允许使用标准方法通过应用程序添加其他类型。RESTful的实现:构建RESTfulWeb服务的多层架构RESTfulWeb服务和动态Web应用程序在许多方面都是类似的。有时它们提供相同或非常类似的数据和函数，尽管客户端的种类不同。例如，在线电子商务分类网站为用户提供一个浏览器界面，用于搜索、查看和订购产品。如果还提供Web服务供公司、零售商甚至个人能够自动订购产品，它将非常有用。与大部分动态Web应用程序一样，Web服务可以从多层架构的关注点分离中受益。业务逻辑和数据可以由自动客户端和GUI客户端共享。惟一的不同点在于客户端的本质和中间层的表示层。此外，从数据访问中分离业务逻辑可实现数据库独立性，并为各种类型的数据存储提供插件能力。图1展示了自动化客户端，包括Java和各种语言编写的脚本，这些语言包括Python、Perl、Ruby、PHP或命令行工具，比如curl。在浏览器中运行且作为RESTfulWeb服务消费者运行的Ajax、Flash、JavaFX、GWT、博客和wiki都属于此列，因为它们都代表用户以自动化样式运行。自动化Web服务客户端在Web层向ResourceRequestHandler发送HTTP响应。客户端的无状态请求在头部包含方法信息，即POST、GET、PUT和DELETE，这又将映射到ResourceRequestHandler中资源的相应操作。每个请求都包含所有必需的信息，包括ResourceRequestHandler用来处理请求的凭据。从Web服务客户端收到请求之后，ResourceRequestHandler从业务逻辑层请求服务。ResourceRequestHandler确定所有概念性的实体，系统将这些实体作为资源公开，并为每个资源分配一个惟一的URI。但是，概念性的实体在该层是不存在的。它们存在于业务逻辑层。可以使用Jersey或其他框架(比如Restlet)实现ResourceRequestHandler，它应该是轻量级的，将大量职责工作委托给业务层。Ajax和RESTfulWeb服务本质上是互为补充的。它们都可以利用大量Web技术和标准，比如HTML、JavaScript、浏览器对象、XML/JSON和HTTP。当然也不需要购买、安装或配置任何主要组件来支持Ajax前端和RESTfulWeb服务之间的交互。RESTfulWeb服务为Ajax提供了非常简单的API来处理服务器上资源之间的交互。图1中的Web浏览器客户端作为GUI的前端，使用表示层中的BrowserRequestHandler生成的HTML提供显示功能。BrowserRequesterHandler可以使用MVC模型(JSF、Struts或Spring都是Java的例子)。它从浏览器接受请求，从业务逻辑层请求服务，生成表示并对浏览器做出响应。表示供用户在浏览器中显示使用。表示不仅包含内容，还包含显示的属性，比如HTML和CSS。业务规则可以集中到业务逻辑层，该层充当表示层和数据访问层之间的数据交换的中间层。数据以域对象或值对象的形式提供给表示层。从业务逻辑层中解耦BrowserRequestHandler和ResourceRequestHandler有助于促进代码重用，并能实现灵活和可扩展的架构。此外，由于将来可以使用新的REST和MVC框架，实现它们变得更加容易，无需重写业务逻辑层。数据访问层提供与数据存储层的交互，可以使用DAO设计模式或者对象-关系映射解决方案(如Hibernate、OJB或iBATIS)实现。作为替代方案，业务层和数据访问层中的组件可以实现为EJB组件，并取得EJB容器的支持，该容器可以为组件生命周期提供便利，管理持久性、事务和资源配置。但是，这需要一个遵从JavaEE的应用服务器(比如JBoss)，并且可能无法处理Tomcat。该层的作用在于针对不同的数据存储技术，从业务逻辑中分离数据访问代码。数据访问层还可以作为连接其他系统的集成点，可以成为其他Web服务的客户端。数据存储层包括数据库系统、LDAP服务器、文件系统和企业信息系统(包括遗留系统、事务处理系统和企业资源规划系统)。使用该架构，您可以开始看到RESTfulWeb服务的力量，它可以灵活地成为任何企业数据存储的统一API，从而向以用户为中心的Web应用程序公开垂直数据，并自动化批量报告脚本。什么是REST:结束语REST描述了一个架构样式的互联系统(如Web应用程序)。REST约束条件作为一个整体应用时，将生成一个简单、可扩展、有效、安全、可靠的架构。由于它简便、轻量级以及通过HTTP直接传输数据的特性，RESTfulWeb服务成为基于SOAP服务的一个最有前途的替代方案。用于web服务和动态Web应用程序的多层架构可以实现可重用性、简单性、可扩展性和组件可响应性的清晰分离。Ajax和RESTfulWeb服务本质上是互为补充的。

REST是一种架构风格，其核心是面向资源，REST专门针对网络应用设计和开发方式，以降低开发的复杂性，提高系统的可伸缩性。REST提出设计概念和准则为： 1.网络上的所有事物都可以被抽象为资源(resource) 2.每一个资源都有唯一的资源标识(resource identifier)，对资源的操作不会改变这些标识 3.所有的操作都是无状态的 REST简化开发，其架构遵循CRUD原则，该原则告诉我们对于资源(包括网络资源)只需要四种行为：创建，获取，更新和删除就可以完成相关的操作和处理。您可以通过统一资源标识符（Universal Resource Identifier，URI）来识别和定位资源，并且针对这些资源而执行的操作是通过 HTTP 规范定义的。其核心操作只有GET,PUT,POST,DELETE。 由于REST强制所有的操作都必须是stateless的，这就没有上下文的约束，如果做分布式，集群都不需要考虑上下文和会话保持的问题。极大的提高系统的可伸缩性。 对于SOAP Webservice和Restful Webservice的选择问题，首先需要理解就是SOAP偏向于面向活动，有严格的规范和标准，包括安全，事务等各个方面的内容，同时SOAP强调操作方法和操作对象的分离，有WSDL文件规范和XSD文件分别对其定义。而REST强调面向资源，只要我们要操作的对象可以抽象为资源即可以使用REST架构风格。REST ful 应用问题 是否使用REST就需要考虑资源本身的抽象和识别是否困难，如果本身就是简单的类似增删改查的业务操作，那么抽象资源就比较容易，而对于复杂的业务活动抽象资源并不是一个简单的事情。比如校验用户等级，转账，事务处理等，这些往往并不容易简单的抽象为资源。 其次如果有严格的规范和标准定义要求，而且前期规范标准需要指导多个业务系统集成和开发的时候，SOAP风格由于有清晰的规范标准定义是明显有优势的。我们可以在开始和实现之前就严格定义相关的接口方法和接口传输数据。 简单数据操作，无事务处理，开发和调用简单这些是使用REST架构风格的优势。而对于较为复杂的面向活动的服务，如果我们还是使用REST，很多时候都是仍然是传统的面向活动的思想通过转换工具再转换得到REST服务，这种使用方式是没有意义的。效率和易用性 SOAP协议对于消息体和消息头都有定义，同时消息头的可扩展性为各种互联网的标准提供了扩展的基础，WS-*系列就是较为成功的规范。但是也由于SOAP由于各种需求不断扩充其本身协议的内容，导致在SOAP处理方面的性能有所下降。同时在易用性方面以及学习成本上也有所增加。 REST被人们的重视，其实很大一方面也是因为其高效以及简洁易用的特性。这种高效一方面源于其面向资源接口设计以及操作抽象简化了开发者的不良设计，同时也最大限度的利用了Http最初的应用协议设计理念。同时，在我看来REST还有一个很吸引开发者的就是能够很好的融合当前Web2.0的很多前端技术来提高开发效率。例如很多大型网站开放的REST风格的API都会有多种返回形式，除了传统的xml作为数据承载，还有（JSON,RSS,ATOM）等形式，这对很多网站前端开发人员来说就能够很好的mashup各种资源信息安全性 技术没有好坏，只有是不是合适，一种好的技术和思想被误用了，那么就会得到反效果。REST和SOAP各自都有自己的优点，同时如果在一些场景下如果去改造REST，其实就会走向SOAP（例如安全）。 REST对于资源型服务接口来说很合适，同时特别适合对于效率要求很高，但是对于安全要求不高的场景。而SOAP的成熟性可以给需要提供给多开发语言的，对于安全性要求较高的接口设计带来便利。所以我觉得纯粹说什么设计模式将会占据主导地位没有什么意义，关键还是看应用场景。 同时很重要一点就是不要扭曲了REST现在很多网站都跟风去开发REST风格的接口，其实都是在学其形，不知其心，最后弄得不伦不类，性能上不去，安全又保证不了。成熟度 SOAP虽然发展到现在已经脱离了初衷，但是对于异构环境服务发布和调用，以及厂商的支持都已经达到了较为成熟的情况。不同平台，开发语言之间通过SOAP来交互的web service都能够较好的互通。 由于没有类似于SOAP的权威性协议作为规范，REST实现的各种协议仅仅只能算是私有协议，当然需要遵循REST的思想，但是这样细节方面有太多没有约束的地方。REST日后的发展所走向规范也会直接影响到这部分的设计是否能够有很好的生命力。

　　REST（REpresentationStateTransfer）描述了一个架构样式的网络系统，比如web应用程序。　　它首次出现在2000年RoyFielding的博士论文中，他是HTTP规范的主要编写者之一。　　REST指的是一组架构约束条件和原则。　　满足这些约束条件和原则的应用程序或设计就是RESTful。　　Web应用程序最重要的REST原则是，客户端和服务器之间的交互在请求之间是无状态的。　　从客户端到服务器的每个请求都必须包含理解请求所必需的信息。　　如果服务器在请求之间的任何时间点重启，客户端不会得到通知。　　此外，无状态请求可以由任何可用服务器回答，这十分适合云计算之类的环境。　　客户端可以缓存数据以改进性能。　　在服务器端，应用程序状态和功能可以分为各种资源。　　资源是一个有趣的概念实体，它向客户端公开。　　资源的例子有：应用程序对象、数据库记录、算法等等。　　每个资源都使用URI（UniversalResourceIdentifier）得到一个惟一的地址。　　所有资源都共享统一的界面，以便在客户端和服务器之间传输状态。　　使用的是标准的HTTP方法，比如GET、PUT、POST和DELETE。　　Hypermedia是应用程序状态的引擎，资源表示通过超链接互联。　　另一个重要的REST原则是分层系统，这表示组件无法了解它与之交互的中间层以外的组件。　　通过将系统知识限制在单个层，可以限制整个系统的复杂性，促进了底层的独立性。　　当REST架构的约束条件作为一个整体应用时，将生成一个可以扩展到大量客户端的应用程序。　　它还降低了客户端和服务器之间的交互延迟。　　统一界面简化了整个系统架构，改进了子系统之间交互的可见性。　　REST简化了客户端和服务器的实现。　　RESTful的实现：RESTfulWeb服务与RPC样式的Web服务了解了什么是什么是REST，再看看RESTful的实现。　　最近，使用RPC样式架构构建的基于SOAP的Web服务成为实现SOA最常用的方法。　　RPC样式的Web服务客户端将一个装满数据的信封（包括方法和参数信息）通过HTTP发送到服务器。

好处：REST规范：强调HTTP应当以资源为中心，并且规范了资源URI的风格；2.规范了HTTP请求动作（PUT，POST等）的使用，具有对应的语义；3.遵循REST规范的Web应用将会获得下面好处：a.URL具有很强可读性的，具有自描述性；b.资源描述与视图的松耦合；c.可提供OpenAPI，便于第三方系统集成，提高互操作性；d.如果提供无状态的服务接口，可提高应用的水平扩展性；

一个好的RESTfulAPI，应该具备以下特征：　　这个API应该是对浏览器友好的，能够很好地融入Web，而不是与Web格格不入。　　1.浏览器是最常见和最通用的REST客户端。好的RESTfulAPI应该能够使用浏览器+HTML完成所有的测试（不需要使用编程语言）。这样的API还可以很方便地使用各种自动化的Web功能测试、性能测试工具来做测试。Web前端应用（基于浏览器的RIA应用、移动App等等）也可以很方便地将多个RESTfulAPI的功能组合起来，建造Mashup类的应用。　　这个API中所包含的资源和对于资源的操作，应该是直观和容易理解的，并且符合HTTP协议的要求。　　REST开发又被称作“面向资源的开发”，这说明对于资源的抽象，是设计RESTfulAPI的核心内容。RESTfulAPI建模的过程与面向对象建模类似，是以名词为核心的。这些名词就是资源，任何可命名的抽象概念都可以定义为一个资源。而HTTP协议并不是一种传输协议，它实际提供了一个操作资源的统一接口。对于资源的任何操作，都应该映射到HTTP的几个有限的方法（常用的有GET/POST/PUT/DELETE四个方法，还有不常用的PATCH/HEAD/OPTIONS方法）上面。所以RESTfulAPI建模的过程，可以看作是具有统一接口约束的面向对象建模过程。　　按照HTTP协议的规定，GET方法是安全且幂等的，POST方法是既不安全也不幂等的（可以用来作为所有写操作的通配方法），PUT、DELETE方法都是不安全但幂等的。将对资源的操作合理映射到这四个方法上面，既不过度使用某个方法（例如过度使用GET方法或POST方法），也不添加过多的操作以至于HTTP的四个方法不够用。　　2.如果发现资源上的操作过多，以至于HTTP的方法不够用，应该考虑设计出的资源。设计出资源（以及相应的URI）对于RESTfulAPI来说并没有什么害处。　　这个API应该是松耦合的。　　RESTfulAPI的设计包括了三个循序渐进、由低到高的层次：资源抽象、统一接口、超文本驱动。正是这三个层次确保了RESTfulAPI的松耦合性。　　3.当设计面向互联网的API时，松耦合变成了一种“必须有”的强需求。紧耦合的API非常脆弱，一旦公布出去，服务器端和客户端都无法持续进化。尤其是服务器端，公布出去的接口根本不敢改，改了之后，几乎所有客户端应用立即无法正常工作。REST这种架构风格就是紧耦合API的解毒剂，这个话题可以谈的很深，这里就不了。感兴趣的读者可以参考《REST实战》。　　这个API中所使用的表述格式应该是常见的通用格式　　在RESTfulAPI中，对于资源的操作，是通过在服务器端-客户端之间传递资源的表述来间接完成的。资源的表述可以有很多种格式，并且在响应和请求中的资源表述格式也会有所不同。GET/POST响应中的资源表述格式，常见的有HTML、XML、JSON；POST/PUT请求中的资源表述格式，常见的有标准的HTML表单参数、XML、JSON。　　4.这些常见表述格式，处理起来非常容易，有大量的框架和库提供支持。所以除非有很合理的要求，通常不需要使用自定义的私有格式。　　使用HTTP响应状态代码来表达各种出错情况　　HTTP响应状态代码，是HTTP协议这个统一接口中用来表达出错情况的标准机制。响应状态代码分成两部分：statuscode和reasonphase。两部分都是可定制的，也可以使用标准的statuscode，只定制reasonphase。　　5.如果一个所谓的“RESTfulAPI”对于任何请求都返回200OK响应，在响应的消息体中返回出错情况信息，这种做法显然不符合“确保操作语义的可见性”这个REST架构风格的基本要求。　　这个API应该对于HTTP缓存是友好的　　6.充分利用好HTTP缓存是RESTfulAPI可伸缩性的根本。HTTP协议是一个分层的架构，从两端的useragent到originserver之间，可以插入很多中间组件。而在整个HTTP通信链条的很多位置，都可以设置缓存。HTTP协议内建有很好的缓存机制，可以分成过期模型和验证模型两套缓存机制。如果API设计者完全没有考虑过如何利用HTTP缓存，那么这个API的可伸缩性会有很多问题。

REST(REpresentationStateTransfer)描述了一个架构样式的网络系统，比如web应用程序。它首次出现在2000年RoyFielding的博士论文中，他是HTTP规范的主要编写者之一。REST指的是一组架构约束条件和原则。满足这些约束条件和原则的应用程序或设计就是RESTful。Web应用程序最重要的REST原则是，客户端和服务器之间的交互在请求之间是无状态的。从客户端到服务器的每个请求都必须包含理解请求所必需的信息。如果服务器在请求之间的任何时间点重启，客户端不会得到通知。此外，无状态请求可以由任何可用服务器回答，这十分适合云计算之类的环境。客户端可以缓存数据以改进性能。在服务器端，应用程序状态和功能可以分为各种资源。资源是一个有趣的概念实体，它向客户端公开。资源的例子有:应用程序对象、数据库记录、算法等等。每个资源都使用URI(UniversalResourceIdentifier)得到一个惟一的地址。所有资源都共享统一的界面，以便在客户端和服务器之间传输状态。使用的是标准的HTTP方法，比如GET、PUT、POST和DELETE。Hypermedia是应用程序状态的引擎，资源表示通过超链接互联。另一个重要的REST原则是分层系统，这表示组件无法了解它与之交互的中间层以外的组件。通过将系统知识限制在单个层，可以限制整个系统的复杂性，促进了底层的独立性。当REST架构的约束条件作为一个整体应用时，将生成一个可以扩展到大量客户端的应用程序。它还降低了客户端和服务器之间的交互延迟。统一界面简化了整个系统架构，改进了子系统之间交互的可见性。REST简化了客户端和服务器的实现。RESTful的实现:RESTfulWeb服务与RPC样式的Web服务了解了什么是什么是REST，我们再看看RESTful的实现。最近，使用RPC样式架构构建的基于SOAP的Web服务成为实现SOA最常用的方法。RPC样式的Web服务客户端将一个装满数据的信封(包括方法和参数信息)通过HTTP发送到服务器。服务器打开信封并使用传入参数执行指定的方法。方法的结果打包到一个信封并作为响应发回客户端。客户端收到响应并打开信封。每个对象都有自己独特的方法以及仅公开一个URI的RPC样式Web服务，URI表示单个端点。它忽略HTTP的大部分特性且仅支持POST方法。由于轻量级以及通过HTTP直接传输数据的特性，Web服务的RESTful方法已经成为最常见的替代方法。可以使用各种语言(比如Java程序、Perl、Ruby、Python、PHP和Javascript[包括Ajax])实现客户端。RESTfulWeb服务通常可以通过自动客户端或代表用户的应用程序访问。但是，这种服务的简便性让用户能够与之直接交互，使用它们的Web浏览器构建一个GETURL并读取返回的内容。在REST样式的Web服务中，每个资源都有一个地址。资源本身都是方法调用的目标，方法列表对所有资源都是一样的。这些方法都是标准方法，包括HTTPGET、POST、PUT、DELETE，还可能包括HEADER和OPTIONS。在RPC样式的架构中，关注点在于方法，而在REST样式的架构中，关注点在于资源--将使用标准方法检索并操作信息片段(使用表示的形式)。资源表示形式在表示形式中使用超链接互联。LeonardRichardson和SamRuby在他们的著作RESTfulWebServices中引入了术语REST-RPC混合架构。REST-RPC混合Web服务不使用信封包装方法、参数和数据，而是直接通过HTTP传输数据，这与REST样式的Web服务是类似的。但是它不使用标准的HTTP方法操作资源。它在HTTP请求的URI部分存储方法信息。好几个知名的Web服务，比如Yahoo的FlickrAPI和del.icio.usAPI都使用这种混合架构。RESTful的实现:RESTfulWeb服务的Java框架有两个Java框架可以帮助构建RESTfulWeb服务。eromeLouvel和DavePawson开发的Restlet(见参考资料)是轻量级的。它实现针对各种RESTful系统的资源、表示、连接器和媒体类型之类的概念，包括Web服务。在Restlet框架中，客户端和服务器都是组件。组件通过连接器互相通信。该框架最重要的类是抽象类Uniform及其具体的子类Restlet，该类的子类是专用类，比如Application、Filter、Finder、Router和Route。这些子类能够一起处理验证、过滤、安全、数据转换以及将传入请求路由到相应资源等操作。Resource类生成客户端的表示形式。JSR-311是SunMicrosystems的规范，可以为开发RESTfulWeb服务定义一组JavaAPI。Jersey是对JSR-311的参考实现。JSR-311提供一组注释，相关类和接口都可以用来将Java对象作为Web资源展示。该规范假定HTTP是底层网络协议。它使用注释提供URI和相应资源类之间的清晰映射，以及HTTP方法与Java对象方法之间的映射。API支持广泛的HTTP实体内容类型，包括HTML、XML、JSON、GIF、JPG等。它还将提供所需的插件功能，以允许使用标准方法通过应用程序添加其他类型。RESTful的实现:构建RESTfulWeb服务的多层架构RESTfulWeb服务和动态Web应用程序在许多方面都是类似的。有时它们提供相同或非常类似的数据和函数，尽管客户端的种类不同。例如，在线电子商务分类网站为用户提供一个浏览器界面，用于搜索、查看和订购产品。如果还提供Web服务供公司、零售商甚至个人能够自动订购产品，它将非常有用。与大部分动态Web应用程序一样，Web服务可以从多层架构的关注点分离中受益。业务逻辑和数据可以由自动客户端和GUI客户端共享。惟一的不同点在于客户端的本质和中间层的表示层。此外，从数据访问中分离业务逻辑可实现数据库独立性，并为各种类型的数据存储提供插件能力。图1展示了自动化客户端，包括Java和各种语言编写的脚本，这些语言包括Python、Perl、Ruby、PHP或命令行工具，比如curl。在浏览器中运行且作为RESTfulWeb服务消费者运行的Ajax、Flash、JavaFX、GWT、博客和wiki都属于此列，因为它们都代表用户以自动化样式运行。自动化Web服务客户端在Web层向ResourceRequestHandler发送HTTP响应。客户端的无状态请求在头部包含方法信息，即POST、GET、PUT和DELETE，这又将映射到ResourceRequestHandler中资源的相应操作。每个请求都包含所有必需的信息，包括ResourceRequestHandler用来处理请求的凭据。从Web服务客户端收到请求之后，ResourceRequestHandler从业务逻辑层请求服务。ResourceRequestHandler确定所有概念性的实体，系统将这些实体作为资源公开，并为每个资源分配一个惟一的URI。但是，概念性的实体在该层是不存在的。它们存在于业务逻辑层。可以使用Jersey或其他框架(比如Restlet)实现ResourceRequestHandler，它应该是轻量级的，将大量职责工作委托给业务层。Ajax和RESTfulWeb服务本质上是互为补充的。它们都可以利用大量Web技术和标准，比如HTML、JavaScript、浏览器对象、XML/JSON和HTTP。当然也不需要购买、安装或配置任何主要组件来支持Ajax前端和RESTfulWeb服务之间的交互。RESTfulWeb服务为Ajax提供了非常简单的API来处理服务器上资源之间的交互。图1中的Web浏览器客户端作为GUI的前端，使用表示层中的BrowserRequestHandler生成的HTML提供显示功能。BrowserRequesterHandler可以使用MVC模型(JSF、Struts或Spring都是Java的例子)。它从浏览器接受请求，从业务逻辑层请求服务，生成表示并对浏览器做出响应。表示供用户在浏览器中显示使用。表示不仅包含内容，还包含显示的属性，比如HTML和CSS。业务规则可以集中到业务逻辑层，该层充当表示层和数据访问层之间的数据交换的中间层。数据以域对象或值对象的形式提供给表示层。从业务逻辑层中解耦BrowserRequestHandler和ResourceRequestHandler有助于促进代码重用，并能实现灵活和可扩展的架构。此外，由于将来可以使用新的REST和MVC框架，实现它们变得更加容易，无需重写业务逻辑层。数据访问层提供与数据存储层的交互，可以使用DAO设计模式或者对象-关系映射解决方案(如Hibernate、OJB或iBATIS)实现。作为替代方案，业务层和数据访问层中的组件可以实现为EJB组件，并取得EJB容器的支持，该容器可以为组件生命周期提供便利，管理持久性、事务和资源配置。但是，这需要一个遵从JavaEE的应用服务器(比如JBoss)，并且可能无法处理Tomcat。该层的作用在于针对不同的数据存储技术，从业务逻辑中分离数据访问代码。数据访问层还可以作为连接其他系统的集成点，可以成为其他Web服务的客户端。数据存储层包括数据库系统、LDAP服务器、文件系统和企业信息系统(包括遗留系统、事务处理系统和企业资源规划系统)。使用该架构，您可以开始看到RESTfulWeb服务的力量，它可以灵活地成为任何企业数据存储的统一API，从而向以用户为中心的Web应用程序公开垂直数据，并自动化批量报告脚本。什么是REST:结束语REST描述了一个架构样式的互联系统(如Web应用程序)。REST约束条件作为一个整体应用时，将生成一个简单、可扩展、有效、安全、可靠的架构。由于它简便、轻量级以及通过HTTP直接传输数据的特性，RESTfulWeb服务成为基于SOAP服务的一个最有前途的替代方案。用于web服务和动态Web应用程序的多层架构可以实现可重用性、简单性、可扩展性和组件可响应性的清晰分离。Ajax和RESTfulWeb服务本质上是互为补充的。

一、协议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）的信息，还包括各种动物和雇员的信息，则它的路径应该设计成下面这样。

背景：小A准备给他外地的女朋友寄一封爱情的信件，于是去学校的商店买了一个信封，外加一些非常漂亮的信纸回到宿舍，他诗兴大发，洋洋洒洒一封几千字的情书就写好了，该填信封了，这时，他对信封有点不满意为什么这样说呢？他发现他买的信封竟然需要自己DIY，需要自己写填自己想填的内容，可能这类信封的设计初衷，是为了显示寄信人的创意，可是这很操蛋不是吗，这样的信封邮局会收吗？于是他找到了卖信封的小姐姐小A：美女，我买的信封怎么这么奇葩呀？上面居然需要自己设计，这样的东西一点不规范呢商店姐姐：这不符合当代年轻人的个性吗？不是为了显示你寄信的用心和独特吗小A：可是，假如我在上面写一些无关紧要的内容，邮局的人会不会杀了我商店姐姐：傻瓜，我的意思是你可以在上面画或者一些有趣的东西，基本信息肯定还是要按照邮局的标准来，我这里有个模板，你自己看看小A接过来，恍然大悟，原来是这样，标准还是标准，要是不按照标准来，邮局的人每天光看信封都得累死回到宿舍躺着，思考刚才的一幕。小A毕竟是学计算机的，突然明白过来，要是我们上网的请求乱七八糟，解析判断请求就得哭死（就和邮局的人看乱七八糟的信封是一个道理），甚至很可能压根就解析不了请求，因此采需要一套标准。因此，我们请求的信息需要全部展现给服务器（邮局）。然后邮差们在配送的过程中实际上是可以不用在意所配送的信件的状态的，这就可以类比为REST的无状态。当然我们是可以向快递那样加上快递的物流状态，但是在通信的过程中，实际上是没有必要的，这样会消耗更多的计算力。故设计成无状态不仅仅安全（邮差不会拆开我们的信件）还省事（不用浪费多的计算）。提到了无状态，当然REST还有其他几个特性，比如，需要提供统一的接口，我们寄信肯定找邮局，收信也是。邮局我们可以理解成一个controller。个人的理解是REST最为重要的特性就是无状态。虽然用寄信件类比这个过程有点牵强，因为一般我们web是需要响应的，这里的响应我们可以理解成对方回信，这个不像HTML，是请求一定一定有响应，寄信就不一定了。--------------------- 作者：喝粥也会胖的唐僧 来源：CSDN 原文：https://blog.csdn.net/zhou_438/article/details/83617315 版权声明：本文为博主原创文章，转载请附上博文链接！

所有框架都是在下面这个网站中查询得到的： https://mvnrepository.com/ 注意：选择框架的依赖的版本不要选择太高，最好选择之前比较成熟的版本 第一步：jersey client框架 // https://mvnrepository.com/artifact/org.glassfish.jersey.core/jersey-client compile group: "org.glassfish.jersey.core", name: "jersey-client", version: "2.28" 第二步：jersey server框架，version选择低版本 compile group: "org.glassfish.jersey.core", name: "jersey-server", version: "" 第三步：jersey-container-servlet框架，version选择低版本 compile group: "org.glassfish.jersey.containers", name: "jersey-container-servlet", version: "" 第四步：jersey-hk2框架，version选择低版本 // https://mvnrepository.com/artifact/org.glassfish.jersey.inject/jersey-hk2 compile group: "org.glassfish.jersey.inject", name: "jersey-hk2", version: "" 第五步：jersey.media的json解析库，version选择低版本 compile group: "org.glassfish.jersey.media", name: "jersey-media-json-jackson", version: ""

本文编写目的是为了尽可能的约定好一个公司的产品、组件、项目开发的RESTful API 设计风格，使不同团队间设计的API风格尽量一致，减少项目后期由于规范问题或设计不足导致的接口重构造成的开发、测试返工。最终让接口的最终使用者能够在开发过程中有个良好的体验。 此约定可作为开发人员设计RESTful 接口或项目接口发布评审的参考。 个人观点：用了 JSON-RPC 不等于 是RESTful API ，RESTful API通常是基于HTTP/JSON方式实现的 ，两种方式的API设计方式都不错，项目中选适合的就好。简单对比如下： 本文仅是作者个人根据主观喜好和接口设计经验搜罗总结而来的RESTful API设计约定，仅作为接口设计的基本要求，也欢迎与大家讨论。此约定未涉及超文本HATEOAS相关内容，也不包含RPC类面向后端服务方法映射接口的范畴。 API 是后端应用程序的脸面(UI)，用户体验非常重要。尤其是当你开发的是一个可复用的组件或产品，如果API设计有些许瑕疵，会直接影响开发者的体验，设计者会被骂的…… 有问题的API一旦开放出去了，哪怕是简单的拼写错误，由于要保持兼容性不能删改，会成为技术欠债长期背下去。 以上关键点不只适用于RESTful API，其他类型API也是一样的。 作为对外公开发布的RESTful API，根URL中一般要有域名与版本信息。通常一个WEB站点会同时提供网站服务和API服务，我们需要根据URL能够区分出访问的是服务接口还是网站中的网页、文件等资源。因此RESTful API的根URL中根据不同场景一般会在一级域名中或者是子域名中带api关键字。 常见的两种根URL用法如下： 推荐的方案是根URL中采用子域名的方式区分API，即： https://iam.primeton.com/api/v1/* 路径终点即粗体部分内容： https:// example.org/api/v1/ menus 设计RESTful API时常用的HTTP Method包括：GET、POST、PUT、PATCH、DELETE 简单说明如下： 根据资源标识可以 唯一定位一个资源 时，建议使用URL路径参数方式传递。对应Springboot 的 @PathVariable 。API Path示例如下： 根据资源属性查询过滤 一或多个资源 时，建议使用URL查询参数方式传递。对应Springboot的 @RequestParam 。API Path示例如下： 对于简单查询类接口，可以使用路径参数和查询参数解决，如果是复杂功能型查询接口中需要通过复杂的过滤条件查询时如： > < in between 等等，查询参数用起来会非常痛苦，GET Method又不支持提交Request Body参数。因此我建议这种 复杂型查询采用POST Method 提交到一个特定的Path上 。参见如下场景： 查询接口返回多个数据时，需要支持分页（枚举类数据或少量数据除外）和排序。 如需使用分页查询和排序，建议统一请求与响应报文结构，格式如下： 请求参数示例： GET /users?page=1&size=5&sort=username 单页数据响应结果示例： 上述分页排序与响应报文格式是来自Spring Data定义的模型，为了保持分页排序接口相关的使用习惯，如果持久化不使用JPA，仍然建议采用上述规范的报文定义封装接口。为使用者提供一致的体验。 如果资源需要做一些增删改之外的操作（如状态变更），可以用 /actions 作为path 例如：流程平台中的流程实例会有状态变化，如启动、挂起、恢复、终止等等，这种接口建议这样设计： 组合资源，即两种资源之间存在组合关系，组合指整体与部分的强包含关系，但整体与部分是不可分的，整体的生命周期结束也就意味着部分的生命周期结束。对"部分"的操作一定会由整体作为入口，不会直接跳过"整体"来对"部分"做增删改查。这种组合场景中，推荐API设计方式示例如下： 聚合资源，即两种资源之间存在聚合关系。聚合也是整体与部分的弱包含关系，但整体与部分之间是可分离的，他们可以具有各自的生命周期，部分可以属于多个不同的主体对象，也可以为多个整体对象共享。 例如，机构或角色下包含人员，需要获取机构或角色下的人员的场景，避免做成分别通过机构入口或角色入口找人等重复的具有类似功能的接口： 在RESTful API设计中，正常和异常情况建议通过HTTP约定的status进行区分， 不建议 采用所有接口均POST Method调用，永远返回200这种模式。 推荐的常用Http Status说明如下： HTTP 1.0 Status 详细说明参考 API调用成功后，返回HTTP 2xx状态码，Response Body直接返回业务数据即可。请求和响应报文建议统一采用JSON格式。 RESTful API 对于异常报文需要规范和统一，服务端出现异常情况下，需要进行全局拦截，然后将异常信息封装为规范的格式，返回给调用端。 对于后端的异常信息，建议包含编码和消息 本文是基于学习各路大神们对RESTful 设计相关文章，结合自己设计接口时遇到困惑后的解决方案，收集与总结而成的RESTful API设计约定。部分内容夹杂个人喜好与主观观点，抛砖引玉，希望能为大家设计API带来些许帮助。后如果遇到一些更复杂的场景，欢迎一起沟通。

ic class TestHttp { public void testRegist(){ try{ StringBuffer sb = new StringBuffer("<?xml version="1.0" encoding="UTF-8" ?> "); sb.append("<getData>"); sb.append("<recNum>2015</recNum>"); sb.append("<accountID>wangxin2015</accountID>"); sb.append("</getvData>"); byte[] xmlbyte = sb.toString().getBytes("UTF-8"); URL url = new U uxxx/xxxxxx"); HttpURLConnection conn = (HttpURLConnection)url.openConnection(); conn.setDoOutput(true

1、不使用url参数： 传统API设计：/api/list?pageIndex=2 Restful API设计：/api/list/2 2、用method表示操作类型 传统API设计： Restful API设计： 3、传统API设计：把每个url当做一个功能 Restful API设计：把每个url当做一个唯一的资源 简单说Restful API就是API的规范。 目的： 1、为了实现前后端分离。 2、减少沟通成本，让API通俗易懂，提高API的可读性。 3、多端公用一套接口 在 REST 架构风格中，每一个 URI 代表一种资源。因此，URI 是每一个资源的地址的唯一资源定位符。所谓资源，实际上就是一个信息实体，它可以是服务器上的一段文本、一个文件、一张图片、一首歌曲，或者是一种服务。RESTful API 规定了通过 GET、 POST、 PUT、 PATCH、 DELETE 等方式对服务端的资源进行操作。 http://www.ruanyifeng.com/blog/2014/05/restful_api.html

要先进行注册，再用注册的账号登录restful不必保持用户登录状态，只需要身份验证就可以，比如token认证。但是无论是web开发，还是移动app开发，都需要有判断用户的登录状态，web叫做会话，用session储存。app的实现方法类似，只是把登录状态存到了客户端。web的实现是这样的，如果需要用到restful api，那么在前端和restful之间加一个node做中间层，node调用restful接口获取数据，并创建session会话。所以session处理和判断用户登录状态是放在node这端的，而不是在restful中操作

没必要用restfulrestful把协议和应用逻辑弄在一起的设计本身也不好

6、 江南春 杜牧

App通常用restful api跟server打交道。Rest是stateless的，也就是app不需要像browser那样用cookie来保存session, 因此用session token来标示自己就够了，session/state由api server的逻辑处理。如果你的后端不是stateless的rest api, 那么你可能需要在app里保存session. 可以在app里嵌入webkit,用一个隐藏的browser来管理cookie session.session 和 oauth token 并不矛盾，作为身份认证 token 安全性比session好，因为每个请求都有签名还能防止监听以及重放攻击，而session就必须靠链路层来保障通讯安全了。如上所说，如果你需要实现有状态的会话，仍然可以增加session来在服务器端保存一些状态

　　　　REST -- REpresentational State Transfer 直接翻译：表现层状态转移。这个中文直译经常出现在很多博客中。尼玛谁听得懂“表现层状态转移”？这是人话吗？我自己也困惑了很久，查询了很多资料，花了差不多一年有个还算清晰的理解。分享如下： Ivony 老师的一句话概括很精辟：URL定位资源，用HTTP动词（GET,POST,DELETE,DETC）描述操作。--- 简洁版 ---0. REST不是"rest"这个单词，而是几个单词缩写。但即使那几个单词说出来，也无法理解在说什么 -_-!! （不是要贬低人，是我自己也理解困难）；1. REST描述的是在网络中client和server的一种交互形式；REST本身不实用，实用的是如何设计 RESTful API（REST风格的网络接口）；2. Server提供的RESTful API中，URL中只使用名词来指定资源，原则上不使用动词。“资源”是REST架构或者说整个网络处理的核心。

定义一个简单的restful接口@RestControllerpublic class TestController{@RequestMapping(value = "testPost", method = RequestMethod.POST)public ResponseBean testPost(@RequestBody RequestBean requestBean){ResponseBean responseBean = new ResponseBean();responseBean.setRetCode("0000");responseBean.setRetMsg("succ");return responseBean;}}使用RestTemplate访问该服务//请求地址String url = "http://localhost:8080/testPost";//入参RequestBean requestBean = new RequestBean();requestBean.setTest1("1");requestBean.setTest2("2");requestBean.setTest3("3");RestTemplate restTemplate = new RestTemplate();ResponseBean responseBean = restTemplate.postForObject(url, requestBean, ResponseBean.class);从这个例子可以看出，使用restTemplate访问restful接口非常的简单粗暴无脑。(url, requestMap, ResponseBean.class)这三个参数分别代表 请求地址、请求参数、HTTP响应转换被转换成的对象类型。RestTemplate方法的名称遵循命名约定，第一部分指出正在调用什么HTTP方法，第二部分指示返回的内容。本例中调用了restTemplate.postForObject方法，post指调用了HTTP的post方法，Object指将HTTP响应转换为您选择的对象类型。还有其他很多类似的方法，有兴趣的同学可以参考官方api。三.手动指定转换器(HttpMessageConverter)我们知道，调用reseful接口传递的数据内容是json格式的字符串，返回的响应也是json格式的字符串。然而restTemplate.postForObject方法的请求参数RequestBean和返回参数ResponseBean却都是java类。是RestTemplate通过HttpMessageConverter自动帮我们做了转换的操作。默认情况下RestTemplate自动帮我们注册了一组HttpMessageConverter用来处理一些不同的contentType的请求。如StringHttpMessageConverter来处理text/plain;MappingJackson2HttpMessageConverter来处理application/json;MappingJackson2XmlHttpMessageConverter来处理application/xml。你可以在org.springframework.http.converter包下找到所有spring帮我们实现好的转换器。如果现有的转换器不能满足你的需求，你还可以实现org.springframework.http.converter.HttpMessageConverter接口自己写一个。详情参考官方api。选好了HttpMessageConverter后怎么把它注册到我们的RestTemplate中呢。RestTemplate restTemplate = new RestTemplate();//获取RestTemplate默认配置好的所有转换器List<HttpMessageConverter<?>> messageConverters = restTemplate.getMessageConverters();//默认的MappingJackson2HttpMessageConverter在第7个 先把它移除掉messageConverters.remove(6);//添加上GSON的转换器messageConverters.add(6, new GsonHttpMessageConverter());这个简单的例子展示了如何使用GsonHttpMessageConverter替换掉默认用来处理application/json的MappingJackson2HttpMessageConverter。四.设置底层连接方式要创建一个RestTemplate的实例，您可以像上述例子中简单地调用默认的无参数构造函数。这将使用java.NET包中的标准Java类作为底层实现来创建HTTP请求。但很多时候我们需要像传统的HttpClient那样设置HTTP请求的一些属性。RestTemplate使用了一种很偷懒的方式实现了这个需求，那就是直接使用一个HttpClient作为底层实现......//生成一个设置了连接超时时间、请求超时时间、异常最大重试次数的httpClientRequestConfig config = RequestConfig.custom().setConnectionRequestTimeout(10000).setConnectTimeout(10000).setSocketTimeout(30000).build();HttpClientBuilder builder = HttpClientBuilder.create().setDefaultRequestConfig(config).setRetryHandler(new DefaultHttpRequestRetryHandler(5, false));HttpClient httpClient = builder.build();//使用httpClient创建一个ClientHttpRequestFactory的实现ClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(httpClient);//ClientHttpRequestFactory作为参数构造一个使用作为底层的RestTemplateRestTemplate restTemplate = new RestTemplate(requestFactory);五.设置拦截器(ClientHttpRequestInterceptor)有时候我们需要对请求做一些通用的拦截设置，这就可以使用拦截器进行处理。拦截器需要我们实现org.springframework.http.client.ClientHttpRequestInterceptor接口自己写。举个简单的例子，写一个在header中根据请求内容和地址添加令牌的拦截器。public class TokenInterceptor implements ClientHttpRequestInterceptor{@Overridepublic ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException{//请求地址String checkTokenUrl = request.getURI().getPath();//token有效时间int ttTime = (int) (System.currentTimeMillis() / 1000 + 1800);//请求方法名 POST、GET等String methodName = request.getMethod().name();//请求内容String requestBody = new String(body);//生成令牌 此处调用一个自己写的方法，有兴趣的朋友可以自行google如何使用ak/sk生成token，此方法跟本教程无关，就不贴出来了String token = TokenHelper.generateToken(checkTokenUrl, ttTime, methodName, requestBody);//将令牌放入请求header中request.getHeaders().add("X-Auth-Token",token);return execution.execute(request, body);}}创建RestTemplate实例的时候可以这样向其中添加拦截器RestTemplate restTemplate = new RestTemplate();//向restTemplate中添加自定义的拦截器restTemplate.getInterceptors().add(new TokenInterceptor());

别折腾了，一般人根本就做不了RESTful。绝大部分人都理解RESTful是一种接口的设计形式，然后发现很多时候某些需求根本没法做成RESTful形式的，但就我看来RESTful是从底层架构就应该考虑的问题，或者说是一种架构设计思想，而不仅仅只针对于接口。比如题主的这个情况，如果要让我来做，我会设计两个接口POST /shop/1/query 新建一个商品的查询，返回idGET /shop/1/query/{id} 获取某个查询的结果为什么要这么设计？1.RESTful中，URI代表资源，html/图片这类文件是资源，query这类服务也是资源2.RESTful中，POST用来新建或者更新，GET用来获取资源但是很显然，这肯定不满足题主的需求，要这样做现有的架构肯定满足不了，所以，别折腾了

Representational State Transfer，简称REST）是Roy Fielding博士于2000年在他的博士论文中提出来的一种软件架构风格。Roy Fielding是HTTP协议（1.0版和1.1版）的主要设计者，事实上HTTP 1.1规范正是基于REST架构风格的指导原理来设计的。需要注意的是，REST是一种设计风格而不是标准，如果一个架构符合REST原则，我们就称它为RESTful架构。Why？而要理解RESTful架构，最好的方法就是去理解Representational State Transfer这个词组，直译过来就是「表现层状态转化」，其实它省略了主语。「表现层」其实指的是「资源」的「表现层」，所以通俗来讲就是：资源在网络中以某种表现形式进行状态转移。分解开来：Resource：资源，即数据。比如newsfeed，friends，order等；Representational：某种表现形式，比如用JSON，XML，JPEG等；State Transfer：状态变化。通过HTTP动词实现。

REST ( REpresentational State Transfer ) 首字母的缩写， ≠ rest。REST是一种架构风格，是一组架构约束条件和原则。满足这些约束条件和原则的应用程序或设计就是 RESTful。REST核心是面向资源， 其专门针对网络应用设计和开发方式， 以降低开发的复杂性，提高系统的可伸缩性。

无状态是针对于“状态”来说的。一个WEB应用协议中的“状态”指的是，为两个相互关联的用户交互操作保留某种公共信息，例如用户登录信息，工作流等。这些信息具有不同作用域，如page，request，session，application等。通常由服务器负责保存这些信息。“无状态”的概念逐渐流行，得益于分布式系统的发展。首先，无状态请求易于实现负载均衡。在分布式web系统下，有多个可用服务器，每个服务器都可以处理客户端请求。传统的有状态请求，因为状态信息只保存在第一次发起请求的那台服务器上，之后的请求都只能由这台服务器来处理，服务器无法自由调度请求。无状态请求则完全没有这个限制。其次，无状态请求有较强的容错性和可伸缩性。如果一台服务器宕机，无状态请求可以透明地交由另一台可用服务器来处理，而有状态的请求则会因为存储请求状态信息的服务器宕机而承担状态丢失的风险。需要注意的是，“状态"指请求的状态，而不是资源的状态。Restful风格的无状态约束要求服务器不保存请求状态，如果确实需要维持用户状态，也应由客户端负责。传递usercredentials是Restful的，而传递sessionID是unRestful的,因为session信息保存在服务器端。

确保安全性可以从三个方面去做： 对客户端做身份认证 对敏感的数据做加密，并且防止篡改 身份认证之后的授权 现在比较流行的是使用OAuth协议做身份认证

理解POST和PUT的区别，顺便提下RESTful 首先解释幂等，幂等是数学的一个用语，对于单个输入或者无输入的运算方法，如果每次都是同样的结果，则称其是幂等的 对于两个引数，如果传入值相等，结果也等于每个传入值，则称其为幂等的，如min(a,b) POST 用于提交请求，可以更新或者建立资源，是非幂等的 举个例子，在我们的支付系统中，一个api的功能是建立收款金额二维码，它和金额相关，每个使用者可以有多个二维码，如果连续呼叫则会建立新的二维码，这个时候就用POST PUT 用于向指定的URI传送更新资源，是幂等的 还是那个例子，使用者的账户二维码只和使用者关联，而且是一一对应的关系，此时这个api就可以用PUT，因为每次呼叫它，都将重新整理使用者账户二维码 比如一个介面用于使用者生成，接收的资料是使用者名称、密码等相关资讯，则用POST RESTful建议所有的URI都是对应资源，所以建立使用者不应该理解为一个行为，在此将此介面命名为: /user/creation 每次呼叫它都会新建一个使用者（假定使用者名称可以重复） 而PUT方法更加关心一个具体资源对应的URI，比如更新当前使用者资讯，这里可以用PUT /user/me/update 这里用me来指代当前使用者，如果是针对更多使用者适用的介面，可以考虑 /user/{uid}/update 注意多次呼叫同一介面，只要提交的资料一致，使用者资讯每次结果就会一致，即产生同样的结果：伺服器端某个具体的资源得到了更新 当需要以更新的形式来修改某一具体资源的时候，如何判断用PUT还是POST呢？ 很简单，如果该更新对应的URI多次呼叫的结果一致，则PUT 比如更新某个blog文章，因为该文章具有单一的具体URI，所以每次更新提交相同的内容，结果都一致 /blog/{document_id}/update 在每次更新提交相同的内容，最终的结果不一致的时候，用POST 举个很常见的例子，一个介面的功能是将当前余额减一个值，每次提交指定该值为100，介面如下 /amount/deduction 呼叫一次，你的余额-100，呼叫两次，余额-200 这个时候就用POST RESTful的4种层次 Representational status transfer 个人理解为：表现形式的状态传递 1、只有一个介面交换xml来实现整个服务 目前我们的移动站点的服务就是类似的结构，我们有两个URI介面/mapp/lead和/msdk/safepay 2、每一个资源对应一个具体的URI，比1好维护，但是问题依然很明显，资源版本更新会引入时间戳维护，资源的获取和更新修改必须对应不同的URI 目前PC主站和移动站点的静态内容（包括档案）都是这种形式 3、在2的基础上使用了 verb，每个URI可以有不同的动作，充分利用了协议，所以自然居然协议的完整优势，比如快取和健壮性 HTML4.0只支援POST和GET，所以无论DELETE还是PUT操作，都用POST去模拟了 在WEB开发者看来，就是如果有资料变动，就用POST，如果没有，就用GET 所以目前中国使用者来看，PC端实现RESTful很困难，只有移动端支援Html5的浏览器，才能让前端做出尝试 4、现在似乎更加无法实际应用，Hypemedia control，也就是RESTful的本意，合理的架构原理和以网路为基础的设计相结合，带来一个更加方便、功能强大的通讯架构 在HTTP中，PUT被定义为idempotent的方法，POST则不是，这是一个很重要的区别。 “Methods can also have the property of "idempotence" in that (aside from error or expiration issues) the side-effects of N > 0 identical requests is the same as for a single request.” 上面的话就是说，如果一个方法重复执行多次，产生的效果是一样的，那就是idempotent的。 REST 定义了一组体系架构原则，您可以根据这些，包括使用不同语言编写的客户端如何通过 HTTP 处理和传输资源状态。所以在事实上，REST 对 Web的影响非常大，由于其使用相当方便，已经普遍地取代了基于 SOAP 和 WSDL 的介面设计。在多年以后的今天，REST的主要框架已经开始雨后春笋般的出现。 post[英] [pu0259ust] [美] [post] n. 邮件；邮政；柱，桩，杆；岗位； vt. 张贴；宣布；设岗；邮寄； vi. 快速行进； adj. 有关赛跑（或赛马，赛狗）起点标志的； adv. 〈外〉在后；用急件[驿马]；赶紧地，火速地； put[英] [put] [美] [pu028at] vt. 放；表达；给予（重视、信任、价值等）；使处于（某种状态）； vt.& vi. 使感觉到；使受到…的影响； vi. 说；猛推；将…送往；使与…连线； n. [方]笨蛋，怪人；对策； adj. 固定的；不动的； restful[英] [u02c8restfu0259l] [美] [u02c8ru025bstfu0259l] adj. 平静的，悠闲的，让人得到休息的；安生； post 和 put 的区别 POST请求的URI表示处理该封闭实体的资源，该资源可能是个资料接收过程、某种协议的闸道器、或者接收注解的独立实体。然而，PUT请求中的URI表示请求中封闭的实体-使用者代理知道URI的目标，并且伺服器无法将请求应用到其他资源。如果伺服器希望该请求应用到另一个URI，就必须传送一个301响应；使用者代理可通过自己的判断来决定是否转发该请求。 HTTP/1.1没有定义一个PUT请求如何影响原始伺服器的状态。 PUT请求必须遵守资讯传输要求。 除非另有说明，PUT请求中的实体头部应该用于PUT建立或修改的资源上。 restful和soap的区别 rest轻量级，SOAP重量级；rest学习起来比较简单，容易上手，SOAP相对来说难些；rest能通过形式的直接呼叫，基于JSON，SOAP通过XML传输；rest效率和速度来说相对快些，SOAP则稍逊一筹 webservice和restful的区别 REST是一种架构风格，其核心是面向资源，REST专门针对网路应用设计和开发方式，以降低开发的复杂性，提高系统的可伸缩性。REST提出设计概念和准则为： 1.网路上的所有事物都可以被抽象为资源(resource) 2.每一个资源都有唯一的资源标识(resource identifier)，对资源的操作不会改变这些标识 3.所有的操作都是无状态的 REST简化开发，其架构遵循CRUD原则，该原则告诉我们对于资源(包括网路资源)只需要四种行为：建立，获取，更新和删除就可以完成相关的操作和处理。您可以通过统一资源识别符号（Universal Resource Identifier，URI）来识别和定位资源，并且针对这些资源而执行的操作是通过 HTTP 规范定义的。其核心操作只有GET,PUT,POST,DELETE。 由于REST强制所有的操作都必须是stateless的，这就没有上下文的约束，如果做分散式，丛集都不需要考虑上下文和会话保持的问题。极大的提高系统的可伸缩性。 对于SOAP Webservice和Restful Webservice的选择问题，首先需要理解就是SOAP偏向于面向活动，有严格的规范和标准，包括安全，事务等各个方面的内容，同时SOAP强调操作方法和操作物件的分离，有WSDL档案规范和XSD档案分别对其定义。而REST强调面向资源，只要我们要操作的物件可以抽象为资源即可以使用REST架构风格。 REST ful 应用问题 是否使用REST就需要考虑资源本身的抽象和识别是否困难，如果本身就是简单的类似增删改查的业务操作，那么抽象资源就比较容易，而对于复杂的业务活动抽象资源并不是一个简单的事情。比如校验使用者等级，转账，事务处理等，这些往往并不容易简单的抽象为资源。 其次如果有严格的规范和标准定义要求，而且前期规范标准需要指导多个业务系统整合和开发的时候，SOAP风格由于有清晰的规范标准定义是明显有优势的。我们可以在开始和实现之前就严格定义相关的介面方法和介面传输资料。 简单资料操作，无事务处理，开发和呼叫简单这些是使用REST架构风格的优势。而对于较为复杂的面向活动的服务，如果我们还是使用REST，很多时候都是仍然是传统的面向活动的思想通过转换工具再转换得到REST服务，这种使用方式是没有意义的。 效率和易用性 SOAP协议对于讯息体和讯息头都有定义，同时讯息头的可扩充套件性为各种网际网路的标准提供了扩充套件的基础，WS-*系列就是较为成功的规范。但是也由于SOAP由于各种需求不断扩充其本身协议的内容，导致在SOAP处理方面的效能有所下降。同时在易用性方面以及学习成本上也有所增加。 REST被人们的重视，其实很大一方面也是因为其高效以及简洁易用的特性。这种高效一方面源于其面向资源介面设计以及操作抽象简化了开发者的不良设计，同时也最大限度的利用了Http最初的应用协议设计理念。同时，在我看来REST还有一个很吸引开发者的就是能够很好的融合当前Web2.0的很多前端技术来提高开发效率。例如很多大型网站开放的REST风格的API都会有多种返回形式，除了传统的xml作为资料承载，还有（JSON,RSS,ATOM）等形式，这对很多网站前端开发人员来说就能够很好的mashup各种资源资讯 安全性 技术没有好坏，只有是不是合适，一种好的技术和思想被误用了，那么就会得到反效果。REST和SOAP各自都有自己的优点，同时如果在一些场景下如果去改造REST，其实就会走向SOAP（例如安全）。 REST对于资源型服务介面来说很合适，同时特别适合对于效率要求很高，但是对于安全要求不高的场景。而SOAP的成熟性可以给需要提供给多开发语言的，对于安全性要求较高的介面设计带来便利。所以我觉得纯粹说什么设计模式将会占据主导地位没有什么意义，关键还是看应用场景。 同时很重要一点就是不要扭曲了REST现在很多网站都跟风去开发REST风格的介面，其实都是在学其形，不知其心，最后弄得不伦不类，效能上不去，安全又保证不了。 成熟度 SOAP虽然发展到现在已经脱离了初衷，但是对于异构环境服务释出和呼叫，以及厂商的支援都已经达到了较为成熟的情况。不同平台，开发语言之间通过SOAP来互动的web service都能够较好的互通。 由于没有类似于SOAP的权威性协议作为规范，REST实现的各种协议仅仅只能算是私有协议，当然需要遵循REST的思想，但是这样细节方面有太多没有约束的地方。REST日后的发展所走向规范也会直接影响到这部分的设计是否能够有很好的生命力。 restful和的区别 REST 定义了一组体系架构原则，您可以根据这些，包括使用不同语言编写的客户端如何通过 HTTP 处理和传输资源状态。所以在事实上，REST 对 Web的影响非常大，由于其使用相当方便，已经普遍地取代了基于 SOAP 和 WSDL 的介面设计。在多年以后的今天，REST的主要框架已经开始雨后春笋般的出现。 个人理解： （一） 首先REST只是一种风格，不是一种标准 （二） REST是以资源为中心的 （三） REST充分利用或者说极端依赖HTTP协议 一．对于今天正在吸引如此多注意力的最纯粹形式的 REST Web 服务，其具体实现应该遵循以下基本设计原则： 1.1．显式地使用不同的 HTTP 请求方法 1.2．无状态 1.3．公开目录结构式的 URI(通过逻辑URI定位资源)。 1.1．显式地使用不同的 HTTP 请求方法 我们在 Web 应用中处理来自客户端的请求时，通常只考虑 GET 和 POST 这两种 HTTP 请求方法。实际上，HTTP 还有 HEAD、PUT、DELETE 等请求方法。而在 REST 架构中，用不同的 HTTP 请求方法来处理对资源的 CRUD（建立、读取、更新和删除）操作： 若要在伺服器上建立资源，应该使用 POST 方法。 若要检索某个资源，应该使用 GET 方法。 若要更改资源状态或对其进行更新，应该使用 PUT 方法。 若要删除某个资源，应该使用 DELETE 方法。 PHP中put和post区别 1.　使用支援和范围的区别： PHP提供了对PUT方法的支援，在Http定义的与伺服器的互动方法中，PUT是把讯息本体中的讯息传送到一个URL，形式上跟POST类似; PHP 提供对诸如 Netscape Composer 和 W3C Amaya 等客户端使用的 HTTP PUT 方法的支援; PHP 4 中，必须使用标准的输入流来读取一个 HTTP PUT 的内容; PUT方法没有POST方法使用广泛，但PUT方法却是向伺服器上传档案最有效率的方法： 2.上传过程的区别： POST上传档案时，通常需要将所有的资讯组合成multipart 传送过去，然后伺服器再解码这些资讯，解码过程则必不可少的会消耗记忆体和CPU资源，这种现象在上传大档案时尤其明显； PUT方法则允许你通过与伺服器建立的socket连结传递档案的内容，而不附带其他的资讯，效果上更直接； 3.上传效果的区别： PHP 接受到 PUT 方法的请求时，会把上传的档案储存到和其它用 POST 方法处理过的档案相同的临时目录；请求结束时，临时档案将被删除。 用来处理 PUT 的 PHP 指令码必须将该档案拷贝到其它的地方； 4. POST和PUT请求根本区别 POST请求的URI表示处理该封闭实体的资源，该资源可能是个资料接收过程、某种协议的闸道器、或者接收注解的独立实体； PUT请求中的URI表示请求中封闭的实体-使用者代理知道URI的目标； 伺服器无法将请求应用到其他资源； 如果伺服器希望该请求应用到另一个URI，就必须传送一个301响应； 使用者代理可通过自己的判断来决定是否转发该请求； get和post的区别，你真的理解吗 get是收到得到 post 发出一进一出就是根本区别 He is ( ) a coat Ain B putting on C wearing 选什么？ 顺便讲下in put on wear的区别 选C。 in强调穿着什么样的衣服（这里一般 用in引导的介词短语 作定语。）； 例：The girl in a blue blouse is my sister. in a blue blouse是介词短语，在句中作为定语来修饰the girl。 put on强调穿上衣服的动作，一般用现在进行时； 例：The girl is putting on a blue blouse. put on是行为动词的固定搭配。 wear强调穿着某衣服的状态。 例：The girl wears a blue blouse. wear意为“穿着”。

粉色冯绍峰是分色分