首页 > 其他分享 >SpringMVC教程

SpringMVC教程

时间:2023-12-13 11:12:03浏览次数:33  
标签:教程 return 请求 SpringMVC request 控制器 视图 String

概述

本次项目以SpringMVC为主,使用Maven和themleaf,themleaf是一种模板引擎,主要用来编写动态页面。

MVC概念

MVC是一种软件架构的思想,将软件按照模型、视图、控制器来划分。

M:Model,模型层,指工程中的JavaBean,作用是处理数据。JavaBean分为两类:一类称为实体类Bean:专门存储业务数据的,如Student,User等。一类称为业务处理Bean:指Service或Dao对象,专门用于处理业务逻辑和数据访问。

V:View,视图层,指工程中的html或jsp等页面,作用是与用户进行交互,展示数据。

C:Controller,控制层,指工程中的servlet,作用是接收请求和响应浏览器。

MVC的工作流程:用户通过视图层发送请求到服务器,在服务器中请求被Controller接收,Controller调用相应的Model层处理请求,处理完毕将结果返回到Controller,Controller再根据请求处理的结果找到相应的View视图,渲染数据后最终响应给浏览器。

SpringMVC的特点

  • Spring家族原生产品,与IOC容器等基础设施无缝对接
  • 基于原生的Servlet,通过功能强大的前端控制器DispatcherServlet,对请求和响应进行统一处理
  • 表述层各细分领域需要解决的问题全方位覆盖,提供全面解决方案
  • 代码清新简洁,大幅度提升开发效率
  • 内部组件化程度高,可插拔式组件即插即用,想要什么功能配置相应组件即可
  • 性能卓著,尤其适合现代大型、超大型互联网项目要求

创建webapp文件夹,然后在项目结构处配置xml文件的所处位置。或者使用webapp模板新建模块就可以免去该步骤。

SpringMVC初体验

配置web.xml

默认配置方式:此配置作用下,SpringMVC的配置文件默认位于WEB-lNF下,默认名称为<servlet-name>-servlet.xml,例如,以下配置所对应SpringMVC的配置文件位于WEB-lNF下,文件名为springMVC-servlet.xml。

拓展配置方法:使用<init-param>表情配置文件的位置,这样就可以存放到resources文件夹下。

<!--web.xml-->
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    
<!--    配置SpringMVC的前端控制器,对浏览器发送的请求进行统一处理-->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--        配置xml文件所在位置-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springMVC.xml</param-value>
        </init-param>
<!--        将前端控制器的初始化时间提前到服务器启动时-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
<!--/所匹配的请求可以是/login或.html或.js或.css方式的请求路径,但是/不能匹配.jsp请求路径的请求-->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

配置Thymeleaf视图解析器只需关心视图前缀和视图后缀,原理与字符串拼接类似。

<bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
    <property name="order" value="1"/>
    <property name="characterEncoding" value="UTF-8"/>
    <property name="templateEngine">
        <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
            <property name="templateResolver">
                <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
                    <!-- 视图前缀 -->
                    <property name="prefix" value="/WEB-INF/templates/"/>
                    <!-- 视图后缀 -->
                    <property name="suffix" value=".html"/>
                    <property name="templateMode" value="HTML5"/>
                    <property name="characterEncoding" value="UTF-8" />
                </bean>
            </property>
        </bean>
    </property>
</bean>

HTML页面需要加上<html lang="en" xmlns:th="http://www.thymeleaf.org">的命名空间,否则thymeleaf不可用。可以在文件模板处进行修改。

控制器的方法加上@RequestMapping("/")注解来指定要匹配的访问路径,在方法中返回要访问的文件。

@Controller
public class HelloController {
    //指定要匹配的路径
    @RequestMapping("/")
    public String index(){
        //返回视图名称,要访问的页面
        return "index";
    }
}

遇到Tomcat报错结果为Tomcat启动时报错找到多个名为spring_web的片段。这是不合法的相对排序。,可以在web.xml最后处加上<absolute-ordering/>即可参考解决

<a th:href="@{/target}">访问目标页面target.html</a>使用thymeleaf来解决绝对路径问题。

SpringMVC对版本有要求,如果遇到 Failed to read candidate component class报错则可以在java Compiler设置适合的jdk版本参考解决

总结

浏览器发送请求,若请求地址符合前端控制器的url-pattern,该请求就会被前端控制器DispatcherServlet处理。前端控制器会读取SpringMVC的核心配置文件,通过扫描组件找到控制器,将请求地址和控制器中@RequestMapping注解的value属性值进行匹配,若匹配成功,该注解所标识的控制器方法就是处理请求的方法。处理请求的方法需要返回一个字符串类型的视图名称,该视图名称会被视图解析器解析,加上前缀和后缀组成视图的路径,通过Thymeleaf对视图进行渲染,最终转发到视图所对应页面。

@RequestMapping注解

