Tech Tutorials

Monday, November 4, 2024

Spring MVC @RequestParam Annotation Example

In this Spring MVC @RequestParam annotation example we’ll see how request data which is passed as query parameter in the URI can be extracted using @RequestParam annotation.

Spring @RequestParam and @RequestMapping annotation

If you are passing request parameters as query parameters, then you can use @RequestParam along with @RequestMapping annotation in the Spring controller method to get value of those request parameters.

For example- /spring-mvc/getUser?userId=101

Here userId is the query parameter that can be retrieved using the @RequestParam annotation.

Spring web MVC example with @RequestParam annotation

In this Spring MVC example we’ll have a JSP (home page) with 3 fields, entered values in these 3 fields are sent as query parameters with in the URL.

Refer Spring Web MVC Example With Annotations to see how to set Spring MVC project structure with XML configuration.

Refer Spring Web MVC Java Configuration Example to see how to set Spring MVC project structure for Java configuration.

home.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>Spring MVC tutorial - Home JSP</title>
</head>
<body>
  <div>Message- ${message}</div>
  <form name="userform" action="showUser" method="get">
    <table>
      <tr>
        <td>
          First Name: <input type="text" id="firstName" name="firstName">
        </td>
      </tr>
      <tr>
        <td>
          Last Name: <input type="text" id="lastName" name="lastName">
        </td>
      </tr>
      <tr>
        <td>
          DOB: <input type="text" id="dob" name="dob">
        </td>
      </tr>        
    </table>               
    <input type="submit" value="Submit">
  </form>
</body>
</html>

Spring MVC - Controller class

In the controller class there are two methods. First method showHome() is annotated with RequestMapping value parameter as “/” and returns the logical view name as "home" which results in the display of home.jsp.

Another method showUser() serves the request where path is “/showUser”. In this method the method parameters are annotated with @RequestParam. The value parameter with in the @RequestParam should match the query parameter name. For example this handler method will serve the requests in the form - /showUser?firstName=Leonard&lastName=Nimoy&dob=1956-05-23

The value of the query parameter will be assigned to the corresponding method parameter.

MessageController.java

import java.time.LocalDate;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class MessageController {
 @RequestMapping(value = "/", method = RequestMethod.GET)
 public String showHome(Model model) {
  model.addAttribute("message", "MVC Example with dynamic URL");
  return "home";
 }
 
 @RequestMapping(value = "/showUser", method = RequestMethod.GET)
 public String showUser(@RequestParam("firstName") String firstName, 
                @RequestParam("lastName") String lastName, 
                @DateTimeFormat(pattern = "yyyy-MM-dd")
                @RequestParam("dob") LocalDate dob,
                Model model) { 

  model.addAttribute("firstName", firstName);
  model.addAttribute("lastName", lastName);
  model.addAttribute("dob", dob);
  return "user";
 }
}

The parameters of the method showUser() which have the values of the query parameters assigned to them are added to the Model. The method returns the logical view name as "user" which is resolved to the view user.jsp.

Note that if method parameter name is same as the query parameter name in the @RequestMapping then the value parameter with @RequestParam is optional. So the same method can also be written as-

@RequestMapping(value = "/showUser", method = RequestMethod.GET)
public String showUser(@RequestParam String firstName, 
             @RequestParam String lastName, 
             @DateTimeFormat(pattern = "yyyy-MM-dd")
             @RequestParam LocalDate dob,
             Model model) {

 ...
 ...
}

user.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>Spring MVC tutorial - User</title>
</head>
<body>
<div>First Name: ${firstName}</div>
<div>Last Name: ${lastName}</div>
<div>DOB: ${dob}</div>
</body>
</html>

Home page

User page

Default value for RequestParam parameters in Spring MVC

If you want to provide default value for the RequestParam parameters if the query parmeters are not there in the request then you can use defaultValue attribute of the @RequestParam. The default value is used as a fallback when the request parameter is not provided or has an empty value.

@RequestMapping(value = "/showUser", method = RequestMethod.GET)
public String showUser(
  @RequestParam(value="firstName", defaultValue="Test") String firstName, 
  @RequestParam(value="lastName", defaultValue="User") String lastName, 
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  @RequestParam(value="dob", defaultValue="2000-01-01") LocalDate dob,
  Model model) { 
 ...
 ...
}

required attribute in Spring @RequestParam annotation

You can set whether the parameter is required or not using required attribute. Default value for the required attribute is true, which means an exception is thrown if the parameter is missing in the request. By setting required as false null value is assigned if the parameter is not present in the request.

For example if you want to make DOB as optional.

@RequestMapping(value = "/showUser", method = RequestMethod.GET)
public String showUser(
  @RequestParam(value="firstName", defaultValue="Test") String firstName, 
  @RequestParam(value="lastName", defaultValue="User") String lastName, 
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  @RequestParam(value="dob", required=false) LocalDate dob,
  Model model) {
 ...
 ...
}

That's all for this topic Spring MVC @RequestParam Annotation Example. If you have any doubt or any suggestions to make please drop a comment. Thanks!

>>>Return to Spring Tutorial Page

Related Topics

You may also like-

Sunday, November 3, 2024

Java Stream - min() With Examples

In Java Stream API there is a min() method that is used to get the minimum element of this stream according to the provided Comparator. In this post we’ll see some examples of the min() method.

Syntax of the Stream.min() method

