REST 的 HATEOAS 原则
了解并在 REST API 中应用超媒体作为应用状态引擎（HATEOAS）。
REST 的 HATEOAS 原则 是 CoddyKit 上的免费 Spring Boot 4 Microservices & REST APIs 课时。 这是第 3 节课，共 3 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Spring Boot 4 Microservices & REST APIs 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Spring Boot 4 Microservices & REST APIs 课程共包含 3 节课。
本课时的部分内容尚未翻译，以英文显示。
HATEOAS Unpacked
HATEOAS stands for Hypermedia as the Engine of Application State. It's a core constraint of RESTful architecture that suggests an API should guide clients through available actions using hypermedia links.
Think of it like a website: you navigate by clicking links, not by typing URLs from memory. HATEOAS brings this same idea to APIs.
Benefits of HATEOAS
HATEOAS makes your API more discoverable and evolvable. Instead of hardcoding URLs, clients discover available actions directly from the API's responses.
- Client Independence: Clients don't need to know URL structures beforehand.
- API Evolution: You can change URL paths without breaking clients, as long as the link relation names ("rel") remain consistent.
- Self-Documentation: Responses inherently describe what actions can be taken next.
Hypermedia as State Engine
The 'Engine of Application State' means that the client transitions between application states (e.g., from viewing a user to viewing their orders) by selecting links within the hypermedia response.
The API response doesn't just return data; it returns data PLUS instructions (links) on what you can do with that data or where you can go next.
Introducing Spring HATEOAS
Implementing HATEOAS manually can be verbose. Thankfully, Spring Boot provides the Spring HATEOAS library to simplify adding links to your REST resources.
It offers classes like EntityModel, CollectionModel, and WebMvcLinkBuilder to make link creation intuitive and robust.
Your First Self-Link
Let's start by adding a 'self' link to a single user resource. This link points back to the resource itself, allowing clients to easily retrieve its current state.
We use EntityModel to wrap our data and WebMvcLinkBuilder to construct the link.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.hateoas.EntityModel;
import org.springframework.hateoas.server.mvc.WebMvcLinkBuilder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import static org.springframework.hateoas.server.mvc.WebMvcLinkBuilder.linkTo;
import static org.springframework.hateoas.server.mvc.WebMvcLinkBuilder.methodOn;
@SpringBootApplication
public class SelfLinkApp {
public static void main(String[] args) {
SpringApplication.run(SelfLinkApp.class, args);
}
}
class User {
private Long id;
private String name;
public User(Long id, String name) {
this.id = id; this.name = name;
}
public Long getId() { return id; }
public String getName() { return name; }
public void setId(Long id) { this.id = id; }
public void setName(String name) { this.name = name; }
}
@RestController
class UserController {
@GetMapping("/users/{id}")
public EntityModel<User> getUser(@PathVariable Long id) {
User user = new User(id, "Alice"); // Dummy user
EntityModel<User> resource = EntityModel.of(user);
// Add a "self" link
resource.add(linkTo(methodOn(this.getClass()).getUser(id))
.withSelfRel());
return resource;
}
}`EntityModel` & `Link` Deep Dive
When you use Spring HATEOAS, your API responses will typically return objects like EntityModel or CollectionModel.
EntityModel<T>: A wrapper for a single domain object (like ourUser), allowing you to add links to it.Link: Represents a hyperlink, containing a URI and a relation name (e.g., 'self', 'orders').
The client then parses these links to navigate the API.
Linking to Related Resources
Beyond 'self' links, you can add links to related resources. For instance, a user resource might include a link to their orders.
We use withRel("relationName") to define the relationship between the current resource and the linked resource.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.hateoas.EntityModel;
import org.springframework.hateoas.server.mvc.WebMvcLinkBuilder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import static org.springframework.hateoas.server.mvc.WebMvcLinkBuilder.linkTo;
import static org.springframework.hateoas.server.mvc.WebMvcLinkBuilder.methodOn;
@SpringBootApplication
public class RelatedLinkApp {
public static void main(String[] args) {
SpringApplication.run(RelatedLinkApp.class, args);
}
}
class User { // Re-using User class
private Long id; private String name;
public User(Long id, String name) {
this.id = id; this.name = name;
}
public Long getId() { return id; }
public String getName() { return name; }
public void setId(Long id) { this.id = id; }
public void setName(String name) { this.name = name; }
}
@RestController
class UserController {
@GetMapping("/users/{id}")
public EntityModel<User> getUser(@PathVariable Long id) {
User user = new User(id, "Bob");
EntityModel<User> resource = EntityModel.of(user);
resource.add(linkTo(methodOn(this.getClass()).getUser(id))
.withSelfRel());
// Add link to user's orders
resource.add(linkTo(methodOn(this.getClass()).getUserOrders(id))
.withRel("orders")); // Define relation
return resource;
}
@GetMapping("/users/{id}/orders")
public String getUserOrders(@PathVariable Long id) {
return "Orders for user " + id; // Dummy endpoint
}
}`WebMvcLinkBuilder` Magic
WebMvcLinkBuilder is crucial for HATEOAS in Spring. It allows you to create links by directly referencing your controller methods, rather than hardcoding URL strings.
This makes your links type-safe and automatically updates them if you refactor your controller's path or method names, making your API more robust.
HATEOAS for Collections
When returning a list of items, you should use CollectionModel. Each item in the collection can have its own self-link, and the collection itself can have a self-link (e.g., to the list endpoint).
This allows clients to navigate to individual items from a list, or to refresh the entire collection.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.hateoas.CollectionModel;
import org.springframework.hateoas.EntityModel;
import org.springframework.hateoas.server.mvc.WebMvcLinkBuilder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
import java.util.stream.Collectors;
import java.util.Arrays;
import static org.springframework.hateoas.server.mvc.WebMvcLinkBuilder.linkTo;
import static org.springframework.hateoas.server.mvc.WebMvcLinkBuilder.methodOn;
@SpringBootApplication
public class CollectionHateoasApp {
public static void main(String[] args) {
SpringApplication.run(CollectionHateoasApp.class, args);
}
}
class User { // Re-using User class
private Long id; private String name;
public User(Long id, String name) {
this.id = id; this.name = name;
}
public Long getId() { return id; }
public String getName() { return name; }
public void setId(Long id) { this.id = id; }
public void setName(String name) { this.name = name; }
}
@RestController
class UserController {
private List<User> users = Arrays.asList(
new User(1L, "Charlie"),
new User(2L, "David")
);
@GetMapping("/users")
public CollectionModel<EntityModel<User>> getAllUsers() {
List<EntityModel<User>> userResources = users.stream()
.map(user -> EntityModel.of(user,
linkTo(methodOn(this.getClass()).getUser(user.getId()))
.withSelfRel()))
.collect(Collectors.toList());
return CollectionModel.of(userResources,
linkTo(methodOn(this.getClass()).getAllUsers())
.withSelfRel()); // Link for the collection
}
// Need a getUser method for the link builder to reference
@GetMapping("/users/{id}")
public EntityModel<User> getUser(@PathVariable Long id) {
return EntityModel.of(new User(id, "Dummy"),
linkTo(methodOn(this.getClass()).getUser(id)).withSelfRel());
}
}HATEOAS Quick Check
Which of the following are key benefits of applying HATEOAS principles to a REST API?
HATEOAS Recap & Next
Great job! You've learned about HATEOAS and how it makes REST APIs more discoverable and evolvable by embedding hypermedia links in responses.
- HATEOAS: Hypermedia as the Engine of Application State.
- Spring HATEOAS: Provides tools like
EntityModel,CollectionModel, andWebMvcLinkBuilder. - Links: Guide clients through API interactions, reducing hardcoding.
By applying HATEOAS, you create truly RESTful APIs that are more robust and easier for clients to consume over time.
用 AI 导师学习 Java — 免费
在浏览器中编写并运行真实代码，获得全天候 AI 导师的即时帮助，并在网页或应用中继续学习。
- 课程
- 24
- 课程
- 93
常见问题解答
「REST 的 HATEOAS 原则」课时是免费的吗？
是的 — 「REST 的 HATEOAS 原则」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Spring Boot 4 Microservices & REST APIs 课程的其余内容，请升级到 CoddyKit PRO。 Spring Boot 4 Microservices & REST APIs 课程共包含 3 节课。
「REST 的 HATEOAS 原则」这节课中我会学到什么？
了解并在 REST API 中应用超媒体作为应用状态引擎（HATEOAS）。 你通过在浏览器中直接运行的动手代码来练习 Spring Boot 4 Microservices & REST APIs，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 Spring Boot 4 Microservices & REST APIs 需要有经验吗？
无需任何先前经验。CoddyKit 上的 Spring Boot 4 Microservices & REST APIs 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 3 节课，共 3 节。
「REST 的 HATEOAS 原则」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 Spring Boot 4 Microservices & REST APIs 课中编写并运行代码吗？
能。每节 Spring Boot 4 Microservices & REST APIs 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。