从注解名称上我们可以看到,@RequestMapping注解的作用就是将请求和处理请求的控制器方法关联起来,建立映射关系。 SpringMVC接收到指定的请求,就会来找到在映射关系中对应的控制器方法来处理这个请求。

@RequestMapping标识一个类:设置映射请求的请求路径的初始信息;@RequestMapping:标识一个方法:设置映射请求请求路径的具体信息。类似父子文件夹的关系。

value属性是一个数组,可以匹配数组中的任一请求。

@RequestMapping注解的method属性通过请求的请求方式(get或post)匹配请求映射。若当前请求的请求地址满足请求映射的value属性,但是请求方式不满足method属性,则浏览器报措405。默认是任何请求方式都可以匹配。

对于处理指定请求方式的控制器方法,SpringMVC中提供了@RequestMapping的派生注解:@GetMapping、@PostMapping、@PutMapping、@DeleteMapping。

常用的请求方式有get,post,put,delete。但是目前浏览器只支持get和post,若在form表单提交时,为method设置了其他请求方式的字符串(put或 delete),则按照默认的请求方式get处理。若要发送put和deletei请求,则需要通过spring提供的过滤器HiddenHttpMethodFilter,在restful部分会讲到。

@RequestMapping注解的params属性通过请求的请求参数匹配请求映射。要求里面的条件同时满足,报错代码为400

@RequestMapping注解的neaders属性通过请求的请求头信息匹配请求映射。要求里面的条件同时满足,报错代码为404

ant风格的路径

符号 含义
单个任意字符
* 表示任意的0个或多个字符
** 表示任意的一层或多层目录,在使用**时,只能使用/**/xxx的方式

SpringMVC支持路径中的占位符

URL地址只需写value,在注解中使用{}占位符指明key的值。再通过@PathVariable注解,将占位符所表示的数据赋值给控制器方法的形参

//<a th:href="@{/testPath/1}">测试占位符风格的路径</a><br>
@RequestMapping("/testPath/{id}")
public String testPath(@PathVariable("id")Integer id){
    System.out.println("id="+id);
    return "success";
}

SpringMVC获取请求参数

xml装配是有则装配,无则忽略,而基于注解的方式则是有则装配,无则报错。

@RequestParam是将请求参数和控制器方法的形参创建映射关系,有三个参数:value指定为形参传输的参数名,required参数设置是否需要传值,defaultValue设置默认值。

@RequestHeader是将请求头信息和控制器方法的形参创建映射关系,参数同上。

@CookieValue是将cookie数据和控制器方法的形参创建映射关系,参数同上。

可以在控制器方法的形参位置设置一个实体类类型的形参,此时若浏览器传输的请求参数的参数名和实体类中的属性名一致,那么请求参数就会为此属性赋值。

乱码解决

在VMoption中添加-Dfile.encoding=UTF-8,但记得要放在Javaagent设置之前,否则idea会不能打开。

get方式的乱码是由Tomcat造成的,只需修改Tomcat的conf目录下的server.xml文件中添加URIEncoding="UTF-8"属性。(问题尚未解决,修改后仍然有乱码问题)。

<Connector port="8080" URIEncoding="UTF-8" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443"
           maxParameterCount="1000"
           />

在post方式下,由于需要在servlet之前修改文件编码,因此我们使用过滤器中修改编码。(修改后仍乱码)

<filter>
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
        <param-name>forceResponseEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>

通过servletAPI获取

将HttpServletRequest作为控制器方法的形参,此时HttpServletRequest类型的参数表示封装了当前请求的请求报文的对象。

//形参位置的request表示当前请求
public String testServletAPI(HttpServletRequest request){
    HttpSession session = request.getSession();
    String username = request.getParameter("username");
    String password = request.getParameter("password");
    return "success";
}

通过控制器方法获取

可以在形参处填写与HTML页面相同的key值,控制器会自动获取值。如果遇到key值相同的情况,如果形参设置为string则会将对应的value值拼接在一起,用逗号隔开,如果形参是string数组则会按数组存放。

public String testParam(String username,String password){
    System.out.println("username:"+username+",password:"+password);
    return "success";
}

域对象共享数据

request域

使用servletAPI

public String testRequestByServletAPI(HttpServletRequest request){
    request.setAttribute("testRequestScope", "hello,servletAPI");
    return "success";
}

使用ModelAndView

ModelAndView必须作为方法的返回值返回,而不是返回需要的访问的HTML名称。

这种方式是SpringMVC推荐的使用方式,不管是使用什么方式,最终都是封装到ModelAndView中。

public ModelAndView testModelAndView(){
    ModelAndView mav = new ModelAndView();
    //处理模型数据,即向请求域request共享数据
    mav.addObject("testRequestScope", "hello,ModelAndView");
    //设置视图名称
    mav.setViewName("success");
    return mav;
}

使用Model

public String testModel(Model model){
    model.addAttribute("testRequestScope", "hello,model");
    return "success";
}

使用map

public String testMap(Map<String, Object> map){
    map.put("testRequestScope", "hello,map");
    return "success";
}

