spring mvc form handling annotation example. agenda spring annotations spring mvc 3 (2.5)
TRANSCRIPT
Spring MVC form handling annotation example
Agenda
Spring AnnotationsSpring MVC 3 (2.5)
Spring Annotations
Spring 2.x Data Access AnnotationsSpring 2.x AspectsSpring 2.5 Context AnnotationsSpring 2.5 StereotypesSpring 2.5 Factory AnnotationsJSR-250 javax.annotationsSpring 2.5 MVC AnnotationsSpring 3.0 MVC AdditionsSpring 3.0 Annotations
What's new in Spring 2.5?
Annotation-driven dependency injection through the @Autowired annotation and fine-grained auto-wiring control with @Qualifier.
Support for JSR-250 annotations, including @Resource for dependency injection of a named resource, as well as @PostConstruct and @PreDestroy for lifecycle methods.
Auto-detection of Spring components that are annotated with @Component (or one of several stereotype annotations).
An all-new annotation-driven Spring MVC programming model that greatly simplifies Spring web development.
A new integration test framework that is based on JUnit 4 and annotations.
What's new in Spring 3.0?
Full-scale REST support in Spring MVC New annotations for Spring MVC, including @CookieVal
ue and @RequestHeader. Support for declarative validation with JSR-303 (Bean V
alidation) annotations. Support for the new JSR-330 dependency injection speci
fication. Annotation-oriented declaration of asynchronous and sch
eduled methods. A new annotation-based configuration model that allows
for nearly XML-free Spring configuration. The Object-to-XML (OXM) mapping functionality from th
e Spring Web Services project has been moved into the core Spring Framework.
Spring 2.5 Context Annotations
@Scope Indicates the scope to use for annotated class instances Default == “singleton” Options:
Singleton Prototype
Web Options: Request Session Global session
Spring 2.5 Stereotypes
@Component ** Indicates that a class is a component Class is a candidate for auto-detection Custom component extensions
@Controller Specialized Component Typically used with RequestMapping annotation Discussed in section on web mvc
@Repository 2.0 stereotype… previously mentioned Now an extension of @Component
@Service Intended to be a business service facade
Spring 2.5 Factory Annotations
@Autowired Marks a constructor, field, setter or config method for injection. Fields are injected
After construction Before config methods
@Autowired(required=false) Config:
AutowiredAnnotationBeanPostProcessor @Configurable
Marks class as being eligible for Spring-driven configuration Used with AspectJ
@Qualifier Qualifies a bean for autowiring May be customized
@Required Marks a method as being injection required
Types of Injections
Constructor
Setter
Field
New Injection Type
configuration method
with any number of arguments
Annotation Call Stack
@Configuration and @Bean
Annotating a class with the @Configuration indicates that the class can be used by the Spring IoC container as a source of bean definitions.
@Bean is a method-level annotation and a direct analog of the XML <bean/> element.
@Configuration and @Bean
@Configurationpublic class AppConfig { @Bean public MyService myService() { return new MyServiceImpl(); }}
<beans> <bean id="myService" class="com.acme.services.MyServiceImpl"/></beans>
Spring <beans/> XML :
Bean-annotated :
@Autowired
You can apply the @Autowired annotation to "traditional" setter methods.
At run time you will be able to access all methods of the class without worrying about how you got the class. This is known as Dependency Injection.
@Autowired
public class SimpleMovieLister {
private MovieFinder movieFinder;
@Autowired public void setMovieFinder(MovieFinder movieFinder) { this.movieFinder = movieFinder; }
// ...}
Spring MVC 3 (2.5)
Spring 2.5 MVC Annotations
@Controller Stereotype used to “Controller” of MVC Scanned for RequestMappings
@RequestMapping Annotates a handler method for a request
@RequestParam Annotates that a method parameter should be bound to
a web request parameter
@SessionAttributes Marks session attributes that a handler uses
Spring 3 Annotations (New Only)
@Value @RequestHeader @CookieValue @PathVariable @Async @Scheduled @Model @Bound @ActionMapping @EventMapping @RenderMapping
@ResourceMapping @ExceptionHandler @Mapping @RequestBody @ResponseBody @ResponseStatus
Setting up Spring MVC
Spring MVC in our application is to place the following <servlet> declaration in the web.xml file:
Spring MVC configuration
Use the spring-context schema as shown in the following XML snippet:
Spring MVC configuration (2)
In a Spring MVC application, you may configure a custom ConversionService instance explicity as an attribute of the annotation-driven element of the MVC namespace.
SimpleUrlHandlerMapping
In Spring configuration :
Handling Annotated Controllers
In Spring configuration :
Both are automatically registered by DispatcherServlet
Spring MVC namespace
New in Spring 3.0:
Automatically discovering beans
When you added to your Spring <context:annotation-config> configuration, you told Spring that you want it to honor a certain set of annotations in the beans that you declare and to use those beans to guide bean wiring.
Annotating beans for auto-discovery
By default, looks for classes that are annotated <context:component-scan> with one of a handful of special stereotype annotations: @Component - A general-purpose stereotype annotatio
n indicating that the class is a Spring component. @Controller - Indicates that the class defines a Spring
MVC controller. @Repository - Indicates that the class defines a data re
pository. @Service - Indicates that the class defines a service. Any custom annotation that is itself annotated with @Co
mponent
@Controller
This annotation support is available for both Servlet MVC and Portlet MVC.
Typically used with @RequestMapping annotation.
A simple controller
SimpleFormController vs @Controller
In XML-based Spring MVC web application, you create a form controller by extending the SimpleFormController class. In annotation-based, the @Controller can also use to handle form.
SimpleFormController vs @Controller
SimpleFormController
Annotation
public class CustomerController extends SimpleFormController{ //...}
@Controller @RequestMapping("/customer.htm") public class CustomerController{ //... }
Mapping requests with @RequestMapping
The class-level annotation maps a specific request path (or path pattern) onto a form controller.
The method-level annotations narrowing the primary mapping for a specific HTTP method request method ("GET"/"POST") or specific HTTP request parameters.
@RequestParam
Annotation which indicates that a method parameter should be bound to a web request parameter.
Mapping requests
By path @RequestMapping(“path”)
By HTTP method @RequestMapping(“path”, method=RequestMethod.GET) POST, PUT, DELETE, OPTIONS, and TRACE are are also
supported By presence of query parameter
@RequestMapping(“path”, method=RequestMethod.GET, params=”foo”)
Negation also supported: params={ “foo”, “!bar” }) By presence of request header
@RequestMapping(“path”, header=”content-type=text/*”)
Obtaining request data
A query parameter value @RequestParam(“name”)
A path element value @PathVariable(“var”)
A request header value @RequestHeader(“name”)
A cookie value @CookieValue(“name”)
The request body @RequestBody
The request body and any request header HttpEntity<T>
formBackingObject() vs RequestMethod.GET
In SimpleFormController, you can initialize the command object for binding in the formBackingObject() method. In annotation-based, you can do the same by annotated the method name with @RequestMapping(method = RequestMethod.GET).
formBackingObject() vs RequestMethod.GET (cont.)
SimpleFormController
@Override protected Object formBackingObject(HttpServletRequest request) throws Exception {
Customer cust = new Customer(); //Make "Spring MVC" as default checked value cust.setFavFramework(new String []{"Spring MVC"});
return cust; }
formBackingObject() vs RequestMethod.GET (cont.)
Annotation
@RequestMapping(method = RequestMethod.GET) public String initForm(ModelMap model){ Customer cust = new Customer(); //Make "Spring MVC" as default checked value cust.setFavFramework(new String []{"Spring MVC"});
//command object model.addAttribute("customer", cust);
//return form view return "CustomerForm"; }
onSubmit() vs RequestMethod.POST
In SimpleFormController, the form submission is handle by the onSubmit() method. In annotation-based, you can do the same by annotated the method name with @RequestMapping(method = RequestMethod.POST).
onSubmit() vs RequestMethod.POST
SimpleFormController
@Override protected ModelAndView onSubmit(HttpServletRequest request, HttpServletResponse response, Object command, BindException errors) throws Exception { Customer customer = (Customer)command; return new ModelAndView("CustomerSuccess"); }
onSubmit() vs RequestMethod.POST
Annotation @RequestMapping(method = RequestMethod.POST) public String processSubmit( @ModelAttribute("customer") Customer customer, BindingResult result, SessionStatus status) {
//clear the command object from the session status.setComplete();
//return form success view return "CustomerSuccess"; }
referenceData() vs @ModelAttribute
In SimpleFormController, usually you put the reference data in model via referenceData() method, so that the form view can access it. In annotation-based, you can do the same by annotated the method name with @ModelAttribute.
referenceData() vs @ModelAttribute SimpleFormController
Spring’s form
@Override protected Map referenceData(HttpServletRequest request) throws Exception { Map referenceData = new HashMap();
//Data referencing for web framework checkboxes List<String> webFrameworkList = new ArrayList<String>(); webFrameworkList.add("Spring MVC"); webFrameworkList.add("Struts 1"); webFrameworkList.add("Struts 2"); webFrameworkList.add("JSF"); webFrameworkList.add("Apache Wicket"); referenceData.put("webFrameworkList", webFrameworkList);
return referenceData; }
<form:checkboxes items=“${webFrameworkList}" path="favFramework" />
referenceData() vs @ModelAttribute
Annotation
Spring’s form <form:checkboxes items=“${webFrameworkList}" path="favFramework" />
@ModelAttribute("webFrameworkList") public List<String> populateWebFrameworkList() { //Data referencing for web framework checkboxes List<String> webFrameworkList = new ArrayList<String>(); webFrameworkList.add("Spring MVC"); webFrameworkList.add("Struts 1"); webFrameworkList.add("Struts 2"); webFrameworkList.add("JSF"); webFrameworkList.add("Apache Wicket");
return webFrameworkList; }
initBinder() vs @InitBinder
In SimpleFormController, you define the binding or register the custom property editor via initBinder() method. In annotation-based, you can do the same by annotated the method name with @InitBinder.
initBinder() vs @InitBinder
SimpleFormController
Annotation
protected void initBinder(HttpServletRequest request, ServletRequestDataBinder binder) throws Exception {
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd"); binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, true)); }
@InitBinder public void initBinder(WebDataBinder binder) { SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd"); binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, true)); }
From Validation
In SimpleFormController, you have to register and map the validator class to the controller class via XML bean configuration file, and the validation checking and work flows will be executed automatically.
In annotation-based, you have to explicitly execute the validator and define the validation flow in the @Controller class manually.
From Validation
SimpleFormController <bean class="com.mkyong.customer.controller.CustomerController"> <property name="formView" value="CustomerForm" /> <property name="successView" value="CustomerSuccess" />
<!-- Map a validator --> <property name="validator"> <bean class="com.mkyong.customer.validator.CustomerValidator" /> </property> </bean>
From Validation Annotation
@Controller @RequestMapping("/customer.htm") public class CustomerController{ CustomerValidator customerValidator;
@Autowired public CustomerController(CustomerValidator customerValidator){ this.customerValidator = customerValidator; }
@RequestMapping(method = RequestMethod.POST) public String processSubmit( @ModelAttribute("customer") Customer customer, BindingResult result, SessionStatus status) { customerValidator.validate(customer, result);
if (result.hasErrors()) { //if validator failed return "CustomerForm"; } else { status.setComplete(); //form success return "CustomerSuccess"; } } //...
Working with Session
The type-level @SessionAttributes annotation declares session attributes used by a specific handler.
More Crazy Stuff
Annotation Access to: Headers Cookies
Reference
Spring MVC form handling annotation example http://www.mkyong.com/spring-mvc/spring-mvc-form-handling-annotation-example/