2부의 6장-9장은 스프링 애플리케이션을 다른 애플리케이션과 통합하는 데 도움을 주는 주제를 다룬다.

6장에서는 스프링에서 REST API를 작성하는 방법을 살펴보면서 2장에서 시작했던 스프링 MVC를 더 폭넓게 다룰 것이다.

이 장에서 배우는 내용

• 스프링 MVC에서 REST 엔트포인트 정의하기
• 하이퍼링크 REST 리소스 활성화하기
• 리퍼지터리 기반의 REST 엔드포인트 자동화

이번 장에서는...

스프링을 사용해 타코 클라우드 앱에 REST API를 제공한다.

• rest controller를 작성
• 하이퍼미디어를 사용해 API에서 url 목록을 받아온다
• 데이터 기반 서비스 활성화

II의 내용은 III에서 더 간단한 코드로 대체된다. 하이퍼링크가 어떻게 동작하는지 구조를 살펴본다고 생각하자.

앵귤러 클라이언트 코드로 HTTP 요청을 통해 REST API로 통신

이번 장에서는 앵귤러 기반의 UI와 통신하는 REST API를 생성하자. (추후, 2장에서 생성했던 서버 생성 페이지를 앵귤러 프레임워크, SPA로 대체하게 된다.)

이 책의 목적은 앵귤러를 배우는게 아니므로 백엔드 스프링 코드에 초점을 두고, 앵귤러는 작동을 위한 간단한 코드만 구현할 것이다.

SPA (Single Page Application)

• MPA(Multi-Page Application)와 반대되는 개념
• 프리젠테이션 계층이 백엔드 처리와 독립적
• 따라서, 같은 백엔드 기능으로 여러 사용자 인터페이스(ex. 모바일앱, PC웹)을 개발할 수 있다.
• 또한 다른 애플리케이션과 통합할 수 있는 기회도 제공합니다.
• 모든 애플리케이션이 이와 같은 유연성을 필요로 하는 것은 아니므로 웹페이지에 정보를 보여주는게 전부라면 MPA가 간단할 수 있습니다.

2장에서 @GetMapping, @PostMapping 을 사용해서 서버에서 데이터를 가져오거나 전송했는데,

REST API에도 여전히 위 애너테이션을 사용합니다. 또한 Spring MVC는 다양한 타입의 HTTP 요청에 사용되는 어노테이션을 제공한다.

스프링 MVC의 HTTP 요청-처리 어노테이션

가장 최근에 생성된 타코를 가져오는 간단한 REST 엔드포인트를 작성해보겠다.

recents.component.ts

최근에 생성된 타코를 보여주는 코드(RecentTacosComponent)는 아래와 같다.

• ngOnInit에서 주입된 http모듈로 작성된 URL에 대해 HTTP GET 요청을 수행한다.
• 이 경우 recentTacos 모델 변수로 참조되는 타코들의 내역이 응답에 포함된다.
• 그리고 recents.component.html의 뷰에서는 브라우저에 나타나는 HTML로 모델 데이터를 보여준다.

import { Component, OnInit, Injectable } from '@angular/core';
import { Http } from '@angular/http';
import { HttpClient } from '@angular/common/http';

@Component({
  selector: 'recent-tacos',
  templateUrl: 'recents.component.html',
  styleUrls: ['./recents.component.css']
})

@Injectable()
export class RecentTacosComponent implements OnInit {
  recentTacos: any;

  constructor(private httpClient: HttpClient) { }

  ngOnInit() {
  // 최근 생성된 타코들을 서버에서 가져온다.
    this.httpClient.get('http://localhost:8080/design/recent') // <1>
        .subscribe(data => this.recentTacos = data);
  }
}

DesignTacoController.java

이제 앵귤러 컴포넌트가 수행하는 design/recent 의 GET 요청을 수행하는 엔드포인트 코드를 살펴보자.

• 2장에서는 동일한 컨트롤러명으로 MPA에 사용하는 코드였다면, 이번의 코드는 @RestController 어노테이션으로 나타낸 REST 컨트롤러다.

package tacos.web.api;
// import 생략

@RestController
@RequestMapping(path="/design",                      // <1>
                produces="application/json")
@CrossOrigin(origins="*")        // <2>
public class DesignTacoController {
  private TacoRepository tacoRepo;
  
