Introduction to SpringMVC and integration of Swagger

Keywords: Front-end Spring mvc

Introduction to Spring MVC

Spring MVC is the framework design Srping provides for Web applications. SpringMVC is a typical textbook-style MVC framework, unlike Struts and others, which are variants or are not entirely mvc-based.

Spring MVC has clear roles, detailed division of labor, and seamlessly combines with the Spring framework. As the most mainstream Web development framework in the industry today, Spring MVC has become the hottest development skill and is widely used in desktop development.

MVC design is not limited to java Web applications, but also includes many references, such as front-end, PHP,.NET, and so on. The reason for this is to decouple the modules.

MVC is an abbreviation for Model, View, and Conntroller, representing three responsibilities in a Web application.

  • Model: Business logic for storing data and handling user requests

  • View: Submit data to the controller, display data in the model

  • Conntroller: Determine which module to submit the request to for processing based on the request made by the view, and update the display to which view to submit the processed results

The implementation of Servlet-based MVC mode is as follows:

  • Model: One or more JavaBean objects used to store data (entity models, created by JavaBean classes) and process business logic (business models, created by generic java classes)

  • View: Submit data to the controller and display data for the model. JSP pages display data mainly using HTML and JavaBean Tags

  • Controller: One or more Servlet objects that are controlled based on requests submitted by the view, which forwards the request to the javaBean of the Business Logic Department, and stores the processing results in the entity model javaBean, which is output to the view display.

