springboot2入门（4-starter-hateoas）

最新推荐文章于 2024-04-11 23:30:48 发布
最新推荐文章于 2024-04-11 23:30:48 发布
阅读量4.1k 收藏 4
点赞数
分类专栏： spring-boot2 文章标签： springboot hateoas restful
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tiaya/article/details/78408098
版权

Spring HATEOAS：方便创建满足HATEOAS规则的Spring REST应用的库。这样的REST应用，返回的资源满足HAL规范，不止包含了data，还包含了对相关资源的link，因此能在很大程度上解耦服务器端与客户端代码。

举个例子，请求以下资源：
http://localhost:8080/greeting

附带Hypermedia元素（link）的 JSON格式的响应资源类似这样：

{
  "content":"Hello, World!",
  "_links":{
    "self":{
      "href":"http://localhost:8080/greeting?name=World"
    }
  }
}

几个概念

  • REST：Representational state transfer
  • HATEOAS：Hypermedia as the Engine of Application State
  • HAL：Hypertxt Application Language

Richardson 提出的 REST 成熟度模型

该模型把 REST 服务按照成熟度划分成 4 个层次：

第一个层次（Level 0）的 Web 服务只是使用 HTTP 作为传输方式，实际上只是远程方法调用（RPC）的一种具体形式。SOAP 和 XML-RPC 都属于此类。

第二个层次（Level 1）的 Web 服务引入了资源的概念。每个资源有对应的标识符和表达。

第三个层次（Level 2）的 Web 服务使用不同的 HTTP 方法来进行不同的操作，并且使用 HTTP 状态码来表示不同的结果。如 HTTP GET 方法来获取资源，HTTP DELETE 方法来删除资源。

第四个层次（Level 3）的 Web 服务使用 HATEOAS。在资源的表达中包含了链接信息。客户端可以根据链接来发现可以执行的动作。

HATEOAS 约束

HATEOAS 是 REST 架构风格中最复杂的约束，也是构建成熟 REST 服务的核心。它的重要性在于打破了客户端和服务器之间严格的契约，使得客户端可以更加智能和自适应，而 REST 服务本身的演化和更新也变得更加容易。

从上述 REST 成熟度模型中可以看到，使用 HATEOAS 的 REST 服务是成熟度最高的，也是推荐的做法。对于不使用 HATEOAS 的 REST 服务，客户端和服务器的实现之间是紧密耦合的。客户端需要根据服务器提供的相关文档来了解所暴露的资源和对应的操作。当服务器发生了变化时，如修改了资源的 URI，客户端也需要进行相应的修改。而使用 HATEOAS 的 REST 服务中，客户端可以通过服务器提供的资源的表达来智能地发现可以执行的操作。当服务器发生了变化时，客户端并不需要做出修改，因为资源的 URI 和其他信息都是动态发现的。

HATEOAS 的核心是链接。链接的存在使得客户端可以动态发现其所能执行的动作。

开工

打开eclipse，建立maven工程，pom.xml如下：

<project
  xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.springframework</groupId>
  <artifactId>gs-hateoas-service</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <java.version>1.8</java.version>
  </properties>

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.0.M5</version>
  </parent>

  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-hateoas</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>com.jayway.jsonpath</groupId>
      <artifactId>json-path</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>

  <repositories>
    <repository>
      <id>spring-milestones</id>
      <name>Spring Milestones</name>
      <url>https://repo.spring.io/libs-milestone</url>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
    </repository>
  </repositories>
  <pluginRepositories>
    <pluginRepository>
      <id>spring-milestones</id>
      <name>Spring Milestones</name>
      <url>https://repo.spring.io/libs-milestone</url>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
    </pluginRepository>
  </pluginRepositories>
</project>

创建资源表现模型。Spring HATEOAS提供了一个基类ResourceSupport，允许我们添加Link对象，以返回符合HAL规范的JSON结果。

// src/main/java/hello/User.java
package hello;

import org.springframework.hateoas.ResourceSupport;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;

public class User extends ResourceSupport {

    private Integer uid;

    private final String code;

    private final String name;

    @JsonCreator
    public User(@JsonProperty("id") Integer uid, @JsonProperty("code") String code, @JsonProperty("name") String name) {
        this.uid = uid;
        this.code = code;
        this.name = name;
    }

    /**
     * @return the code
     */
    public String getCode() {
        return code;
    }

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /**
     * @return the id
     */
    public Integer getUid() {
        return uid;
    }

}
// src/main/java/hello/UserList.java
package hello;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.springframework.hateoas.ResourceSupport;

public class UserList extends ResourceSupport {

