编程知识 cdmana.com

Spring boot enhancement (4) -- Integration and principle analysis of spring MVC framework

Spring MVC brief introduction

When designing large software systems , Business tends to be relatively complex , If all the business implementation code is entangled , There will be a lack of logic 、 Poor readability , Difficult to maintain , Change a place to pull a hair and move the whole body and other issues . In order to better solve this problem, we now often talk about hierarchical architecture design .

MVC What is it?

MVC It's a software architecture design idea , be based on MVC Architecture will be our application software layered design and Implementation , For example, it can be divided into view layers (View), Control layer (Controller), The model layer (Model), Through this layered design, our program has better flexibility and scalability . Because it simplifies a complex application , Realize that each of them performs his or her own duties , Let each person do his best . More suitable for the development of a large application .
View (View) - UI Designers design graphical interfaces , Responsible for implementing interaction with users .
controller (Controller)- Responsible for getting requests , Processing requests , In response to the results .
Model (Model) - Implement business logic , Data logic implementation .
image.png

Spring MVC summary

Spring MVC yes MVC The design idea is Spring An implementation in the framework , Based on this idea spring The framework designs some related objects , For better based on MVC Architecture handles requests and responses , Its simple structure is shown in the figure :
image.png
1. Front controller DispatcherServlet It is the entry point for all requests from the client , Responsible for request forwarding .
2. Processor mapper RequestMapping Responsible for storing requests url To the back end handler Mapping between objects .
3. Processor adapter Handler Used for processing DispatcherServlet The object of the request .
4. view resolver ViewResolver Take care of all Handler Object response result view.

Spring MVC Quick start

preparation

First step : Create project module, The basic information is shown in the figure :

image.png

The second step : Add project dependency ( Can be in module Creation time , It can also be created after ), The code is as follows :

Spring Web rely on ( Provides spring mvc Support and embed a tomcat)

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Thymeleaf rely on ( Provided by html As a page template for parsing and operating related objects )

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

static Directory analysis and Application

static The catalogue is springboot The project was created by adding web Rely on directories created automatically later , This directory can store html、css、js、image, These resources can be started after the server , Access directly from the browser .
image

templates Directory analysis and Application

templates The catalogue is springboot The project was created by adding thymeleaf Rely on directories created automatically later , This directory needs to store some html Templates , This template page cannot be accessed directly through the browser url Visit , It needs to be based on the back-end controller , Define the page response in the method
image
among , If default.html Put it in the templates Subdirectory , You also need to configure... In the configuration file thymeleaf The prefix of

#server port
server.port=80
#spring web
spring.thymeleaf.prefix=classpath:/templates/health/
spring.thymeleaf.suffix=.html
#spring thymeleaf
spring.thymeleaf.cache=false

Definition HealthController Class to test

package com.cy.pj.health.controller;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;
@Controller
public class HealthController {//Handler object   To deal with it DispatcherServlet Requests handed out 
    // Three situations 
    //1. Just go back to the page 
    //2. return json character string 
    //3. Return to the page and add parameters 
     @RequestMapping("/doPrint")
     @ResponseBody
     public void doPrint(HttpServletResponse response) throws Exception{
         Map<String,Object> map =new HashMap<>();
         map.put("username", "tony");
         map.put("state", true);
         //return map ;
         // take map Convert data in to json Format string , The underlying implementation is as follows 
         ObjectMapper om=new ObjectMapper();
         String jsonStr=om.writeValueAsString(map);//jackson Medium conversion json String method 
         System.out.println("jsonStr="+jsonStr);
         // Respond the string to the client 
         response.setCharacterEncoding("utf-8");// Change the encoding 
         response.setContentType("text/html;charset=utf-8");// Tell the client our encoding format to parse the data in this way 
         PrintWriter pw = response.getWriter();// Write to the response stream 
         pw.println(jsonStr);
     }
     @RequestMapping("/doHealth")
     public String doHealth(Model model) {
        model.addAttribute("username"," Zhang San ");
        model.addAttribute("state"," sub-health ");
        return "default"; // The returned string is passed to the ViewResolver view resolver , Automatic analysis , Pass the parameters and present the page 
     }
     @RequestMapping("/health.html")
     @ResponseBody
     // When using this annotation to describe the control method , Used to tell spring frame , The return value of this method can be in a specific format ( example json character string ) convert , To respond to clients 
     // Write the converted result to response In the response body of the object 
     //f The return value of Enfa is no longer encapsulated as ModelAndView object , It will not be handed over to the view parser for parsing , It's directly based on response Object responds to the client 
     public Map<String, Object> doHealth(){
         Map<String,Object> map =new HashMap<>();
         map.put("username", "tony");
         map.put("state", true);
         return map ;
     }
    //public ModelAndView doHealth(){// This method by DispatcherServlet Object is called by reflection 
        //ModelAndView mv =new ModelAndView();
        //mv.setViewName("default");//viewname
        //mv.addObject("username"," Li Si ");
        //mv.addObject("state"," sub-health ");// It's an object , So you can pass more than strings 
        //return mv;
     //1. The return value will be given to DispatcherServlet Object to process 
     //2.DispatcherServlet The object will call viewresolver Parse the results 
     //2.1 be based on viewname To find the corresponding view page (prefix+viewname+suffix)
     //2.2 take model The data in is populated with view On the page 
     //2.3 Returns a value with module Data page to DispatcherServlet
     //3.DispatcherServlet Will have model Data returned to the client 
    