使用ModelMap

有个疑问,ModelMap和Model还有Map有什么区别,感觉跟Model是一样的。实际上三者的实现类都是一样的,都是BindingAwareModelMap

public String testModelMap(ModelMap modelMap){
    modelMap.addAttribute("testRequestScope", "hello,ModelMap");
    System.out.println(modelMap.getClass().getName());
    return "success";
}

通过servletAPI向session域共享数据

public String testSession(HttpSession session){
    session.setAttribute("testSessionScope", "hello,session");
    return "success";
}

通过servletAPI向application域对象共享数据

public String testApplication(HttpSession session){
    ServletContext application = session.getServletContext();
    application.setAttribute("testApplicationScope", "hello,application");
    return "success";
}

视图

SpringMVC中的视图是View接口,视图的作用是渲染数据,将模型Model中的数据展示给用户。SpringMVC视图的种类很多,默认有转发视图(InternalResourrceView)和重定向视图(RedirectView)。

ThymeleafView:当控制器方法中所设置的视图名称没有任何前缀时,此时的视图名称会被SpringMVCi配置文件中所配置的视图解祈器解析,视图名称拼接视图前缀和视图后缀所得到的最终路径,会通过转发的方式实现跳转。

前缀为forward:则创建转发视图,为redirect:则是重定向视图,程序会去掉前缀,然后再次创建视图。

视图控制器

适合在无需Java代码处理,仅仅是进行请求转发的情况。

<mvc:view-controller path="/" view-name="index"></mvc:view-controller>
<mvc:view-controller path="/test_view" view-name="test_view"></mvc:view-controller>
<mvc:view-controller path="/test_rest" view-name="test_rest"></mvc:view-controller>

<!--开启mvc的注解驱动,当SpringMVC中设置任何一个view-controller时,
其他控制器中的请求映射将全部失效,此时需要在 SpringMVC的核心配置文件中设置开启mvc注解驱动的标签-->
<mvc:annotation-driven />

JSP的xml配置

用的视图解析器是InternalResourceViewResolver,是转发视图。

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/templates/"></property>
    <property name="suffix" value=".jsp"></property>
</bean>

RESTFUL

REST:Representational State Transfer,表现层资源状态转移。RESTFUL是一种代码风格。

资源是一种看待服务器的方式,即,将服务器看作是由很多离散的资源组成。每个资源是服务器上一个可命名的抽象概念。因为资源是一个抽象的概念,所以它不仅仅能代表服务器文件系统中的一个文件、数据库中的一张表等具体的东西,可以将资源设计的要多抽象有多抽象。

具体说,就是HTTP协议里面,四个表示操作方式的动词:G正T、POST、PUT、DELETE。它们分别对应四种基本操作:GET用来获取资源,POST用来新建资源,PUT用来更新资源,DELETE用来删除资源。

<a th:href="@{/employee/${employee.id}}">delete</a>是错误的写法,因为${}@{}内被转义,因此不会被解析,应该这样写<a th:href="@{'/employee/'+${employee.id}}">delete</a>,加上单引号就没有问题了。或者可以将其放在@{}外,再使用加号拼接。

静态资源不能使用DispatcherServlet处理,因为没有在控制器内设置对应关系,需要使用默认的servlet,需要在springMVC.xml文件内<mvc:default-servlet-handler />。此时DispatcherServlet先寻找,找不到再由默认的servlet进行查找。

让单选框回显:th:field="${employee.gender}",会自行判断。

激活PUT和DELETE方法

开启后,使用post方式提交,然后设定隐藏域<input type="hidden" name="_method" value="PUT",在value处填写自己需要的提交方法。

<!--配置HiddenHttpMethodFilter-->
<filter>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

HttpMessageConverter

HttpMessageConverter,报文信息转换器,将请求报文转换为Java对象,或将ava对象转换为响应报文。

HttpMessageConverter提供了两个注解和两个类型:@RequestBody,@ResponseBody,RequestEntity,ResponseEntity。

ResponseEntity用于控制器方法的返回值类型,该控制器方法的返回值就是响应到浏览器的响应报文。可用于文件上传和下载。

@RequestBody

@RequestBody可以获取请求体,需要在控制器方法设置一个形参,使用@RequestBody进行标识,当前请求的请求体就会为当前注解所标识的形参赋值。使用时将注解标记在形参前即可。

public String testRequestBody(@RequestBody String requestBody){
    System.out.println("requestBody:"+requestBody);
    return "success";
}

RequestEntity

RequestEntity封装请求报文的一种类型,需要在控制器方法的形参中设置该类型的形参,当前请求的请求报文就会赋值给该形参,可以通过getHeaders()获取请求头信息,通过getBody0获取请求体信息。

public String testRequestEntity(RequestEntity<String> requestEntity){
  //当前requestEnity表示整个请求报文的信息
  System.out.println("请求头:"+requestEntity.getHeaders());
  System.out.println("请求体:"+requestEntity.getBody());
  return "success";
}

