CODEWITHSUNDEEP
javaspringspring-bootspring-data-jpahateoas
Smajl
Smajl

Reputation: 8015

Navigating through HATEOAS with Spring client

We have an API which uses Spring JPA and provides access to some data in our database via REST. This API is exposed in a Hateoas fashion (we are using the Spring implementation).

We are now considering whether stick with this approach or code s=our own REST interface manually. Now, I have read a lot of articles about HATEOAS but I am not sure what's the big advantage of using it. Sure, I understand that I can navigate through it using links but I still have to know about the existence of the links at each level, right?

To illustrate my problem, let's say that I have the following structure:

server.com/
- /store
- /users/

server.com/users
- /managers/
- /other/

server.com/managers
- list of entities with ids

I want to consume this API and get all 'manager' entities (located under server.com/users/managers)

What is the correct way to do so when using Spring boot links?

Option one:

  RequestEntity<Void> request = RequestEntity.get("server.com/users/managers").accept(HAL_JSON).build();
  final Resource<Manager> managers = restTemplate.exchange(request, new ResourcesType<Manager>() {
        }).getBody();

Option two:

   // global endpoint
   RequestEntity<Void> request = RequestEntity.get("server.com").accept(HAL_JSON).build();
   final Resource<Object> rootLinks = restTemplate.exchange(request, new ResourceType<Object>() {
        }).getBody();

    Links links = new Links(rootLinks.getLinks());
    final Link userLink = links.getLink("users").expand();

    // users endpoint
    request = RequestEntity.get(URI.create(userLink.getHref())).accept(HAL_JSON).build();
    final Resource<Object> managerLinks = restTemplate.exchange(request, new ResourceType<Object>() {
        }).getBody();

    links = new Links(managerLinks.getLinks());
    final Link managerLink = links.getLink("managers").expand();

    // managers endpoint
    request = RequestEntity.get(URI.create(managerLink.getHref())).accept(HAL_JSON).build();
    final Resources<Manager> resourceAccounts = restTemplate.exchange(request, new ResourcesType<Manager>() {
        }).getBody();

The first option one seems straightforward and I can get all entities with single request. However, I fail to see hot Hateoas is beneficial if I just use this approach. Spring documentation states, that using hardcoded links is not recommended.

The second approach seems to be more in the Hateoas fashion but it creates three requests just to get to the resource which location I already know. That doesn't seem right either.

I know it's probably a dummy question but can somebody explain me what is the great idea behind Hateoas that I am clearly missing?

Upvotes: 4

Views: 994

Answers (1)

Denis
Denis

Reputation: 83

With HATEOAS server can guide a client through provided links. A contract between server and client is link's relation type and media type. A server can, by providing or not providing links on same resource representation, give client information if a resource is in a state where editing is enabled or not enabled or if a user is authorized for some operation on the resource and so on. A server can change URLs without breaking a contract.

Upvotes: 0

Related Questions