Spring Boot RESTFul Web Service Example – GET/POST/PUT/PATCH/DELETE

2018. 2. 1. 11:23

예제에 앞서 REST 에 대한 정의는 Representational state transfer 이다. RESTFul을 이용하는 이유에 대해서는 굳이 설명을 하지 않아도 될 듯 하다. 간단히 내 생각을 이야기 하자면, 우선 cloud 가 아닌 단일 Web Application만 생각해 볼때 현재 개발 추세가 Back-end 의 중요성 보다는 Front-end 의 UI/UX 디자인의 비중이 좀더 커가고 있다. 예전에 그저 model을 던저 주고 JSP 에서 그 모델을 JSP 페이지 쪽에 던져 주어 content를 만드는 방법에서 이제는 Front-end 가 로딩 되어진 상태에서 asynchronous 방식으로 content를 서버쪽에서 받아와 보여주는 방식을 선호 하게 되었다. 이렇게 하여 우선 Front-end의 로딩 속도를 빨리 가져 갈수 있다. 머 사실 어찌 되었던 간에 Back-end 데이타 가져 오는 데 걸리는 시간은 같지만…. 그래도 페이지 전체가 먼저 보여 졌을 때랑, 그렇지 않고 back-end 데이타를 기다리는 동안 페이지르 볼 수 없는 것이랑은 느낌이 틀리니. 이런 이유로 RESTFul Web Service 의 비중도 커졌고 이에 대한 개발도 좀더 구체화 되었다.

먼저 내가 사용한 개발 환경은:

Spring Boot 1.4.3.RELEASE (Spring Framework 4.3.5.RELEASE 가 사용 되어 진다.)
Java 1.7 version으로 세팅 (1.8로 해도 무난)
Postman – RESTFul 개발시 test 를 위해 사용 되어 지는 GUI 이다. Mac OS, Windows, Chrome browser 용으로 설치 하면 된다.
Eclipse

자 그럼 시작에 앞서 아래 5가지의 HTTP request method type 들에 대해서 알아 보자.

GET – 데이타를 검색하여 해당 값을 받아 올때 사용한다. (CRUD 에서 Retrieve 할 때 사용)
POST – 새롭게 데이타를 생성 할 때 사용 한다. (CRUD 에서 Create 할 때 사용)
PUT – 데이타를 업데이트 할 때 사용 한다. (CRUD 에서 Update 할 때 사용)
PATCH – PUT 과 마찬가지로 데이타를 업데이트 할 때 사용하지만 PUT 과 달리 전체 Entity 데이타의 업데이트가 아닌 부분의 값을 업데이트 할 때 사용한다.
DELETE – 데이타를 삭제 할 때 사용한다. (CRUD 에서 Delete 할 떄 사용)

이렇게 HTTP request method type 에 대해 Front-end 개발자와 Back-end 개발자 사이에 확실한 이해를 하고 넘어 가야 한다. 물론 Back-end 개발자의 경우 Front-end 개발자가 사용 할 수 있도록 정확한 문서를 제공해야 한다.

먼저 아래와 같이 Eclipse 를 이용하여 sbrest 라고 하는 프로젝트를 만들고 pom.xml 을 설정하자.

pom.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	
	<groupId>com.pristinecore</groupId>
	<artifactId>sbrest</artifactId>
	<version>1.0.1</version>
	<packaging>war</packaging>
	
	<name>sbrest</name>
	<url>http://maven.apache.org</url>
	
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.4.3.RELEASE</version>
	</parent>
	
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<java.version>1.7</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-data-jpa</artifactId>
		</dependency>
		
		<dependency>
			<groupId>com.h2database</groupId>
			<artifactId>h2</artifactId>
		</dependency>
		
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

그러면 이제 Customer Entity 를 이용한 CRUD 를 하는 간단한 RESTFul 을 만들어 보자. 우선 아래와 같이 Customer entity를 만든다.

Customer.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
package com.pristinecore.sbrest.domain;
 
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
 
/**
 * Customer Entity
 *
 * @author Brient Oh
 */
@Entity
public class Customer {
	
	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	private Long id;
	private String firstname;
	private String lastname;
	
	/**
	 * Default protected constructor
	 */
	protected Customer() {}
	
	/**
	 * Customer constructor with first and last name
	 * @param firstname first name
	 * @param lastname last name
	 */
	public Customer(final String firstname, final String lastname) {
		this.firstname = firstname;
		this.lastname = lastname;
	}
 
