Spring Web Annotations

@RequestMapping

Simply put, @RequestMapping marks request handler methods inside @Controller classes; it can be configured using:
  • path, or its aliases, name, and value: which URL the method is mapped to
  • method: compatible HTTP methods
  • params: filters requests based on presence, absence, or value of HTTP parameters
  • headers: filters requests based on presence, absence, or value of HTTP headers
  • consumes: which media types the method can consume in the HTTP request body
  • produces: which media types the method can produce in the HTTP response body
Example:
1
2
3
4
5
6
7
8
@Controller
class VehicleController {
 
    @RequestMapping(value = "/vehicles/home", method = RequestMethod.GET)
    String home() {
        return "home";
    }
}
We can provide default settings for all handler methods in a @Controller class if we apply this annotation on the class level. The only exception is the URL which Spring won’t override with method level settings but appends the two path parts.
For example, the following configuration has the same effect as the one above:
1
2
3
4
5
6
7
8
9
@Controller
@RequestMapping(value = "/vehicles", method = RequestMethod.GET)
class VehicleController {
 
    @RequestMapping("/home")
    String home() {
        return "home";
    }
}
Moreover, @GetMapping, @PostMapping, @PutMapping, @DeleteMapping, and @PatchMapping are different variants of @RequestMapping with the HTTP method already set to GET, POST, PUT, DELETE, and PATCH respectively.
These are available since Spring 4.3 release.

@RequestBody

@RequestBody maps the body of the HTTP request to an object:
1
2
3
4
@PostMapping("/save")
void saveVehicle(@RequestBody Vehicle vehicle) {
    // ...
}
The deserialization is automatic and depends on the content type of the request.

@PathVariable

@PathVariable indicates that a method argument is bound to a URI template variable. We can specify the URI template with the @RequestMapping annotation and bind a method argument to one of the template parts with @PathVariable.
We can achieve this with the name or its alias, the value argument:
1
2
3
4
@RequestMapping("/{id}")
Vehicle getVehicle(@PathVariable("id") long id) {
    // ...
}
If the name of the part in the template matches the name of the method argument, we don’t have to specify it in the annotation:
1
2
3
4
@RequestMapping("/{id}")
Vehicle getVehicle(@PathVariable long id) {
    // ...
}
Moreover, we can mark a path variable optional by setting the argument required to false:
1
2
3
4
@RequestMapping("/{id}")
Vehicle getVehicle(@PathVariable(required = false) long id) {
    // ...
}

@RequestParam

We use @RequestParam for accessing HTTP request parameters:
1
2
3
4
@RequestMapping
Vehicle getVehicleByParam(@RequestParam("id") long id) {
    // ...
}
It has the same configuration options as the @PathVariable annotation.
In addition to those settings, with @RequestParam we can specify an injected value when Spring finds no or empty value in the request. To achieve this, we have to set the defaultValue argument.
Providing a default value implicitly sets required to false:
1
2
3
4
@RequestMapping("/buy")
Car buyCar(@RequestParam(defaultValue = "5") int seatCount) {
    // ...
}
Besides parameters, there are other HTTP request parts we can access: cookies and headers. We can access them with the annotations @CookieValue and @RequestHeader respectively.
We can configure them the same way as @RequestParam.

Response Handling Annotations

In the next sections, we will see the most common annotations to manipulate HTTP responses in Spring MVC.

@ResponseBody

If we mark a request handler method with @ResponseBody, Spring treats the result of the method as the response itself:
1
2
3
4
5
@ResponseBody
@RequestMapping("/hello")
String hello() {
    return "Hello World!";
}
If we annotate a @Controller class with this annotation, all request handler methods will use it.

@ExceptionHandler

With this annotation, we can declare a custom error handler method. Spring calls this method when a request handler method throws any of the specified exceptions.
The caught exception can be passed to the method as an argument:
1
2
3
4
@ExceptionHandler(IllegalArgumentException.class)
void onIllegalArgumentException(IllegalArgumentException exception) {
    // ...
}

