Поддержка встроенных ресурсов Spring HATEOAS

Question

Поддержка встроенных ресурсов Spring HATEOAS

Я хочу использовать формат HAL для моего REST API для включения встроенных ресурсов. Я использую Spring HATEOAS для своих API, и Spring HATEOAS поддерживает встроенные ресурсы; однако, нет документации или примера того, как это использовать.

Может кто-нибудь привести пример использования Spring HATEOAS для включения встроенных ресурсов?

54

java spring spring-hateoas

Источник

user390227 15 сен '14 в 23:57

6 ответов

Другие вопросы по тегам java spring spring-hateoas

user1245622 15 май '16 в 09:48 2016-05-15 09:48 · Answer 1 · 2016-05-15 09:48

Обязательно прочитайте документацию Spring о HATEOAS, это поможет понять основы.

В этом ответе основной разработчик указывает на концепцию Resource, Resources а также PagedResources что-то существенное, что не указано в документации.

Мне потребовалось некоторое время, чтобы понять, как это работает, поэтому давайте рассмотрим несколько примеров, чтобы сделать его кристально ясным.

Возврат одного ресурса

ресурс

import org.springframework.hateoas.ResourceSupport;


public class ProductResource extends ResourceSupport{
    final String name;

    public ProductResource(String name) {
        this.name = name;
    }
}

контроллер

import org.springframework.hateoas.Link;
import org.springframework.hateoas.Resource;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {
    @RequestMapping("products/{id}", method = RequestMethod.GET)
    ResponseEntity<Resource<ProductResource>> get(@PathVariable Long id) {
        ProductResource productResource = new ProductResource("Apfelstrudel");
        Resource<ProductResource> resource = new Resource<>(productResource, new Link("http://example.com/products/1"));
        return ResponseEntity.ok(resource);
    }
}

ответ

{
    "name": "Apfelstrudel",
    "_links": {
        "self": { "href": "http://example.com/products/1" }
    }
}

Возврат нескольких ресурсов

Spring HATEOAS поставляется со встроенной поддержкой, которая используется Resources отражать ответ с несколькими ресурсами.

    @RequestMapping("products/", method = RequestMethod.GET)
    ResponseEntity<Resources<Resource<ProductResource>>> getAll() {
        ProductResource p1 = new ProductResource("Apfelstrudel");
        ProductResource p2 = new ProductResource("Schnitzel");

        Resource<ProductResource> r1 = new Resource<>(p1, new Link("http://example.com/products/1"));
        Resource<ProductResource> r2 = new Resource<>(p2, new Link("http://example.com/products/2"));

        Link link = new Link("http://example.com/products/");
        Resources<Resource<ProductResource>> resources = new Resources<>(Arrays.asList(r1, r2), link);

        return ResponseEntity.ok(resources);
    }

ответ

