Spring is a framework for developing Java applications, it helps applications with high performance, easy to test and reuse code, …
Spring is organized in modules so it is easy to reuse.
- Spring MVC: is designed for building web-based applications.
- Spring Security: provides authentication and authorization.
- Spring Boot: framewrok develops applications quickly
- Spring Batch: Make it easy for users to scheduling, processing.
- Spring IO
- Spring Cloud
- Spring Mobile
- Spring for Android
- Spring Session
Spring MVC is a framework designed for building web-based applications.
It follows the MVC (Model-View-Controller) pattern.
Basic operation model:
- Model: are POJO, Service, DAO files that access database, process business
- View: are JSP, html files …
- Control: is the Dispatcher Controller, Handler Mapping, Controller – to handle the request.
Flow in Spring MVC:
- Any request to web application will be sent to Front Controller (Dispatcher Servlet).
- The Front Controller will use Handler Mapping to know which controller will process the request
- The controller receives the request, calls the appropriate service classes to handle the request.
- After processing is complete, the Controller will receive the model from the Service layer or the DAO layer.
- Controller sends the received model to the Front Controller (Dispatcher Servlet).
- The Dispatcher Servlet finds the view templates, uses the view resolver, and passes the model to it.
- View template, model, view page are built and returned to the Front Controller
- The Front Controller sends a page view to the browser to display it to the user.
- The layers in Spring MVC are independent so unit testing is easier.
- The view section can be integrated with many UI Frameworks such as JSF, Freemarker, Themeleaf …
- Spring MVC base is on POJO class so its actions are quite simple
- Supports both Annotation and XML config for faster and cleaner code development.
- Provide a clear, flexible division between controller, service, data acces layer.
@Controller is the main annotation that indicates the annotated class serves as the Controller of MVC. The Dispatcher Servlet scans the classes annotated with it to map web requests to methods annotated using
@Controller inherits from the
@Component annotation just like other Spring annotations, such as
@RequestMapping to map requests to controller methods. It has different properties to match URL, HTTP method, request parameter, title, and media type. You can use it at the class level to represent shared mappings, or at the method level to narrow it down to a specific endpoint mapping.
-> Class HomeController will handle 2 URLs “/ method1”, “/ method2”.
- On a method argument in the
@RequestMappingmethods to create or access an Object from the model and associate it with the request via WebDataBinder.
- Is a method-level annotation in the
@ControllerAdviceclasses that initializes the model before any
- On the
@RequestMappingmethod to mark its return value as a model attribute.
- This section discusses the
@ModelAttributemethods – the second item in the previous list. A controller can have any number of
@ModelAttributemethods. All such methods are called before
@RequestMappingmethods in the same controller. The
@ModelAttributemethod can also be shared on controllers via
@ControllerAdvice. See section Controller Advice for more details.
@ModelAttributemethod has flexible method signature. They support many of the same arguments as the
@RequestMappingmethod, except the
@ModelAttributeitself or anything related to the request body.
@ControllerAdviceclasses can have
@InitBindermethods that initialize copies of WebDataBinder, and these methods can:
- Bind the request parameters (that is, form or query data) to a model object.
- Converts string-based request values (such as request parameters, path variables, titles, cookies, and others) to the target type of the controller method argument.
- Format model object values as String values when displaying HTML forms.
@InitBindermethod can register
@InitBinderspecific java.beans.PropertyEditor or Spring Converter and Formatter components. Alternatively, you can use the MVC configuration to register Transform and Format types in a globally shared FormattingConversionService.
@InitBindermethods support many of the same arguments as the
@RequestMappingmethods, except for the
@ModelAttribute(command object). Usually, they are declared with the WebDataBinder argument (for registration) and the value returns void.
@ControllerAdvice classes can have
@ExceptionHandler methods to handle exceptions from controller methods.
Some Anomations support validating
@NotNull: value cannot be empty.
@Min: number must be equal to or greater than the specified value.
@Max: the number must be equal to or less than the specified value.
@Size: the size should be equal to the specified value.
@Pattern: string obeys specified regular expression. For example: email format, password must have lower case letters, …
Spring MVC – Multilingual example code in Spring MVC, Internationliaztion-i18n
Similar to JSF Framework, Spring MVC also supports multiple languages, helping to display different languages without having to hard code. I will make .properties files containing label / text for each language (English, Vietnamese, Japanese, French). Whenever you select a language, it will display the label / text of that language.
It supports the following classes:
Above are some of the basic knowledge for newcomers about Java language in general and Spring MVC in particular. Hope you learn well!