min is a terminal operation and its syntax is as given below-

Optional<T> min(Comparator<? super T> comparator)

Here comparator argument is an implementation of the Comparator to compare elements of this stream.

Method returns an Optional describing the minimum element of this stream, or an empty Optional if the stream is empty.

Stream.min is considered a special case of a reduction operation as it takes a sequence of input elements and combines them into a single summary result.

min() method Java examples

1. Finding min value from a stream of numbers.

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class StreamMin {
  public static void main(String[] args) {
    List<Integer> numList = Arrays.asList(7, 9, 14, 1, 59, 23, 77, 10, 12, 4);
      Optional<Integer> minElement = numList.stream().min(Integer::compare);
      if(minElement.isPresent()){
        System.out.println("Minimum element: " + minElement.get());
      }
  }
}

Output

Minimum element: 1

2. In the following example custom comparator is passed as an argument to the min() method to get minimum method as per the passed Comparator.

public class StreamMin {
  public static void main(String[] args) {
    List<Integer> numList = Arrays.asList(7, 9, 14, 1, 59, 23, 77, 10, 12, 4);
      Optional<Integer> minElement = numList.stream().min(new MyComparator());
      if(minElement.isPresent()){
        System.out.println("Minimum element: " + minElement.get());
      }
  }
}

class MyComparator implements Comparator<Integer>{
  @Override
  public int compare(Integer o1, Integer o2) {
    return o1.compareTo(o2);
  }
}

Output

Minimum element: 1

3. Using Stream.min() method with custom object. In the example, objects of Employee class are used and the objective is to find minimum salary using the min() method of the Java Stream API.

Employee class used is as given here.

public class Employee {
  private String empId;
  private int age;
  private String name;
  private char gender;
  private int salary;
  Employee(String empId, int age, String name, char gender, int salary){
    this.empId = empId;
    this.age = age;
    this.name = name;
    this.gender = gender;
    this.salary = salary;
  }
  public String getEmpId() {
    return empId;
  }

  public int getAge() {
    return age;
  }

  public String getName() {
    return name;
  }

  public char getGender() {
    return gender;
  }

  public int getSalary() {
    return salary;
  }
}

In the example mapToInt() method is used to get the salary part of the employee object which is then passed to the min() to get the minimum salary.

public class StreamMin {
  public static void main(String[] args) {
    List<Employee> empList = Arrays.asList(new Employee("E001", 40, "Ram", 'M', 5000), 
                new Employee("E002", 35, "Shelly", 'F', 7000), 
                new Employee("E003", 24, "Mark", 'M', 9000), 
                new Employee("E004", 37, "Rani", 'F', 10000),
                new Employee("E005", 32, "Anuj", 'M', 12000));  
     OptionalInt minEmpSal = empList.stream()
                .mapToInt(Employee::getSalary)
                .min();
      if(minEmpSal.isPresent()){
        System.out.println("Minimum salary: " + minEmpSal.getAsInt());
      }
  }
}

Output

Minimum salary: 5000

That's all for this topic Java Stream - min() With Examples. If you have any doubt or any suggestions to make please drop a comment. Thanks!

>>>Return to Java Advanced Tutorial Page

Related Topics

You may also like-

Thursday, October 17, 2024

Spring MVC Dropdown Example Using Select, Option And Options Tag

In this post we’ll see how to show dropdown box in a Spring MVC application using select, option and options tag provided by the form tag library in the Spring MVC framework.

Spring MVC Project structure using Maven

Please refer Spring Web MVC Example With Annotations for getting the project structure using Spring XML configuration.
Please refer Spring Web MVC Java Configuration Example for getting the project structure using Spring Java configuration.

Table of contents

<form:select> tag in Spring MVC
Spring MVC dropdown example using select tag
<form:option> tag in Spring MVC
Spring MVC dropdown example using option tag
<form:options> tag in Spring MVC
Spring MVC dropdown example using options tag
Deploying and testing the application

<form:select> tag in Spring MVC

This tag renders an HTML 'select' element. It supports data binding using the "items" property. Select tag also supports use of nested option and options tag.

The items attribute is typically populated with a collection or array of item objects. If itemValue and itemLabel attributes are specified then these attributes refer to the bean properties of those item objects otherwise the item objects value itself is used. You can also specify a Map of items, in which case the map keys are interpreted as option values and the map values correspond to option labels. If itemValue and/or itemLabel happen to be specified as well, the item value property will apply to the map key and the item label property will apply to the map value.

One advantage of using select tag is that it has an attribute multiple when set to true you can select multiple values from the list box. One drawback of using only select tag is that you can’t give any display only value like “-please select-” for that you’ll have to use option tag.

Spring MVC dropdown example using select tag

For the Spring MVC form dropwdown example let’s assume there is a class UserPreferences that stores the selected value of the dropdowns. There are two set of dropdowns in the JSP and there are two properties in the UserPreferences bean class to store the selected options.

Spring MVC dropdown example – Model Class

public class UserPreferences {

 private String exercise;
 private String country;
 public String getExercise() {
  return exercise;
 }
 public void setExercise(String exercise) {
  this.exercise = exercise;
 }
 public String getCountry() {
  return country;
 }
 public void setCountry(String country) {
  this.country = country;
 }
}

Spring MVC dropdown example using select tag – View

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>