	/**
	 * @return the id
	 */
	public Long getId() {
		return id;
	}
 
	/**
	 * @param id the id to set
	 */
	public void setId(final Long id) {
		this.id = id;
	}
 
	/**
	 * @return the firstname
	 */
	public String getFirstname() {
		return firstname;
	}
 
	/**
	 * @param firstname the firstname to set
	 */
	public void setFirstname(final String firstname) {
		this.firstname = firstname;
	}
 
	/**
	 * @return the lastname
	 */
	public String getLastname() {
		return lastname;
	}
 
	/**
	 * @param lastname the lastname to set
	 */
	public void setLastname(final String lastname) {
		this.lastname = lastname;
	}
 
	/* (non-Javadoc)
	 * @see java.lang.Object#toString()
	 */
	@Override
	public String toString() {
		return "Customer [id=" + id + ", firstname=" + firstname
				+ ", lastname=" + lastname + "]";
	}
}

Spring framework 4.0 이후 버전에서는 Entity class 에서 @Table annotation 을 사용 하지 않으면 기본적으로 class 이름과 같은 table 을 맵핑한다. 따라서 class 이름과 다른 table 이름을 사용 한다면 @Table(name = “tbl_customer”) 처럼 명시 하여 주어야 한다. 또 한 가지는 class의 property 들도 @Column annotation을 사용 하지 않는 다면 기본적으로 property 이름을 이용하여 table column 이름과 맵핑을 하게 된다. 위에서는 firstname과 lastname이 이 경우에 해당한다.

다음으로 Spring Data JPA 를 이용하여 아래와 같이 간단하게 Repository 인터페이스와 Service 를 만들자.

CustomerRepository.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.pristinecore.sbrest.repository;
 
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
 
import com.pristinecore.sbrest.domain.Customer;
 
/**
 * Repository for Customer entity
 *
 * @author Brient Oh
 */
@Repository
public interface CustomerRepository extends CrudRepository<Customer, Long> {
 
}

CustomerService.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
package com.pristinecore.sbrest.service;
 
import java.util.List;
 
import com.pristinecore.sbrest.domain.Customer;
 
/**
 * CustomerService interface
 * 
 * @author Brient Oh
 */
public interface CustomerService {
 
	/**
	 * To return a customer object fetched by ID
	 * 
	 * @param customerId customer ID
	 * @return Customer object
	 */
	Customer findById(Long customerId);
	
	/**
	 * @return the list of all customers
	 */
	List<Customer> findAllCustomers();
	
	/**
	 * @param customer Customer entity to be saved
	 */
	Customer saveCustomer(Customer customer);
	
	/**
	 * @param customer Customer entity to check existence
	 * @return true if exist; otherwise, return false
	 */
	Boolean isCustomerExist(Customer customer);
	
	/**
	 * @param id customer ID to be updated
	 * @param customer updated customer entity
	 * @return updated customer entity
	 */
	Customer updateCustomer(Long id, Customer customer);
	
	/**
	 * @param id customer ID to be updated
	 * @param customer updated customer entity
	 * @return patched customer entity
	 */
	Customer patchCustomer(Long id, Customer customer);
	
	/**
	 * @param id customer ID to be deleted
	 * @return true, if deleted; otherwise, return false
	 */
	Boolean deleteCustomer(Long id);
}

CustomerServiceImpl.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
package com.pristinecore.sbrest.service;
 
import java.util.List;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import com.pristinecore.sbrest.domain.Customer;
import com.pristinecore.sbrest.repository.CustomerRepository;
 
/**
 * CustomerService Implementation
 *
 * @author Brient Oh
 */
@Service("customerService")
public class CustomerServiceImpl implements CustomerService {
	
	@Autowired
	private CustomerRepository customerRepository;
 
	@Override
	public Customer findById(final Long customerId) {
		return customerRepository.findOne(customerId);
	}
 
	@Override
	public List<Customer> findAllCustomers() {
		return (List<Customer>) customerRepository.findAll();
	}
 
	@Override
	public Customer saveCustomer(final Customer customer) {
		return customerRepository.save(customer);
	}
 
