Introduction to Spring MVC Framework

A key design principle in Spring Web MVC and in Spring in general is the “Open for extension, closed for modification” principle.

Please follow detailed tutorial get in-depth knowledge: Spring MVC Hello World Tutorial

Also if you have below questions then you are at right place:

• spring framework modules
• best way to download spring framework
• spring framework interview questions
• why use spring framework
• spring framework mvc
• spring framework in java
• advantages of spring framework

The Spring MVC framework is a popular framework for building Java-based web applications. It is part of the larger Spring Framework and provides a model-view-controller (MVC) architecture for building web applications.

With Spring MVC, developers can create web applications with clean and maintainable code, by separating the presentation layer from the business logic. This separation of concerns makes it easier to test, modify and maintain the application over time.

In Spring MVC, the controller handles incoming HTTP requests, and maps them to the appropriate method for handling the request. The model represents the data for the application, and the view is responsible for rendering the model data for the user.

Spring MVC also provides a wide range of features for building modern, dynamic web applications, including support for RESTful web services, validation, and data binding.

Getting started with Spring MVC is straightforward, and there are many resources available online to help developers quickly get up and running, including tutorials, sample code, and online forums.

The Spring MVC framework is a powerful and flexible tool for building Java-based web applications, and is a great choice for developers who want to create well-structured and maintainable web applications.

---

The Spring Web model-view-controller (MVC) framework is designed around a DispatcherServlet  that dispatches requests to handlers, with configurable handler mappings, view resolution, locale and theme resolution as well as support for uploading files.

The default handler is based on the @Controller  and @RequestMapping  annotations, offering a wide range of flexible handling methods. With the introduction of Spring 3.0, the @Controller mechanism also allows you to create RESTful Web sites and applications, through the @PathVariable annotation and other features.

In Spring Web MVC you can use any object as a command or form-backing object; you do not need to implement a framework-specific interface or base class. Spring’s data binding is highly flexible: for example, it treats type mismatches as validation errors that can be evaluated by the application, not as system errors.

Thus you need not duplicate your business objects’ properties as simple, untyped strings in your form objects simply to handle invalid submissions, or to convert the Strings properly. Instead, it is often preferable to bind directly to your business objects. Spring’s view resolution is extremely flexible.

A Controller  implementation can even write directly to the response stream. Typically, a ModelAndView  instance consists of a view name and a model Map, which contains bean names and corresponding objects such as a command or form, which contain reference data. View name resolution is highly configurable, through bean names, a properties file, or your own  ViewResolver implementation.

The model (the M in MVC) is based on the Map interface, which allows for the complete abstraction of the view technology. You can integrate directly JSP, Velocity, or any other rendering technology. The model Map is simply transformed into an appropriate format, such as JSP request attributes or a Velocity template model.

To summarize, this is a simple flow:

1. The client sends a request to web container in the form of http request.
2. This incoming request is intercepted by Front controller (DispatcherServlet) and it will then tries to find out appropriate Handler Mappings.
3. With the help of Handler Mappings, the DispatcherServlet will dispatch the request to appropriate Controller.
4. The Controller tries to process the request and returns the Model and View object in form of ModelAndView instance to the Front Controller.
5. The Front Controller then tries to resolve the View (which can be JSP, Freemarker, Velocity etc) by consulting the View Resolver object.
6. The selected view is then rendered back to client.

Configuring Spring 5.X MVC

As we saw in previous Spring MVC HelloWorld Example, DispatcherServlet is an entry point to MVC3. Here is a sample:

    <servlet>
        <servlet-name>crunchify</servlet-name>
        <servlet-class>
            org.springframework.web.servlet.DispatcherServlet
        </servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>crunchify</servlet-name>
        <url-pattern>*.html</url-pattern>
    </servlet-mapping>

Once the DispatcherServlet is initialized, it will looks for a file name [servlet-name]-servlet.xml in WEB-INF folder of web application. In above example, the framework will look for file called crunchify-servlet.xml.

Simplest Spring MVC Framework Tutorial – Hello World Example with UI (JSP) Page