Stereotype Annotations Cut Down XML Configuration in Spring : Page 4

Handler Method Parameters

You can pass arguments to controller handler methods (methods with the @RequestMapping annotation). Specifically, you can pass any argument of the type listed in Table 3 to a handler method without further annotation in the controller. The Spring container automatically locates the correct object and passes it as the proper argument.

Table 3. Types of Arguments You Can Pass to Handler Methods

Parameter Type	Description
BindingResult	Spring MVC BindingResult object (org.springframework.validation.BindingResult)
Command Object	Spring MVC-defined Command objects
Errors	Spring MVC Errors object (org.springframework.validation.Errors)
InputStream/Reader	Servlet API provided raw InputStream/Reader (java.io.InputStream or Reader)
Locale	Request locale (java.util.Locale)
Map	Map provided as Spring model to the view (java.util.Map)
Model	Map provided as Spring model to the view (org.springframework.ui.Model)
ModelMap	Map provided as Spring model to the view (org.springframework.ui.ModelMap)
OutputStream/Writer	Servlet API provided raw OutputStream/Writer (java.io.OutputStream or Writer)
Request	Servlet API Request object (use either HttpServletRequest or ServletRequest)
Response	Servlet API Response object (use either HttpServletRequest or ServletRequest)
Session	Servlet API Session object
SessionStatus	Spring provided handle for marking when form processing is finished (org.springframework.web.bind.support.SessionStatus)
WebRequest	Spring-provided objects for parameter and attribute access without the Servlet API (use org.springframework.web.context.request.WebRequest or NativeWebRequest)

The Spring container automatically detects the parameter need and passes the appropriate object to the handler method. For example, the sayHello method here automatically gets passed the HttpServletRequest object.

@Controller
public class HelloWorldController {

  @RequestMapping("/greeting.request")
  protected String sayHello (HttpServletRequest req){
    String name = req.getParameter("name");
    return "greet";
  }
}

Author's Note: When creating the handler methods, consider some of the ramifications of using certain parameter types. Using parameters such as Model or HttpServletRequest couples the controller to Spring, the Servlet API, or both. Part of the rationale for moving to the annotated controllers may be to remove or reduce such coupling.

You can use the @RequestParam annotation, another of the Spring 2.5 MVC annotations, on a handler method to bind a request parameter to a method parameter. In the code example above, the "name" parameter is programmatically fetched out of the HttpServletRequest object. In the following example, the @RequestParam annotation accomplishes the same task more directly and automatically.

@Controller
public class HelloWorldController {

  @RequestMapping("/greeting.request")
  protected String sayHello (@RequestParam("name") String name){
    return "greet";
  }
}

By default, parameters annotated with @RequestParam are required method parameters. You can make a parameter optional by setting the required attribute of @RequestParam to false.

Similar to how @RequestParam binds a request parameter to a method parameter, the @ModelAttribute annotation can be used on a handler method parameter to bind a model object's attribute to a method parameter.

 @RequestMapping("/displaycustomer.request")
 public String show(@ModelAttribute("customer") Customer cust) {
  ...
  return "displaycustomer";
 }

The @ModelAttribute annotation also has a second use. You can use it to put information, such as reference data, into the model. When you place the @ModelAttribute annotation on a method, the method it annotates will get executed before the appropriate handler method. This has the effect of pre-populating the model.

Consider the HTML for a simple form entry page in Listing 1. The @ModelAttribute annotated method in the controller populates the "titles" options in the getname.jsp before the page displays.

@Controller
public class HelloWorldController {

  @ModelAttribute("titles")
  public List<String> populateTitles() {
  String[] titles = { "Mr.", "Mrs.", "Miss", "Ms.", "Dr." };
    return Arrays.asList(titles); 
  }
  
  @RequestMapping(value="/greeting.request",method=RequestMethod.GET)
  protected String showForm (){
    return "getname";
  }

  @RequestMapping(value="/greeting.request",method=RequestMethod.POST)
  protected String sayHello (@RequestParam(value="name") String name, @RequestParam(value="title") String title){
    System.out.println("Yep name is: " + title + " " + name);
    return "greet";
  }
}

Handler Method Return Types

Handler methods can return almost any type of data. You can use the data returned as the model, view, or other such Spring MVC component depending on its type. Table 4 describes the types of data that a handler method can return and how the Spring container uses that data. Again, using a Spring type (like ModelAndView) as the return type of a handler method couples the controller to Spring. So use some return objects with caution.

Table 4. Types and Uses of Data That a Handler Method Can Return

Return Data Type	How the Return Data Is Used
ModelAndView	Used as any ModelAndView object would be used, as if returned by a handleRequest method of a non-annotated controller (org.springframework.web.servlet.ModelAndView)
Model	The Model object (of the ModelAndView) containing key-value pairs of model data (org.springframework.ui.Model)
Map	Key-value pair model data (java.util.Map)
View	The View object (of the ModelAndView) containing information on the logical view name (org.springframework.web.servlet.View)
String	Interpreted as the logical view name, as would be represented in a View object
void	Indicates that the handler method handles the response rendering itself, just as any handleRequest type method of a non-annotated controller
other	Any other return type gets treated as a single model attribute value accessed by the name specified in @ModelAttribute (if provided) or based on the return type class name (when @ModelAttribute is not used)

Previous Page

Next Page