Nasza strona używa cookies. Korzystając ze strony, wyrażasz zgodę na używanie cookies, zgodnie z aktualnymi ustawieniami przeglądarki. Rozumiem

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

Aditya Sridhar Senior Software Engineer / Myntra
Dowiedz się, jak możesz stworzyć dwa API do obsługi metod GET i POST w Spring Boot.

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:

  1. @Configuration: potrzebna do ręcznej zmiany ustawień. Dzięki niej można zmienić konfigurację z tego poziomu, zamiast oddzielnego pliku XML.
  2. @EnableAutoConfiguration: Spring wymaga dużej konfiguracji. Adnotacja ta zapewnia, że jej większość wykonywana jest automatycznie.
  3. @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.

1 komentarz

Lubisz dzielić się wiedzą i chcesz zostać autorem?

Podziel się wiedzą z 160 tysiącami naszych czytelników

Dowiedz się więcej