    private List<User> list;


    public UserList(Collection<User> users) {
        this.list = new ArrayList<User>();
        this.list.addAll(users);
    }

    /**
     * @return the code
     */
    public List<User> getUserList() {
        return list;
    }
}

接下来是 控制器等

// src/main/java/hello/UserController.java
package hello;

import static org.springframework.hateoas.mvc.ControllerLinkBuilder.linkTo;
import static org.springframework.hateoas.mvc.ControllerLinkBuilder.methodOn;

import java.util.Arrays;

import javax.websocket.server.PathParam;

import org.springframework.http.HttpEntity;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    @RequestMapping(method = RequestMethod.GET, value = "/user/list")
    public HttpEntity<UserList> list(@RequestParam(value = "name", required = false) String name) {

        User[] users = { new User(1, "jack", "jack T"), new User(2, "tom", "tom C") };
        UserList list = new UserList(Arrays.asList(users));

        list.add(linkTo(methodOn(UserController.class).list(name)).withSelfRel());
        list.add(linkTo(methodOn(UserController.class).get("")).withRel("get"));
        list.add(linkTo(methodOn(UserController.class).insert(null)).withRel("new"));
        list.add(linkTo(methodOn(UserController.class).update("")).withRel("update"));

        return new ResponseEntity<UserList>(list, HttpStatus.OK);
    }

    @RequestMapping(method = RequestMethod.GET, value = "/user/{id}")
    public HttpEntity<User> get(@PathParam(value = "uid") String uid) {

        User user = new User(1, "jack", "jack T");

        user.add(linkTo(methodOn(UserController.class).get(uid)).withSelfRel());
        user.add(linkTo(methodOn(UserController.class).insert(null)).withRel("new"));
        user.add(linkTo(methodOn(UserController.class).update(uid)).withRel("update"));
        user.add(linkTo(methodOn(UserController.class).list("")).withRel("collection"));

        return new ResponseEntity<User>(user, HttpStatus.OK);
    }

    @RequestMapping(method = RequestMethod.PUT, value = "/user/new")
    @ResponseStatus(HttpStatus.CREATED)
    public HttpEntity<User> insert(@RequestBody User auser) {
        String code = auser.getCode();
        String name = auser.getName();

        User user = new User(1000, code, name);

        user.add(linkTo(methodOn(UserController.class).insert(null)).withSelfRel());
        user.add(linkTo(methodOn(UserController.class).get("")).withRel("get"));
        user.add(linkTo(methodOn(UserController.class).update("")).withRel("update"));
        user.add(linkTo(methodOn(UserController.class).list("")).withRel("collection"));

        return new ResponseEntity<User>(user, HttpStatus.OK);
    }

    @RequestMapping(method = RequestMethod.PATCH, value = "/user/{id}")
    public HttpEntity<User> update(@PathParam(value = "uid") String uid) {

        User user = new User(1, "jack", "jack T");

        user.add(linkTo(methodOn(UserController.class).update(uid)).withSelfRel());
        user.add(linkTo(methodOn(UserController.class).get(uid)).withRel("get"));
        user.add(linkTo(methodOn(UserController.class).insert(null)).withRel("new"));
        user.add(linkTo(methodOn(UserController.class).list("")).withRel("collection"));

        return new ResponseEntity<User>(user, HttpStatus.OK);
    }
}

最后是启动类

// src/main/java/hello/App.java
package hello;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

/**
 * Hello world!
 */
@SpringBootApplication
public class App extends SpringBootServletInitializer {
    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }
}

查看效果

maven spring-boot:run 启动服务端

使用curl访问服务器：

$ curl http://localhost:8080/user/list
{
  "userList" : [ {
    "id" : 1,
    "code" : "jack",
    "name" : "jack T"
  }, {
    "id" : 2,
    "code" : "tom",
    "name" : "tom C"
  } ],
  "_links" : {
    "self" : {
      "href" : "http://localhost:8080/user/list{?name}",
      "templated" : true
    },
    "get" : {
      "href" : "http://localhost:8080/user/{id}",
      "templated" : true
    },
    "new" : {
      "href" : "http://localhost:8080/user/new"
    },
    "update" : {
      "href" : "http://localhost:8080/user/{id}",
      "templated" : true
    }
  }
}
$ curl -X PUT -H 'content-type: application/json' -d '{"code":"TestAddCode"}' http://localhost:8080/user/new

