知識庫 / Spring / Spring Data RSS 訂閱

curl -i -X GET http://localhost:8080/libraries/1/books

返回的JSON對象將包含一個 books 數組：

{
  "_embedded" : {
    "books" : [ {
      "title" : "Book1",
      "_links" : {
        "self" : {
          "href" : "http://localhost:8080/books/1"
        },
        "book" : {
          "href" : "http://localhost:8080/books/1"
        },
        "bookLibrary" : {
          "href" : "http://localhost:8080/books/1/library"
        }
      }
    } ]
  },
  "_links" : {
    "self" : {
      "href" : "http://localhost:8080/libraries/1/books"
    }
  }
}

為了解除關聯，我們可以使用關聯資源上的 DELETE 方法：

curl -i -X DELETE http://localhost:8080/books/1/library

4. 多對多關係

我們使用 @ManyToMany 註解定義多對多關係，並且可以添加 @RestResource 註解。

4.1. 數據模型

為了創建一個多對多關係示例，我們將添加一個新的模型類，Author，它與Book實體存在多對多關係：

@Entity
public class Author {

    @Id
    @GeneratedValue
    private long id;

    @Column(nullable = false)
    private String name;

    @ManyToMany(cascade = CascadeType.ALL)
    @JoinTable(name = "book_author", 
      joinColumns = @JoinColumn(name = "book_id", referencedColumnName = "id"), 
      inverseJoinColumns = @JoinColumn(name = "author_id", 
      referencedColumnName = "id"))
    private List<Book> books;

    //standard constructors, getters, setters
}

然後，我們還將添加對 Book 類的關聯：

public class Book {
 
    //...
 
    @ManyToMany(mappedBy = "books")
    private List<Author> authors;
 
    //...
}

4.2. 倉庫

接下來，我們將創建一個倉庫接口來管理 Author 實體：

public interface AuthorRepository extends CrudRepository<Author, Long> { }

4.3. 關聯資源

如前幾節所述，首先必須 創建資源，在此基礎上才能建立關聯。

我們將通過向 /authors 資源集合發送 POST 請求，創建一個 作者 實例：

// 創建作者實例
// This code creates an Author instance.
//  This is a sample code snippet to illustrate the process.

curl -i -X POST -H "Content-Type:application/json" 
  -d "{\"name\":\"author1\"}" http://localhost:8080/authors

接下來，我們將向數據庫添加第二個 Book 記錄：

curl -i -X POST -H "Content-Type:application/json" 
  -d "{\"title\":\"Book 2\"}" http://localhost:8080/books

然後，我們將執行一個 GET 請求，訪問我們的 Author 記錄以查看關聯 URL：

{
  "name" : "author1",
  "_links" : {
    "self" : {
      "href" : "http://localhost:8080/authors/1"
    },
    "author" : {
      "href" : "http://localhost:8080/authors/1"
    },
    "books" : {
      "href" : "http://localhost:8080/authors/1/books"
    }
  }
}

現在我們可以使用 PUT 方法，通過 endpoint authors/1/books 建立兩個 Book 記錄和 Author 記錄之間的關聯，該 endpoint 支持 media type text/uri-list 並可以接收多個 URI。

為了發送多個 URI，需要用換行符分隔：

curl -i -X PUT -H "Content-Type:text/uri-list" 
  --data-binary @uris.txt http://localhost:8080/authors/1/books

uris.txt 文件包含書籍的 URI，每本書在一行：

http://localhost:8080/books/1
http://localhost:8080/books/2

為了驗證這兩本書與作者相關聯，我們可以向關聯端點發送一個 GET 請求：

curl -i -X GET http://localhost:8080/authors/1/books

我們將會收到以下響應：

{
  "_embedded" : {
    "books" : [ {
      "title" : "Book 1",
      "_links" : {
        "self" : {
          "href" : "http://localhost:8080/books/1"
        }
      //...
      }
    }, {
      "title" : "Book 2",
      "_links" : {
        "self" : {
          "href" : "http://localhost:8080/books/2"
        }
      //...
      }
    } ]
  },
  "_links" : {
    "self" : {
      "href" : "http://localhost:8080/authors/1/books"
    }
  }
}

為了解除關聯，我們可以向關聯資源的 URL 後加上 {bookId} 發送帶有 DELETE 方法的請求：

curl -i -X DELETE http://localhost:8080/authors/1/books/1

2. 使用 TestRestTemplate 測試端點

讓我們創建一個測試類，其中注入一個 TestRestTemplate 實例，並定義我們將使用的常量：

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringDataRestApplication.class, 
  webEnvironment = WebEnvironment.DEFINED_PORT)
public class SpringDataRelationshipsTest {

    @Autowired
    private TestRestTemplate template;