	@Override
	public Boolean isCustomerExist(final Customer customer) {
		if (customer.getId() != null) {
			final Customer existingCustomer = customerRepository.findOne(customer.getId());
			if (existingCustomer == null) {
				return false;
			} else {
				return true;
			}
		} else {
			return false;
		}
	}
 
	@Override
	public Customer updateCustomer(final Long id, final Customer customer) {
		
		final Customer fetchedCustomer = customerRepository.findOne(id);
		if (fetchedCustomer == null) {
			return null;
		}
		fetchedCustomer.setFirstname(customer.getFirstname());
		fetchedCustomer.setLastname(customer.getLastname());
		
		customerRepository.save(fetchedCustomer);
		
		return fetchedCustomer;
	}
 
	@Override
	public Customer patchCustomer(Long id, Customer customer) {
 
		final Customer fetchedCustomer = customerRepository.findOne(id);
		if (fetchedCustomer == null) {
			return null;
		}
		
		if (customer.getFirstname() != null) {
			fetchedCustomer.setFirstname(customer.getFirstname());
		}
		
		if (customer.getLastname() != null) {
			fetchedCustomer.setLastname(customer.getLastname());
		}
		
		customerRepository.save(fetchedCustomer);
		
		return fetchedCustomer;
	}
 
	@Override
	public Boolean deleteCustomer(final Long id) {
		final Customer fetchedCustomer = customerRepository.findOne(id);
		if (fetchedCustomer == null) {
			return false;
		} else {
			customerRepository.delete(fetchedCustomer);
			return true;
		}
	}
 
}

여기 까지 간단하게 Customer entity 에 대한 CRUD 오퍼레이션을 하는 Repository와 Service 를 만들어 보았다. 이제 RESTFul 을 만들어 보자. 개인적으로 @RestController 들을 따로 package를 만들어 관리를 하는 것을 선호 한다. 따라서 아래와 같이 rest package를 만들어 그곳에 Rest Controller 들을 정의 한다.

위와 같이 RestCustomerConstroller.java 를 만들고 @RestController annotation을 설정 하여 Rest Controller를 만들었다. 먼저 GET/POST/PUT/PATCH/DELETE 를 이용한 Rest 코드 부터 하나 하나 알아 보겠다.

GET – To retrieve data

GET 을 이용 하는 경우는 Data를 검색할 때 사용 한다.

GET - To retrieve data
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@RequestMapping(value = "/customer", method = RequestMethod.GET) 
public ResponseEntity<List<Customer>> listAllCustomers() {
	final List<Customer> allCustomers = customerService.findAllCustomers();
	if (allCustomers.isEmpty()) {
		return new ResponseEntity<List<Customer>>(HttpStatus.NO_CONTENT);
	}
	
	return new ResponseEntity<List<Customer>>(allCustomers, HttpStatus.OK);
}
 
@RequestMapping(value = "/customer/{id}", method = RequestMethod.GET)
public ResponseEntity<Customer> getCustomer(@PathVariable("id") final Long id) {
	final Customer fetchedCustomer = customerService.findById(id);
	if (fetchedCustomer == null) {
		return new ResponseEntity<Customer>(HttpStatus.NOT_FOUND);
	}
	
	return new ResponseEntity<Customer>(fetchedCustomer, HttpStatus.OK);
}

위에서 보면 전체 customer list를 가져오거나 @PathVariable을 이용하여 customer ID 를 보내 특정 customer 를 검색하여 데이타를 받는 경우이다. method = RequestMethod.GET 을 @RequestMapping 에 정의 하면 된다. 리턴은 ReponseEntity<T> 클래스를 이용하여 검색이 되지 않았을 경우에는 HttpStatus.NOT_FOUND 를 넘겨 주고, 검색이 되었을 경우에는 검색한 결과 object을 HttpStatus.OK 와 함께 넘겨 준다. 이때 Spring 에서는 자동으로 jackson-databind 를 이용하여 JSON 포맷으 데이타를 넘겨 준다.

POST – To create data

POST 를 이용 하는 경우는 Data를 새롭게 만들 때 사용 한다.

POST - To create data
1
2
3
4
5
6
7
8
9
10
11
12
13
@RequestMapping(value = "/customer", method = RequestMethod.POST)
public ResponseEntity<Void> createCustomer(@RequestBody final Customer customer,
		final UriComponentsBuilder ucBuilder) {
	
	if (customerService.isCustomerExist(customer)) {
		return new ResponseEntity<Void>(HttpStatus.CONFLICT);
	}
	final Customer savedCustomer = customerService.saveCustomer(customer);
	
	final HttpHeaders headers = new HttpHeaders();
	headers.setLocation(ucBuilder.path("/customer/{id}").buildAndExpand(savedCustomer.getId()).toUri());
	return new ResponseEntity<Void>(headers, HttpStatus.CREATED);
}