<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>
<title>Spring MVC dropdown example using select tag</title>
</head>
<body>
  <h3>Spring MVC dropdown example using select tag</h3>
  <form:form method="POST" action="showPreferences" modelAttribute="preferences">
    <table>
      <tr>
        <td><b>Country:</b></td>      
        <td><form:select path="country" items="${countryOptions}"/></td>
      </tr>
      <tr>
        <td><b>Favorite Exercise:</b></td>        
        <td><form:select path="exercise" items="${exerciseList}" multiple="true"/></td>
      </tr>
      <tr>
        <td><input type="submit" value="Submit"></td>
      </tr>
    </table>
  </form:form>
</body>
</html>

As you can see <form:select> tag is used with the items property. The values used with the items property in the JSP countryOptions and exerciseList should be available as a model attribute containing String of values to be shown in the dropdown.

With one of the <form:select> tag multiple attribute set as true is also used. This will enable multiple selections.

There is another JSP that is used to display the values selected in the dropdown and listbox.

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<title>User Preferences</title>
</head>
<body>
<h3>Spring MVC dropdown example using select tag</h3>
Country: ${preferences.country}<br/>
Favorite exercise: ${preferences.exercise}

</body>
</html>

Spring MVC dropdown example – Controller class

public class UserController {
    
  @RequestMapping(value = "/showUser", method = RequestMethod.GET)
  public String showUser(Model model) throws Exception{
    UserPreferences pref = new UserPreferences();    
    // Default Value for country dropdown
    pref.setCountry("IN");
  
    // Preparing values for "Country" Dropdown
    Map<String, String> countryMap = new HashMap<>();
    countryMap.put("AR", "Argentina");
    countryMap.put("IN", "India");
    countryMap.put("JP", "Japan");
    countryMap.put("US", "United States");
    countryMap.put("SG", "Singapore");
    model.addAttribute("countryOptions", countryMap);
    model.addAttribute("preferences", pref);
    return "user";
  }
    
  @RequestMapping(value = "/showPreferences", method = RequestMethod.POST)
  public String showPreferences(@ModelAttribute("preferences") UserPreferences preferences, Model model) throws Exception{
    model.addAttribute("preferences", preferences);
    return "showPreferences";
  }
    
  // List for "Favorite Exercise" dropdown
  @ModelAttribute("exerciseList")
  public List<String> getExerciseList(){
    List<String> exerciseList = new ArrayList<>();
    exerciseList.add("Aerobic");
    exerciseList.add("Anaerobic");
    exerciseList.add("Flexibility Trng");
    return exerciseList;
  }
}

In the Controller class, showUser() method is used to handle the /showUser request path. Method returns the view name as “user” which resolves to /WEB-INF/jsp/user.jsp JSP.

As you can see exerciseList and countryOptions which are used in the JSP to show dropdown options are set here as model attribute. Default value is also set for one of the dropdown so that the value is pre-selected in the JSP.

Another handler method showPreferences() handles the request when submit button is clicked in the user.jsp.

Deploying and testing the application

Once the application is deployed to Tomcat server it can be accessed using the URL- http://localhost:8080/spring-mvc/showUser

As you can see India is already selected as the property was set in the bean object. Since multiple attribute is set as true for the other select tag so multiple values can be selected. Clicking the submit button displays the selected values.

<form:option> tag in Spring MVC

This tag renders an HTML 'option'. If you want to hardcode dropdown values with in the JSP itself then you can use option tag.

Spring MVC dropdown example using option tag

If we have to create the same view using option tag as created above using the select tag where there are two drop downs and one of them is rendered as a listbox by using multiple=”true” attribute. In this case dropdown options are hardcoded with in the JSP itself.

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>

<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>
<title>Spring MVC dropdown example using option tag</title>
</head>
<body>
  <h3>Spring MVC dropdown example using option tag</h3>
  <form:form method="POST" action="showPreferences" modelAttribute="preferences">
    <table>
      <tr>
        <td><b>Country:</b></td>      
        <td>
            <form:select path="country">
              <form:option value="AR" label="Argentina"/>
              <form:option value="IN" label="India"/>
              <form:option value="JP" label="Japan"/>
              <form:option value="US" label="United States"/>
              <form:option value="SG" label="Singapore"/>
            </form:select>
        </td>
      </tr>
      <tr>
        <td><b>Favorite Exercise:</b></td>
        <td>
          <form:select path="exercise" multiple="true">
            <form:option value="Aerobic"/>
            <form:option value="Anaerobic"/>
            <form:option value="Flexibility Trng"/>
          </form:select>
        </td>
      </tr>
      <tr>
        <td><input type="submit" value="Submit"></td>
      </tr>
    </table>
  </form:form>
</body>
</html>

<form:options> tag in Spring MVC

This tag renders a list of HTML 'option' tags. Options tag also let you provide options at run time rather than hardcoding them. You pass in an Array, a List or a Map containing the available options in the "items" property.

Spring MVC dropdown example using options tag

In this example Model class and Controller class are the same as used above.

User.jsp with changes for options tag is as below.

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>

