REST 개요. 3부: Spring Boot에서 RESTful 서비스 생성

이것은 REST 구문 분석의 마지막 부분입니다. 이전 부분에서:

• REST란 무엇인가
• 클라이언트와 서버 간의 통신

프로젝트 만들기

이 섹션에서는 Spring Boot를 사용하여 작은 RESTful 애플리케이션을 만듭니다. 우리 애플리케이션은 분석 마지막 부분 의 예제에서 클라이언트에 대한 CRUD(생성, 읽기, 업데이트, 삭제) 작업을 구현합니다 . 먼저 File -> New -> Project 메뉴를 통해 새로운 Spring Boot 애플리케이션을 생성해 보겠습니다 . 열리는 창에서 Spring 초기화를 선택하고 프로젝트 SDK를 지정합니다. 다음 버튼을 클릭합니다. 다음 창에서 Maven 프로젝트 유형을 지정하고 그룹 및 아티팩트를 지정하십시오. 다음 버튼을 클릭하십시오. 다음 창에서는 프로젝트에 필요한 Spring Framework 구성 요소를 선택해야 합니다. Spring Web이면 충분합니다. Next 버튼을 클릭하세요. 다음으로 남은 것은 프로젝트 이름과 파일 시스템에서의 위치를 ​​지정하는 것입니다. 마침 버튼을 클릭합니다. 프로젝트가 생성되었으므로 이제 그 구조를 볼 수 있습니다. IDEA는 Maven 빌드 시스템 배포 설명자(pom.xml 및 기본 애플리케이션 클래스)를 생성했습니다 RestExampleApplication. 코드는 다음과 같습니다.

pom.xml:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-parent</artifactId>
       <version>2.2.2.RELEASE</version>
       <relativePath/> <!-- lookup parent from repository -->
   </parent>
   <groupId>com.javarush.lectures</groupId>
   <artifactId>rest_example</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>rest_example</name>
   <description>REST example project</description>

   <properties>
       <java.version>1.8</java.version>
   </properties>

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

       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-test</artifactId>
           <scope>test</scope>
           <exclusions>
               <exclusion>
                   <groupId>org.junit.vintage</groupId>
                   <artifactId>junit-vintage-engine</artifactId>
               </exclusion>
           </exclusions>
       </dependency>
   </dependencies>

   <build>
       <plugins>
           <plugin>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-maven-plugin</artifactId>
           </plugin>
       </plugins>
   </build>

</project>

나머지예제응용 프로그램:

@SpringBootApplication
public class RestExampleApplication {

   public static void main(String[] args) {
       SpringApplication.run(RestExampleApplication.class, args);
   }

}

REST 기능 생성

우리 애플리케이션은 클라이언트를 관리합니다. 따라서 가장 먼저 해야 할 일은 고객 엔터티를 만드는 것입니다. 이것은 POJO 클래스가 될 것입니다. modelpackage 안에 패키지를 만들어 보겠습니다 com.javarush.lectures.rest_example. 패키지 내부에 model클래스를 만들어 보겠습니다 Client.

public class Client {

   private Integer id;
   private String name;
   private String email;
   private String phone;

   public Integer getId() {
       return id;
   }

   public void setId(Integer id) {
       this.id = id;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public String getEmail() {
       return email;
   }

   public void setEmail(String email) {
       this.email = email;
   }

   public String getPhone() {
       return phone;
   }

   public void setPhone(String phone) {
       this.phone = phone;
   }
}

서비스는 클라이언트에서 CRUD 작업을 구현합니다. 다음 단계는 이러한 작업을 구현할 서비스를 만드는 것입니다. 패키지에서 우리는 인터페이스를 생성할 com.javarush.lectures.rest_example패키지를 생성할 것입니다 . 주석이 포함된 인터페이스 코드는 다음과 같습니다. serviceClientService

public interface ClientService {

   /**
    * Создает нового клиента
    * @param client - клиент для создания
    */
   void create(Client client);

   /**
    * returns список всех имеющихся клиентов
    * @return список клиентов
    */
   List<client> readAll();

   /**
    * returns клиента по его ID
    * @param id - ID клиента
    * @return - an object клиента с заданным ID
    */
   Client read(int id);

   /**
    * Обновляет клиента с заданным ID,
    * в соответствии с переданным клиентом
    * @param client - клиент в соответсвии с которым нужно обновить данные
    * @param id - id клиента которого нужно обновить
    * @return - true если данные были обновлены, иначе false
    */
   boolean update(Client client, int id);