@ResponseBody

@ResponseBody用于标识一个控制器方法,可以将该方法的返回值直接作为响应报文的响应体响应到浏览器。

@RestController注解是springMVC提供的一个复合注解,标识在控制器的类上,就相当于为类添加了@Controller注解,并且为其中的每个方法添加了@ResponseBody注解。

这个注解是相当重要的注解,日后会经常使用到。

@ResponseBody
public String testResponseBody(){
    return "成功";
}
//返回对象也可以,但是需要导入JSON依赖jackson-databind
@ResponseBody
public User testResponseUser(){
    return new User(1001, "admin", "123456", 23, "男");
}

文件上传和下载

文件上传需要导入commons-fileupload的依赖,还需要在springMVC.xml中配置文件上传解析器,将上传的文件封装成MultipartFile,配置为<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"></bean>。这个bean是按ID获取的,并且最好是这个名字。

@Controller
public class FileUpAndDownController {

    @RequestMapping("/testDown")
    public ResponseEntity<byte[]> testResponseEntity(HttpSession session) throws IOException {
        //获取ServletContext对象
        ServletContext servletContext = session.getServletContext();
        //获取服务器中文件的真实路径
        String realPath = servletContext.getRealPath("/static/img/1.jpg");
        System.out.println(realPath);
        //创建输入流
        InputStream is = new FileInputStream(realPath);
        //创建字节数组,is.available获取当前输入流的最大字节数
        byte[] bytes = new byte[is.available()];
        //将流读到字节数组中
        is.read(bytes);
        //创建HttpHeaders对象设置响应头信息
        MultiValueMap<String, String> headers = new HttpHeaders();
        //设置要下载方式以及下载文件的名字
        headers.add("Content-Disposition", "attachment;filename=1.jpg");
        //设置响应状态码
        HttpStatus statusCode = HttpStatus.OK;
        //创建ResponseEntity对象
        ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(bytes, headers, statusCode);
        //关闭输入流
        is.close();
        return responseEntity;
    }

    @RequestMapping("/testUp")
    public String testUp(MultipartFile photo, HttpSession session) throws IOException {
        //获取上传的文件的文件名
        String fileName = photo.getOriginalFilename();
        //获取上传的文件的后缀名
        String suffixName = fileName.substring(fileName.lastIndexOf("."));
        //将UUID作为文件名
        String uuid = UUID.randomUUID().toString().replaceAll("-","");
        //将uuid和后缀名拼接后的结果作为最终的文件名
        fileName = uuid + suffixName;
        //通过ServletContext获取服务器中photo目录的路径
        ServletContext servletContext = session.getServletContext();
        String photoPath = servletContext.getRealPath("photo");
        File file = new File(photoPath);
        //判断photoPath所对应路径是否存在
        if(!file.exists()){
            //若不存在,则创建目录
            file.mkdir();
        }
        String finalPath = photoPath + File.separator + fileName;
        //上传文件
        photo.transferTo(new File(finalPath));
        return "success";
    }
}

拦截器

SpringMVC中的拦截器用于拦截控制器方法的执行。

拦截器的实现可以通过实现HandlerInterceptor接口完成。

配置拦截器

<!--1.配置bean-->
<bean class="com.atguigu.mvc.interceptors.FirstInterceptor"></bean>
<!--2.在拦截器前加上注解,然后引用-->
<mvc:interceptors>
    <ref bean="firstInterceptor"></ref>
    <ref bean="secondInterceptor"></ref>
</mvc:interceptors>
<!--3.可配置拦截路径,较为复杂-->
<mvc:interceptor>
    <mvc:mapping path="/**"/>
    <mvc:exclude-mapping path="/"/>
    <ref bean="firstInterceptor"></ref>
</mvc:interceptor>

拦截器的三个抽象方法

  1. preHandle:控制器方法执行之前执行preHandle(),其boolean类型的返回值表示是否拦截或放行,返回true为放行,即调用控制器方法;返回false表示拦截,即不调用控制器方法。
  2. postHandle:控制器方法执行之后执行postHandle()。
  3. afterComplation:处理完视图和模型数据,渲染视图完毕之后执行afterComplation()。
  4. 只有preHandle方法按照xml配置顺序执行,其他两个是逆序执行。
  5. 如果遇到第n个拦截器方法返回false,那么前n个preHandle方法会执行,postHandle全部不执行,前n-1个afterComplation方法执行。

异常处理器

SpringMVC提供了一个处理控制器方法执行过程中所出现的异常的接口:HandlerExceptionResolver。

基于配置

<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <property name="exceptionMappings">
        <props>
            <prop key="java.lang.ArithmeticException">error</prop>
        </props>
    </property>
    <!--设置将异常信息共享在请求域中的键-->;
    <property name="exceptionAttribute" value="ex"></property>
</bean>

基于注解

@ControllerAdvice
public class ExceptionController {