<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>
<title>Spring MVC dropdown example using select tag</title>
</head>
<body>
  <h3>Spring MVC dropdown example using select tag</h3>
  <form:form method="POST" action="showPreferences" modelAttribute="preferences">
    <table>
      <tr>
        <td><b>Country:</b></td>
    
        <td>
          <form:select path="country">
            <form:option value="-" label="-Please Select-"/>
            <form:options items="${countryOptions}"/>            
          </form:select>
        </td>
      </tr>
      <tr>
        <td><b>Favorite Exercise:</b></td>
        <td>
          <form:select path="exercise" multiple="true">
            <form:options items="${exerciseList}"/>    
          </form:select>
        </td>
      </tr>
      <tr>
        <td><input type="submit" value="Submit"></td>
      </tr>
    </table>
  </form:form>
</body>
</html>

Deploying and testing the application

Once the application is deployed to Tomcat server it can be accessed using the URL- http://localhost:8080/spring-mvc/showUser

Now no default value is set in the Controller class so first option “Please Select” is displayed. Since multiple is set as true for the other select tag so multiple values can be selected.

After selecting some values.

Showing the selected values once submit button is clicked.

Reference- https://docs.spring.io/spring/docs/current/spring-framework-reference/web.html#mvc-view-jsp-formtaglib

That's all for this topic Spring MVC Dropdown Example Using Select, Option And Options Tag. If you have any doubt or any suggestions to make please drop a comment. Thanks!

>>>Return to Spring Tutorial Page

Related Topics

You may also like-

Wednesday, October 16, 2024

Spring MVC Radiobutton And Radiobuttons Form Tag Example

In this post we’ll see how to use radiobutton and radiobuttons tag provided by the form tag library in the Spring MVC framework.

Spring MVC Project structure using Maven

Please refer Spring Web MVC Example With Annotations for getting the project structure using Spring XML configuration.
Please refer Spring Web MVC Java Configuration Example for getting the project structure using Spring Java configuration.

Table of contents

<form:radiobutton> and <form:radiobuttons> tags in Spring MVC
Spring MVC radiobutton example
Spring MVC radiobuttons tag example

<form:radiobutton> and <form:radiobuttons> tags in Spring MVC

<form:radiobutton>- This tag renders an HTML 'input' tag with type 'radio'. With this tag the values for the radio button are hardcoded with in the JSP page. You will have multiple radiobutton tag instances bound to the same property but with different values.
<form:radiobuttons>- If you don't want to harcode the values for the radiobutton in the JSP but want to pass available options at runtime then you can use radiobuttons tag.

In this post we’ll see example using both <form:radiobutton> and <form:radiobuttons> one by one.

Spring MVC radiobutton example

For the Spring MVC form radiobutton tag example let’s assume there is a class UserPreferences that stores the radio button value. There are two set of radiobuttons in the JSP and there are two properties in the UserPreferences bean class to store the selected option.

Spring MVC radiobutton example – Model Class

public class UserPreferences {
	private String exercise;
	private String gender;
	
	public String getExercise() {
		return exercise;
	}
	public void setExercise(String exercise) {
		this.exercise = exercise;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
}

Spring MVC radiobutton example – View

There is a JSP (user.jsp) that has two sets of radiobutton tag with options for user to select.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>
  <title>Spring MVC tutorial - User</title>
</head>
<body>
<h3>Spring MVC radio button example</h3>
  <form:form method="POST" action="showPreferences" modelAttribute="preferences">
    <table>
      <tr>
        <td><b>Gender:</b></td>
        <td>
          <form:radiobutton path="gender" value="M"/>Male
          <form:radiobutton path="gender" value="F"/>Female
          <form:radiobutton path="gender" value="O"/>Other
        </td>
      </tr>
      <tr>
        <td><b>Favorite Exercise:</b></td>
        <td>
          <form:radiobutton path="exercise" value="Aerobic"/>Aerobic
          <form:radiobutton path="exercise" value="Anaerobic"/>Anaerobic
          <form:radiobutton path="exercise" value="Flexibility Trng"/>Flexibility Training
        </td>
      </tr>
      <tr>
        <td><input type="submit" value="Submit"></td>
      </tr>
    </table>
  </form:form>
</body>
</html>

The values for the properties are taken from an object of type UserPreferences bean which is bound using the attribute “modelAttribute” with in the form tag. The object is set with in the handler method of the Controller class.

There is another JSP that is used to display the selected radio button option.

showPreferences.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>User Preferences</title>
</head>
<body>
  <h3>Spring MVC radio button example</h3>
  Gender: ${preferences.gender}<br/>
  Favorite exercise: ${preferences.exercise}
</body>
</html>

Spring MVC radiobutton example – Controller class

import org.netjs.model.UserPreferences;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class UserController {
	@RequestMapping(value = "/user", method = RequestMethod.GET)
	public String showUser(Model model) throws Exception{
    UserPreferences pref = new UserPreferences();    
    // Setting default values
    pref.setGender("M");
    pref.setExercise("Anaerobic");
    model.addAttribute("preferences", pref);
    return "user";
	}
	    
	@RequestMapping(value = "/showPreferences", method = RequestMethod.POST)
	public String showPreferences(@ModelAttribute("preferences") UserPreferences preferences, Model model) throws Exception{
    model.addAttribute("preferences", preferences);
    return "showPreferences";
	}
}

In the Controller class, showUser() method is used to handle the /showUser request path. Method returns the view name as "user" which resolves to /WEB-INF/jsp/user.jsp JSP.

In the handler method object of UserPreferences class is set to the Model which is used in the JSP to bind the bean properties with the radio button. If you want any radio button option to be selected by default in JSP then you can set the values for the properties in the UserPreferences object.

Another handler method showPreferences() handles the request when submit button is clicked in the user.jsp.

Deploying and testing the application

Once the application is deployed to Tomcat server it can be accessed using the URL- http://localhost:8080/springwebproj/user (As per the web application name used in this example, please change as per your web application)

Page which shows the selected options.

Spring MVC radiobuttons tag example

If you want to provide the options for the radiobutton at runtime rather than hardcoding them then you can use radiobuttons tag in Spring MVC application. You pass in an Array, a List or a Map containing the available options in the "items" property.

Spring MVC radiobuttons tag example – Model Class

public class UserPreferences {