POST 는 새로운 Data를 생성 할 때 사용 하는 방법으로 method = RequestMethod.POST 로 설정을 해 준다. argument 들로 Customer 객체를 @RequestBody 를 이용하여 받아 왔다. Front-end 쪽에서 JSON 포맷으로 Customer 데이타를 보내 주면 된다. 이 떄 Front-end 개발자는 POST 이기 때문에 새로운 객체를 생성해야 하는 것으로 알고 데이타를 보내 주어야 한다. 두번 째 argument 로 UriComponentBuilder 를 설정 했다. 이유는 Customer를 생성하고 HttpHeaders 객체의 location 정보를 넣어 주기 위함이다. 이렇게 해 주면 Front-end 쪽 개발자는 새로운 데이타가 성공적으로 생성 (HttpStatus.CREATED) 되었을 경우 header 정보에서 location 값을 찾아 redirect 해 줄 수 있게 된다.

위에서 보면 만약 새롭게 생성하려고 하는 데이타가 이미 존재 하는 경우라면 HttpStatus.CONFLICT를 ResponseEntity<Void> 를 통해 리턴해 준다.

PUT – To update data

PUT 을 이용 하는 경우는 존재 하는 Data를 업데이트 할 때 사용 한다.

PUT - To update data
1
2
3
4
5
6
7
8
9
10
11
@RequestMapping(value = "/customer/{id}", method = RequestMethod.PUT)
public ResponseEntity<Customer> updateCustomer(@PathVariable("id") final Long id,
		@RequestBody final Customer customer) {
	final Customer updatedCustomer = customerService.updateCustomer(id, customer);
	
	if (updatedCustomer == null) {
		return new ResponseEntity<Customer>(HttpStatus.NOT_FOUND);
	}
	
	return new ResponseEntity<Customer>(updatedCustomer, HttpStatus.OK);
}

PATCH – To update partial data

PATCH 는 부분적이 Data를 업데이트 할 때 사용 한다. 즉 Front-end 쪽에서 객체 전체 업데이트가 아닌 부분만 업데이트 할 때 업데이트 하는 부분만 RESTFul 에 보내 준다. PUT 과 PATCH 는 공통적으로 update 할 때 사용 하지만 PATCH 가 부분 데이타를 업데이트 한다는 점에서 PUT 과 차이가 있다.

PATHC - To update partial data
1
2
3
4
5
6
7
8
9
10
11
@RequestMapping(value = "/customer/{id}", method = RequestMethod.PATCH)
public ResponseEntity<Customer> patchCustomer(@PathVariable("id") final Long id,
		@RequestBody final Customer customer) {
	final Customer patchedCustomer = customerService.patchCustomer(id, customer);
	
	if (patchedCustomer == null) {
		return new ResponseEntity<Customer>(HttpStatus.NOT_FOUND);
	}
	
	return new ResponseEntity<Customer>(patchedCustomer, HttpStatus.OK);
}

위에서 method = RequestMethod.PATCH 를 설정해 주었고 업데이트 하려는 Customer의 ID와 Customer 객체를 받았다. 받은 Customer 객체의 경우 실제 업데이트 하려는 property 에만 값이 들어 있고 나머지는 null 이 들어 있게 된다. PATCH 가 성공적으로 되었으면 업데이트된 Customer 와 HttpStatus.OK 를 ResponseEntity<Customer> 에 넣어 보내 주고, 그렇지 않을 경우에는 HttpStatus.NOT_FOUND 를 넘겨준다. CustomerServiceImpl.java 의 patchCustomer 메소드를 참고 하기 바란다.

DELETE – To delete data

DELETE 를 이용 하는 경우는 Data를 삭제 할 때 사용 한다.

DELETE - To delete data
1
2
3
4
5
6
7
8
9
10
@RequestMapping(value = "/customer/{id}", method = RequestMethod.DELETE)
public ResponseEntity<Void> deleteCustomer(@PathVariable("id") final Long id) {
	Boolean deleteResult = customerService.deleteCustomer(id);
	
	if (deleteResult == null || !deleteResult) {
		return new ResponseEntity<Void>(HttpStatus.NOT_FOUND);
	}
	
	return new ResponseEntity<Void>(HttpStatus.OK);
}