    @ExceptionHandler(value = {ArithmeticException.class, NullPointerException.class})
    public String testException(Exception ex, Model model){
        model.addAttribute("ex", ex);
        return "error";
    }
}

注解配置SpringMVC




使用配置类和注解替代web.xml和SpringMVC.xml配置文件的功能。

创建初始化类替代web.xml

public class WebInit extends AbstractAnnotationConfigDispatcherServletInitializer {

    /**
     * 指定spring的配置类
     */
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    /**
     * 指定springMVC的配置类
     */
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{WebConfig.class};
    }

    /**
     * 指定DispatcherServlet的映射规则,即url-pattern
     */
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    /**
     * 注册过滤器
     */
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
        characterEncodingFilter.setEncoding("UTF-8");
        characterEncodingFilter.setForceResponseEncoding(true);
        HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
        return new Filter[]{characterEncodingFilter, hiddenHttpMethodFilter};
    }
}

替代SpringMVC

/**
 * 代替SpringMVC的配置文件:
 * 1、扫描组件   2、视图解析器     3、view-controller    4、default-servlet-handler
 * 5、mvc注解驱动    6、文件上传解析器   7、异常处理      8、拦截器
 */
//将当前类标识为一个配置类
@Configuration
//1、扫描组件
@ComponentScan("com.atguigu.mvc.controller")
//5、mvc注解驱动
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    //4、default-servlet-handler,需要实现WebMvcConfigurer接口
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    //8、拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        TestInterceptor testInterceptor = new TestInterceptor();
        registry.addInterceptor(testInterceptor).addPathPatterns("/**");
    }

    //3、view-controller
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/hello").setViewName("hello");
    }

    //6、文件上传解析器
    @Bean
    public MultipartResolver multipartResolver(){
        CommonsMultipartResolver commonsMultipartResolver = new CommonsMultipartResolver();
        return commonsMultipartResolver;
    }

    //7、异常处理
    @Override
    public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
        SimpleMappingExceptionResolver exceptionResolver = new SimpleMappingExceptionResolver();
        Properties prop = new Properties();
        prop.setProperty("java.lang.ArithmeticException", "error");
        exceptionResolver.setExceptionMappings(prop);
        exceptionResolver.setExceptionAttribute("exception");
        resolvers.add(exceptionResolver);
    }

    //配置生成模板解析器
    @Bean
    public ITemplateResolver templateResolver() {
        WebApplicationContext webApplicationContext = ContextLoader.getCurrentWebApplicationContext();
        // ServletContextTemplateResolver需要一个ServletContext作为构造参数,可通过WebApplicationContext 的方法获得
        ServletContextTemplateResolver templateResolver = new ServletContextTemplateResolver(
                webApplicationContext.getServletContext());
        templateResolver.setPrefix("/WEB-INF/templates/");
        templateResolver.setSuffix(".html");
        templateResolver.setCharacterEncoding("UTF-8");
        templateResolver.setTemplateMode(TemplateMode.HTML);
        return templateResolver;
    }

    //生成模板引擎并为模板引擎注入模板解析器
    @Bean
    public SpringTemplateEngine templateEngine(ITemplateResolver templateResolver) {
        SpringTemplateEngine templateEngine = new SpringTemplateEngine();
        templateEngine.setTemplateResolver(templateResolver);
        return templateEngine;
    }

    //生成视图解析器并为解析器注入模板引擎
    @Bean
    public ViewResolver viewResolver(SpringTemplateEngine templateEngine) {
        ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
        viewResolver.setCharacterEncoding("UTF-8");
        viewResolver.setTemplateEngine(templateEngine);
        return viewResolver;
    }

}

SpringMVC执行流程

DispatcherServlet本质上是一个Servlet,所以天然的遵循Servlet的生命周期。

DispatcherServlet

初始化WebApplicationContext

所在类:org.springframework.web.servlet.FrameworkServlet

protected WebApplicationContext initWebApplicationContext() {
    WebApplicationContext rootContext =
        WebApplicationContextUtils.getWebApplicationContext(getServletContext());
    WebApplicationContext wac = null;

    if (this.webApplicationContext != null) {
        // A context instance was injected at construction time -> use it
        wac = this.webApplicationContext;
        if (wac instanceof ConfigurableWebApplicationContext) {
            ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
            if (!cwac.isActive()) {
                // The context has not yet been refreshed -> provide services such as
                // setting the parent context, setting the application context id, etc
                if (cwac.getParent() == null) {
                    // The context instance was injected without an explicit parent -> set
                    // the root application context (if any; may be null) as the parent
                    cwac.setParent(rootContext);
                }
                configureAndRefreshWebApplicationContext(cwac);
            }
        }
    }
    if (wac == null) {
        // No context instance was injected at construction time -> see if one
        // has been registered in the servlet context. If one exists, it is assumed
        // that the parent context (if any) has already been set and that the
        // user has performed any initialization such as setting the context id
        wac = findWebApplicationContext();
    }
    if (wac == null) {
        // No context instance is defined for this servlet -> create a local one
        // 创建WebApplicationContext
        wac = createWebApplicationContext(rootContext);
    }

    if (!this.refreshEventReceived) {
        // Either the context is not a ConfigurableApplicationContext with refresh
        // support or the context injected at construction time had already been
        // refreshed -> trigger initial onRefresh manually here.
        synchronized (this.onRefreshMonitor) {
            // 刷新WebApplicationContext
            onRefresh(wac);
        }
    }

    if (this.publishContext) {
        // Publish the context as a servlet context attribute.
        // 将IOC容器在应用域共享
        String attrName = getServletContextAttributeName();
        getServletContext().setAttribute(attrName, wac);
    }

    return wac;
}

