How to use @RequestParam annotation in Spring Boot Controller.
- Maheshwar
- Java, Junit, microservices
- Jan 01, 2021
In this tutorial, we are going to use the @RequestParam
annotation to read request param from request in the controller. Whether it is REST request or non REST request. @RequestParam plays key role in taking input from user or client.
@RequestParam annotation code snippet.
@Target(value=PARAMETER)
@Retention(value=RUNTIME)
@Documented
public @interface RequestParam
Annotation which indicates that a method parameter should be bound to a web request parameter.
If the method parameter type is Map
and a request parameter name is specified, then the request parameter value is converted to a Map
assuming an appropriate conversion strategy is available.
If the method parameter is Map<String, String>
or MultiValueMap<String, String>
and a parameter name is not specified, then the map parameter is populated with all request parameter names and values.
Example:-
We will create one simple example with one single cotroller. Here we will reuse our mustache helloworld example.
which we have published at below location.
https://medium.com/techwasti/spring-boot-mustache-hello-world-example-ded94471577c
build.gradle
plugins {
id 'org.springframework.boot' version '2.4.1'
id 'io.spring.dependency-management' version '1.0.10.RELEASE'
id 'java'
}
group = 'com.techwasti.mustache'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '11'
repositories {
mavenCentral()
}
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-mustache'
implementation 'org.springframework.boot:spring-boot-starter-web'
testImplementation 'org.springframework.boot:spring-boot-starter-test'
}
test {
useJUnitPlatform()
}
In the the gradle build file we have the spring-boot-starter-web
, which is a starter for building web applications using Spring MVC. It uses Tomcat as the default embedded container. The spring-boot-devtools
is an artifact useful when developing Spring Boot applications; it allows automatic restart or live reload of applications. The application is packaged into a JAR file.
HelloController.java:
package com.techwasti.springmustacheex;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
@Controller
public class HelloController {
@GetMapping(value = {"/", "/hello"})
public String greetMessage(Model model) {
String helloworld="Hello and welcome to mustache";
model.addAttribute("message", helloworld);
return "hello";
}
// this is we have added to demonstrate the @RequestParam annotation.
@RequestMapping(path="/greeting", produces=MediaType.TEXT_PLAIN_VALUE)
@ResponseBody
public String greetUser(@RequestParam(defaultValue="GuestUser") String name,
@RequestParam(required = false) String adult) {
var greet = "on".equals(adult) ? "Good morning" : "Hi";
return String.format("%s %s!", greet, name);
}
}
The HelloController processes the HTML form. It reads two parameters from the request. A controller class is annotated with the @Controller
stereotype annotation in Spring.
@RequestMapping(path="/greeting", produces=MediaType.TEXT_PLAIN_VALUE)
@ResponseBody
The greetUser() method is mapped to the /greeting path and produces the plain text response. With the @RequestParam
annotation, we bind the request parameter to the method variable. We are binding two values from request to two variables name and adult respectively. The defaultValue
option gives a default value if the parameter is not available. The required
option tells that the parameter is mandatory.
public String greetUser(@RequestParam(defaultValue="GuestUser") String name,@RequestParam(required = false) String adult)
index.html:
The index.html
file is the home page. The file is located in the src/main/resources/static
folder, where Spring Boot expects static resources such as HTML, javascript, images or CSS files. We have a simple HTML form with input text and check box tags.
<!DOCTYPE html>
<html lang="en">
<head>
<title>Home page</title>
<meta charset="UTF-8"/>
<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
</head>
<body>
<form action="greeting">
<div>
<label>Name:</label>
<input type="text" name="name">
</div>
<div>
<label><input type="checkbox" name="adult">Adult</label>
</div>
<button type="submit">Submit</button>
</form>
</body>
</html>
In the index.html we have <form action=”greeting”>, the same mapping we have in our controller to handle this request.
Application class
package com.techwasti.springmustacheex;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class SpringMustacheExApplication {
public static void main(String[] args) {
SpringApplication.run(SpringMustacheExApplication.class, args);
}
}
The @SpringBootApplication
annotation enables auto-configuration and component scanning. This is the entry point of your application. Now everything is ready let us go and run the application and enjoy the output.
$ mvn spring-boot:run
This is just introductory tutorial, please play with it and find more insight about this annotation.
Source Code:-
https://github.com/maheshwarLigade/spring-boot-examples
$ git clone https://github.com/maheshwarLigade/spring-boot-examples
$ cd spring-mustache-ex
$ gradle build
$ gradle bootRun
Reference Links:
More tutorials like this visit below link
https://www.techwasti.com/category/java/
You must log in to post a comment.