method = RequestMethod.DELETE 를 이용 하고 성공했을 경우 ResponseEntity<Void> 에 HttpStatus.OK 를 넣어 주고 그렇지 않을 경우 HttpStatus.NOT_FOUND 를 넣어 넘겨주었다.

지금 까지 RESTFul controller 를 개발 하는 방법을 설명 하였다. 아래는 최종 파일 이다.

RestCustomerController.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
package com.pristinecore.sbrest.rest;
 
import java.util.List;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
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.RestController;
import org.springframework.web.util.UriComponentsBuilder;
 
import com.pristinecore.sbrest.domain.Customer;
import com.pristinecore.sbrest.service.CustomerService;
 
/**
 * RestCustomerController class
 * 
 * @author Brient Oh
 */
@RestController
public class RestCustomerController {
	
	@Autowired
	private CustomerService customerService;
	
	/**
	 * Retrieve All customers
	 * 
	 * @return ResponseEntity<List<Customer>>
	 */
	@RequestMapping(value = "/customer", method = RequestMethod.GET) 
	public ResponseEntity<List<Customer>> listAllCustomers() {
		final List<Customer> allCustomers = customerService.findAllCustomers();
		if (allCustomers.isEmpty()) {
			return new ResponseEntity<List<Customer>>(HttpStatus.NO_CONTENT);
		}
		
		return new ResponseEntity<List<Customer>>(allCustomers, HttpStatus.OK);
	}
 
	/**
	 * Retrieve a single customer
	 * 
	 * @param id customer ID
	 * @return ResponseEntity<Customer>
	 */
	@RequestMapping(value = "/customer/{id}", method = RequestMethod.GET)
	public ResponseEntity<Customer> getCustomer(@PathVariable("id") final Long id) {
		final Customer fetchedCustomer = customerService.findById(id);
		if (fetchedCustomer == null) {
			return new ResponseEntity<Customer>(HttpStatus.NOT_FOUND);
		}
		
		return new ResponseEntity<Customer>(fetchedCustomer, HttpStatus.OK);
	}
 
	/**
	 * Create a customer
	 * 
	 * @param customer object to be created
	 * @param ucBuilder UriComponentBuilder
	 * @return ResponseEntity<Void>
	 */
	@RequestMapping(value = "/customer", method = RequestMethod.POST)
	public ResponseEntity<Void> createCustomer(@RequestBody final Customer customer,
			final UriComponentsBuilder ucBuilder) {
		
		if (customerService.isCustomerExist(customer)) {
			return new ResponseEntity<Void>(HttpStatus.CONFLICT);
		}
		final Customer savedCustomer = customerService.saveCustomer(customer);
		
		final HttpHeaders headers = new HttpHeaders();
		headers.setLocation(ucBuilder.path("/customer/{id}").buildAndExpand(savedCustomer.getId()).toUri());
		return new ResponseEntity<Void>(headers, HttpStatus.CREATED);
	}
 
	/**
	 * Update a customer
	 * 
	 * @param id customer ID to be updated
	 * @param customer source Customer object to be updated
	 * @return ResponseEntity<Customer>
	 */
	@RequestMapping(value = "/customer/{id}", method = RequestMethod.PUT)
	public ResponseEntity<Customer> updateCustomer(@PathVariable("id") final Long id,
			@RequestBody final Customer customer) {
		final Customer updatedCustomer = customerService.updateCustomer(id, customer);
		
		if (updatedCustomer == null) {
			return new ResponseEntity<Customer>(HttpStatus.NOT_FOUND);
		}
		
		return new ResponseEntity<Customer>(updatedCustomer, HttpStatus.OK);
	}
 
	/**
	 * Patch a customer
	 * 
	 * @param id customer ID to be patched
	 * @param customer Customer object to be patched
	 * @return ResponseEntity<Customer>
	 */
	@RequestMapping(value = "/customer/{id}", method = RequestMethod.PATCH)
	public ResponseEntity<Customer> patchCustomer(@PathVariable("id") final Long id,
			@RequestBody final Customer customer) {
		final Customer patchedCustomer = customerService.patchCustomer(id, customer);
		
		if (patchedCustomer == null) {
			return new ResponseEntity<Customer>(HttpStatus.NOT_FOUND);
		}
		
		return new ResponseEntity<Customer>(patchedCustomer, HttpStatus.OK);
	}
 