Features and Advantages of MVC

  1. Let's make it very easy to design clean and thin Web layers;

  2. Inborn integration with Spring framework (such as IOC container, AOP, etc.);

  3. Provides strong contractual programming support with conventions larger than configurations;

  4. Simple unit testing at the Web tier;

  5. Support flexible mapping of URL s to page controllers;

  6. Very easy to integrate with other view technologies;

  7. Very flexible data validation, formatting, and data binding mechanisms;

  8. Simpler exception handling;

  9. Support for static resources;

  10. Support Restful style.

    SpringMVC Workflow

  11. The user sends a request to the server, which is captured by the Spring Front End Control Servelt Dispatcher Servlet;

  12. Dispatcher Servlet parses the request URL to get the request resource identifier (URI). Then, based on the URI, call HandlerMapping to get all the related objects (including the Handler object and the interceptor corresponding to the Handler object) of the Handler configuration, and finally return as the HandlerExecutionChain object;

  13. Dispatcher Servlet chooses an appropriate Handler Adapter based on the handler obtained. (Note: If the Handler Adapter is successfully obtained, execution of the interceptor's preHandler(...) method will begin at this point)

  14. Extract the model data from Request, populate the Handler input, and start executing the Handler. During the process of populating the Handler input, Spring will do some additional work for you, depending on your configuration:

  • HttpMessageConveter: Converts a request message (such as Json, xml, etc.) into an object and an object into a specified response message
  • Data conversion: Data conversion of request messages. For example, String conversion to Integer, Double, etc.
  • Data Rooting: Data formatting of request messages. For example, converting strings to formatted numbers or formatted dates
  • Data validation: Validate the validity of the data (length, format, etc.) and store the validation results in BindingResult or Error
  1. After the Handler execution is completed, a ModelAndView object is returned to the Dispatcher Servlet;

  2. Based on the returned ModelAndView, select a suitable ViewResolver (which must be a ViewResolver registered in the Spring container) to return to Dispatcher Servlet;

  3. ViewResolver combines Model and View to render the view

  4. Returns the rendering result to the client.

Spring MVC Workflow Description

  1. First the user sends a request to the front-end controller, which decides which page controller to process and delegates the request to based on the request information (such as the URL). This is the control logic part of the previous controller; steps 1 and 2 in the diagram;
  2. After the page controller receives the request, it performs functional processing. First, it collects and binds the request parameters to an object, which is called a command object in Spring Web MVC, validates it, and then delegates the command object to a business object for processing. Return a ModelAndView (model data and logical view name) after processing; Steps 3, 4, and 5 in the diagram;
  3. The front-end controller takes back control, then chooses the appropriate view to render based on the returned logical view name, and passes in the model data for view rendering. Steps 6 and 7 in the diagram;
  4. The front-end controller takes back control again and returns the response to the user, step 8 in the figure; This concludes the whole story.

### Spring MVC development steps

  1. Configuring Tomcat in your project
  2. Add Maven Dependent Libraries for Spring and Spring Web MVC
  3. Configure Dispatcher Servlet
  4. Configure applicationContext.xml
  5. Define Controller for Controller
  6. Define JSP

Maven Dependent Library

  1. spring-core

  2. spring-context

  3. spring-context-support

  4. spring-aspects

  5. **spring-webmvc **

  6. jstl

  7. commons-logging



  • DispatcherServlet

    • Front-end central controller for Spring MVC, where all requests are centralized for subsequent processing, such as selecting a mapped Controller for request processing

    • web.xml

      <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "" >
          <display-name>Archetype Created Web Application</display-name>
      <!--Why is it called MvcServlet,Because it's called here
              If this is called here XX ,that dispatcherServlet The configuration file is called xx-servlet.xml-->

Resolve Random Code

  • web.xml


Configuring ViewResolver in applicationContext.xml

  • Configure ViewResolver

    	<property name="viewClass"
    	<property name="prefix" value="/WEB-INF/jsp/"></property>
    	<property name="suffix" value=".jsp"></property>

    InternalResourceViewResolver: Used to support Servlet, JSP view resolution;

    viewClass: JstlView means that the JSP template page needs to use a JSTL tag library, and the classpath must contain the relevant jar package of jstl;

    Prefix and suffix: Find the prefix and suffix (prefix [logical view name] suffix) of the view page, such as the incoming logical view name hello, which should be stored in "WEB-INF/jsp/hello.jsp";

Configure <mvc:annotation-driven>in applicationContext.cml

Zero Configuration
  1. Use notes

    <context:component-scan base-package="com.trkj"/>
    <!--Automatic Scan Class-->
    <!--Enable mvc annotation-->
    <beans xmlns=""
    	xmlns:xsi="" xmlns:aop=""
    	xmlns:tx="" xmlns:p=""
    	xmlns:jpa="" xmlns:mvc=""
    <!-- Turn on automatic scanning-->
    	<context:component-scan base-package="com.trkj" />
    <!--View Resolution-->
    	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    		<property name="viewClass" value="org.springframework.web.servlet.view.JstlView"></property>
    		<property name="prefix" value="/WEB-INF/jsp/"></property>
    		<property name="suffix" value=".jsp"></property>
    <!--        http://localhost:8080/con/index-->
    <!--        What you get is index,In front of him /WEB-INF/jsp/ ,Followed by .jsp. This is spelled-->
    <!--        /WEB-INF/jsp/index.jsp-->
    <!--Open Notes-->
    <mvc:annotation-driven />

@Controller and @RequestMapping


Declare Bean as Controller Controller

  • Define Controller

    You can specify different access paths for different methods to implement a Controller that handles multiple different requests

  • method = RequestMethod.GET | POST

    Define Request Type

Controller Annotation Implementation



@RequestMapping("/wa")//Narrow mapping, as a prefix to access paths, can be omitted
public class WorldController{
    @RequestMapping("/hello")//Access Path
	public ModelAndView hello(){
        System.out.println("Get into Controller");
        ModelAndView mv = new ModelAndView();
        mv.addObject("attr2","Xu Xian");
        return mv;

Controller receives request parameters

  • The parameter of the method is the request parameter
    • Automatic Type Conversion
    • By default, request and method parameter names are the same
      • @RequestParam is used to specify the request parameter name
@RequestMapping("/xuxiang")//Narrow mapping, prefix to access path, omitted
public class WorldController{
    public ModelAndView world(@ReuqestParam("aa") int a, int b){
        System.out.println(a + "," + b);
        return null;

Visit http://localhost:8089/SpringMVC3/wa/world?aa=10&b=20

Full folder

Spring MVC Integration Swagger

Overview of Swagger

Swagger is a canonical and complete framework for generating, describing, invoking, and visualizing RESTful-style Web services.

If there is no good development specification during the development process, code modification may occur, but the document is not updated in time, and the front end cannot get the latest interface in time.

Swagger is a good solution. It can generate Api interface documents dynamically, reduce communication costs, and promote efficient project development. Swagger2 is a specification and complete framework for generating, invoking, describing, and visualizing RESTful-style Web services. Its advantages are as follows:

	1. Timeliness: After interface changes, front-end and back-end developers can be informed promptly and accurately.
	2. Normality: and guarantees the specificity of an interface, such as its address, request mode, parameters, response format, and error information.
	3. Consistency: Interface information is consistent and there are no differences due to inconsistent versions of documents available to developers.
	4. Testability: Testing directly on the interface documentation to facilitate understanding the business.

Adding dependencies to pox.xml


<!--because swagger Need jackson Support, so pom.xml Need to be introduced in jackson Associated Packages-->

Add swaggerConfig

Create a config directory under the directory and add

 * @author XuLuBao
 * @version V1.0
 * @Package com.trkj.config
 * @date 2021/4/20 9:04
public class SwaggerConfig extends WebMvcConfigurationSupport {
    public Docket createRestApi(){
        Docket docket = new Docket(DocumentationType.SWAGGER_2);
        //Call the apiInfo method to create an ApiInfo instance.
        //Inside is the information displayed in the document
        //Control instances under exposed paths
        //If an interface does not want to be exposed, you can use a comment
        return docket;

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                //Page Title
                    .title("SpringMVC swagger List")
                    .description("Controller Interface Testing")
                    .contact(new Contact("Contact us","",""))

MvcServlet-servlet.xml Configuration

Add in the original MVCservlet-servlet.xml

<!--    swagger2 Static Resource Mapping-->
    <mvc:resources mapping="/swagger-ui/**" location="classpath:/META-INF/resources/webjars/springfox-swagger-ui"/>
    <mvc:resources mapping="/webjars/**" location="classpath:/META-INF/resources/webjars/"/>


  • Add Api to Class Name

    @Api(value = "IndexController",tags = {"Module 1 example"})
  • Method

    • No parameters

      @ApiOperation(value = "Jump to index Home page",notes="index",httpMethod = "GET")
    • Has Parameters

      @ApiOperation(value="Register user, enter after success show Page, showing user information",notes = "register",httpMethod = "GET")
      @ApiImplicitParams(value = {@ApiImplicitParam(name="name",value="Full name",required = true,dataType = "String"),
                                      @ApiImplicitParam(name="sex",value = "Gender",required = true,dataType = "String"),
                                      @ApiImplicitParam(name="age",value = "Age",required = true,dataType = "String")})

Test Swagger

Start the server with the following access addresses:

​ http://localhost:8080/mvcPart1/swagger-ui/index.html

Posted by scallywag05 on Fri, 03 Dec 2021 11:19:07 -0800