   /**
    * Удаляет клиента с заданным ID
    * @param id - id клиента, которого нужно удалить
    * @return - true если клиент был удален, иначе false
    */
   boolean delete(int id);
}

다음으로 이 인터페이스의 구현을 생성해야 합니다. 이제 클라이언트 저장소 역할을 하게 됩니다 Map<Integer, Client>. 카드 키는 클라이언트 ID가 되고 값은 클라이언트 자체가 됩니다. 이는 데이터베이스 작업의 세부 사항으로 예제에 과부하가 걸리지 않도록 수행되었습니다. 그러나 앞으로는 실제 데이터베이스에 연결할 수 있는 또 다른 인터페이스 구현을 작성할 수 있을 것입니다. 패키지에서 service인터페이스 구현을 생성합니다 ClientService.

@Service
public class ClientServiceImpl implements ClientService {

   // Хранorще клиентов
   private static final Map<Integer, Client> CLIENT_REPOSITORY_MAP = new HashMap<>();

   // Переменная для генерации ID клиента
   private static final AtomicInteger CLIENT_ID_HOLDER = new AtomicInteger();

   @Override
   public void create(Client client) {
       final int clientId = CLIENT_ID_HOLDER.incrementAndGet();
       client.setId(clientId);
       CLIENT_REPOSITORY_MAP.put(clientId, client);
   }

   @Override
   public List<Client> readAll() {
       return new ArrayList<>(CLIENT_REPOSITORY_MAP.values());
   }

   @Override
   public Client read(int id) {
       return CLIENT_REPOSITORY_MAP.get(id);
   }

   @Override
   public boolean update(Client client, int id) {
       if (CLIENT_REPOSITORY_MAP.containsKey(id)) {
           client.setId(id);
           CLIENT_REPOSITORY_MAP.put(id, client);
           return true;
       }

       return false;
   }

   @Override
   public boolean delete(int id) {
       return CLIENT_REPOSITORY_MAP.remove(id) != null;
   }
}

주석은 @ServiceSpring에게 이 클래스가 서비스임을 알려줍니다. 이는 애플리케이션의 일부 비즈니스 로직이 구현되는 특별한 유형의 클래스입니다. 이후 이 주석 덕분에 Spring은 종속성 주입을 사용하여 필요한 위치에 이 클래스의 인스턴스를 제공합니다. 이제 컨트롤러를 생성할 차례입니다. 끝점(URI)에 대한 클라이언트 요청을 처리하기 위한 논리를 구현하는 특수 클래스입니다. 더 명확하게 하기 위해 이 클래스를 부분적으로 생성하겠습니다. 먼저 클래스 자체를 생성하고 이에 대한 종속성을 도입해 보겠습니다 ClientService.

@RestController
public class ClientController {

   private final ClientService clientService;