	private String exercise;
	private String gender;
	
	public String getExercise() {
		return exercise;
	}
	public void setExercise(String exercise) {
		this.exercise = exercise;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
}

Spring MVC radiobuttons example – Views

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>
  <title>Spring MVC tutorial - User</title>
</head>
<body>
<h3>Spring MVC radio button example</h3>
  <form:form method="POST" action="showPreferences" modelAttribute="preferences">
    <table>
      <tr>
        <td><b>Gender:</b></td>
        <td><form:radiobuttons path="gender" items="${genderOptions}"/></td>
      </tr>
      <tr>
        <td><b>Favorite Exercise:</b></td>
        <td><form:radiobuttons path="exercise" items="${exerciseList}"/></td>
      </tr>
      <tr>
        <td><input type="submit" value="Submit"></td>
      </tr>
    </table>
  </form:form>
</body>
</html>

As you can see now <form:radiobuttons> tag is used with the items property. The values used with the items property in the JSP genderOptions and exerciseList should be available as a model attribute containing String of values to be selected from. If a Map is used, the map entry key will be used as the value and the map entry’s value will be used as the label to be displayed.

There is another JSP that is used to display the selected radio button option.

showPreferences.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>User Preferences</title>
</head>
<body>
  <h3>Spring MVC radio button example</h3>
  Gender: ${preferences.gender}<br/>
  Favorite exercise: ${preferences.exercise}
</body>
</html>

Spring MVC radiobuttons example – Controller class

@Controller
public class UserController {
    
  @RequestMapping(value = "/user", method = RequestMethod.GET)
  public String showUser(Model model) throws Exception{
    UserPreferences pref = new UserPreferences();    
    // Default Values
    pref.setGender("F");
    pref.setExercise("Flexibility Trng");
    
    // Preparing values for "Sex Options" radio button
    Map<String, String> genderOptions = new HashMap<>();
    genderOptions.put("M", "Male");
    genderOptions.put("F", "Female");
    genderOptions.put("O", "Other");
    model.addAttribute("genderOptions", genderOptions);
    model.addAttribute("preferences", pref);
    return "user";
  }

  @RequestMapping(value = "/showPreferences", method = RequestMethod.POST)
  public String showPreferences(@ModelAttribute("preferences") UserPreferences preferences, Model model) throws Exception{
    model.addAttribute("preferences", preferences);
    return "showPreferences";
  }
      