创建WebApplicationContext

所在类:org.springframework.web.servlet.FrameworkServlet

protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) {
    Class<?> contextClass = getContextClass();
    if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
        throw new ApplicationContextException(
            "Fatal initialization error in servlet with name '" + getServletName() +
            "': custom WebApplicationContext class [" + contextClass.getName() +
            "] is not of type ConfigurableWebApplicationContext");
    }
    // 通过反射创建 IOC 容器对象
    ConfigurableWebApplicationContext wac =
        (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);

    wac.setEnvironment(getEnvironment());
    // 设置父容器
    wac.setParent(parent);
    String configLocation = getContextConfigLocation();
    if (configLocation != null) {
        wac.setConfigLocation(configLocation);
    }
    configureAndRefreshWebApplicationContext(wac);

    return wac;
}

DispatcherServlet初始化策略

FrameworkServlet创建WebApplicationContext后,刷新容器,调用onRefresh(wac),此方法在DispatcherServlet中进行了重写,调用了initStrategies(context)方法,初始化策略,即初始化DispatcherServlet的各个组件。

所在类:org.springframework.web.servlet.DispatcherServlet

protected void initStrategies(ApplicationContext context) {
   initMultipartResolver(context);
   initLocaleResolver(context);
   initThemeResolver(context);
   initHandlerMappings(context);
   initHandlerAdapters(context);
   initHandlerExceptionResolvers(context);
   initRequestToViewNameTranslator(context);
   initViewResolvers(context);
   initFlashMapManager(context);
}

DispatcherServlet调用组件处理请求

processRequest()

FrameworkServlet重写HttpServlet中的service()和doXxx(),这些方法中调用了processRequest(request, response)

所在类:org.springframework.web.servlet.FrameworkServlet

protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {

    long startTime = System.currentTimeMillis();
    Throwable failureCause = null;

    LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
    LocaleContext localeContext = buildLocaleContext(request);

    RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
    ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());

    initContextHolders(request, localeContext, requestAttributes);

    try {
        // 执行服务,doService()是一个抽象方法,在DispatcherServlet中进行了重写
        doService(request, response);
    }
    catch (ServletException | IOException ex) {
        failureCause = ex;
        throw ex;
    }
    catch (Throwable ex) {
        failureCause = ex;
        throw new NestedServletException("Request processing failed", ex);
    }

    finally {
        resetContextHolders(request, previousLocaleContext, previousAttributes);
        if (requestAttributes != null) {
            requestAttributes.requestCompleted();
        }
        logResult(request, response, failureCause, asyncManager);
        publishRequestHandledEvent(request, response, startTime, failureCause);
    }
}

doService()

所在类:org.springframework.web.servlet.DispatcherServlet

@Override
protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
    logRequest(request);

    // Keep a snapshot of the request attributes in case of an include,
    // to be able to restore the original attributes after the include.
    Map<String, Object> attributesSnapshot = null;
    if (WebUtils.isIncludeRequest(request)) {
        attributesSnapshot = new HashMap<>();
        Enumeration<?> attrNames = request.getAttributeNames();
        while (attrNames.hasMoreElements()) {
            String attrName = (String) attrNames.nextElement();
            if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
                attributesSnapshot.put(attrName, request.getAttribute(attrName));
            }
        }
    }

    // Make framework objects available to handlers and view objects.
    request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
    request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
    request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
    request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());

    if (this.flashMapManager != null) {
        FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
        if (inputFlashMap != null) {
            request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
        }
        request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
        request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
    }

    RequestPath requestPath = null;
    if (this.parseRequestPath && !ServletRequestPathUtils.hasParsedRequestPath(request)) {
        requestPath = ServletRequestPathUtils.parseAndCache(request);
    }

    try {
        // 处理请求和响应
        doDispatch(request, response);
    }
    finally {
        if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
            // Restore the original attribute snapshot, in case of an include.
            if (attributesSnapshot != null) {
                restoreAttributesAfterInclude(request, attributesSnapshot);
            }
        }
        if (requestPath != null) {
            ServletRequestPathUtils.clearParsedRequestPath(request);
        }
    }
}

doDispatch()