    //public String doHealth(){
    //   return "default" ;//  You can directly return to the page with the corresponding name 
    //    }
}

JSON Data response

We have a business that doesn't need pages , Just convert the response data to json, And then respond to the client , How to achieve it ?
First step : Definition ResponseResult Object is used to encapsulate response data , for example :

package com.cy.pj.module.pojo;
public class ResponseResult {
    private Integer code;
    private String message;
    public Integer getCode() {
        return code;
    }
    public void setCode(Integer code) {
        this.code = code;
    }
    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }
}

The second step : Definition JsonObjectController And how , The code is as follows :

package com.cy.pj.health.controller;
import com.cy.pj.health.pojo.ResponseResult;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;
@RestController//=@Controller+@ResponseBody
public class JsonObjectController {
    @RequestMapping("/doConvertResponseToJson")
    public ResponseResult doConvertResponseToJson(){
        ResponseResult rs=new ResponseResult();
 rs.setCode(200);
 rs.setMessage("OK");
 return rs;
 }
    @RequestMapping("/doConvertMapToJson")
    public Map<String,Object> doConvertMapToJson(){
        Map<String,Object> map=new HashMap<>();
 map.put("username"," Lau Andy ");
 map.put("state",true);
 return map;
 }
    @RequestMapping("/doPrintJSON")
    public void doPrint(HttpServletResponse response)throws Exception{
        Map<String,Object> map=new HashMap<>();
 map.put("username"," Lau Andy ");
 map.put("state",true);
 // take map The data in is converted to json Format string 
 ObjectMapper om=new ObjectMapper();
 String jsonStr=om.writeValueAsString(map);
 System.out.println("jsonStr="+jsonStr);
 // Respond the string to the client 
 // Set the encoding of the response data 
 response.setCharacterEncoding("utf-8");
 // Tell the client , The data type to respond to is text/html, Encoded as utf-8. Please use this encoding for data presentation 
 response.setContentType("text/html;charset=utf-8");
 PrintWriter pw=response.getWriter();
 pw.println(jsonStr);
 }
}

SpingMVC Request parameter data processing

We usually pass some request parameters to the server during business execution , How does the server get the parameters and inject them into our method parameters ?

package com.cy.pj.health.controller;
import com.cy.pj.health.pojo.RequestParameter;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
@RestController
public class ParamObjectController {
//    @GetMapping
//    @PostMapping
 // Restricted type on request , If the type does not match, the client will report 405 error ( Request type mismatch )
 @RequestMapping("/doParam01")
    public String doMethodParam(@RequestParam(required = false) String name){// Parameters of direct quantity receiving request , The parameter name should be the same as the request parameter name 
 // added @RequestParam(required = false)  It means that you can pass the parameters, but you can not   If the annotation doesn't add required Parameters   Will report a mistake 400( The number of parameter types does not match )
 return "request params" +name;
 }
    @RequestMapping("/doParam02")
    public String doMethodParam(RequestParameter param){//pojo Object receives request parameters ,pojo In the object, you need to provide set Method 
 return "request params" +param.toString();
 }
    @RequestMapping("/doParam03")
    public String doMethodParam(@RequestParam Map<String,Object> param){// Use map Comments are used when receiving parameters @RequestParam Describe the parameters 
 return "request params" +param.toString();
 }
}

POJO Object mode

Definition pojo object , Used to accept client request parameters , for example :

package com.cy.pj.module.pojo;
public class RequestParameter {
    private String name;
    //......
 public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
 public String toString() {
        return "RequestParam{" +
                "name='" + name + ''' +
                '}';
    }
}

版权声明
本文为[He Bai Shao er]所创,转载请带上原文链接,感谢

Scroll to Top