  // List for "Favorite Exercise" radio button
  @ModelAttribute("exerciseList")
  public List<String> getExerciseList(){
    List<String> exerciseList = new ArrayList<>();
    exerciseList.add("Aerobic");
    exerciseList.add("Anaerobic");
    exerciseList.add("Flexibility Trng");
    return exerciseList;
  }
}

As you can see exerciseList and genderOptions which are used in the JSP to show radiobutton options are set here as model attribute. Default values for the radio buttons are also set here to be pre-selected.

Deploying and testing the application

Once the application is deployed to Tomcat server it can be accessed using the URL- http://localhost:8080/springwebproj/user

Reference- https://docs.spring.io/spring/docs/current/spring-framework-reference/web.html#mvc-view-jsp-formtaglib

That's all for this topic Spring MVC Radiobutton And Radiobuttons Form Tag Example. If you have any doubt or any suggestions to make please drop a comment. Thanks!

>>>Return to Spring Tutorial Page

Related Topics

You may also like-

Tuesday, October 15, 2024

Spring MVC Checkbox And Checkboxes Form Tag Example

In this post we’ll see how to use checkbox and checkboxes provided by the form tag in the Spring MVC framework.

Technologies used

Following is the list of tools used for the Spring MVC checkbox and checkboxes form tag example.

Spring 6.1.x Release (Spring core, spring web, spring webmvc).
Java 21
JSTL tag library
Tomcat server V 10.x

Spring MVC Project structure using Maven

Please refer Spring Web MVC Example With Annotations for getting the project structure using Spring XML configuration.
Please refer Spring Web MVC Java Configuration Example for getting the project structure using Spring Java configuration.

Maven Dependencies

Apart from Spring dependencies following dependency is also needed in the pom.xml for JSTL tags.

<dependency>
  <groupId>jakarta.servlet.jsp.jstl</groupId>
  <artifactId>jakarta.servlet.jsp.jstl-api</artifactId>
  <version>3.0.0</version>
</dependency>
<dependency>
  <groupId>org.glassfish.web</groupId>
  <artifactId>jakarta.servlet.jsp.jstl</artifactId>
  <version>3.0.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/jstl/jstl -->
<dependency>
  <groupId>jstl</groupId>
  <artifactId>jstl</artifactId>
  <version>1.2</version>
</dependency>

Table of contents

<form:checkbox> and <form:checkboxes> tags in Spring MVC
Spring MVC checkbox example
Spring MVC checkboxes tag example

<form:checkbox> and <form:checkboxes> tags in Spring MVC

<form:checkbox>- This tag renders an HTML 'input' tag with type 'checkbox'. With this tag the value for the checkbox is hardcoded with in the JSP page.
<form:checkboxes>- This tag renders multiple HTML 'input' tags with type 'checkbox'. If you don't want to list the value for the checkbox with in the JSP but want to provide a list of available options at runtime and pass that in to the tag then you can use checkboxes tag. You pass in an Array, a List or a Map containing the available options in the "items" property.

Spring MVC checkbox example

For the Spring MVC form checkbox example let’s assume there is a class UserPreferences which is used to list out preferences as check boxes in the JSP page.

Spring MVC checkbox example – Model Class

public class UserPreferences {
 private boolean receiveNewsletter;
 private String[] cardioExercises;
 private String favouriteFood;
 public boolean isReceiveNewsletter() {
  return receiveNewsletter;
 }
 public void setReceiveNewsletter(boolean receiveNewsletter) {
  this.receiveNewsletter = receiveNewsletter;
 }
 public String[] getCardioExercises() {
  return cardioExercises;
 }
 public void setCardioExercises(String[] cardioExercises) {
  this.cardioExercises = cardioExercises;
 }
 public String getFavouriteFood() {
  return favouriteFood;
 }
 public void setFavouriteFood(String favouriteFood) {
  this.favouriteFood = favouriteFood;
 }
}

Spring MVC checkbox example – View

Following JSP (preferences.jsp) shows all the approaches to the checkbox tag in Spring MVC.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>
  <title>Spring MVC checkbox example in form tag</title>
</head>
<body>
  <form:form method="POST" action="showPreferences" modelAttribute="preferences">
  <table>
    <tr>
      <td>Subscribe to newsletter?:</td>
      <!--  Property is of type java.lang.Boolean-->
      <td><form:checkbox path="receiveNewsletter"/></td>
    </tr>
    <tr>
      <td>Favorite cardio exercises:</td>
      <!--  Property is of an array or of type java.util.Collection -->
      <td>Running: <form:checkbox path="cardioExercises" value="Running"/>
      <td>Skipping: <form:checkbox path="cardioExercises" value="Skipping"/>
      <td>Cycling: <form:checkbox path="cardioExercises" value="Cycling"/>
      <td>Burpee: <form:checkbox path="cardioExercises" value="Burpee"/>
    </tr>
    <tr>
      <td>Favourite Food:</td>
      <%-- Property is of type java.lang.Object --%>
      <td>Raw Vegetables: <form:checkbox path="favouriteFood" value="Raw Vegetables"/></td>
      <td>Steamed Vegetables: <form:checkbox path="favouriteFood" value="Steamed Vegetables"/></td>
    </tr>
    <tr>
      <td><input type="submit" value="Submit"></td>
    </tr>
  </table>
  </form:form>
</body>
</html>

The check boxes with in the JSP are checked or left unchecked based on the following-

When the bound value is of type java.lang.Boolean, the input(checkbox) is marked as 'checked' if the bound value is true.
When the bound value is of type array or java.util.Collection, the input(checkbox) is marked as 'checked' if the configured value is present in the bound Collection.
For any other bound value type, the input(checkbox) is marked as 'checked' if the configured setValue(Object) is equal to the bound value.

There is another JSP that is used to display the values selected by checking the check boxes.

showPreferences.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<title>User Preferences</title>
</head>
<body>

  <div>
    <span>Subscribe to newsletter?:</span>
    <span>${preferences.receiveNewsletter}</span>
  </div>
  <div>
    <span>Favorite cardio exercises:</span>
    <c:forEach items="${preferences.cardioExercises}" var="exercise" varStatus="counter">
      <span>${exercise}
        <c:if test="${not counter.last}">
          <c:out value="," ></c:out> 
        </c:if>
      </span>        
    </c:forEach>
  </div>
  <div>
    <span>Favourite Food:</span>
    <span>${preferences.favouriteFood}</span>
  </div>
</table>
</body>
</html>

Spring MVC checkbox example – Configuration changes

Since JSTL tags are also used so you need to configure InternalResourceViewResolver to resolve a JstlView for that following configuration has to be added in the configuration file.

<bean id="JSPViewResolver" class=
    "org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
    <property name="prefix" value="/WEB-INF/jsp/" />
    <property name="suffix" value=".jsp" />
</bean>

Spring MVC checkbox example – Controller class

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import com.netjstech.springweb.model.UserPreferences;

@Controller
public class PreferenceController {
	@GetMapping("/preferences")
	public String showUserPreferences(Model model) throws Exception{
		UserPreferences pref = new UserPreferences(); 
		pref.setReceiveNewsletter(true);
		pref.setCardioExercises(new String[]{"Running", "Burpee"});
		pref.setFavouriteFood("Steamed Vegetables");
		model.addAttribute("preferences", pref);
		return "preferences";
	}
	 
