精华内容
下载资源
问答
  • 主要介绍了vue 调用 RESTful风格接口操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 使用servlet开发的时候,所需要的jar包,千万不要导入we.rs上的jar包,吃了一次亏,闹了好久才搞定
  • 一个Delphi实现的HttpServer,支持RESTful风格路由
  • 基本框架 ...1,前一级分离思想 ...进行负责的业务/数据接口,前端负责展现/交互逻辑,前逐步开发对于同时份数数据接口,我们可以自定义开发多个客户端,可以选择web和app就可以使用同一个接口,多个前端展示。...
  • restful风格

    万次阅读 多人点赞 2018-08-24 11:55:19
    一种软件架构风格、设计风格,而不是标准,只是提供了一组设计原则和约束条件。它主要用于客户端和服务器交互类的软件。基于这个风格设计的软件可以更简洁,更有层次,更易于实现缓存等机制。 URL定义 资源:...

    概念

             一种软件架构风格、设计风格,而不是标准,只是提供了一组设计原则和约束条件。它主要用于客户端和服务器交互类的软件。基于这个风格设计的软件可以更简洁,更有层次,更易于实现缓存等机制。

     

    URL定义

    资源:互联网所有的事物都可以被抽象为资源 
    资源操作:使用POST、DELETE、PUT、GET,使用不同方法对资源进行操作。 
    分别对应 添加、 删除、修改、查询。 


    传统方式操作资源 

    http://127.0.0.1/item/queryUser.action?id=1   查询,GET 
    http://127.0.0.1/item/saveUser.action             新增,POST 
    http://127.0.0.1/item/updateUser.action          更新,POST 
    http://127.0.0.1/item/deleteUser.action?id=1  删除,GET或POST

     

    请求方式

    可以通过 GET、 POST、 PUT、 PATCH、 DELETE 等方式对服务端的资源进行操作。其中,GET 用于查询资源,POST 用于创建资源,PUT 用于更新服务端的资源的全部信息,PATCH 用于更新服务端的资源的部分信息,DELETE 用于删除服务端的资源。

    这里使用“用户”的案例进行回顾通过 GET、 POST、 PUT、 PATCH、 DELETE 等方式对服务端的资源进行操作。

     

    使用RESTful操作资源 

    【GET】 /users # 查询用户信息列表

    【GET】 /users/1001 # 查看某个用户信息

    【POST】 /users # 新建用户信息

    【PUT】 /users/1001 # 更新用户信息(全部字段)

    【PATCH】 /users/1001 # 更新用户信息(部分字段)

    【DELETE】 /users/1001 # 删除用户信息

    之前的操作是没有问题的,大神认为是有问题的,有什么问题呢?你每次请求的接口或者地址,都在做描述,例如查询的时候用了queryUser,新增的时候用了saveUser ,修改的时候用了updateUser,其实完全没有这个必要,我使用了get请求,就是查询.使用post请求,就是新增的请求,PUT就是修改,delete就是删除,我的意图很明显,完全没有必要做描述,这就是为什么有了restful.

     

    API设计风格基本规则

    1.使用名词而不是动词

    不要使用:

    /getAllUsers
    /createNewUser
    /deleteAllUser

    2.Get方法和查询参数不应该涉及状态改变

    使用PUT, POST 和DELETE 方法 而不是 GET 方法来改变状态,不要使用GET 进行状态改变:

    3.使用复数名词

    不要混淆名词单数和复数,为了保持简单,只对所有资源使用复数。

    /cars 而不是 /car
    /users 而不是 /user
    /products 而不是 /product
    /settings 而部署 /setting

    4. 使用子资源表达关系

    如果一个资源与另外一个资源有关系,使用子资源:

    GET /cars/711/drivers/ 返回 car 711的所有司机
    GET /cars/711/drivers/4 返回 car 711的4号司机

    5.使用Http头声明序列化格式

    在客户端和服务端,双方都要知道通讯的格式,格式在HTTP-Header中指定

    Content-Type 定义请求格式
    Accept 定义系列可接受的响应格式

    6.为集合提供过滤 排序 选择和分页等功能

    Filtering过滤:

    使用唯一的查询参数进行过滤:

    GET /cars?color=red 返回红色的cars
    GET /cars?seats<=2 返回小于两座位的cars集合

    Sorting排序:

    允许针对多个字段排序

    GET /cars?sort=-manufactorer,+model

    这是返回根据生产者降序和模型升序排列的car集合

    Field selection

    移动端能够显示其中一些字段,它们其实不需要一个资源的所有字段,给API消费者一个选择字段的能力,这会降低网络流量,提高API可用性。

    GET /cars?fields=manufacturer,model,id,color

    Paging分页

    使用 limit 和offset.实现分页,缺省limit=20 和offset=0;

    GET /cars?offset=10&limit=5

    为了将总数发给客户端,使用订制的HTTP头: X-Total-Count.

    链接到下一页或上一页可以在HTTP头的link规定,遵循Link规定:

    Link: <https://blog.mwaysolutions.com/sample/api/v1/cars?offset=15&limit=5>; rel="next",
    <https://blog.mwaysolutions.com/sample/api/v1/cars?offset=50&limit=3>; rel="last",
    <https://blog.mwaysolutions.com/sample/api/v1/cars?offset=0&limit=5>; rel="first",
    <https://blog.mwaysolutions.com/sample/api/v1/cars?offset=5&limit=5>; rel="prev",

    7.版本化你的API

    使得API版本变得强制性,不要发布无版本的API,使用简单数字,避免小数点如2.5.

    一般在Url后面使用?v

    /blog/api/v1

    8. 使用Http状态码处理错误

    如果你的API没有错误处理是很难的,只是返回500和出错堆栈不一定有用

    Http状态码提供70个出错,我们只要使用10个左右:

    200 – OK – 一切正常
    201 – OK – 新的资源已经成功创建
    204 – OK – 资源已经成功擅长

    304 – Not Modified – 客户端使用缓存数据

    400 – Bad Request – 请求无效,需要附加细节解释如 "JSON无效"
    401 – Unauthorized – 请求需要用户验证
    403 – Forbidden – 服务器已经理解了请求,但是拒绝服务或这种请求的访问是不允许的。
    404 – Not found – 没有发现该资源
    422 – Unprocessable Entity – 只有服务器不能处理实体时使用,比如图像不能被格式化,或者重要字段丢失。

    500 – Internal Server Error – API开发者应该避免这种错误。

    使用详细的错误包装错误:

    {

      "errors": [

       {

        "userMessage": "Sorry, the requested resource does not exist",

        "internalMessage": "No car found in the database",

        "code": 34,

        "more info": "http://dev.mwaysolutions.com/blog/api/v1/errors/12345"

       }

      ]

    }

    9.允许覆盖http方法

    一些代理只支持POST 和 GET方法, 为了使用这些有限方法支持RESTful API,需要一种办法覆盖http原来的方法。

    使用订制的HTTP头 X-HTTP-Method-Override 来覆盖POST 方法.

     

    Restful风格的springMVC配搭ajax请求的例子

    总而言之restful是一种旧技术新风格

    展开全文
  • 使用axios自动发送请求,支持筛选, 自定义操作列, 让 RESTful 风格的 CRUD 更简单
  • NULL 博文链接:https://357029540.iteye.com/blog/2329730
  • Restful风格

    千次阅读 2019-04-15 15:00:11
    什么是Restful风格? 简单点说就是访问后台时的请求路径与请求的方式有所不同. 传统的请求路径如:http://127.0.0.1:8080/user/getUser.do?id=1 Restful风格的请求路径为:http://127.0.0.1:8080/user/1 概念 Restful...

    什么是Restful风格?

    简单点说就是访问后台时的请求路径与请求的方式有所不同.
    传统的请求路径如:http://127.0.0.1:8080/user/getUser.do?id=1
    Restful风格的请求路径为:http://127.0.0.1:8080/user/1

    概念

    Restful就是一个资源定位及资源操作的风格。不是标准也不是协议,只是一种风格。基于这个风格设计的软件可以更简洁,更有层次,更易于实现缓存等机制。

    功能
    资源:互联网所有的事物都可以被抽象为资源
    资源操作:使用POST、DELETE、PUT、GET,使用不同方法对资源进行操作。
    分别对应 添加、 删除、修改、查询。

    操作步骤

    将web.xml中

    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
    

    改为

    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    

    然后再Controller中的写法

    @Controller
    public class TestController {
    
    
    
        //新增
        @RequestMapping(value = "user",method = RequestMethod.POST,produces = "application/json;charset=UTF-8")
        @ResponseBody
        public String addUser(User user){
            return "新增用户"+user;
        }
    
        //修改
        @RequestMapping(value = "user",method = RequestMethod.PUT,produces ="application/json;charset=UTF-8" )
        @ResponseBody
        public String editUser(User user){
            return "修改用户"+user;
        }
    
        //删除
        @RequestMapping(value = "user",method = RequestMethod.DELETE,produces = "application/json;charset=UTF-8")
        @ResponseBody
        public String deleteById(Integer id){
            return "删除用户"+id;
        }
    
        //根据id查询
        @RequestMapping(value = "user/{id}",method = RequestMethod.GET,produces = "application/json;charset=UTF-8")
        public String selectUserById(@PathVariable("id") Integer id){
            return "根据主键查询id"+id;
        }
    
        //条件查询
        @RequestMapping(value = "user",method = RequestMethod.GET,produces = "application/json;charset=UTF-8")
        @ResponseBody
        public String selectUser(User user){
            return "条件查询"+user;
        }
    
    }
    

    浏览器默认只去打开get请求,所以我们需要用到一个软件去测试Postman
    在这里插入图片描述

    注意:

    虽然每个请求的路径都一样,但是请求方式都不同,查询操作一般为GET请求,新增操作一般为POST请求,修改操作一般为PUT请求,删除操作一般为DELETE请求

    SpringMVC配置静态资源

    https://www.cnblogs.com/banning/p/6195072.html
    https://blog.csdn.net/daiyutage/article/details/71250382

    展开全文
  • 轻量级的postman测试小工具 支持简单的GET/POST/PUT/DELETE四种常用请求方式,支持请求历史记录已经文件上传等功能。 忒:根据请求的历史记录还可以生成优雅的接口api文档 源码地址:...
  • 完整的IntelliJ IDEA项目,使用springmvc实现resrful风格的api,增删改次完整
  • Http请求Restful风格的远程调用,在远程调用的过程中会出现四种请求方式,这个工具把此部分代码给封装了一下。
  • 基于SpringBoot 搭建的 SpringBoot+JPA +Mybatis PageHelper 分页 +Restful 风格的小案例
  • 1.C#语言OPC client通信组件,能够快速的读取标签的值,使用方面,只需要简单的配置TAG就可以完成数据...支持跨平台远程获取OPC TAG的数据,能读能写,采用RestFul API风格,解决了以往OPC远程调用需要配置DCOM的问题。
  • 具体实现和一些配合框架都有
  • RESTful API初试 后端 控制器使用@RestController注解声明,隐式默认为每个方法加上@ResponseBody注解,返回的数据不再被视图解析器解析 @RequestMapping(value = "/register", method = RequestMethod.POST, ...
  • 基于Python Django,用于restful风格API的MockServer
  • Spring boot Restful风格Demo

    热门讨论 2015-05-06 18:56:10
    Spring boot Restful风格Demo,基于maven架构。
  • #restful-socket Introduction 在某些如服务器需要即时推送消息给客户端的情况下,会使用WebSocket以实现双向通讯。此时,对于其他原本使用HTTP的请求和数据交互,也可以借用WebSocket来处理,以提高性能,减少流量...
  • RESTful风格API详解

    2021-01-27 20:00:47
    在学习RESTful 风格接口之前,即使你不知道它是什么,但你肯定会好奇它能解决什么问题?有什么应用场景?听完下面描述我想你就会明白: 在互联网并没有完全流行的初期,移动端也没有那么盛行,页面请求和并发量也不...

    在学习RESTful 风格接口之前,即使你不知道它是什么,但你肯定会好奇它能解决什么问题?有什么应用场景?听完下面描述我想你就会明白:

    在互联网并没有完全流行的初期,移动端也没有那么盛行,页面请求和并发量也不高,那时候人们对接口的要求没那么高,一些动态页面(jsp)就能满足绝大多数的使用需求。

    在这里插入图片描述

    但是随着互联网和移动设备的发展,人们对Web应用的使用需求也增加,传统的动态页面由于低效率而渐渐被HTML+JavaScript(Ajax)的前后端分离所取代,并且安卓、IOS、小程序等形式客户端层出不穷,客户端的种类出现多元化,而客户端和服务端就需要接口进行通信,但接口的规范性就又成了一个问题:

    在这里插入图片描述

    所以一套结构清晰、符合标准、易于理解、扩展方便让大部分人都能够理解接受的接口风格就显得越来越重要,而RESTful风格的接口(RESTful API)刚好有以上特点,就逐渐被实践应用而变得流行起来。

    在这里插入图片描述

    现在,RESTful是目前最流行的接口设计规范,在很多公司有着广泛的应用,其中Github 的API设计就是很标准的RESTful API,你可以参考学习。

    在开发实践中我们很多人可能还是使用传统API进行请求交互,很多人其实并不特别了解RESTful API,对RESTful API的认知可能会停留在:

    • 面向资源类型的
    • 是一种风格
    • (误区)接口传递参数使用斜杠(/)分割而不用问号(?)传参。

    而其实一个很大的误区不要认为没有查询字符串就是RESTful API,也不要认为用了查询字符串就不是RESTful API,更不要认为用了JSON传输的API就是RESTful API。

    本篇将带你了解RESTful并用SpringBoot实战RESTful API.

    一、REST介绍

    REST涉及一些概念性的东西可能比较多,在实战RESTful API之前,要对REST相关的知识有个系统的认知。

    REST的诞生

    REST(英文:Representational State Transfer,简称REST,直译过来表现层状态转换)是一种软件架构风格、设计风格,而不是标准,只是提供了一组设计原则和约束条件。它主要用于客户端和服务器交互类的软件。基于这个风格设计的软件可以更简洁,更有层次,更易于实现缓存等机制。

    它首次出现在 2000 年 Roy Thomas Fielding 的博士论文中,这篇论文定义并详细介绍了表述性状态转移(Representational State Transfer,REST)的架构风格,并且描述了 如何使用 REST 来指导现代 Web 架构的设计和开发。用他自己的原话说:

    我写这篇文章的目的是:在符合架构原理前提下,理解和评估基于网络的应用软件的架构设计,得到一个功能强、性能好、适宜通信的架构。

    需要注意的是REST并没有一个明确的标准,而更像是一种设计的风格,满足这种设计风格的程序或接口我们称之为RESTful(从单词字面来看就是一个形容词)。所以RESTful API 就是满足REST架构风格的接口。

    在这里插入图片描述

    Fielding博士答辩

    Fielding博士当时提出的是REST架构在很久的时间内并没有被关注太多,而近些年REST在国内才变得越来越流行。下面开始详细学习REST架构特征。

    REST架构特征

    既然知道REST和RESTful的联系和区别,现在就要开始好好了解RESTful的一些约束条件和规则,RESTful是一种风格而不是标准,而这个风格大致有以下几个主要特征:

    以资源为基础 :资源可以是一个图片、音乐、一个XML格式、HTML格式或者JSON格式等网络上的一个实体,除了一些二进制的资源外普通的文本资源更多以JSON为载体、面向用户的一组数据(通常从数据库中查询而得到)。

    统一接口: 对资源的操作包括获取、创建、修改和删除,这些操作正好对应HTTP协议提供的GET、POST、PUT和DELETE方法。换言而知,使用RESTful风格的接口但从接口上你可能只能定位其资源,但是无法知晓它具体进行了什么操作,需要具体了解其发生了什么操作动作要从其HTTP请求方法类型上进行判断。具体的HTTP方法和方法含义如下:

    • GET(SELECT):从服务器取出资源(一项或多项)。
    • POST(CREATE):在服务器新建一个资源。
    • PUT(UPDATE):在服务器更新资源(客户端提供完整资源数据)。
    • PATCH(UPDATE):在服务器更新资源(客户端提供需要修改的资源数据)。
    • DELETE(DELETE):从服务器删除资源。

    当然也有很多在具体使用的时候使用PUT表示更新。从请求的流程来看,RESTful API和传统API大致架构如下:

    在这里插入图片描述

    URI指向资源:URI = Universal Resource Identifier 统一资源标志符,用来标识抽象或物理资源的一个紧凑字符串。URI包括URL和URN,在这里更多时候可能代指URL(统一资源定位符)。RESTful是面向资源的,每种资源可能由一个或多个URI对应,但一个URI只指向一种资源。

    无状态:服务器不能保存客户端的信息, 每一次从客户端发送的请求中,要包含所有必须的状态信息,会话信息由客户端保存, 服务器端根据这些状态信息来处理请求。当客户端可以切换到一个新状态的时候发送请求信息, 当一个或者多个请求被发送之后, 客户端就处于一个状态变迁过程中。每一个应用的状态描述可以被客户端用来初始化下一次的状态变迁。

    REST架构限制条件

    Fielding在论文中提出REST架构的6个限制条件,也可称为RESTful 6大原则, 标准的REST约束应满足以下6个原则:

    客户端-服务端(Client-Server): 这个更专注客户端和服务端的分离,服务端独立可更好服务于前端、安卓、IOS等客户端设备。

    无状态(Stateless):服务端不保存客户端状态,客户端保存状态信息每次请求携带状态信息。

    可缓存性(Cacheability) :服务端需回复是否可以缓存以让客户端甄别是否缓存提高效率。

    统一接口(Uniform Interface):通过一定原则设计接口降低耦合,简化系统架构,这是RESTful设计的基本出发点。当然这个内容除了上述特点提到部分具体内容比较多详细了解可以参考这篇REST论文内容。

    分层系统(Layered System):客户端无法直接知道连接的到终端还是中间设备,分层允许你灵活的部署服务端项目。

    按需代码(Code-On-Demand,可选):按需代码允许我们灵活的发送一些看似特殊的代码给客户端例如JavaScript代码。

    REST架构的一些风格和限制条件就先介绍到这里,后面就对RESTful风格API具体介绍。

    二、RESTful API设计规范

    既然了解了RESTful的一些规则和特性,那么具体该怎么去设计一个RESTful API呢?要从URL路径、HTTP请求动词、状态码和返回结果等方面详细考虑。至于其他的方面例如错误处理、过滤信息等规范这里就不详细介绍了。

    URL设计规范

    URL为统一资源定位器 ,接口属于服务端资源,首先要通过URL这个定位到资源才能去访问,而通常一个完整的URL组成由以下几个部分构成:

    URI = scheme "://" host  ":"  port "/" path [ "?" query ][ "#" fragment ]
    

    scheme: 指底层用的协议,如http、https、ftp
    host: 服务器的IP地址或者域名
    port: 端口,http默认为80端口
    path: 访问资源的路径,就是各种web 框架中定义的route路由
    query: 查询字符串,为发送给服务器的参数,在这里更多发送数据分页、排序等参数。
    fragment: 锚点,定位到页面的资源

    我们在设计API时URL的path是需要认真考虑的,而RESTful对path的设计做了一些规范,通常一个RESTful API的path组成如下:

    /{version}/{resources}/{resource_id}
    

    version:API版本号,有些版本号放置在头信息中也可以,通过控制版本号有利于应用迭代。
    resources:资源,RESTful API推荐用小写英文单词的复数形式。
    resource_id:资源的id,访问或操作该资源。

    当然,有时候可能资源级别较大,其下还可细分很多子资源也可以灵活设计URL的path,例如:

    /{version}/{resources}/{resource_id}/{subresources}/{subresource_id}
    

    此外,有时可能增删改查无法满足业务要求,可以在URL末尾加上action,例如

    /{version}/{resources}/{resource_id}/action
    

    其中action就是对资源的操作。

    从大体样式了解URL路径组成之后,对于RESTful API的URL具体设计的规范如下:

    1. 不用大写字母,所有单词使用英文且小写。
    2. 连字符用中杠"-“而不用下杠”_"
    3. 正确使用 "/"表示层级关系,URL的层级不要过深,并且越靠前的层级应该相对越稳定
    4. 结尾不要包含正斜杠分隔符"/"
    5. URL中不出现动词,用请求方式表示动作
    6. 资源表示用复数不要用单数
    7. 不要使用文件扩展名

    HTTP动词

    在RESTful API中,不同的HTTP请求方法有各自的含义,这里就展示GET,POST,PUT,DELETE几种请求API的设计与含义分析。针对不同操作,具体的含义如下:

    GET /collection:从服务器查询资源的列表(数组)
    GET /collection/resource:从服务器查询单个资源
    POST /collection:在服务器创建新的资源
    PUT /collection/resource:更新服务器资源
    DELETE /collection/resource:从服务器删除资源
    

    在非RESTful风格的API中,我们通常使用GET请求和POST请求完成增删改查以及其他操作,查询和删除一般使用GET方式请求,更新和插入一般使用POST请求。从请求方式上无法知道API具体是干嘛的,所有在URL上都会有操作的动词来表示API进行的动作,例如:query,add,update,delete等等。

    而RESTful风格的API则要求在URL上都以名词的方式出现,从几种请求方式上就可以看出想要进行的操作,这点与非RESTful风格的API形成鲜明对比。

    在谈及GET,POST,PUT,DELETE的时候,就必须提一下接口的安全性和幂等性,其中安全性是指方法不会修改资源状态,即读的为安全的,写的操作为非安全的。而幂等性的意思是操作一次和操作多次的最终效果相同,客户端重复调用也只返回同一个结果。

    上述四个HTTP请求方法的安全性和幂等性如下:

    HTTP Method安全性幂等性解释
    GET安全幂等读操作安全,查询一次多次结果一致
    POST非安全非幂等写操作非安全,每多插入一次都会出现新结果
    PUT非安全幂等写操作非安全,一次和多次更新结果一致
    DELETE非安全幂等写操作非安全,一次和多次删除结果一致

    状态码和返回数据

    服务端处理完成后客户端也可能不知道具体成功了还是失败了,服务器响应时,包含状态码和返回数据两个部分。

    状态码

    我们首先要正确使用各类状态码来表示该请求的处理执行结果。状态码主要分为五大类:

    1xx:相关信息
    2xx:操作成功
    3xx:重定向
    4xx:客户端错误
    5xx:服务器错误

    每一大类有若干小类,状态码的种类比较多,而主要常用状态码罗列在下面:

    200 OK - [GET]:服务器成功返回用户请求的数据,该操作是幂等的(Idempotent)。
    201 CREATED - [POST/PUT/PATCH]:用户新建或修改数据成功。
    202 Accepted - [*]:表示一个请求已经进入后台排队(异步任务)
    204 NO CONTENT - [DELETE]:用户删除数据成功。
    400 INVALID REQUEST - [POST/PUT/PATCH]:用户发出的请求有错误,服务器没有进行新建或修改数据的操作,该操作是幂等的。
    401 Unauthorized - [*]:表示用户没有权限(令牌、用户名、密码错误)。
    403 Forbidden - [*]:表示用户得到授权(与401错误相对),但是访问是被禁止的。
    404 NOT FOUND - [*]:用户发出的请求针对的是不存在的记录,服务器没有进行操作,该操作是幂等的。
    406 Not Acceptable - [GET]:用户请求的格式不可得(比如用户请求JSON格式,但是只有XML格式)。
    410 Gone -[GET]:用户请求的资源被永久删除,且不会再得到的。
    422 Unprocesable entity - [POST/PUT/PATCH] 当创建一个对象时,发生一个验证错误。
    500 INTERNAL SERVER ERROR - [*]:服务器发生错误,用户将无法判断发出的请求是否成功。

    返回结果

    针对不同操作,服务器向用户返回数据,而各个团队或公司封装的返回实体类也不同,但都返回JSON格式数据给客户端。

    三、一个RESTful API案例

    上面讲了RESTful理论知识,下面动手实现一个小案例吧!

    预备

    在本案例的实战中,我们访问的RESTful接口都是对数据库真实的操作,新建数据库,创建一个数据库和表(根据自己喜好)。

    选择Maven依赖的时候,只需要勾选其中Spring的Web模块、MySQL驱动以及MyBatis框架。

    本案例的POJO创建Dog.java实体对象,其具体构造为:

    package com.restfuldemo.pojo;
    
    public class Dog {
        private int id;//唯一id标识
        private String name;//名称
        private  int age;//年龄
        //省略get set
    }
    

    上面创建好了项目,我们就开始构建RESTful风格的API。在具体构建RESTful API的时候,需要对各种请求有更细致的认知,当然,本案例在实现各种请求的时候为了演示的便捷并没有完全遵循RESTful API规范,例如版本号等信息这里就不添加了,案例更侧重于使用SpringBoot实现这个接口。

    本案例实现对dog资源的增删改查,如下是非RESTful 和RESTful接口对比:

    API name非 RESTfulRESTful
    获取dog/dogs/query/{dogid}GET: /dogs/{dogid}
    插入dog/dogs/addPOST: /dogs
    更新dog/dogs/update/{dogid}PUT:/dogs/{dogid}
    删除dog/dods/delete/{dogid}DELETE:/dogs/{dogid}

    另外在使用postman进行发送请求的时候,有三种常用的文件类型传递到后端:

    在这里插入图片描述

    form-data :就是form表单中的multipart/form-data,会将表单数据处理为一条信息,用特定标签符将一条条信息分割开,而这个文件类型通常用来上传二进制文件。
    x-www-form-urlencoded:就是application/x-www-form-urlencoded,是form表单默认的encType,form表单会将表单内的数据转换为键值对,这种格式不能上传文件。

    raw:可以上传任意格式的文本,可以上传Text,JSON,XML等,但目前大部分还是上传JSON格式数据。当后端需要接收JSON格式数据处理的时候,可以采用这种格式来测试。

    因为GET请求查询参数在URL上,其他类型请求使用x-www-form-urlencoded方式向后端传值。

    GET POST PUT DELETE请求

    GET请求用来获取资源:GET请求会向数据库发索取数据的请求,从而来获取资源,该请求就像数据库的select操作一样,只是用来查询数据,不会影响资源的内容。无论进行多少次操作,结果都是一样的。

    并且GET请求会把请求的参数附加在URL后面,但是不同的浏览器对其有不同的大小长度限制。

    在本案例中,我们设计两个GET请求的API。
    GET /dogs :用来返回dog资源的列表。
    GET /dogs/{dogid} :用来查询此id的单个dog资源。

    POST请求用来新增一个资源 : POST请求向服务器发送数据,但是该请求会改变数据的内容(新添),就像数据库的insert操作一样,会创建新的内容。且POST请求的请求参数都是请求体中,其大小是没有限制的。

    在本案例中,我们设计以下POST请求的API。
    POST /dogs :服务端新增一个dog资源。

    PUT请求用来更新资源,PUT请求是向服务器端发送数据的, 与POST请求不同的是,PUT请求侧重于数据的修改 ,就像数据库中update一样,而POST请求侧重于数据的增加。

    在本案例中,我们设计以下POST请求的API。
    PUT /dogs/{dogid} :用来更新此id的单个dog资源。

    DELETE 请求用来删除资源,DELETE请求用途和它字面意思一致,用来删除资源。和数据库中delete相对应。

    在本案例中,我们设计以下DELETE请求的API。
    DELETE /dogs/{dogid} :用来删除此id的单个dog资源。

    对应的Mapper文件为:

    package com.restfuldemo.mapper;
    
    import com.restfuldemo.pojo.Dog;
    import org.apache.ibatis.annotations.*;
    import java.util.List;
    
    @Mapper
    public interface DogMapper {
    
        @Select("select * from dog")
        List<Dog> getAllDog();
    
        @Select("select * from dog where id=#{id}")
        Dog getDogById(@Param("id") int id);
    
        @Insert("insert into dog (name,age) values (#{name},#{age})")
        boolean addDog(Dog dog);
    
        @Update("update dog set name=#{name},age=#{age} where id=#{id}")
        boolean updateDog(Dog dog);
    
        @Delete("delete  from dog where id=#{id}")
        boolean deleteDogById(int id);
    }
    

    对应controller文件为:

    package com.restfuldemo.controller;
    
    import com.restfuldemo.mapper.DogMapper;
    import com.restfuldemo.pojo.Dog;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.*;
    
    import java.util.Arrays;
    import java.util.List;
    
    @RestController
    public class TestController {
    
        @Autowired(required = false)
        DogMapper dogMapper;
    
        @GetMapping("dogs")
        public List<Dog> getDogs()
        {
            return  dogMapper.getAllDog();
        }
    
        @GetMapping("dogs/{id}")
        public Dog getDogById(@PathVariable("id") int id)
        {
            Dog dog=dogMapper.getDogById(id);
            return  dog;
        }
        @PostMapping("dogs")
        public boolean addDog(Dog dog)
        {
            return dogMapper.addDog(dog);
        }
        @PutMapping("dogs/{id}")
        public boolean updateDog(@PathVariable("id")int id,@RequestParam("name")String name,@RequestParam("age")int age)
        {
    
            Dog dog=dogMapper.getDogById(id);
            dog.setName(name);
            dog.setAge(age);
            return  dogMapper.updateDog(dog);
        }
    
        @DeleteMapping("dogs/{id}")
        public boolean deleteDog(@PathVariable("id") int id)
        {
            return  dogMapper.deleteDogById(id);
        }
    }
    

    经过笔者测试一切都是ok的,如果要项目源文件请联系笔者发你哈!

    总结

    RESTful风格的API 固然很好很规范,但大多数互联网公司并没有按照或者完全按照其规则来设计,因为REST是一种风格,而不是一种约束或规则,过于理想的RESTful API 会付出太多的成本。

    比如RESTful API也有一些缺点

    • 比如操作方式繁琐,RESTful API通常根据GET、POST、PUT、DELETE 来区分操作资源的动作,而HTTP Method 本身不可直接见,是隐藏的,而如果将动作放到URL的path上反而清晰可见,更利于团队的理解和交流。
    • 并且有些浏览器对GET,POST之外的请求支持不太友好,还需要特殊额外的处理。
    • 过分强调资源,而实际业务API可能有各种需求比较复杂,单单使用资源的增删改查可能并不能有效满足使用需求,强行使用RESTful风格API只会增加开发难度和成本。

    所以,当你或你们的技术团队在设计API的时候,如果使用场景和REST风格很匹配,那么你们可以采用RESTful 风格API。但是如果业务需求和RESTful风格API不太匹配或者很麻烦,那也可以不用RESTful风格API或者可以借鉴一下,毕竟无论那种风格的API都是为了方便团队开发、协商以及管理,不能墨守成规。

    在这里插入图片描述

    到这里RESTful API的介绍和实战就结束啦,本篇首先从RESTful的一些特点进行介绍,再到SpringBoot实战RESTful API,最后也说了一些RESTful API并不完美的地方,相信睿智的你对RESTful 一定有了很深刻的理解。在以后项目的API设计上定能有所优化。

    不同的人对RESTful API可能有着不同的理解,但存在即合理,RESTful API有着其鲜明的优势和特点,目前也是一种API设计的主要选型之一,所以掌握和理解RESTful API还是相当重要的!

    展开全文
  • 基于springMVC 的restful风格接口前后端使用说明,方便前后端协作开发
  • 1.C#语言OPC client通信组件,能够快速的读取标签的值,使用方面,只需要简单的配置TAG就可以完成...2.支持跨平台远程获取OPC TAG的数据,能读能写,采用RestFul API风格,解决了以往OPC远程调用需要配置DCOM的问题。
  • Restful风格的介绍

    2018-02-28 15:10:32
    Rest风格的发展历史简介,Rest的实例,实例之间的性能比较,选取最优。
  • springmvc-restful 第一个基于springmvc-restful风格 获取url的案例
  • RestFul风格详解

    千次阅读 2021-03-11 16:52:16
    文章目录一、前言二、什么是RestFul风格三、传统风格与RestFul风格对比1. 传统方式操作资源2. RestFul方式操作资源四、RestFul代码演示1.代码展示2.拓展情景五、使用method属性指定请求类型六、总结 一、前言 该技术...

    一、前言

    该技术博客总结与狂神说SpringMVC课程

    二、什么是RestFul风格

    Restful就是一个资源定位、资源操作的风格。不是标准也不是协议,只是一种风格。基于这个风格设计的软件可以更简洁,更有层次,更易于实现缓存等机制。

    资源:互联网所有的事物都可以被抽象为资源
    资源操作:分为POST、DELETE、PUT、GET四种方法,使用不同方法对资源进行操作(增、删、改、查)
    在这里插入图片描述

    三、传统风格与RestFul风格对比

    1. 传统方式操作资源

    通过不同的参数来实现不同的效果!方法单一!

    http://127.0.0.1/item/queryItem.action?id=1 (查询,GET)
    http://127.0.0.1/item/saveItem.action (新增,POST)
    http://127.0.0.1/item/updateItem.action (更新,POST)
    http://127.0.0.1/item/deleteItem.action?id=1 (删除,GET或POST)

    2. RestFul方式操作资源

    可以通过不同的请求方式来实现不同的效果!
    如下:请求地址一样,但是功能可以不同!

    http://127.0.0.1/item/1 (查询,GET)
    http://127.0.0.1/item (新增,POST)
    http://127.0.0.1/item (更新,PUT)
    http://127.0.0.1/item/1 (删除,DELETE)

    四、RestFul代码演示

    1.代码展示

    在进行代码演示之前,需要配置好环境!

    首先导入依赖:

    <!--springmvc注解-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.1.9.RELEASE</version>
    </dependency>
    

    接着创建springmvc.xml配置文件:

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            https://www.springframework.org/schema/context/spring-context.xsd
            http://www.springframework.org/schema/mvc
            https://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
    
        <!-- 自动扫描指定的包,下面所有注解类交给IOC容器管理 -->
        <context:component-scan base-package="com.xu.controller"/>
        <!--处理器映射器 + 处理器适配器注入-->
        <mvc:annotation-driven />
    
        <!--视图解析器-->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/jsp/"/>
            <property name="suffix" value=".jsp"/>
        </bean>
    </beans>
    

    接着配置web.xml文件:

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
             http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
             version="4.0">
    
        <!--注册DispatcherServlet-->
        <servlet>
            <servlet-name>DispatcherServlet</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
            <!--关联一个springmvc配置文件:springmvc.xml-->
            <init-param>
                <param-name>contextConfigLocation</param-name>
                <param-value>classpath:springmvc.xml</param-value>
            </init-param>
            <!--启动级别:1-->
            <load-on-startup>1</load-on-startup>
        </servlet>
        <servlet-mapping>
            <servlet-name>DispatcherServlet</servlet-name>
            <url-pattern>/</url-pattern>
        </servlet-mapping>
    </web-app>
    

    然后在WEB-INF下创建jsp/test.jsp文件,用于接收值:

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>Test</title>
    </head>
    <body>
    ${msg}
    </body>
    </html>
    

    最后创建RestFulController类:

    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.servlet.ModelAndView;
    
    @Controller
    public class RestFulController {
        //映射访问路径
        @RequestMapping("/commit/{p1}/{p2}")
        //在SpringMVC中可以使用 @PathVariable,让方法参数的值对应绑定到一个URI模板变量上
        public ModelAndView index(@PathVariable int p1, @PathVariable int p2, ModelAndView mv){
            int result = p1 + p2;
            //实例化一个ModelAndView对象用于向视图中传值
            mv.addObject("msg","结果:" + result);
            //返回视图
            mv.setViewName("test");
            return mv;
        }
    }
    

    搭建好Tomcat服务器并运行,输入请求进行测试:
    在这里插入图片描述

    2.拓展情景

    通过路径变量的类型可以约束访问参数,如果类型不一样,则访问不到对应的请求方法,如果这里访问是的路径是 /commit/1/a,则路径与方法不匹配,而不会是参数转换失败。
    在这里插入图片描述
    解决方式:将RestFulController类中方法第二个参数类型改成String

    五、使用method属性指定请求类型

    用于约束请求的类型,可以收窄请求范围。
    指定请求谓词的类型如:GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE等

    代码展示:

    //在RestFulController类中增加一个方法
    //映射访问路径,必须是POST请求
    @RequestMapping(value = "/hello",method = {RequestMethod.POST})
    public String index2(Model model){
       model.addAttribute("msg", "hello!");
       return "test";
    }
    

    发送请求后,显示如下结果:
    在这里插入图片描述
    原因:我们使用浏览器地址栏进行访问默认是Get请求,会报错405!

    解决方式:将POST修改为GET就正常了

    //映射访问路径,必须是Get请求
    @RequestMapping(value = "/hello",method = {RequestMethod.GET})
    //我们一般采用这种方式:@GetMapping("/hello")
    public String index2(Model model){
       model.addAttribute("msg", "hello!");
       return "test";
    }
    

    成功显示!
    在这里插入图片描述

    六、总结

    所有的地址栏请求默认都会是GET类型的。

    针对章节五的问题,我们也可以通过组合注解来解决:

    @GetMapping:扮演的是@RequestMapping(method =RequestMethod.GET) 的快捷方式。
    @PostMapping
    @PutMapping
    @DeleteMapping
    @PatchMapping
    

    项目结构:
    在这里插入图片描述

    展开全文
  • 已集成自动生成代码工具mybatis-generator,swagger2 API界面,分页插件PageHelper,改一改数据库配置就可以直接拿来用了
  • ssm框架的完美整合,结合mysql数据库和restful风格的增删改查,其中restful是什么自行百度,这是我解决了许多问题,自行创建的第一个工程,其中的艰辛不足为外人道也。
  • 自己对RESTful风格的理解,和一个简单的demo的截图及配置描述。
  • RESTFUL风格规范

    2019-11-27 11:10:44
    现在项目都采用前后端分离开发,所以后端的接口遵循RESTFUL风格很重要。RESTful只是一种架构方式的约束,给出一种约定的标准,完全严格遵守RESTful标准并不是很多,也没有必要。但是在实际运用中,有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 57,022
精华内容 22,808
关键字:

resful风格