所在类:org.springframework.web.servlet.DispatcherServlet

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpServletRequest processedRequest = request;
    HandlerExecutionChain mappedHandler = null;
    boolean multipartRequestParsed = false;

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

    try {
        ModelAndView mv = null;
        Exception dispatchException = null;

        try {
            processedRequest = checkMultipart(request);
            multipartRequestParsed = (processedRequest != request);

            // Determine handler for the current request.
            /*
                mappedHandler:调用链
                包含handler、interceptorList、interceptorIndex
                handler:浏览器发送的请求所匹配的控制器方法
                interceptorList:处理控制器方法的所有拦截器集合
                interceptorIndex:拦截器索引,控制拦截器afterCompletion()的执行
            */
            mappedHandler = getHandler(processedRequest);
            if (mappedHandler == null) {
                noHandlerFound(processedRequest, response);
                return;
            }

            // Determine handler adapter for the current request.
               // 通过控制器方法创建相应的处理器适配器,调用所对应的控制器方法
            HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

            // Process last-modified header, if supported by the handler.
            String method = request.getMethod();
            boolean isGet = "GET".equals(method);
            if (isGet || "HEAD".equals(method)) {
                long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                    return;
                }
            }
            
            // 调用拦截器的preHandle()
            if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                return;
            }

            // Actually invoke the handler.
            // 由处理器适配器调用具体的控制器方法,最终获得ModelAndView对象
            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

            if (asyncManager.isConcurrentHandlingStarted()) {
                return;
            }

            applyDefaultViewName(processedRequest, mv);
            // 调用拦截器的postHandle()
            mappedHandler.applyPostHandle(processedRequest, response, mv);
        }
        catch (Exception ex) {
            dispatchException = ex;
        }
        catch (Throwable err) {
            // As of 4.3, we're processing Errors thrown from handler methods as well,
            // making them available for @ExceptionHandler methods and other scenarios.
            dispatchException = new NestedServletException("Handler dispatch failed", err);
        }
        // 后续处理:处理模型数据和渲染视图
        processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
    }
    catch (Exception ex) {
        triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
    }
    catch (Throwable err) {
        triggerAfterCompletion(processedRequest, response, mappedHandler,
                               new NestedServletException("Handler processing failed", err));
    }
    finally {
        if (asyncManager.isConcurrentHandlingStarted()) {
            // Instead of postHandle and afterCompletion
            if (mappedHandler != null) {
                mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
            }
        }
        else {
            // Clean up any resources used by a multipart request.
            if (multipartRequestParsed) {
                cleanupMultipart(processedRequest);
            }
        }
    }
}

processDispatchResult()

private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
                                   @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
                                   @Nullable Exception exception) throws Exception {

    boolean errorView = false;

    if (exception != null) {
        if (exception instanceof ModelAndViewDefiningException) {
            logger.debug("ModelAndViewDefiningException encountered", exception);
            mv = ((ModelAndViewDefiningException) exception).getModelAndView();
        }
        else {
            Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
            mv = processHandlerException(request, response, handler, exception);
            errorView = (mv != null);
        }
    }

    // Did the handler return a view to render?
    if (mv != null && !mv.wasCleared()) {
        // 处理模型数据和渲染视图
        render(mv, request, response);
        if (errorView) {
            WebUtils.clearErrorRequestAttributes(request);
        }
    }
    else {
        if (logger.isTraceEnabled()) {
            logger.trace("No view rendering, null ModelAndView returned.");
        }
    }

    if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
        // Concurrent handling started during a forward
        return;
    }

    if (mappedHandler != null) {
        // Exception (if any) is already handled..
        // 调用拦截器的afterCompletion()
        mappedHandler.triggerAfterCompletion(request, response, null);
    }
}

SpringMVC的执行流程

  1. 用户向服务器发送请求,请求被SpringMVC 前端控制器 DispatcherServlet捕获。

  2. DispatcherServlet对请求URL进行解析,得到请求资源标识符(URI),判断请求URI对应的映射:

    不存在

    • 再判断是否配置了mvc:default-servlet-handler。
    • 如果没配置,则控制台报映射查找不到,客户端展示404错误。
    • 如果有配置,则访问目标资源(一般为静态资源,如:JS,CSS,HTML),找不到客户端也会展示404错误
  3. 存在则执行下面的步骤

  4. 根据该URI,调用HandlerMapping获得该Handler配置的所有相关的对象(包括Handler对象以及Handler对象对应的拦截器),最后以HandlerExecutionChain执行链对象的形式返回。

  5. DispatcherServlet 根据获得的Handler,选择一个合适的HandlerAdapter。

  6. 如果成功获得HandlerAdapter,此时将开始执行拦截器的preHandler(…)方法【正向】

  7. 提取Request中的模型数据,填充Handler入参,开始执行Handler(Controller)方法,处理请求。在填充Handler的入参过程中,根据你的配置,Spring将帮你做一些额外的工作:

    • HttpMessageConveter: 将请求消息(如Json、xml等数据)转换成一个对象,将对象转换为指定的响应信息。
    • 数据转换:对请求消息进行数据转换。如String转换成Integer、Double等。
    • 数据格式化:对请求消息进行数据格式化。 如将字符串转换成格式化数字或格式化日期等。
    • 数据验证: 验证数据的有效性(长度、格式等),验证结果存储到BindingResult或Error中
  8. Handler执行完成后,向DispatcherServlet 返回一个ModelAndView对象。

  9. 此时将开始执行拦截器的postHandle(...)方法【逆向】。

  10. 根据返回的ModelAndView(此时会判断是否存在异常:如果存在异常,则执行HandlerExceptionResolver进行异常处理)选择一个适合的ViewResolver进行视图解析,根据Model和View,来渲染视图。

  11. 渲染视图完毕执行拦截器的afterCompletion(…)方法【逆向】。

  12. 将渲染结果返回给客户端。

