Jak w Spring Boot stworzyć API do obsługi GET i POST

Będziemy tutaj tworzyć 2 REST API, korzystając przy tym ze Spring Boot. Artykuł ten pomoże Ci wystartować z tym frameworkiem. Zaczynajmy!
Zanim zaczniemy
Upewnij się, że masz zainstalowane Maven. Jeśli nie, może je zainstalować stąd. Co więcej, upewnij się, że Maven jest w PATH, żeby działała komenda mvn
. Zweryfikuj oba powyższe punkty.
mvn -v
Upewnij się również, że masz ustawione JAVA HOME.
Konfiguracja Projektu
Po pierwsze, musimy skonfigurować projekt. Zadanie to nie należy do najtrudniejszych. Kilknij https://start.spring.io/ W polu Artifact wpisz nazwę simple-rest-api. Przy dependencies wybierz Web. W polu Artifact możesz również wpisać inną nazwę.
Po przeczytaniu tego artykułu możesz zacząć samemu eksperymentować. Po wprowadzeniu wszystkich informacji ekran powinien wyglądać następująco:
Kliknij Generate Project - pobierzesz wtedy spakowany plik. Wypakuj go - wypakowany folder to Twój projekt Spring Boot. Zaimportuj projekt do swojego IDE. Ja będę używać Eclipse.
Struktura projektu
pom.xml
Plik ten zawiera wszystkie zależności Maven. Oto nasza główna zależność:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
Zależność spring-boot-starter-web
sprawia, że projekt może być używany dla aplikacji webowych. Oto kolejna ważna rzecz, na którą należy zwrócić uwagę w pom.xml
:
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.6.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
spring-boot-starter-parent
jest nadrzędny dla tego projektu. Gwarantuje to, że wszelkie wewnętrzne zależności wymagane przez Spring Boot są automatycznie dodawane, a programiści nie muszą się nimi martwić.
SimpleRestApisApplication.Java
Nazwa tego pliku pochodzi od nazwy projektu, po której dodajemy Application
. Plik ten znajduje się w folderze src/main/java
oraz w pakiecie com.example.simplerestapis
. Oto kod, który się w nim znajduje.
package com.example.simplerestapis;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class SimpleRestApisApplication {
public static void main(String[] args) {
SpringApplication.run(SimpleRestApisApplication.class, args);
}
}
Chodzi nam tutaj głównie o adnotację @SpringBootApplication
. Wewnętrznie, to połączenie 3 następujących adnotacji:
@Configuration
: potrzebna do ręcznej zmiany ustawień. Dzięki niej można zmienić konfigurację z tego poziomu, zamiast oddzielnego pliku XML.@EnableAutoConfiguration
: Spring wymaga dużej konfiguracji. Adnotacja ta zapewnia, że jej większość wykonywana jest automatycznie.@ComponentScan
: Adnotacja ta mówi Springowi, gdzie szukać komponentów.
Linijka kodu SpringApplication.run(SimpleRestApisApplication.class, args);
ładuje aplikację.
Application.properties
Plik ten znajduje się w src/main/resources
. Może on służyć do wyszczególnienia różnych właściwości używanych podczas uruchamiania aplikacji. Na przykład możemy przy jego pomocy wspomnieć, na którym porcie aplikacja ma działać.
Kod
Tutaj znajdziecie kod, którego używamy do tworzenia naszych API.
Tworzymy pierwsze API
To będzie proste API demonstrujące żądanie GET. Utwórz pakiet o nazwie com.example.simplerestapis.models
. Wewnątrz utwórz plik o nazwie SampleResponse.java
. Skopiuj następujący kod do pliku SampleResponse.java
.
package com.example.simplerestapis.models;
public class SampleResponse {
private String message;
private long id;
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
}
SampleResponse.java
to tylko model. Klasa ta wskazuje pola, które są obecne w odpowiedzi Twojego API. Utwórz pakiet o nazwie com.example.simplerestapis.controller
. Wewnątrz utwórz plik o nazwie WebController.java
. Skopiuj tam następujący kod:
package com.example.simplerestapis.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.example.simplerestapis.models.SampleResponse;
@RestController
public class WebController {
@RequestMapping("/sample")
public SampleResponse Sample(@RequestParam(value = "name",
defaultValue = "Robot") String name) {
SampleResponse response = new SampleResponse();
response.setId(1);
response.setMessage("Your name is "+name);
return response;
}
}
Adnotacja @RestController
wskazuje, że klasa będzie miała REST-owe punkty końcowe. Adnotacja ta w zasadzie mówi, że klasa ta jest kontrolerem, a wartość zwrócona przez funkcję w tej klasie zostanie przekonwertowana na JSON lub XML. Domyślny format to JSON.
@RequestMapping
mapuje punkt końcowy /sample na funkcję Sample
@RequestParam
wskazuje na to, że punkt końcowy /sample będzie miał jeden parametr o nazwie name. Domyślna wartość dla name to „Robot”.
Kod wewnątrz funkcji jest dosyć prosty. Odpowiedź jest ustawiana na podstawie wartości przekazanej w name. Przejdź do linii poleceń. Idź do folderu projektu i uruchom następujące polecenie, aby uruchomić aplikację.
mvn spring-boot:run
Aplikacja domyślnie działa na porcie 8080 w localhost. Aby przetestować punkty końcowe API, możesz użyć programu Postman. Wpisz w programie następujący URL: localhost:8080/sample?name=aditya
i naciśnij Send.
Zwróci to następującą odpowiedź:
{
"message": "Your name is aditya",
"id": 1
}
Teraz wypróbuj następujący URL: localhost:8080/sample i naciśnij Send. Zwróci to następującą odpowiedź:
{
"message": "Your name is Robot",
"id": 1
}
Gratulacje!
Stworzyliście właśnie swoje pierwsze API za Spring Boot. Wiecie teraz, jak stworzyć proste GET REST API z parametrem query.
Tworzymy drugie API
Drugie API pokaże, jak stworzyć interfejs, który obsługuje żądanie POST. W pakiecie com.example.simplerestapis.models
utwórz klasę o nazwie PostRequest.java
. Skopiuj tam następujący kod:
package com.example.simplerestapis.models;
public class PostRequest {
int id;
String name;
public int getId() {
return id;
}
public String getName() {
return name;
}
public void setId(int id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
}
Żądanie POST zawiera zazwyczaj ciało, w którym znajdą się dane wejściowe. PostRequest.java
wskazuje wszystkie pola, które są obecne w ciele żądania. W pakiecie com.example.simplerestapis.models
utwórz klasę o nazwie PostResponse.java
. Skopiuj poniższy kod do PostResponse.java
:
package com.example.simplerestapis.models;
public class PostResponse {
int id;
String message;
String extra;
public String getExtra() {
return extra;
}
public int getId() {
return id;
}
public String getMessage() {
return message;
}
public void setExtra(String extra) {
this.extra = extra;
}
public void setId(int id) {
this.id = id;
}
public void setMessage(String message) {
this.message = message;
}
}
PostResponse.java
wskazuje pola, które są obecne w danych wyjściowych żądania POST. W WebController.java
dodaj następujące importy.
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMethod;
import com.example.simplerestapis.models.PostRequest;
import com.example.simplerestapis.models.PostResponse;
Dodaj też następującą funkcję w WebController.java
:
@RequestMapping(value = "/test", method = RequestMethod.POST)
public PostResponse Test(@RequestBody PostRequest inputPayload) {
PostResponse response = new PostResponse();
response.setId(inputPayload.getId()*100);
response.setMessage("Hello " + inputPayload.getName());
response.setExtra("Some text");
return response;
}
Kod ten tworzy nowy punkt końcowy o nazwie /test
i mapuje go na funkcję Test
. Co więcej, method = RequestMethod.POST
wskazuje na to, że punkt końcowy /test
może akceptować żądania POST.
@RequestBody PostRequest inputPayload
wskazuje na to, że żądane wejście zinterpretujemy jako PostRequest
, a w inputPayload
znajdą się wszystkie dane wejściowe. Kod, w którym odpowiedź jest ustawiana na podstawie nadchodzących danych wejściowych, jest dosyć prosty.
ID z danych wejściowych jest mnożony przez 100 i ustawiany na odpowiedź. Do parametru name dołączane jest Hello i ustawiany na odpowiedź. Dodatkowy parametr zostaje zakodowany na stałe jako ciąg znaków o wartości Some text.
Finalnie, kod w WebController.java
wygląda następująco:
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.example.simplerestapis.models.PostRequest;
import com.example.simplerestapis.models.PostResponse;
import com.example.simplerestapis.models.SampleResponse;
@RestController
public class WebController {
@RequestMapping("/sample")
public SampleResponse Sample(@RequestParam(value = "name",
defaultValue = "Robot") String name) {
SampleResponse response = new SampleResponse();
response.setId(1);
response.setMessage("Your name is "+name);
return response;
}
@RequestMapping(value = "/test", method = RequestMethod.POST)
public PostResponse Test(@RequestBody PostRequest inputPayload) {
PostResponse response = new PostResponse();
response.setId(inputPayload.getId()*100);
response.setMessage("Hello " + inputPayload.getName());
response.setExtra("Some text");
return response;
}
}
Przejdź do linii poleceń. Następnie przejdź do folderu projektu i uruchom następujące polecenie, aby uruchomić aplikację:
mvn spring-boot:run
Otwórz Postmana i ustaw wartości tak, jak widać na poniższym obrazku:
Ważne, by ustawić typ żądania na POST. Adres URL punktu końcowego ustaw na localhost:8080/test
. Aby wprowadzić ciało żądania, przejdź do treści, wybierz raw i potem JSON (application/json). Ustawmy następującą treść jako ciało żądania.
{
"id": 1,
"name": "aditya"
}
Po kliknięciu Send zostanie wyświetlony następujący wynik:
{
"id": 100,
"message": "Hello aditya",
"extra": "Some text"
}
Możesz z tym poeksperymentować, wysyłając różne dane wejściowe.
Gratulacje!
Wiesz już teraz, jak utworzyć proste API REST oparte na żądaniach GET i POST przy użyciu Spring Boot ? Na https://spring.io// dowiesz się więcej o Spring i Spring Boot.
Oryginał tekstu w języku angielskim przeczytasz tutaj.