  @Autowired
  EntityLinks entityLinks;

  public DesignTacoController(TacoRepository tacoRepo) {
    this.tacoRepo = tacoRepo;
  }

  @GetMapping("/recent")
  public Iterable<Taco> recentTacos() {                 //<3>
    PageRequest page = PageRequest.of(
            0, 12, Sort.by("createdAt").descending());
    return tacoRepo.findAll(page).getContent();
  }

@RestController 의 지원기능

1. (스테레오타입 어노테이션으로서) 이 어노테이션이 지정된 클래스를 스프링 컴포넌트 검색으로 찾을 수 있다.
2. 컨트롤러의 모든 HTTP 처리 메서드에서 HTTP 응답 몸체에 직접 쓰는 값을 반환함을 스프링에 알려준다.

• @RestController 대신 모든 메서드에 @Controller + @ResponseBody 조합을 붙이거나, ResponseEntity 객체를 반환하는 방법도 존재한다.

<3>

/design/recent 경로의 GET 요청을 처리할 때 사용되는 메서드로 앵귤러 코드가 실행될 때 필요한 기능이다.

produces="application/json"

요청의 Accept 헤더에 "application/json"이 포함된 요청만을 DesignTacoController의 메서드에 처리한다는 것을 나타낸다. 이 경우 응답 결과는 JSON 형식이 되지만, produces 속성의 값은 String 배열로 저장되므로, 다른 컨트롤러에서도 요청을 처리할 수 있도록 JSON만이 아닌 다른 콘텐트 타입을 같이 지정할 수 있다.

만약 xml로 출력하려면 produces 속성에 "text/xml"를 추가한다.

@RequestMapping(path="/design",
                produces={"application/json", "text/xml"})

@CrossOrigin(origins="*")

다른 도메인의 클라이언트에서 API를 사용할 수 있게 해준다.

현재 앵귤러 코드는 API와 별도의 도메인에서 실행중이므로 앵귤러 클라이언트에서 API를 사용하지 못하게 웹 브라우저가 막는다. 이런 제약은 서버 응답에 CORS 헤더를 포함시켜 극복할 수 있고, 스프링에서는 위 어노테이션을 지정해 적용 가능하다.

recentTacos()

최근 생성일자 순으로 정렬된 처음 12개의 결과를 갖는 첫 번째 페이지만 원한다는 것을 PageRequest 객체에 지정한다.
그리고 TacoRepository의 findAll() 메서드 인자로 PageRequest 객체가 전달되어 호출된 후 결과 페이지의 콘텐츠가 클라이언트에게 반환된다.

만약 타코ID로 특정 타코만 가져오는 엔트포인트를 제공하고 싶다면

메서드 경로에 플레이스홀더{} 변수를 지정하고 해당 변수를 통해 ID를 인자를 받는 메서드를 추가한다.

지정된 타코 ID가 없을 수 있으므로 Optional을 사용했고, 값이 없으면 null을 반환하고 있는데 이는 좋은 방법이 아니다. 콘텐츠가 없는데도 정상 처리를 나타내는 HTTP 200(OK) 상태 코드를 클라이언트가 받기 때문이다.

// before
@GetMapping("/{id}")
  public Taco tacoById(@PathVariable("id") Long id) {
    Optional<Taco> optTaco = tacoRepo.findById(id);
    if (optTaco.isPresent()) {
      return optTaco.get();
    }
    return null;
  }

따라서 아래와 같이 HTTP 404(NOT FOUND) 상태 코드를 반환하는 것이 더 좋다.

바뀐 코드에서 Taco 객체 대신 ResponseEntity가 반환되었는데, 반환할 객체와 상태코드를 함께 보낼 수 있다.

// after
@GetMapping("/{id}")
  public ResponseEntity<Taco> tacoById(@PathVariable("id") Long id) {
    Optional<Taco> optTaco = tacoRepo.findById(id);
    if (optTaco.isPresent()) {
      return new ResponseEntity<>(optTaco.get(), HttpStatus.OK);
    }
    return new ResponseEntity<>(null, HttpStatus.NOT_FOUND);
  }

이제, 클라이언트에서 타코 클라우드 API를 사용할 수 있게 되었다.

개발 시에 API 테스트를 위해서 curl이나 HTTPie를 사용해도 된다.

$ curl localhost:8080/design/recent

http :8080/design/recent

이제까지는 서버에서 데이터를 받아오는 것만 했다면, 이번에는 클라이언트에서 데이터를 받는 부분을 살펴보겠다. request의 입력 데이터를 처리하는 컨트롤러 메서드를 작성해보자.

타코 클라우드를 SPA로 변환하기 위해 앵귤러 컴포넌트와 엔드포인트를 생성해보자.

onSubmit() 메서드는 타코 디자인 폼의 제출을 처리한다.

이번엔 post방식으로, API로부터 데이터를 가져오는 대신 API로 데이터를 전송하는 것을 의미한다.

즉, model 변수에 저장된 데이터를 API 엔드포인트로 전송한다는 것이다.

onSubmit() {
  this.httpClient.post(
      'http://localhost:8080/design',
      this.model, {
          headers: new HttpHeaders().set('Content-type', 'application/json'),
      }).subscribe(taco => this.cart.addToCart(taco));

  this.router.navigate(['/cart']);
}

따라서 DesignTacoController에 디자인 데이터를 요청하고 저장하는 메서드를 추가해야 한다.

consumes="application/json"

Content-type이 application/json인 요청만 처리한다.

@RequestBody

요청 몸체의 JSON 데이터가 Taco 객체로 변환되어 taco 매개변수와 바인딩 된다.

@ResponseStatus(HttpStatus.CREATED)

해당 요청이 성공적이면서 요청의 결과로 리소스가 생성되면 HTTP 201(CREATED)가 전달

HTTP 200(OK)보다 더 정확한 상태 설명을 전달할 수 있다.

@PostMapping(consumes="application/json")
@ResponseStatus(HttpStatus.CREATED)
public Taco postTaco(@RequestBody Taco taco) {
  return tacoRepo.save(taco);
}

위에선 새로운 Taco 객체를 생성했다면, 이번에는 (Taco 객체를) 변경해보겠다.

데이터 변경을 위한 HTTP 메서드로 put, patch가 존재한다.

PUT은 데이터 전체를 변경할 때, PATCH는 데이터의 일부만 변경할 때 사용된다.

예를 들어, 특정 주문 데이터의 주소를 변경하고 싶다면?

• PUT을 사용한다면 해당 주문 데이터 전체를 PUT 요청으로 제출해야 한다. 뭐 하나라도 데이터가 생략되면 값이 null로 변경된다.