	@RequestMapping(value = "/showPreferences", method = RequestMethod.POST)
	public String showPreferences(@ModelAttribute("preferences") UserPreferences preferences, Model model) throws Exception{
		//System.out.println("In ShowPreferences");
		model.addAttribute("preferences", preferences);
		return "showPreferences";
	}
}

In the Controller class, showUserPreferences() method is used to handle the /preferences request path. Method returns the view name as "preferences" which resolves to /WEB-INF/jsp/preferences.jsp JSP.

In the handler method, object of UserPreferences class is set to the Model which is used in the JSP to mark the check box as checked or leave it unchecked. If you want some of the check boxes to be checked in the JSP by default then you can set the values for the properties in the UserPreferences object.

Another handler method showPreferences() handles the request when submit button is clicked in the preferences.jsp.

Deploying and testing the application

Once the application is deployed to Tomcat server it can be accessed using the URL- http://localhost:8080/springwebproj/preferences (This is as per my project name- springwebproj)

In the above page it shows those check boxes as checked for which values are set in the handler method of the controller class. In the following page some more boxes are checked before clicking on submit button.

Page which shows all the values that are checked.

Spring MVC checkboxes tag example

If you want to provide the list of options for the checkbox at runtime rather than hardcoding them then you can add checkboxes tag in Spring MVC application. You pass in an Array, a List or a Map containing the available options in the "items" property.

Spring MVC checkboxes example – Model Class

public class UserPreferences {
  private boolean receiveNewsletter;
  private String[] cardioExercises;
  private List<String> favouriteFood;
  public boolean isReceiveNewsletter() {
    return receiveNewsletter;
  }
  public void setReceiveNewsletter(boolean receiveNewsletter) {
    this.receiveNewsletter = receiveNewsletter;
  }
  public String[] getCardioExercises() {
    return cardioExercises;
  }
  public void setCardioExercises(String[] cardioExercises) {
    this.cardioExercises = cardioExercises;
  }
  public List<String> getFavouriteFood() {
    return favouriteFood;
  }
  public void setFavouriteFood(List<String> favouriteFood) {
    this.favouriteFood = favouriteFood;
  }
}

Spring MVC checkboxes example – Views

preferences.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>
  <title>Spring MVC checkbox example in form tag</title>
</head>
<body>
  <form:form method="POST" action="showPreferences" modelAttribute="preferences">
    <table>
      <tr>
        <td>Subscribe to newsletter?:</td>
        <!--  Property is of type java.lang.Boolean-->
        <td><form:checkbox path="receiveNewsletter"/></td>
      </tr>
      <tr>
        <td>Favorite cardio exercises:</td>
        <td><form:checkboxes path="cardioExercises" items="${prefMap}"/></td>
      </tr>
      <tr>
        <td>Favourite Food:</td>
        <td><form:checkboxes path="favouriteFood" items="${foodList}"/></td>
      </tr>
      <tr>
        <td><input type="submit" value="Submit"></td>
      </tr>
    </table>
  </form:form>
</body>
</html>

As you can see now <form:checkboxes> tag is used with the items property. The values used with the items property in the JSP prefMap and foodList should be available as a model attribute containing String of values to be selected from. If a Map is used, the map entry key will be used as the value and the map entry’s value will be used as the label to be displayed.

There is another JSP that is used to display the values selected by checking the check boxes.

showPreferences.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<title>User Preferences</title>
</head>
<body>
  <div>
    <span>Subscribe to newsletter?:</span>
    <span>${preferences.receiveNewsletter}</span>
  </div>
  <div>
    <span>Favorite cardio exercises:</span>
    <c:forEach items="${preferences.cardioExercises}" var="exercise" varStatus="counter">
        <span>${exercise}
          <c:if test="${not counter.last}">
               <c:out value="," ></c:out> 
          </c:if>
        </span>   
    </c:forEach>
  </div>
  <div>
    <span>Favourite Food:</span>
    <c:forEach items="${preferences.favouriteFood}" var="food" varStatus="foodCounter">
        <span>${food}
        <c:if test="${not foodCounter.last}">
          <c:out value="," ></c:out> 
        </c:if>
        </span>           
    </c:forEach>
  </div>
</body>
</html>

Spring MVC checkboxes example – Controller class

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import com.netjstech.springweb.model.UserPreferences;

@Controller
public class PreferenceController {
  @GetMapping("/preferences")
  public String showUserPreferences(Model model) throws Exception{
    UserPreferences pref = new UserPreferences();    
    //default check values
    pref.setReceiveNewsletter(true);
    pref.setCardioExercises(new String[]{"Running", "Burpee"});
    pref.setFavouriteFood(Arrays.asList("Boiled legumes", "Steamed Vegetables"));
    // Preparing values for "Favorite cardio exercises" check box
    Map<String, String> prefMap = new HashMap<>();
    prefMap.put("Running", "Running");
    prefMap.put("Burpee", "Burpee");
    prefMap.put("Skipping", "Skipping");
    prefMap.put("Cycling", "Cycling");    
    model.addAttribute("prefMap", prefMap);
    model.addAttribute("preferences", pref);        
    return "preferences";
  }
  
  // List for "Favourite Food" check box
  @ModelAttribute("foodList")
  public List<String> getFoodList(){
    List<String> foodList = new ArrayList<>();
    foodList.add("Steamed Vegetables");
    foodList.add("Boiled legumes");
    foodList.add("Pizza");
    foodList.add("Burger");
    return foodList;
  }
    