@ResponseStatus

We can specify the desired HTTP status of the response if we annotate a request handler method with this annotation. We can declare the status code with the code argument, or its alias, the value argument.
Also, we can provide a reason using the reason argument.
We also can use it along with @ExceptionHandler:
1
2
3
4
5
@ExceptionHandler(IllegalArgumentException.class)
@ResponseStatus(HttpStatus.BAD_REQUEST)
void onIllegalArgumentException(IllegalArgumentException exception) {
    // ...
}
For more information about HTTP response status, please visit this article.

Other Web Annotations

@Controller

We can define a Spring MVC controller with @Controller. 

@RestController

The @RestController combines @Controller and @ResponseBody.
Therefore, the following declarations are equivalent:
1
2
3
4
5
@Controller
@ResponseBody
class VehicleRestController {
    // ...
}
1
2
3
4
@RestController
class VehicleRestController {
    // ...
}

@ModelAttribute

With this annotation we can access elements that are already in the model of an MVC @Controller, by providing the model key:
1
2
3
4
@PostMapping("/assemble")
void assembleVehicle(@ModelAttribute("vehicle") Vehicle vehicleInModel) {
    // ...
}
Like with @PathVariable and @RequestParam, we don’t have to specify the model key if the argument has the same name:
1
2
3
4
@PostMapping("/assemble")
void assembleVehicle(@ModelAttribute Vehicle vehicle) {
    // ...
}
Besides, @ModelAttribute has another use: if we annotate a method with it, Spring will automatically add the method’s return value to the model:
1
2
3
4
@ModelAttribute("vehicle")
Vehicle getVehicle() {
    // ...
}
Like before, we don’t have to specify the model key, Spring uses the method’s name by default:
1
2
3
4
@ModelAttribute
Vehicle vehicle() {
    // ...
}
Before Spring calls a request handler method, it invokes all @ModelAttribute annotated methods in the class.

@CrossOrigin

@CrossOrigin enables cross-domain communication for the annotated request handler methods:
1
2
3
4
5
@CrossOrigin
@RequestMapping("/hello")
String hello() {
    return "Hello World!";
}

Comments

Post a Comment

Popular posts from this blog

gsutil Vs Storage Transfer Service Vs Transfer Appliance

When transferring data from an on-premiss location, use gsutil When transferring data from another cloud storage provider, use storage transfer service gsutil is a Python application that lets you access Cloud Storage from the command line. You can use gsutil to do a wide range of bucket and object management tasks, including: Creating and deleting buckets. Uploading, downloading, and deleting objects. Listing buckets and objects. Moving, copying, and renaming objects. Editing object and bucket ACLs. gsutil performs all operations, including uploads and downloads, using HTTPS and transport-layer security (TLS). For a complete list of guides to completing tasks with gsutil, see  Cloud Storage How-to Guides . Storage Transfer Service is a product that enables you to: Move or backup data to a Cloud Storage bucket either from other cloud storage providers or from your  on-premises  storage. Move data from one Cloud Storage bucket to another, so that it is available to differe...
Read more

SQL basic interview question

Image
Question #1) What is SQL? Structured Query Language is a database tool which is used to create and access database to support software application. Question #2) What are tables in SQL? The table is a collection of record and its information at a single view. Question #3) What are different types of statements supported by SQL? There are 3 types of SQL statements 1) DDL (Data Definition Language):  It is used to define the database structure such as tables. It includes three statements such as Create, Alter, and Drop. Some of the DDL Commands are listed below CREATE : It is used for creating the table. 1 CREATE   TABLE  table_name 2 column_name1 data_type( size ), 3 column_name2 data_type( size ), 4 column_name3 data_type( size ), ALTER:  The ALTER table is used for modifying the existing table object in the database. ALTER TABLE table_name ADD column_name datatype OR ALTER TABLE table_name DROP ...
Read more