  @PutMapping(path="/{orderId}")
    public Order putOrder(@RequestBody Order order) {
      return repo.save(order);
    }

• 그러므로 PATCH를 사용한다.

  메서드 구현부가 길어졌는데, 데이터 일부만 변경하기 위한 로직으로, 각 주문의 속성이 null이 아닐 경우 변경을 수행하기 위해서이다.

  @PatchMapping(path="/{orderId}", consumes="application/json")
    public Order patchOrder(@PathVariable("orderId") Long orderId,
                            @RequestBody Order patch) {
      
      Order order = repo.findById(orderId).get();
      if (patch.getDeliveryName() != null) {
        order.setDeliveryName(patch.getDeliveryName());
      }
      if (patch.getDeliveryStreet() != null) {
        order.setDeliveryStreet(patch.getDeliveryStreet());
      }
      if (patch.getDeliveryCity() != null) {
        order.setDeliveryCity(patch.getDeliveryCity());
      }
      if (patch.getDeliveryState() != null) {
        order.setDeliveryState(patch.getDeliveryState());
      }
      if (patch.getDeliveryZip() != null) {
        order.setDeliveryZip(patch.getDeliveryState());
      }
      if (patch.getCcNumber() != null) {
        order.setCcNumber(patch.getCcNumber());
      }
      if (patch.getCcExpiration() != null) {
        order.setCcExpiration(patch.getCcExpiration());
      }
      if (patch.getCcCVV() != null) {
        order.setCcCVV(patch.getCcCVV());
      }
      return repo.save(order);
    }

patchOrder() 메서드의 제약

1. 특정 필드의 데이터를 변경하지 않음을 나타내는 것을 null로 정한다면 해당 필드를 null로 변경하고 싶을 때 클라이언트에서 이를 표현할 방법이 필요하다.
2. 컬렉션에 저장된 항목을 삭제 혹은 추가할 방법이 없다. 따라서 클라이언트가 컬렉션의 항목을 삭제 혹은 추가하려면 변경될 컬렉션 테이터 전체를 전송해야 한다.

데이터를 삭제할 때에는 DELETE 요청을 처리하는 메서드에 @DeleteMapping을 지정한다.

예를 들어, 주문 데이터를 삭제하는 API의 컨트롤러 메서드는 다음과 같다.

이 메서드는 특정 주문 데이터를 삭제하는데, 해당 주문이 존재하지 않으면 Empty ResultDataAccessException이 발생된다.

@ResponseStatus(HttpStatus.NO_CONTENT)

응답의 상태코드가 204(NO CONTENT)가 된다. (주문 데이터를 삭제하는 것이므로 클라이언트에게 데이터를 반환할 필요가 없기 때문)

@DeleteMapping("/{orderId}")
@ResponseStatus(HttpStatus.NO_CONTENT)
public void deleteOrder(@PathVariable("orderId") Long orderId) {
  try {
    repo.deleteById(orderId);
  } catch (EmptyResultDataAccessException e) {}
}

지금까지는 클라이언트가 API 요청을 위해 URL스킴을 알아야 했다.

때문에 클라이언트 코드에서 하드코딩된 URL 패턴을 사용했는데, 만약 API의 URL 스킴이 변경되면 클라이언트 코드는 정상적으로 실행되지 않을 것이다.

HATEOAS

REST API를 구현하는 또 다른 방법으로 HATEOAS(Hypermedia As The Engine Of Application)이 있다. 여기엔 API로부터 반환되는 리소스에 해당 리소스와 관련된 하이퍼링크들이 포함되어있다.

클라이언트가 최소한의 API URL만 알면 다른 API URL들을 알아내 사용할 수 있다.

클라이언트가 최근 생성된 타코 리스트를 요청했다고 하자.

하이퍼링크가 없는 형태의 API 요청은 (JSON 형식으로) 타코 관련 정보만 클라이언트에서 수신될 것이다.

하이퍼링크가 없는 타코 리스트

{
	{
		"id": 4,
		"name":"Veg-Out",
		"createdAt":"2018-01-31T20:15:53.219+0000",
		"ingredients": [
			{"id": "FLTO", "name": "Flour Totila", "type": "WRAP"},
			...
		]
	},
	...
}

하이퍼링크를 포함한 타코 리스트

{
 "_embedded": {
   "tacoResourceList": [{
     "name": "Veg-Out",
     "createdAt": "2018-01-31T20:15:53.219+0000",
     "ingredients": [{
       "name": "Flour Tortilla", "type": "WRAP",
       "_links": {
         "self": { "href": "http://localhost:8080/ingredients/FLTO" }
       }
     },
     {
       "name": "Corn Tortilla", "type": "WRAP",
       "_links": {
         "self": { "href": "http://localhost:8080/ingredients/COTO" }
       }
     }],
     "_links": {
       "self": { "href": "http://localhost:8080/design/4" }
     }
   },
   { // 다른 taco
 ...
 ]}, // taco 끝
 "_links": {
   "recents": {
     "href": "http://localhost:8080/design/recent"
   }
 }
}

이런 형태의 HATEOAS를 HAL이라고 하며, JSON응답에 하이퍼링크를 포함시킬 떄 주로 사용된다.

• "_link" : 클라이언트가 관련 API를 수행할 수 있는 하이퍼링크 포함(self, recent)
• self는 특정 타코 경로, recent는 현재 접근한 recent 경로를 표출한다.
• 따라서 특정 타코에 대해 HTTP 요청을 수행할 때 해당 타코 리소스의 URL을 지정하지 않아도 된다. 원하는 self링크를 요청하면 된다.

Spring HATEOAS를 사용하기 위해서는 아래의 의존성을 pom.xml에 추가하고 처리 메소드에서 반환시 도메인 객체가 아닌 EntityModel 객체(EntityModel, CollectionModel)를 반환하면 된다.

이렇게 하면

• 스프링 HATEOAS를 해당 프로젝트의 classpath에 추가
• 스프링 HATEOAS를 활성화하는 자동-구성 제공

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-hateoas</artifactId>
</dependency>

/design/recent에 대한 GET 요청에서 반환되는 최근 타코 리스트에 하이퍼미디어 링크를 추가해보자.

spring HATEOAS의 리소스를 나타내는 두 가지 기본타입이 있는데, Resource와 Resources이다.

Resource는 단일 리소스, Resources는 리소스 컬렉션을 나타내고 두 타입 모두 스프링 MVC 컨트롤러 메서드에서 반환될 때 클라이언트가 받는 JSON(or XML)에 포함된다.

최근 생성된 타코 리스트에 하이퍼링크를 추가하려면 List 대신 Resources 객체를 반환하도록 수정한다.

@GetMapping("/recent")
public Resources<Resource<Taco>> recentTacos() {
    PageRequest page = PageRequest.of(0, 12, Sort.by("createdAt").descending());

    List<Taco> tacos = tacoRepo.findAll(pageRequest).getContent();
		Resources<Resource<Taco>> recentResources = Resources.wrap(tacos); // <1>

    recentResources.add(new Link("http://localhost:8080/design/recent", "recents")); //<2>
    return recentResources;
}

<1> : 직접 타코 리스트를 반환하지 않고 Resources.wrap()를 사용해 Resouces<..>로 타코를 래핑

<2> : 이 코드로 인해 JSON에 다음 링크가 포함된다.

"_links": {
  "recents": {
    "href": "http://localhost:8080/design/recent"
  }
}

현재 <2>에 링크가 하드코딩 되어 있다.

**링크 빌더 ControllerLinkBuilder**를 사용하자.

• URL을 하드코딩하지 않고 호스트 이름을 알 수 있게 도와줌
• 컨트롤러의 기본 URL에 관련된 링크의 빌드를 도와주는 API 제공

recentResources.add(new Link("http://localhost:8080/design/recent", "recents")); //<2>

// 위의 코드와 아래의 코드는 동일하다. 점점 하드코딩이 사라진다.

// 1.
recentModels.add(
    ControllerLinkBuilderr.linkTo(DesignTacoController.class)
                     .slash("recent")
                     .withRel("recents")
    );

// 2. methodOn()를 사용해 아래처럼 작성할 수도 있다. 
recentResources.add(
        linkTo(methodOn(RecentTacosController.class).recentTacos())
        .withRel("recents"));

컨트롤러의 기본 경로를 사용해 Link 객체를 생성

slash()메서드를 호출해 슬래시(/)와 인자로 전달된 값을 URL에 추가

이 링크의 관계이름을 지정(recents)

methodOn()을 활용해 컨트롤러 클래스 경로, 메서드 경로 둘중 하나를 호출할 수 있게 해준다.

이번에는 리스트에 포함된 각 타코 리스트에 대한 링크를 추가해보자.

각 타코 리스트 링크를 일일히 추가하기 위해 반복 루프를 돌려도 되지만, 각 API코드마다 코드를 추가하는 것이 번거롭다.

따라서 유틸리티 클래스를 정의해, Taco 객체를 TacoResource객체(Taco + 링크)로 변환하자.

package tacos.web.api;
// import 생략
@Relation(value="taco", collectionRelation="tacos")
public class TacoResource extends ResourceSupport {

  private static final IngredientResourceAssembler 
            ingredientAssembler = new IngredientResourceAssembler();
  
  @Getter
  private final String name;

  @Getter
  private final Date createdAt;

  @Getter
  private final List<IngredientResource> ingredients;
  
  public TacoResource(Taco taco) {
    this.name = taco.getName();
    this.createdAt = taco.getCreatedAt();
    this.ingredients = 
        ingredientAssembler.toResources(taco.getIngredients()); <--루프문을 피하게 해주는 코드
  }
  
}

TacoResource 는 ResourceSupport 의 서브 클래스로서 Link 객체 리스트와 이것을 관리하는 메서드를 상속받는다.

• 불필요한 id정보를 감출 수 있고 필요한 데이터만 보낼 수 있다. (self링크가 리소스 식별자 역할)

타코 리소스를 구성하는 리소스 어셈블러

package tacos.web.api;
import org.springframework.hateoas.mvc.ResourceAssemblerSupport;
import tacos.Taco;

public class TacoResourceAssembler
       extends ResourceAssemblerSupport<Taco, TacoResource> {

  public TacoResourceAssembler() {
    super(DesignTacoController.class, TacoResource.class);
  }
  
  @Override
  protected TacoResource instantiateResource(Taco taco) {
    return new TacoResource(taco);
  }

  @Override
  public TacoResource toResource(Taco taco) {
    return createResourceWithId(taco.getId(), taco);
  }

}

기본 생성자 : 부모인 ResourceAssemblerSupport 의 기본 생성자 호출. 컨트롤러의 URL 경로를 결정하기 위해 클래스명을 두번째 인자로 받았다.

instantiateResource() : 인자로 받은 Taco 객체로 TacoResources 인스턴스를 생성한다.

toResource() : Taco 객체로 TacoResources 인스턴스를 생성 + self 링크가 URL에 자동지정

instantiateResource와 toResource의 차이점은 전자는 Resources 인스턴스만 생성하고, 후자는 거기에 더해 링크도 추가해준다는 점이다.

다시 recentTacos() 메서드를 수정하자.

@GetMapping("/recenth")
  public Resources<TacoResource> recentTacosH() {
// 리턴타입이 Resources<Resource<Taco>>에서 변경
    PageRequest page = PageRequest.of(
            0, 12, Sort.by("createdAt").descending());
    List<Taco> tacos = tacoRepo.findAll(page).getContent();

    List<TacoResource> tacoResources = 
        new TacoResourceAssembler().toResources(tacos);
    Resources<TacoResource> recentResources = 
        new Resources<TacoResource>(tacoResources);
    recentResources.add(
        linkTo(methodOn(DesignTacoController.class).recentTacos())
        .withRel("recents"));
    return recentResources;
  }

여기까지 하면 self, recent 링크는 있지만, 각 타코의 식자재 링크가 없다. 식자재의 리소스 어셈블러 클래스(와 IngredientResource) 도생성하자.

TacoResourceAssembler와 이름만 다를뿐 코드의 역할,기능은 동일하다.

IngredientResourceAssembler

package tacos.web.api;

import org.springframework.hateoas.mvc.ResourceAssemblerSupport;

import tacos.Ingredient;

class IngredientResourceAssembler extends 
          ResourceAssemblerSupport<Ingredient, IngredientResource> {

  public IngredientResourceAssembler() {
    super(IngredientController.class, IngredientResource.class);
  }

  @Override
  public IngredientResource toResource(Ingredient ingredient) {
    return createResourceWithId(ingredient.getId(), ingredient);
  }
  
  @Override
  protected IngredientResource instantiateResource(
                                            Ingredient ingredient) {
    return new IngredientResource(ingredient);
  }

}

IngredientResource

package tacos.web.api;
import org.springframework.hateoas.ResourceSupport;
import lombok.Getter;
import tacos.Ingredient;
import tacos.Ingredient.Type;

public class IngredientResource extends ResourceSupport {

  @Getter
  private String name;

  @Getter
  private Type type;
  
  public IngredientResource(Ingredient ingredient) {
    this.name = ingredient.getName();
    this.type = ingredient.getType();
  }

}

IngredientResource 객체를 처리하도록 TacoResource 클래스 수정

package tacos.web.api;
import java.util.Date;
import java.util.List;

import org.springframework.hateoas.ResourceSupport;
import org.springframework.hateoas.core.Relation;

import lombok.Getter;
import tacos.Taco;

public class TacoResource extends ResourceSupport {

  private static final IngredientResourceAssembler 
            ingredientAssembler = new IngredientResourceAssembler();
  
  @Getter
  private final String name;

  @Getter
  private final Date createdAt;

  @Getter
  private final List<IngredientResource> ingredients;
  
  public TacoResource(Taco taco) {
    this.name = taco.getName();
    this.createdAt = taco.getCreatedAt();
    this.ingredients = 
        ingredientAssembler.toResources(taco.getIngredients()); // <---- 수정된 부분
  }
  
}

이제 최근 생성된 타코리스트의 하이퍼링크를 완벽히 구현했다.

최상위 요소의 _embedded 하위의 tacoResourceList를 살펴보자.

{
    "_embedded": {
        "tacoResourceList": [
...

Resources 객체가 List로부터 생성되어 생긴 이름이다. 기본적으로 이 이름은 컨트롤러 명을 따라가지만, 컨트롤러명과 JSON 필드명 간의 결합도를 낮추고 싶다면 @Relation 을 사용하자.

@Relation(value="taco", collectionRelation="tacos")
public class TacoResource extends ResourceSupport {
...

// JSON 객체는 다음과 같이 만들어진다.
{
    "_embedded": {
        "tacos": [
...

위에서 열심히 RESP API를 노출시키려고 코드 작성을 했다.

그런데 스프링 데이터 API를 사용하면 알아서 REST 엔드포인트를 생성해준다.

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-rest</artifactId>
</dependency>

위 의존성을 추가하고 지금까지 생성했던 @RestController 어노테이션이 지정된 모든 클래스(의 어노테이션)들을 이 시점에서 제거하자.

그럼 위에서 뿌려줬던 JSON객체가 동일하게 나타난다.

스프링 데이터 REST가 자동 생성한 API의 기본 경로를 설정해주자.

해당 API의 엔드포인트가 우리가 아까 작성한 다른 컨트롤러와 충돌하는것을 막기 위함이다.

spring:
  data:
    rest:
  		base-path: /api

이제 기본 경로에 /api가 붙어 식자재의 엔드포인트는 /api/ingredients가 된다.

그런데, 스프링 데이터 REST가 /api/taco 엔드포인트는 노출시키지 않는다.

스프링 데이터 REST는 엔드포인트를 노출시킬 때 해당 클래스 이름의 복수형을 사용한다.

order는 orders, ingredient는 ingredients가 복수형이지만 taco의 복수형은 tacoes이다.

관계이름을 tacos로 변경하고 싶다면 @RestResource를 사용하자.

@Data
@Entity
@RestResource(rel="tacos", path="tacos")
public class Taco {

그리고 스프링 데이터 REST는 노출된 모든 엔드포인트의 링크를 갖는 **홈 리소스(/api)**도 노출시켜준다.

홈 리소스의 모든 링크는 선택적 매개변수인 page, size, sort 를 제공한다.

기본적으로 한 페이지당 20개의 항목이 반환되며 page 와 size 를 사용해 원하는 페이지와 페이지 사이즈를 조정할 수 있다.

curl localhost:8080/api/tacos?size=5          // 첫번째 페이지(한 페이지에 5개 item)
curl "localhost:8080/api/tacos?size=5&page=1" // 두번째 페이지(한 페이지에 5개 item)

curl 명령어를 사용할 떄 앰퍼샌드(&)가 들어가면 겹따옴표로 감싸줘야 한다.

HATEOAS는 first, last, next, previous 페이지의 링크를 요청 응답에 제공한다.

"_links": {
	"first": {
		"href": "http://localhost:8080/api/tacos?page=0&size=2"
	},
	"self": {
		"href": "http://localhost:8080/api/tacos",
	},
	"next": {
		"href": "http://localhost:8080/api/tacos?page=1&size=2"
	},
	"last": {
		"href": "http://localhost:8080/api/tacos?page=2&size=2"
	},
	"profile": {
		"href": "http://localhost:8080/api/profile/tacos"
	}
	"recents": {
		"href": "http://localhost:8080/api/tacos/recent"
	}
}
// 현재 페이지가 0이라 previous가 없다.

sort 매개변수를 지정하면 엔티티의 속성을 기준으로 결과 리스트를 정렬 할 수 있다.

curl "localhost:8080/api/tacos?sort=createdAt,desc&page=0&size=12"  // 최근 생성된 타코 12개

여기엔 UI코드가 하드코딩됐다는 문제가 있다.

클라이언트가 링크 리스트에서 URL을 찾을 수 있다면 좋고, URL이 더 간단해지기를 원한다.

스프링 데이터 REST는 자동으로 엔드포인트 생성을 해주지만,

기본적인 CRUD API에서 벗어나 개발자 나름의 엔드포인트를 생성해야할 때도 있다.

@RestController를 사용해 REST가 자동생성하는 엔드포인트에 우리 나름의 엔드포인트를 보충할 수 있다.

커스텀 엔드포인트의 2가지 고려할 점

1. 우리 엔드포인트 컨트롤러는 Spring Data REST의 기본경로로 매핑되지 않는다. 같게 할 수도 있는데, 나중에 기본경로가 수정되면 또 어긋나게 된다. 다시 맞추어야 한다.
2. 우리 컨트롤러에 정의한 엔드포인트는 스프링 데이터 REST 엔드포인트에서 반환되는 리소스의 하이퍼링크에 자동으로 포함되지 않는다. (Spring Data REST가 자동으로 만든 hyperlink에 사용자가 만든 api가 포함되지 않는다.)

.

우선 첫번째 문제를 해결하려면 클래스에 붙이는 @RepositoryRestController 를 사용한다.

이 어노테이션은 설정된 Controller의 실행 경로를 application.yml에서 설정한 data.rest.base-path를 base path(기본경로)로 설정하여 접점 주소를 만든다.

실제 동작을 보기 위해서 메소드가 하나만 있는 새로운 클래스를 하나 생성하고 아래처럼 어노테이션을 추가한 후 Rest 클라이언트에서 localhost:8080/api/tacos로 검색해보면 정상적으로 /api/tacos/recent가 나온다.

@RepositoryRestController는 @RestController과 동일한 기능을 수행하지 않아, 핸들러 메서드의 반환값을 요청 응답의 몸체에 자동으로 수록하지 않는다. 따라서 @ResponseBody를 붙이거나 ResponseEntity를 반환해야 한다.

아래 소스는 단순히 6.2에 있는 소스에서 클래스의 붙은 어노테이션을 붙였고 리턴 타입도 ResponseEntity로 변경하여 처리하고 있다.

여기까지가 첫번째 문제를 이 책에서 제시하는 해결책이다.

package tacos.web.api;
// import 생략
@RepositoryRestController
public class RecentTacosController {

  private TacoRepository tacoRepo;

  public RecentTacosController(TacoRepository tacoRepo) {
    this.tacoRepo = tacoRepo;
  }

  @GetMapping(path="/tacos/recent", produces="application/hal+json")
  public ResponseEntity<Resources<TacoResource>> recentTacos() {
    PageRequest page = PageRequest.of(
                          0, 12, Sort.by("createdAt").descending());
    List<Taco> tacos = tacoRepo.findAll(page).getContent();

    List<TacoResource> tacoResources = 
        new TacoResourceAssembler().toResources(tacos);
    Resources<TacoResource> recentResources = 
            new Resources<TacoResource>(tacoResources);
    
    recentResources.add(
        linkTo(methodOn(RecentTacosController.class).recentTacos())
            .withRel("recents"));
    return new ResponseEntity<>(recentResources, HttpStatus.OK);
  }

}

여기서는 두번째 문제에 대한 해결책을 제시한다.

사용자가 만든 rest 접점을 spring이 자동생성한 hyperlink를 추가하려면 RepresentationModelProcessor 이라는 bean를 생성해서 링크를 추가해야 한다.

@Configuration
public class SpringDataRestConfiguration {

  @Bean
  public ResourceProcessor<PagedResources<Resource<Taco>>>
    tacoProcessor(EntityLinks links) {

    return new ResourceProcessor<PagedResources<Resource<Taco>>>() {
      @Override
      public PagedResources<Resource<Taco>> process(
                          PagedResources<Resource<Taco>> resource) {
        resource.add(
            links.linkFor(Taco.class)
                 .slash("recent")
                 .withRel("recents"));
        return resource;
      }
    };
  }
  
}

이 빈은 익명 이너클래스를 사용했다. 스프링 HATEOAS는 ResourcesProcessor 타입의 빈을 적절한 자원에 적용한다.

지금같은 경우엔 가장 최근에 생성된 타코에 대한 링크를 받는다.

• Spring MVC로 REST 엔드포인트를 생성할 수 있다.
• 컨트롤러 핸들러 메서드는 @ResponseBody를 붙이거나, ResponseEntity 객체를 리턴해 리스폰스바디에 데이터를 담을 수 있다.
• @RestController는 Rest컨트롤러에서 @ResponseBody를 생략할 수 있게 해준다.
• Spring HATEOAS는 자원의 하이퍼링킹을 가능하게 해준다.
• 스프링 데이터 리포지터리는 스프링 데이터 REST를 사용해 자동으로 REST API를 노출시킨다.