  @RequestMapping(value = "/showPreferences", method = RequestMethod.POST)
  public String showPreferences(@ModelAttribute("preferences") UserPreferences preferences, Model model) throws Exception{
    model.addAttribute("preferences", preferences);
    return "showPreferences";
  }
}

As you can see prefMap and foodList which are used in the JSP to show options for checkboxes in the JSP are set here as model attribute. If you want some of the check boxes to be checked in the JSP then you can set the values for the properties in the UserPreferences object.

Deploying and testing the application

Once the application is deployed to Tomcat server it can be accessed using the URL- http://localhost:8080/springwebproj/preferences

This is the page with the check boxes marked as checked for the properties set in the handler method of the controller class.

Page which shows all the values that are checked.

Reference- https://docs.spring.io/spring/docs/current/spring-framework-reference/web.html#mvc-view-jsp-formtaglib

That's all for this topic Spring MVC Checkbox And Checkboxes Form Tag Example. If you have any doubt or any suggestions to make please drop a comment. Thanks!

>>>Return to Spring Tutorial Page

Related Topics

You may also like-

Monday, October 14, 2024

Statement Interface in Java-JDBC

In the post Java JDBC Steps to Connect to DB we have already seen a complete example using the interfaces Driver, Connection, Statement and ResultSet provided by the JDBC API. In this post we’ll see Java Statement interface in detail.

Statement interface in JDBC

java.sql.Statement interface in JDBC API is used to execute a static SQL statement and returning the result of the executed query.

Statement interface has following two sub-interfaces

PreparedStatement
CallableStatement

PreparedStatement– PreparedStatement object stores the SQL statement in its pre-compiled state. That way it can efficiently execute the same SQL statement multiple times with different parameters.

Refer PreparedStatement Interface in Java-JDBC to get more details about PreparedStatement.

CallableStatement- This interface is used to execute SQL stored procedures.

Refer CallableStatement Interface in Java-JDBC to get more details about CallableStatement.

You can get a Statement object by calling the Connection.createStatement() method on the Connection object.

Frequently used methods of the Statement interface

Mostly you will use the execute methods of the Java Statement interface to execute queries.

boolean execute(String sql)- Executes the given SQL statement (it can be any kind of SQL query), which may return multiple results.
Returns a boolean which is true if the first result is a ResultSet object; false if it is an update count or there are no results.
ResultSet executeQuery(String sql)- Executes the given SQL statement, which returns a single ResultSet object. If you want to execute a Select SQL query which returns results you should use this method.
int executeUpdate(String sql)- Executes the given SQL statement, which may be an INSERT, UPDATE, or DELETE statement or an SQL statement that returns nothing, such as an SQL DDL statement.
Returns an int denoting either the row count for the rows that are inserted, deleted, updated or returns 0 if nothing is returned.
Note:This method cannot be called on a PreparedStatement or CallableStatement.
int[] executeBatch()- Submits a batch of commands to the database for execution and if all commands execute successfully, returns an array of update counts.

Java Statement example

Let’s see an example where SQL statements are executed using execute(), executeUpdate and executeQuery methods. In the example-

Using execute() method a SQL statement is executed and then the boolean value is checked.

Using executeUpdate() method insert, update and delete statements are executed and row count of the affected rows is displayed.

Using executeQuery() method select statement is executed and the returned ResultSet is processed.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCStmt {
  public static void main(String[] args) {
    Connection connection = null;
    try {
      // Loading driver
      Class.forName("com.mysql.jdbc.Driver");
   
      // Creating connection
      connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/netjs", 
                   "root", "admin");
  
      // creating Statement
      Statement stmt = connection.createStatement();  
            
      /** execute method **/
      boolean flag = stmt.execute("Update Employee set age = 40 where id in (5, 6)");
      if(flag == false){
        System.out.println("Updated rows " + stmt.getUpdateCount() );
      }
            
      /** executeUpdate method **/
      // Insert
      int count = stmt.executeUpdate("Insert into employee(name, age) values('Kim', 23)");
      System.out.println("Rows Inserted " + count);
            
      // update
      count = stmt.executeUpdate("Update Employee set age = 35 where id = 17");
      System.out.println("Rows Updated " + count);
            
      //delete
      count = stmt.executeUpdate("Delete from Employee where id = 5");
      System.out.println("Rows Deleted " + count);
            
      /** executeQuery method **/
      // Executing Query
      ResultSet rs = stmt.executeQuery("Select * from Employee");

      // Processing Resultset
      while(rs.next()){
        System.out.println("id : " + rs.getInt("id") + " Name : " 
          + rs.getString("name") + " Age : " + rs.getInt("age")); 
      }    
    } catch (ClassNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (SQLException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }finally{
      if(connection != null){
        //closing connection 
        try {
          connection.close();
        } catch (SQLException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }
      } // if condition
    }// finally
  }
}

Reference: https://docs.oracle.com/en/java/javase/21/docs/api/java.sql/java/sql/Statement.html

That's all for this topic Statement Interface in Java-JDBC. If you have any doubt or any suggestions to make please drop a comment. Thanks!

>>>Return to Java Advanced Tutorial Page

Related Topics

You may also like-

Sunday, October 13, 2024

Types of JDBC Drivers

JDBC API standardizes the way any Java application connects to DB. JDBC API is a collection of interfaces and JDBC drivers implement these interfaces in the JDBC API enabling a Java application to interact with a database.

The JDBC driver gives out the connection to the database and implements the protocol for transferring the query and result between client and database.

JDBC Driver Types

JDBC drivers can be categorized into four types.

Type 1 driver
Type 2 driver
Type 3 driver
Type 4 driver