Spring RESTFul Web
Services
Basic Spring 5.0
Lesson Objectives
Introduction to Spring MVC framework
Spring MVC traditional workflow vs Spring MVC REST
Workflow
Using the @ResponseBody Annotation
Life cycle of a Request in Spring MVC Restful
Why REST Controller ?
Spring 4.x MVC RESTful Web Services Workflow
REST Controller
RESTful URLs – HTTP methods
Cross-Origin Resource Sharing (CORS)
@RequestBody annotation
7.1 Spring MVC traditional workflow vs Spring MVC REST Workflow
Request Request Handler
Handler
Mapping Dispatcher Mapping
Servlet
Dispatcher CLient
CLient Controller
Servlet
Response via @ResponseBody
Controller
Response
View
Spring MVC traditional workflow Spring3.x MVC REST Workflow
7.2 Using the @ResponseBody Annotation
When you use the @ResponseBody annotation on a method, Spring converts the return value and
writes it to the http response automatically.
@Controller
@RequestMapping("employees")
public class EmployeeController {
Employee employee = new Employee();
@RequestMapping(value = "/{name}", method = RequestMethod.GET, produces =
"application/json")
public @ResponseBody Employee getEmployeeInJSON(@PathVariable String name) {
employee.setName(name);
employee.setEmail("employee1@genuitec.com");
return employee;
@RequestMapping(value = "/{name}.xml", method = RequestMethod.GET, produces =
"application/xml")
public @ResponseBody Employee getEmployeeInXML(@PathVariable String name) {
employee.setName(name);
employee.setEmail("employee1@genuitec.com");
return employee;
}
7.3 Life cycle of a Request in Spring MVC Restful
HandlerMapping
(@RequestMapping)
DispatcherServlet RestController
HttpRequest HttpResponse
Client
7.4 Why REST Controller ?
Traditional Spring MVC controller and the RESTful web service controller differs in the way the HTTP
response body is created
Traditional MVC controller relies on the View technology
RESTful controller simply returns the object and the object data is written directly to the HTTP
response as JSON/XML
Spring 4.0 introduced @RestController
No longer need to add @ResponseBody
7.5 Spring 4.x MVC RESTful Web Services Workflow
Request Handler
Dispatcher Mapping
Servlet
CLient
Response
RESTController
(@Controller +
@ResponseBody)
7.6 Spring 4 support for RESTful web services
In Spring 4 REST is built on the top of MVC
REST methods: GET, PUT, DELETE, and POST, can be handled by Controllers
Using @PathVariable annotation controllers can handle requested parameterized URLs
7.7 REST Controller
@RestController
@RequestMapping("/service/greeting")
public class SpringRestController {
@RequestMapping(value = "/{name}", method = RequestMethod.GET)
public String sayHello(@PathVariable Optional<String> name) {
String result = “Welcome " + name + " to Spring session!!!";
return result;
} No “name” required. “Do
} not repeat yourself” with
Java 8 version
output
REST Controller
@RestController
@RequestMapping("employees")
public class EmployeeController {
Employee employee = new Employee();
@RequestMapping(value = "/{name}", method = RequestMethod.GET, produces =
"application/json")
public Employee getEmployeeInJSON(@PathVariable String name) {
employee.setName(name);
employee.setEmail("employee1@genuitec.com");
return employee;
@RequestMapping(value = "/{name}.xml", method = RequestMethod.GET, produces =
"application/xml")
public Employee getEmployeeInXML(@PathVariable String name) {
employee.setName(name);
employee.setEmail("employee1@genuitec.com");
return employee;
}
RESTful URLs – HTTP methods
http://localhost:9090/SpringRESTWebServices/rest/co
untries
client Fetching all
country details –
HTTP Get
http://localhost:9090/SpringRESTWebServices/rest/countries/new
Creating a
client new country
– HTTP Post
http://localhost:9090/SpringRESTWebServices/rest/countrie
Deleting an
s/newDel
existing
client country –
HTTP
Delete
7.8 Cross-Origin Resource Sharing (CORS)
• Cross-Origin Resource Sharing (CORS) is a mechanism that uses
additional HTTP headers to let a user agent gain permission to access
selected resources from a server on a different origin (domain) than the
site currently in use.
• A user agent makes a cross-origin HTTP request when it requests a
resource from a different domain, protocol, or port than the one from
which the current document originated.
• An example of a cross-origin request: A HTML page served from
http://domain-a.com makes an <img> src request for http://domain-
b.com/image.jpg. Many pages on the web today load resources like CSS
stylesheets, images, and scripts from separate domains, such as content
delivery networks (CDNs)
Cross-Origin Resource Sharing (CORS)
For security reasons, browsers restrict cross-origin HTTP requests initiated
from within scripts. For example, XMLHttpRequest and the Fetch API follow
the same-origin policy. This means that a web application using those APIs
can only request HTTP resources from the same domain the application was
loaded from unless CORS headers are used.
Cross-Origin Resource Sharing (CORS)
• We can add an @CrossOrigin annotation to
your @RequestMapping annotated handler method in order to
enable CORS on it.
• By default @CrossOrigin allows all origins and the HTTP
methods specified in the @RequestMapping annotation
• It is also possible to enable CORS for the whole controller. So,
we can even use both controller-level and method-level CORS
configurations
• In addition to fine-grained, annotation-based configuration
you’ll probably want to define some global CORS configuration
as well.
Cross-Origin Resource Sharing (CORS)
@CrossOrigin(origins = "http://localhost:4200")
@RestController
public class CountryController {
@Autowired
ICountryService service;
//@CrossOrigin(origins = "http://localhost:4200")
@RequestMapping(value = "/countries/search/{id}",method =
RequestMethod.GET,headers="Accept=application/json")
public Country getCounty(@PathVariable int id) {
return service.searchCountry(id);
}}
6.9 @RequestBody annotation
• If a method parameter is annotated with @RequestBody, Spring will
bind the incoming HTTP request body(for the URL mentioned in
@RequestMapping for that method) to that parameter.
• While doing that, Spring will use HTTP Message converters to convert
the HTTP request body into domain object [deserialize request
body to domain object], based on Accept header present in
request.
@RestController
public class EmployeeController {
@Autowired
IEmployeeService empservice;
@RequestMapping(value ="/employee/create/", consumes =
MediaType.APPLICATION_JSON_VALUE,
headers="Accept=application/json",method =
RequestMethod.POST)
public List<Employee> createEmployee(@RequestBody Employee
emp) {
empservive.addEmployee(emp);
return empservice.getAllEmployee();
}}
Demo: SpringRESTDemos
SpringRESTDemo
Summery
We have so far learnt
Spring MVC traditional workflow vs Spring MVC REST
Workflow
Using the @ResponseBody Annotation
Life cycle of a Request in Spring MVC Restful
Why REST Controller ?
Spring 4.x MVC RESTful Web Services Workflow
REST Controller
RESTful URLs – HTTP methods
Spring ReSTful
Lab
Lab 2
Review Question
Question 1: Which of the following are true?
Option1 : Resource classes are POJOs that have at least one method annotated
with @Path
Option 2: Resource methods are methods of a resource class annotated with a request
method designator such as @GET, @PUT, @POST, or @DELETE
Option 3: @FormParam binds query parameters value to a Java method
Question 2: The @Path annotation’s value is a relative URI path indicating
where the Java class will be hosted?
True
False
Review Question
Question 3: ___________ specifies a media type a resource can generate.
@PUT
@POST
@Produces
@Consumes