   @Autowired
   public ClientController(ClientService clientService) {
       this.clientService = clientService;
   }
}

주석을 명확히 합시다: @RestController - Spring에게 이 클래스가 REST 컨트롤러임을 알려줍니다. 저것들. 이 클래스는 클라이언트 요청 @Autowired 를 처리하기 위한 로직을 구현합니다 . Spring에게 이 위치에 종속성을 주입해야 한다고 알려줍니다. 인터페이스를 생성자에 전달합니다 ClientService. 우리는 이전에 주석으로 이 서비스의 구현을 표시했으며 @Service이제 Spring은 이 구현의 인스턴스를 컨트롤러 생성자에 전달할 수 있습니다. 다음으로 CRUD 작업을 처리하기 위해 각 컨트롤러 메서드를 단계별로 구현하겠습니다. 만들기 작업부터 시작해 보겠습니다. 이를 위해 메소드를 작성해 보겠습니다 create.

@PostMapping(value = "/clients")
public ResponseEntity<?> create(@RequestBody Client client) {
   clientService.create(client);
   return new ResponseEntity<>(HttpStatus.CREATED);
}

이 메소드를 살펴보겠습니다: @PostMapping(value = "/clients")- 여기서는 이 메소드가 /clients 주소에 대한 POST 요청을 처리한다는 것을 의미합니다 ResponseEntity<?>. ResponseEntity- 응답을 반환하기 위한 특수 클래스입니다. 이를 사용하면 나중에 HTTP 상태 코드를 클라이언트에 반환할 수 있습니다. 이 메소드는 매개변수를 사용하며 @RequestBody Client client이 매개변수의 값은 요청 본문에서 대체됩니다. 초록은 이것에 대해 이야기합니다 @RequestBody. 메소드 본문 내에서 이전에 생성된 서비스에 대한 create 메소드를 호출하고 이를 매개변수에 허용된 클라이언트 컨트롤러에 전달합니다. ResponseEntity그런 다음 새 객체를 생성 하고 필요한 열거형 값을 전달하여 201 Created 상태를 반환합니다 HttpStatus. 다음으로 작업을 구현합니다 Read. 먼저 사용 가능한 모든 클라이언트 목록을 얻는 작업을 구현합니다.

@GetMapping(value = "/clients")
public ResponseEntity<List<Client>> read() {
   final List<Client> clients = clientService.readAll();

   return clients != null &&  !clients.isEmpty()
           ? new ResponseEntity<>(clients, HttpStatus.OK)
           : new ResponseEntity<>(HttpStatus.NOT_FOUND);
}

분석을 시작해 보겠습니다. @GetMapping(value = "/clients")- 모든 것이 주석과 유사합니다 @PostMapping. 이제 GET 요청만 처리합니다. 이번에는 ResponseEntity<List<Client>>HTTP 상태 외에도 클라이언트 목록이 될 응답 본문도 반환합니다. Spring REST 컨트롤러에서 모든 POJO 객체와 응답 본문으로 반환되는 POJO 객체 컬렉션은 달리 명시적으로 지정하지 않는 한 자동으로 JSON으로 직렬화됩니다. 우리는 이것에 매우 만족합니다. 메소드 내에서 서비스를 사용하여 모든 클라이언트 목록을 얻습니다. 다음으로 목록이 null이 아니거나 비어 있지 않으면 ResponseEntity클래스를 사용하여 클라이언트 목록과 HTTP 상태 200 OK를 반환합니다. 그렇지 않으면 단순히 HTTP 상태 404 Not Found를 반환합니다. 다음으로, 그의 ID로 클라이언트를 얻는 기능을 구현하겠습니다.

@GetMapping(value = "/clients/{id}")
public ResponseEntity<Client> read(@PathVariable(name = "id") int id) {
   final Client client = clientService.read(id);

   return client != null
           ? new ResponseEntity<>(client, HttpStatus.OK)
           : new ResponseEntity<>(HttpStatus.NOT_FOUND);
}

새로운 점은 이제 경로 변수가 있다는 것입니다. URI에 정의된 변수입니다. value = "/clients/{id}". 우리는 이를 중괄호로 표시했습니다. 그리고 메소드 매개변수에서는 int주석을 사용하여 이를 변수 로 받아들입니다 @PathVariable(name = "id"). 이 메소드는 형식의 uri에 대한 요청을 수락합니다 /clients/{id}. 대신 {id}숫자 값이 있을 수 있습니다. 이 값은 이후에 변수 int id(메소드 매개변수)로 전달됩니다. 본문에서는 Client서비스를 사용하여 개체를 받고 수락합니다 id. 그런 다음 목록과 유사하게 200 OK 상태와 개체 자체를 반환하거나 시스템에 클라이언트가 없는 Client경우 간단히 404 Not Found 상태를 반환합니다. id업데이트와 삭제라는 두 가지 작업을 구현하는 것이 남아 있습니다. 이러한 메소드에 대한 코드는 다음과 같습니다.

@PutMapping(value = "/clients/{id}")
public ResponseEntity<?> update(@PathVariable(name = "id") int id, @RequestBody Client client) {
   final boolean updated = clientService.update(client, id);

   return updated
           ? new ResponseEntity<>(HttpStatus.OK)
           : new ResponseEntity<>(HttpStatus.NOT_MODIFIED);
}

@DeleteMapping(value = "/clients/{id}")
public ResponseEntity<?> delete(@PathVariable(name = "id") int id) {
   final boolean deleted = clientService.delete(id);

   return deleted
           ? new ResponseEntity<>(HttpStatus.OK)
           : new ResponseEntity<>(HttpStatus.NOT_MODIFIED);
}

이러한 방법에는 본질적으로 새로운 것이 없으므로 자세한 설명은 생략하겠습니다. 언급할 가치가 있는 유일한 점은 메소드가 updatePUT 요청(annotation @PutMapping)을 처리하고 메소드가 deleteDELETE 요청(annotation DeleteMapping)을 처리한다는 것입니다. 전체 컨트롤러 코드는 다음과 같습니다.

@RestController
public class ClientController {

   private final ClientService clientService;

   @Autowired
   public ClientController(ClientService clientService) {
       this.clientService = clientService;
   }

   @PostMapping(value = "/clients")
   public ResponseEntity<?> create(@RequestBody Client client) {
       clientService.create(client);
       return new ResponseEntity<>(HttpStatus.CREATED);
   }