标签:教程,return,请求,SpringMVC,request,控制器,视图,String
From: https://www.cnblogs.com/xiqin-huang/p/17898643.html

相关文章

  • 【教程】Ipa Guard为iOS应用提供免费加密混淆方案
    【教程】IpaGuard为iOS应用提供免费加密混淆方案 概述:使用ios加固工具对ios代码保护,保护ios项目中的核心代码,#ipagurd年终大促·百厂联动暖冬特惠,超多软控件立享惊喜优惠>>     ​简介iOS加固保护是直接针对iosipa二进制文件的保护技术,可以对iOSAPP中的可执......
  • 无涯教程-Java - for 语句函数
    for循环是一种重复控制结构,可让您有效地编写需要执行特定次数的循环。for-语法for(initialization;Boolean_expression;update){//Statements}for-示例以下是Java中for循环的示例代码。publicclassTest{publicstaticvoidmain(Stringargs[]){......
  • 无涯教程-Java - while 语句函数
    只要给定条件为真(true),Java编程语言中的while循环语句就会重复执行目标语句。while-语法while(Boolean_expression){//Statements}在这里,声明可以是单个语句或语句块。条件可以是任何表达式,并且true是任何非零值。while-示例publicclassTest{publics......
  • 无涯教程-Java - Non Access Modifiers函数
    Java提供了许多非访问修饰符来实现许多其他功能。static修饰符:用于创建类方法和变量的。final修饰符:用于最终确定类,方法和变量。abstract修饰符:用于创建抽象类和方法。volatile修饰符:用于线程的已同步。static(Static)修饰符Static变量static关键字用于创......
  • 无涯教程-Java Access Modifiers函数
    Java提供了许多访问修饰符来设置类,变量,方法和构造函数的访问级别。四个访问级别是-default(默认):对当前包可见,不需要修饰符。private(私有):当前类可见。public(公共):都可见。protected(受保护):对当前包和所有子类可见。默认访问修饰符默认访问修饰符意味着我们......
  • 侯哥的Python分享--系列教程
    合集-mysql(26) 1.侯哥的Python分享2019-04-162.MySQL基础1-关系型数据库与非关系型数据库2022-03-173.MySQL基础2-数据库及表的操作2022-03-174.MySQL基础3-数据库增删改操作2022-03-175.MySQL基础4-数据查询07-176.MySQL基础5-用户及权限管理07-187.MySQL基础6-常用数......
  • 无涯教程-Java - Singleton Classes函数
    Singleton的目的是控制对象的创建,将对象的数量限制为一个。由于只有一个Singleton实例,因此Singleton的任何实例字段在每个类中只会出现一次,就像static字段一样。单例通常控制对资源的访问,例如数据库连接或Socket。例如,如果您仅对数据库的一个连接拥有许可证,或者JDBC驱动......
  • 无涯教程-MFC - List Control函数
    列表视图控件的功能,该控件显示项目的集合,每个项目由一个图标和一个标签组成,它由CListCtrl类表示,列表控件包括使用以下视图显示项目列表。IconsSmallIconsListReport让无涯教程通过创建一个新的基于MFC对话框的应用程序来研究一个简单的示例。步骤1-删除TODO行并拖动一......
  • 【WinForm详细教程五】WinForm中的MenuStrip 、ContextMenuStrip 、ToolStrip、Status
    原文链接:https://blog.csdn.net/QH2107/article/details/1341922511.MenuStripMenuStrip作为一个容器可以包含多个菜单项。MenuStrip的重要属性包括:Name:菜单的名字Dock:菜单的停靠位置Items:菜单项的集合ToolStripMenuItemToolStripMenuItem是MenuStrip中的菜单项,可以有以下......
  • 无涯教程-MFC - Tree Control函数
    TreeViewControl是一个窗口,其中显示项目的层次结构列表,例如文档中的标题,索引中的条目或磁盘上的文件和目录,每个项目都包含一个标签和一个可选的位图图像,并且每个项目都可以具有与其相关联的子项目列表,通过单击一个项目,用户可以展开和折叠子项目的关联列表,它由CTreeCtrl类表......