	/**
	 * Delete a customer
	 * 
	 * @param id customer ID to be deleted
	 * @return ResponseEntity<Void>
	 */
	@RequestMapping(value = "/customer/{id}", method = RequestMethod.DELETE)
	public ResponseEntity<Void> deleteCustomer(@PathVariable("id") final Long id) {
		Boolean deleteResult = customerService.deleteCustomer(id);
		
		if (deleteResult == null || !deleteResult) {
			return new ResponseEntity<Void>(HttpStatus.NOT_FOUND);
		}
		
		return new ResponseEntity<Void>(HttpStatus.OK);
	}
 
}

이렇게 하여 간단하게 Spring Boot 을 이용한 REST web application을 만들어 보았다.

최종 프로젝트는 위와 같을 것이다. 자 그러면 이제 Postman 을 이용하여 위에서 만든 RESTFul web application을 테스트 해 보자. 아직 Postman을 설치 하지 않았다면 아래 사이트에 가서 각자의 환경에 맞게 다운 받아 설치를 하자.

TEST

자 그러면 먼저 Spring Boot application을 실행 하자.

그리고 이제 Postman을 실행 하자. 원하면 Sign up을 해서 자신이 test 한 것을 저장할 수 있다.

먼저 Data 가 아무 것도 없으니 CREATE method 를 이용하여 생성 해 보자.

위와 같이 POST 로 http://localhost:8080/customer 를 호출 하였다. 이때 Body 에는 javascript의 AJAX 를 이용하여 업데이트 한다는 가정으로 raw 와 JSON (application/json) 을 설정하고 JSON 데이타를 타입한 후에 Send 버튼을 눌러 호출 하면 된다. 이렇게 하면 아래 보는 것과 같이 Status: 201 Created 가 넘어 오는 것을 확인 할 수 있다. 다른 이름을 이용하여 하나 더 만들어 보자.

그 다음으로 위에서 생성한 데이타를 검색해 보자.

위에서는 http://localhost:8080/customer 를 GET 방식을 이용하여 Send 를 눌렀다. 그리고 나면 아래와 같이 Status: 200 OK 와 생성한 Customer 리스트를 볼 수 있다.

위에서는 http://localhost:8080/customer/2 를 GET 방식을 이용하여 Send 를 눌렀다. 그리고 나면 아래와 같이 Status: 200 OK 와 id 값이 2 인 Customer 검색 결과가 리턴 된다.

이번엔 PUT을 이용한 Update 이다.

보는 것과 같이 Front-end 쪽에서는 객체 전체 데이타를 update 하기 위해 보내 주었다. 위와 같이 PUT으로 설정해서 Send 를 누르면 업데이트 된 결과 값이 Status: 200 OK 와 함께 넘어 온다.

이제 PATCH 를 보자.

위에서 보면 front-end 에서는 lastname 만 넣어 PATCH 를 이용하여 request를 보냈다. 이렇게 하면 back-end 쪽에서는 부분 업데이트로 알고 lastname 만 업데이트 해 주었다. 리턴된 결과를 보면 Status: 200 OK 와 lastname 이 업데이트된 JSON 데이타 결과 같이 넘어 왔다.

마지막으로 아래 DELETE 를 해 보자.

DELETE 를 이용 http://localhost:8080/customer/2 를 호출 하여보면 ID 가 2 인 Customer 가 삭제 되고 Status: 200 OK 가 넘어 왔다.

이상 Spring Boot 을 이용한 RESTFul web service 를 만들어 보았다.

** DOWNLOAD this project

** Reference

'JAVA／SPRING > SPRING-BOOT' 카테고리의 다른 글

Spring Boot의 application.properties에 대해.. (0)	2018.02.09
[Spring-boot]eclipse에서 Maven 으로 OpenCV 사용하기 (0)	2018.02.09
[Spring Boot]log4j2 RollingFileAppender 튜토리얼 (0)	2017.12.05
[Spring Boot]log4j2 구성 튜토리얼 (0)	2017.12.05
[Spring Boot]Spring MVC 웹 튜토리얼 (0)	2017.12.05

주노의IT지식창고