   @GetMapping(value = "/clients")
   public ResponseEntity<List<Client>> read() {
       final List<client> clients = clientService.readAll();

       return clients != null &&  !clients.isEmpty()
               ? new ResponseEntity<>(clients, HttpStatus.OK)
               : new ResponseEntity<>(HttpStatus.NOT_FOUND);
   }

   @GetMapping(value = "/clients/{id}")
   public ResponseEntity<Client> read(@PathVariable(name = "id") int id) {
       final Client client = clientService.read(id);

       return client != null
               ? new ResponseEntity<>(client, HttpStatus.OK)
               : new ResponseEntity<>(HttpStatus.NOT_FOUND);
   }

   @PutMapping(value = "/clients/{id}")
   public ResponseEntity<?> update(@PathVariable(name = "id") int id, @RequestBody Client client) {
       final boolean updated = clientService.update(client, id);

       return updated
               ? new ResponseEntity<>(HttpStatus.OK)
               : new ResponseEntity<>(HttpStatus.NOT_MODIFIED);
   }

   @DeleteMapping(value = "/clients/{id}")
   public ResponseEntity<?> delete(@PathVariable(name = "id") int id) {
       final boolean deleted = clientService.delete(id);

       return deleted
               ? new ResponseEntity<>(HttpStatus.OK)
               : new ResponseEntity<>(HttpStatus.NOT_MODIFIED);
   }
}

결과적으로 우리 프로젝트의 구조는 다음과 같습니다.

출시 및 테스트

main애플리케이션을 실행하려면 클래스에서 메서드를 실행하면 됩니다 RestExampleApplication. 그리고 RESTful 웹 서비스를 테스트하려면 새 소프트웨어를 다운로드해야 합니다.) 사실 GET 요청은 일반 브라우저에서 보내기가 매우 쉽지만 POST, PUT 및 DELETE의 경우 일반 브라우저로는 충분하지 않습니다. 걱정하지 마세요. Postman을 사용하여 HTTP 요청을 보낼 수 있습니다. 여기에서 다운로드할 수 있습니다 . 다운로드하고 설치한 후 애플리케이션 테스트를 시작합니다. 이렇게 하려면 프로그램을 열고 새 요청을 작성하십시오. 왼쪽 상단 모서리에 있는 새로 만들기 버튼을 클릭하십시오. 다음으로 요청: 다음을 선택하고 이름을 지정하고 저장합니다. 이제 서버에 POST 요청을 보내고 첫 번째 클라이언트를 생성해 보겠습니다. 이런 방식으로 여러 클라이언트를 생성합니다. 그런 다음 요청 유형을 GET으로 변경하고 이를 서버로 보냅니다.

일반 결과

축하합니다. REST에 관한 주제를 꽤 많이 다루었습니다. 모든 자료는 방대한 것으로 밝혀졌지만 이것이 귀하에게 유용할 수 있기를 바랍니다.

1. REST가 무엇인지 배웠습니다.

2. REST의 역사를 알아봤습니다.

3. 우리는 이 아키텍처 스타일의 한계와 원칙에 대해 이야기했습니다.

   • 아키텍처를 클라이언트-서버 모델로 가져오는 것;
   • 상태 부족;
   • 캐싱;
   • 인터페이스의 균일성;
   • 레이어;
   • 주문형 코드(선택적 제한)

4. REST가 제공하는 이점을 조사했습니다.

5. HTTP 프로토콜을 사용하여 서버와 클라이언트가 어떻게 상호 작용하는지 자세히 살펴보았습니다.

6. 요청과 응답을 자세히 살펴보겠습니다. 해당 구성 요소가 분해되었습니다.

7. 마지막으로 우리는 Spring Boot에서 작은 RESTful 애플리케이션을 연습하고 작성했습니다. 그리고 Postman 프로그램을 사용하여 테스트하는 방법도 배웠습니다.

휴. 방대한 것으로 판명되었지만 그럼에도 불구하고 숙제로 할 일이 있습니다.

숙제

다음을 시도해 보세요:

1. 위의 설명에 따라 자신만의 Spring Boot 프로젝트를 생성하고 강의에서와 같은 로직을 구현해 보세요. 모든 것을 1in1로 반복하세요.
2. 그것을 실행하십시오. 애플리케이션.
3. Postman(또는 요청 전송을 위한 기타 도구, 심지어 컬)을 다운로드하고 설정합니다.
4. 강의에서 설명한 것과 동일한 방법으로 POST 및 GET 요청을 테스트합니다.
5. PUT 및 DELETE 요청을 직접 테스트해 보세요.

1부: REST란 무엇입니까 2부: 클라이언트와 서버 간의 통신