    private static String BOOK_ENDPOINT = "http://localhost:8080/books/";
    private static String AUTHOR_ENDPOINT = "http://localhost:8080/authors/";
    private static String ADDRESS_ENDPOINT = "http://localhost:8080/addresses/";
    private static String LIBRARY_ENDPOINT = "http://localhost:8080/libraries/";

    private static String LIBRARY_NAME = "My Library";
    private static String AUTHOR_NAME = "George Orwell";
}

5.1. 測試一對一關係

我們將創建一個 @Test 方法，通過向集合資源發送 POST 請求，保存 Library 和 Address 對象。

然後，它使用 PUT 請求保存關聯關係，並使用 GET 請求驗證同一資源的關聯關係已建立：

@Test
public void whenSaveOneToOneRelationship_thenCorrect() {
    Library library = new Library(LIBRARY_NAME);
    template.postForEntity(LIBRARY_ENDPOINT, library, Library.class);
   
    Address address = new Address("Main street, nr 1");
    template.postForEntity(ADDRESS_ENDPOINT, address, Address.class);
    
    HttpHeaders requestHeaders = new HttpHeaders();
    requestHeaders.add("Content-type", "text/uri-list");
    HttpEntity<String> httpEntity 
      = new HttpEntity<>(ADDRESS_ENDPOINT + "/1", requestHeaders);
    template.exchange(LIBRARY_ENDPOINT + "/1/libraryAddress", 
      HttpMethod.PUT, httpEntity, String.class);

    ResponseEntity<Library> libraryGetResponse 
      = template.getForEntity(ADDRESS_ENDPOINT + "/1/library", Library.class);
    assertEquals("library is incorrect", 
      libraryGetResponse.getBody().getName(), LIBRARY_NAME);
}

5.2. 測試一對多關係

現在我們將創建一個 <em @Test</em> 方法，該方法保存一個 <em Library</em> 實例以及兩個 <em Book</em> 實例，然後向每個 <em Book</em> 對象的 <em /library</em> 關聯資源發送 PUT 請求，並驗證該關係是否已保存：

@Test
public void whenSaveOneToManyRelationship_thenCorrect() {
    Library library = new Library(LIBRARY_NAME);
    template.postForEntity(LIBRARY_ENDPOINT, library, Library.class);

    Book book1 = new Book("Dune");
    template.postForEntity(BOOK_ENDPOINT, book1, Book.class);

    Book book2 = new Book("1984");
    template.postForEntity(BOOK_ENDPOINT, book2, Book.class);

    HttpHeaders requestHeaders = new HttpHeaders();
    requestHeaders.add("Content-Type", "text/uri-list");    
    HttpEntity<String> bookHttpEntity 
      = new HttpEntity<>(LIBRARY_ENDPOINT + "/1", requestHeaders);
    template.exchange(BOOK_ENDPOINT + "/1/library", 
      HttpMethod.PUT, bookHttpEntity, String.class);
    template.exchange(BOOK_ENDPOINT + "/2/library", 
      HttpMethod.PUT, bookHttpEntity, String.class);

    ResponseEntity<Library> libraryGetResponse = 
      template.getForEntity(BOOK_ENDPOINT + "/1/library", Library.class);
    assertEquals("library is incorrect", 
      libraryGetResponse.getBody().getName(), LIBRARY_NAME);
}

5.3. 測試多對多關係

為了測試 Book 和 Author 實體之間的多對多關係，我們將創建一個測試方法，該方法保存一個 Author 記錄和兩個 Book 記錄。

然後，它向 /books 關聯資源發送 PUT 請求，其中包含兩個 Book 的 URI，並驗證關係已建立：

@Test
public void whenSaveManyToManyRelationship_thenCorrect() {
    Author author1 = new Author(AUTHOR_NAME);
    template.postForEntity(AUTHOR_ENDPOINT, author1, Author.class);

    Book book1 = new Book("Animal Farm");
    template.postForEntity(BOOK_ENDPOINT, book1, Book.class);

    Book book2 = new Book("1984");
    template.postForEntity(BOOK_ENDPOINT, book2, Book.class);

    HttpHeaders requestHeaders = new HttpHeaders();
    requestHeaders.add("Content-type", "text/uri-list");
    HttpEntity<String> httpEntity = new HttpEntity<>(
      BOOK_ENDPOINT + "/1\n" + BOOK_ENDPOINT + "/2", requestHeaders);
    template.exchange(AUTHOR_ENDPOINT + "/1/books", 
      HttpMethod.PUT, httpEntity, String.class);

    String jsonResponse = template
      .getForObject(BOOK_ENDPOINT + "/1/authors", String.class);
    JSONObject jsonObj = new JSONObject(jsonResponse).getJSONObject("_embedded");
    JSONArray jsonArray = jsonObj.getJSONArray("authors");
    assertEquals("author is incorrect", 
      jsonArray.getJSONObject(0).getString("name"), AUTHOR_NAME);
}

6. 結論

在本文中，我們演示了使用不同類型的關係與 Spring Data REST 的用法。