{
    "_links": {
        "self": { "href": "http://example.com/products/" }
    },
    "_embedded": {
        "productResources": [{
            "name": "Apfelstrudel",
            "_links": {
                "self": { "href": "http://example.com/products/1" }
            }, {
            "name": "Schnitzel",
            "_links": {
                "self": { "href": "http://example.com/products/2" }
            }
        }]
    }
}

Если вы хотите изменить ключ productResources вам нужно аннотировать ваш ресурс:

@Relation(collectionRelation = "items")
class ProductResource ...

Возврат ресурса со встроенными ресурсами

Это когда вам нужно начать сутенерство Spring. HALResource представленный @chris-damour в другом ответе подходит идеально.

public class OrderResource extends HalResource {
    final float totalPrice;

    public OrderResource(float totalPrice) {
        this.totalPrice = totalPrice;
    }
}

контроллер

    @RequestMapping(name = "orders/{id}", method = RequestMethod.GET)
    ResponseEntity<OrderResource> getOrder(@PathVariable Long id) {
        ProductResource p1 = new ProductResource("Apfelstrudel");
        ProductResource p2 = new ProductResource("Schnitzel");

        Resource<ProductResource> r1 = new Resource<>(p1, new Link("http://example.com/products/1"));
        Resource<ProductResource> r2 = new Resource<>(p2, new Link("http://example.com/products/2"));
        Link link = new Link("http://example.com/order/1/products/");

        OrderResource resource = new OrderResource(12.34f);
        resource.add(new Link("http://example.com/orders/1"));

        resource.embed("products", new Resources<>(Arrays.asList(r1, r2), link));

        return ResponseEntity.ok(resource);
    }

ответ

{
    "_links": {
        "self": { "href": "http://example.com/products/1" }
    },
    "totalPrice": 12.34,
    "_embedded": {
        "products":     {
            "_links": {
                "self": { "href": "http://example.com/orders/1/products/" }
            },
            "_embedded": {
                "items": [{
                    "name": "Apfelstrudel",
                    "_links": {
                        "self": { "href": "http://example.com/products/1" }
                    }, {
                    "name": "Schnitzel",
                    "_links": {
                        "self": { "href": "http://example.com/products/2" }
                    }
                }]
            }
        }
    }
}

user442773 16 сен '14 в 17:07 2014-09-16 17:07 · Answer 2 · 2014-09-16 17:07

Я не мог найти официальный способ сделать это... вот что мы сделали

public abstract class HALResource extends ResourceSupport {

    private final Map<String, ResourceSupport> embedded = new HashMap<String, ResourceSupport>();

    @JsonInclude(Include.NON_EMPTY)
    @JsonProperty("_embedded")
    public Map<String, ResourceSupport> getEmbeddedResources() {
        return embedded;
    }

    public void embedResource(String relationship, ResourceSupport resource) {

        embedded.put(relationship, resource);
    }  
}

затем заставил наши ресурсы расширить HALResource

user2081626 13 мар '15 в 18:07 2015-03-13 18:07 · Answer 3 · 2015-03-13 18:07

Вот небольшой пример того, что мы нашли. В первую очередь мы используем spring-hateoas-0.16

Изображения у нас есть GET /profile это должно вернуть профиль пользователя со встроенным списком писем.

У нас есть ресурс электронной почты.

@Data
@JsonIgnoreProperties(ignoreUnknown = true)
@Relation(value = "email", collectionRelation = "emails")
public class EmailResource {
    private final String email;
    private final String type;
}

два электронных письма, которые мы хотим включить в ответ профиля

Resource primary = new Resource(new Email("neo@matrix.net", "primary"));
Resource home = new Resource(new Email("t.anderson@matrix.net", "home"));

Чтобы указать, что эти ресурсы встроены, нам нужен экземпляр EmbeddedWrappers:

import org.springframework.hateoas.core.EmbeddedWrappers
EmbeddedWrappers wrappers = new EmbeddedWrappers(true);

С помощью wrappers мы можем создать EmbeddedWrapper экземпляр для каждого письма и положить их в список.

List<EmbeddedWrapper> embeddeds = Arrays.asList(wrappers.wrap(primary), wrappers.wrap(home))

Осталось только создать ресурс нашего профиля с этими вложениями. В приведенном ниже примере я использую lombok для сокращения кода.

@Data
@Relation(value = "profile")
public class ProfileResource {
    private final String firstName;
    private final String lastName;
    @JsonUnwrapped
    private final Resources<EmbeddedWrapper> embeddeds;
}

Имейте в виду аннотацию @JsonUnwrapped на встроенном поле

И мы готовы вернуть все это из контроллера

...
Resources<EmbeddedWrapper> embeddedEmails = new Resources(embeddeds, linkTo(EmailAddressController.class).withSelfRel());
return ResponseEntity.ok(new Resource(new ProfileResource("Thomas", "Anderson", embeddedEmails), linkTo(ProfileController.class).withSelfRel()));
}

Теперь в ответе мы будем иметь

{
"firstName": "Thomas",
"lastName": "Anderson",
"_links": {
    "self": {
        "href": "http://localhost:8080/profile"
    }
},
"_embedded": {
    "emails": [
        {
            "email": "neo@matrix.net",
            "type": "primary"
        },
        {
            "email": "t.anderson@matrix.net",
            "type": "home"
        }
    ]
}
}

Интересная часть в использовании Resources<EmbeddedWrapper> embeddeds в том, что вы можете поместить в него различные ресурсы, и он автоматически сгруппирует их по отношениям. Для этого мы используем аннотацию @Relation от org.springframework.hateoas.core пакет.

Также есть хорошая статья о встроенных ресурсах в HAL

user157591 29 сен '15 в 15:37 2015-09-29 15:37 · Answer 4 · 2015-09-29 15:37

Обычно HATEOAS требует создания POJO, который представляет выходные данные REST и расширяет предоставляемый HATEOAS ResourceSupport. Это можно сделать без создания дополнительного POJO и использовать классы Resource, Resources и Link напрямую, как показано в коде ниже:

@RestController
class CustomerController {

    List<Customer> customers;

    public CustomerController() {
        customers = new LinkedList<>();
        customers.add(new Customer(1, "Peter", "Test"));
        customers.add(new Customer(2, "Peter", "Test2"));
    }

    @RequestMapping(value = "/customers", method = RequestMethod.GET, produces = "application/hal+json")
    public Resources<Resource> getCustomers() {

        List<Link> links = new LinkedList<>();
        links.add(linkTo(methodOn(CustomerController.class).getCustomers()).withSelfRel());
        List<Resource> resources = customerToResource(customers.toArray(new Customer[0]));

        return new Resources<>(resources, links);

    }

    @RequestMapping(value = "/customer/{id}", method = RequestMethod.GET, produces = "application/hal+json")
    public Resources<Resource> getCustomer(@PathVariable int id) {

        Link link = linkTo(methodOn(CustomerController.class).getCustomer(id)).withSelfRel();

        Optional<Customer> customer = customers.stream().filter(customer1 -> customer1.getId() == id).findFirst();

        List<Resource> resources = customerToResource(customer.get());

        return new Resources<Resource>(resources, link);

    }

    private List<Resource> customerToResource(Customer... customers) {

        List<Resource> resources = new ArrayList<>(customers.length);

        for (Customer customer : customers) {
            Link selfLink = linkTo(methodOn(CustomerController.class).getCustomer(customer.getId())).withSelfRel();
            resources.add(new Resource<Customer>(customer, selfLink));
        }

        return resources;
    }
}

user6166627 24 янв '18 в 05:26 2018-01-24 05:26 · Answer 5 · 2018-01-24 05:26

Объединяя ответы выше, я сделал намного более легкий подход:

return resWrapper(domainObj, embeddedRes(domainObj.getSettings(), "settings"))

Это пользовательский служебный класс (см. Ниже). Замечания:

Второй аргумент resWrapper принимает ... из embeddedRes звонки.
Вы можете создать другой метод, который опускает отношение String внутри resWrapper,
Первый аргумент embeddedRes является Objectтак что вы также можете предоставить экземпляр ResourceSupport
Результат выражения имеет тип, который расширяет Resource<DomainObjClass>, Итак, он будет обрабатываться всеми Spring Data REST ResourceProcessor<Resource<DomainObjClass>>, Вы можете создать коллекцию из них, а также обернуть вокруг new Resources<>(),

Создайте служебный класс:

import com.fasterxml.jackson.annotation.JsonUnwrapped;
import java.util.Arrays;
import org.springframework.hateoas.Link;
import org.springframework.hateoas.Resource;
import org.springframework.hateoas.Resources;
import org.springframework.hateoas.core.EmbeddedWrapper;
import org.springframework.hateoas.core.EmbeddedWrappers;

public class ResourceWithEmbeddable<T> extends Resource<T> {

    @SuppressWarnings("FieldCanBeLocal")
    @JsonUnwrapped
    private Resources<EmbeddedWrapper> wrappers;

    private ResourceWithEmbeddable(final T content, final Iterable<EmbeddedWrapper> wrappers, final Link... links) {

        super(content, links);
        this.wrappers = new Resources<>(wrappers);
    }


    public static <T> ResourceWithEmbeddable<T> resWrapper(final T content,
                                                           final EmbeddedWrapper... wrappers) {

        return new ResourceWithEmbeddable<>(content, Arrays.asList(wrappers));

    }

    public static EmbeddedWrapper embeddedRes(final Object source, final String rel) {
        return new EmbeddedWrappers(false).wrap(source, rel);
    }
}

Вам нужно только включить import static package.ResourceWithEmbeddable.* к вашему классу обслуживания, чтобы использовать его.

JSON выглядит так:

{
    "myField1": "1field",
    "myField2": "2field",
    "_embedded": {
        "settings": [
            {
                "settingName": "mySetting",
                "value": "1337",
                "description": "umh"
            },
            {
                "settingName": "other",
                "value": "1488",
                "description": "a"
            },...
        ]
    }
}

user6166627 27 мар '19 в 14:08 2019-03-27 14:08 · Answer 6 · 2019-03-27 14:08

Spring предоставит застройщика https://github.com/spring-projects/spring-hateoas/issues/864

0

Источник

user6166627 27 мар '19 в 14:08

user11277996 29 мар '19 в 14:19 2019-03-29 14:19 · Answer 7 · 2019-03-29 14:19

Вот как я построил такой JSON с Spring-Boot-Starter-Hateoas 2.1.1:

{
    "total": 2,
    "count": 2,
    "_embedded": {
        "contacts": [
            {
                "id": "1-1CW-303",
                "role": "ASP",
                "_links": {
                    "self": {
                        "href": "http://localhost:8080/accounts/2700098669/contacts/1-1CW-303"
                    }
                }
            },
            {
                "id": "1-1D0-267",
                "role": "HSP",
                "_links": {
                    "self": {
                        "href": "http://localhost:8080/accounts/2700098669/contacts/1-1D0-267"
                    }
                }
            }
        ]
    },
    "_links": {
        "self": {
            "href": "http://localhost:8080/accounts/2700098669/contacts?limit=2&page=1"
        },
        "first": {
            "href": "http://localhost:8080/accounts/2700098669/contacts?limit=2&page=1"
        },
        "last": {
            "href": "http://localhost:8080/accounts/2700098669/contacts?limit=2&page=1"
        }
    }
}

Основной класс, который инкапсулирует все эти поля:

public class ContactsResource extends ResourceSupport{
    private long count;
    private long total;
    private final Resources<Resource<SimpleContact>> contacts;

    public long getTotal() {
        return total;
    }

    public ContactsResource(long total, long count, Resources<Resource<SimpleContact>> contacts){
        this.contacts = contacts;
        this.total = total;
        this.count = count;
    }

    public long getCount() {
        return count;
    }

    @JsonUnwrapped
    public Resources<Resource<SimpleContact>> getContacts() {
        return contacts;
    }
}

SimpleContact имеет информацию об одном контакте, и это просто pojo

@Relation(value = "contact", collectionRelation = "contacts")
public class SimpleContact {
    private String id;
    private String role;

    public String getId() {
        return id;
    }

    public SimpleContact id(String id) {
        this.id = id;
        return this;
    }

    public String getRole() {
        return role;
    }

    public SimpleContact role(String role) {
        this.role = role;
        return this;
    }
}

И создание ContactsResource:

public class ContactsResourceConverter {

    public static ContactsResource toResources(Page<SimpleContact> simpleContacts, Long accountId){

        List<Resource<SimpleContact>> embeddeds = simpleContacts.stream().map(contact -> {
            Link self = linkTo(methodOn(AccountController.class).getContactById(accountId, contact.getId())).
                    withSelfRel();
            return new Resource<>(contact, self);
        }
        ).collect(Collectors.toList());

        List<Link> listOfLinks = new ArrayList<>();
        //self link
        Link selfLink = linkTo(methodOn(AccountController.class).getContactsForAccount(
                accountId,
                simpleContacts.getPageable().getPageSize(),
                simpleContacts.getPageable().getPageNumber() + 1)) // +1 because of 0 first index
                .withSelfRel();
        listOfLinks.add(selfLink);

        ... another links           

        Resources<Resource<SimpleContact>> resources = new Resources<>(embeddeds);
        ContactsResource contactsResource = new ContactsResource(simpleContacts.getTotalElements(), simpleContacts.getNumberOfElements(), resources);
        contactsResource.add(listOfLinks);

        return contactsResource;
    }
}

И я просто называю это так из контроллера:

return new ResponseEntity<>(ContactsResourceConverter.toResources(simpleContacts, accountId), HttpStatus.OK);

user6011410 23 апр '19 в 17:09 2019-04-23 17:09 · Answer 8 · 2019-04-23 17:09

Добавьте эту зависимость в вашу пом. Проверьте эту ссылку: https://www.baeldung.com/spring-rest-hal

<dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-rest-hal-browser</artifactId>
</dependency>

Это изменит ваш ответ, как это.

"_links": {
    "next": {
        "href": "http://localhost:8082/mbill/user/listUser?extra=ok&page=11"
    }
}

0

Источник

user6011410 23 апр '19 в 17:09

user7909340 09 ноя '18 в 09:23 2018-11-09 09:23 · Answer 9 · 2018-11-09 09:23

Трудно представить ответ HAL обычным RestTempalte. Код вроде ResourceSupport root = restTemplate.getForEntity(config.entryPoint, Resource.class).getBody(); не будет работать, если сервер вернет результат в формате HAL. Так как _embedded а также _links включены в тело, а не content а также links, Мне пришлось написать много кода, чтобы создать XXXclint.