{
    "id": 1000,
    "code": "TestAddCode",
    "name": null,
    "_links": {
        "self": {
            "href": "http://localhost:8080/user/new"
        },
        "get": {
            "href": "http://localhost:8080/user/{id}",
            "templated": true
        },
        "update": {
            "href": "http://localhost:8080/user/{id}",
            "templated": true
        },
        "collection": {
            "href": "http://localhost:8080/user/list?name="
        }
    }
}

接下来的任务

spring-boot-starter-data-jpa
spring-boot-starter-data-rest

相关文章

spring hateoas项目
http://projects.spring.io/spring-hateoas/

spring guides
https://spring.io/guides/gs/rest-hateoas/

使用 Spring HATEOAS 开发 REST 服务
https://www.ibm.com/developerworks/cn/java/j-lo-SpringHATEOAS/index.html

REST 成熟度模型
https://www.crummy.com/writing/speaking/2008-QCon/act3.html

HAL规范
http://stateless.co/hal_specification.html

郑文君
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot之:SpringBoot中使用HATEOAS
m0_69860228的博客
05-11 361
HATEOAS是实现REST规范的一种原则，通过遵循HATEOAS规范，可以解决我们实际代码实现的各种个问题。作为java最流行的框架Spring 当然也会不缺席HATEOAS的集成。 本文将会通过一个具体的例子来讲解如何在SpringBoot中使用HATEOAS。 我们的目标 HATEOAS规则中，返回的数据会带有链接。我们以熟悉的Book为例，来展示这次的HATEOAS，首先创建一个Book entity： @Data @Entity public class Book { @Id
Spring boot（六）之Spring HATEOAS构建超媒体驱动的 RESTful Web 服务
子时不睡的博客
08-25 422
Springboot（六）之构建超媒体驱动的 RESTful Web 服务 前言 超媒体是 REST 的一个重要方面。它让你构建服务，在很大程度上解耦客户端和服务器，让它们独立发展。为 REST 资源返回的表示不仅包含数据，还包含指向相关资源的链接。因此，表示的设计对于整体服务的设计至关重要。服务处理GET请求http://localhost:8080/greeting时，Json响应如下 { "content":"Hello, World!", "_links":{ "self":{
腾讯春招内幕：2024最全Spring HATEOAS面试题解析，含实战示例！99%的开发者已经收藏！
最新发布
Von_016's Blog
04-11 722
虽然HAL是一种流行的超媒体格式，但在某些情况下，你可能需要使用自定义媒体类型来满足特定的业务需求。在Spring HATEOAS中，你可以通过扩展现有的来创建自定义的资源表示，然后通过配置来支持自定义媒体类型的序列化和反序列化。自定义媒体类型的创建和使用涉及到Spring MVC的更深层次内容，需要对内容协商机制有较深的理解。
SpringBoot(三)
拾荒人博客
03-23 704
1.POM文件解析 1.1父项目 项目需要依赖的父项目【spring‐boot‐starter‐parent】 【spring‐boot‐starter‐parent】依赖于【 spring-boot-dependencies】 <!-- 存放项目需要的所有依赖 --> <properties> <activemq.version>5.16.4</activemq.version> <antlr2.version>
SPRING实战(3)、超媒体与Spring HATEOAS之一
u010105645的专栏
06-23 1005
超媒体作为应用状态引擎（Hypermedia as the Engine of Application State，HATEOAS）是一种创建自描述API的方式。API所返回的资源中会包含相关资源的链接，客户端只需要了解最少的API URL信息就能导航整个API。如果API启用了超媒体功能，那么API将会描述自己的URL，从而减轻客户端对其进行硬编码的痛苦。这种特殊风格的HATEOAS被称为HAL（超文本应用语言，Hypertext Application Language），这是一种在JSON响应中嵌入超
SpringBoot之：SpringBoot的HATEOAS基础
m0_67261762的博客
05-17 273
简介 SpringBoot提供了HATEOAS的便捷使用方式，前面一篇文章我们也讲了如何在SpringBoot中使用HATEOAS。本文将会对这些内容进行扩展深入，详细讲解SpringBoot提供的这些基本方法。 链接Links HATEOAS的一个非常重要的特征就是在resources资源中包含超媒体，而超媒体最简单的表示就是链接。 Spring HATEOAS为我们简化了封装Links的功能。 我们看一个HTML中的link标签的例子： <head> <link rel=
springboot-starter-gemini 一个基于gemini提供的springboot sdk
02-22
《SpringBoot-Starter-Gemini：开启人工智能新篇章》 在当今快速发展的信息技术领域，SpringBoot以其简洁、高效、易用的特性，已经成为Java开发者构建Web应用的首选框架。而SpringBoot-Starter-Gemini，正是在...
netty-spring-boot-starter:Netty与Spring Boot集成
03-19
netty-spring-boot-starter 基于Netty的Spring Boot Starter工程。 介绍 支持TCP长连接消息转发到Spring容器 支持自定义消息枚举类（ CommandController ， CommandMapping ） 支持自定义通信协议解析（ ...
canal-spring-boot-starter：springboot运河支持
02-13
《SpringBoot与Canal的深度整合：canal-spring-boot-starter详解》 在现代的互联网开发中，数据同步和实时处理是不可或缺的部分。Canal作为阿里巴巴开源的一个数据库 binlog 捕获组件，能够实现MySQL数据库的实时...
xss-filter-spring-boot-starter:springboot自动xss
05-17
springboot自动xss 使用方法在项目的pom.xml中加入依赖即口 <groupId>com.djk</groupId> <artifactId>xss-filter-spring-boot-starter <version>0.0.1 目前支持3种入参数xss过滤 @RequestMapping("/test1") ...
springboot-jwt-starter：用于无状态和基于令牌的身份验证应用程序的Spring Boot JWT入门工具包
01-29
_ _ _ _ _ _ _ ___ _ __ _ __(_)_ __ __ _| |__ ___ ___ | |_ (_)_ _| |_ ___| |_ __ _ _ __| |_ ___ _ __ / __| '_ \| '__| | '_ \ / _` | '_ \ / _ \ / _ \| __| | \ \ /\ / / __| / __| __/ _` | '__| __/ _ \ '...
SpringBoot HATEOAS用法简介(入门)
08-25
主要介绍了SpringBoot HATEOAS用法简介(入门)，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
初识Spring HATEOAS
I_forever的专栏
06-09 2458
REST 这个词想必大家都并不陌生。REST 架构REST 是 Representational state transfer 的缩写，翻译过来的意思是表达性状态转换。REST 是一种架构风格，它包含了一个分布式超文本系统中对于组件、连接器和数据的约束。其关键在于所定义的架构上的各种约束。只有满足这些约束，才能称之为符合 REST 架构风格。REST 的约束包括：  客户端-服务器结构。通过一个统...
spring-boot-starter-actuator（健康监控）配置和使用
热门推荐
yangliuhbhd的博客
06-12 3万+
spring-boot-starter-actuator（健康监控）配置和使用添加POM依赖： &lt;!-- spring-boot-监控--&gt; &lt;dependency&gt;    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;    &lt;artifactId&gt;spring-boot-starter-ac...
Spring boot—— Starter详解
u012369153的专栏
12-09 1万+
Starter POMs
<artifactId>spring-boot-starter-hateoas</artifactId>
BLOG域名:programb.blog.csdn.net
05-07 286
开发策略 总体原则：不同的微服务需进行物理隔离。 1、SVN策略：SVN上创建独立的分支，不同微服务的代码提交不受相互影响； 由配置管理员统一控制。 问题：开发分支与集成分支，都将增加很多，维护工作量增加。 2、编译策略：代码编译时，各个微服务独立编译、打包，杜绝直接的依赖； 3、工程构建：代码开发时，各微服务创建独立的工程，工程之间不能产生直接依赖 4、持续集成：每个微服务独立执行持续集成。 5...
spring hateoas初体验
Hello World ^—^
09-29 2万+
前一段时间学习工作流偶然接触到了hateoas，感觉比较有意思，虽然用的不是那么多，但是加强了自己对restful的理解。 hateoas简介 HATEOAS是Hypertext As The Engine Of Application State的缩写。在Richardson Maturity Model中, 它是REST的最高级形态。 在介绍 HATEOAS 之前，先介绍一下 Richards...
SpringBoot2.0深度实践学习手记
weixin_34306593的博客
10-10 345
SpringBoot易学 组件自动装配：规约大于配置，专注于核心业务外部化配置：一次构建、按需调配，到处运行 嵌入式容器：内置容器、无需部署、独立运行 Spring Boot Starter : 简化依赖、按需装配、自我包容 Production-Ready : 一站式运维、生态无缝整合 SpringBoot难精 组件自动装配：模式注解...
使用 Spring HATEOAS 开发 REST 服务
weixin_34232617的博客
07-11 413
2019独角兽企业重金招聘Python工程师标准>>> ...
springboot druid-spring-boot-starter
12-02
`druid-spring-boot-starter`是一个用于在Spring Boot应用程序中集成Druid连接池的Starter。Druid是一个高性能的JDBC连接池，具有监控和扩展功能。使用`druid-spring-boot-starter`可以轻松地将Druid连接池集成到...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值