JavaSpringMVC：核心源码映射规则参数绑定
Posted ahcfl
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JavaSpringMVC：核心源码映射规则参数绑定相关的知识，希望对你有一定的参考价值。
引入
问答题:
SpringMVC是什么?
SpringMVC的总控制器是什么?有哪些作用?
SpringMVC中的三大组件是什么?作用是什么?
口述SpringMVC框架的加载流程? ★
口述SpringMVC执行流程? ★
@RequestMapping注解的作用?有哪些参数?参数什么意思?
SpringMVC可以接收哪些类型的参数?接收规则是什么?
编程题:
SpringMVC入门案例
使用@RequestMapping注解中的所有参数
获取请求携带的所有数据
============================================================
问答题:
SpringMVC是什么?
springMVC依托于spring实现的基于MVC架构的web层的轻量级实现的框架；
MVC:
M:model,模型是对数据的封装
v:view,视图，向用户展示的效果，jsp,html，json
c：controller，控制，调度器，用于处理请求，将model和view进行合并输入
SpringMVC的总控制器是什么?有哪些作用?
DispatcherServlet，本质上就是一个servlet
作用：
1.核心调度器，用于接收和响应用户的请求；
2.springmvc内部调用各个组件（3大组件）完成用户请求
SpringMVC中的三大组件是什么?作用是什么?
处理器映射器：HandlerMapping,作用：根据请求url路径查找对应的处理器；
处理器适配器：
因为处理器有3中实现方案【2中基于实现接口，一种基于注解实现（主流）】
通过适配器适配处理器，然后再调用执行
最后返回ModelAndView给DispatcherServlet
视图解析器：
将DispatcherServlet获取的view逻辑视图转换成物理视图，最后返回给DispatcherServlet
口述SpringMVC框架的加载流程? ★
1.项目引入相关依赖，然后打war包部署；
jar:spring-webmvc servlet-api jsp-api
2.tomcat启动后加载web.xml
3.初始化 DispatcherServlet，然后读取contextConfigLocation下指定springmvc.xml,最后 完成spring IOC容器的初始化；
4.注册核心组件，其中包含springmvc的3大核心组件；
口述SpringMVC执行流程? ★
1.浏览器发送请求，被tomcat获取，然后DispatcherServlet处理请求；
2.DispatcherServlet解析请求获取url地址，然后调用处理器映射器，根据url地址查找对应的handler处理器(处理器方法的全限定名称)；
3.DispatcherServlet调用处理器适配器，适配具体的处理器适配器调用处理器完成请求处理，最后返回ModelAndView；
4. DispatcherServlet调用视图解析器，将逻辑视图转换成物理视图，然后返回；
5. DispatcherServlet将model和物理视图渲染输入给浏览器；
@RequestMapping注解的作用?有哪些参数?参数什么意思?
作用：建立请求url对应的处理器方法之间的关系；
参数：
所有的属性对应的值，都可以是数组；
path/value:指定请求url
method:设置请求的方式，get post delete put
params:限制请求必须携带的参数；
headers:限制请求头中必须携带指定的信息；
SpringMVC可以接收哪些类型的参数?接收规则是什么?
1.基本数据类型+string :请求的参数名称与方法的形参名称一致即可；
2.VO类型： 请求的参数名称与VO中属性的名称一致即可；
3.复杂类型：
3.1 数组 请求的参数名称与数组的名称一致即可；
3.2 List<基本类型> 封装到VO下，然后请求的参数名称与VO下的集合对应的名称一致即可；
3.3 List<VO> 前端请求的参数按照list的索引位指定对应vo属性对应的值 list[0].name=xxx list[0].age=xxx
3.4 Map 前端的数据需要按照k-v格式组装： map[key]=v
1、三层架构概念
-
表现层：负责数据展示
-
业务层：负责业务处理
-
数据层：负责数据操作
2、Servlet概念
Servlet:
运行在服务器上的java小程序.
本质上就是java代码,这个java代码可以被web服务器调用
【1】生命周期:
实例化,创建一个对象放内存
默认第一次请求Servlet时,会创建Servlet对象,并调用init方法进行初始化操作
load-on-startup: 设置servlet的初始化时机
取值: 正整数,值越小优先级越高
初始化,创建完对象后,调用对象的方法进行初始化
init(): 初始化方法
当对象实例化完毕后,立即调用init方法完成初始化工作, 1次
service(): 提供服务
每次请求来的时候,tomcat都会调用service方法提供服务, 请求一次执行一次
destory(): 销毁方法
当对象从内存中移除前调用destory方法进行销毁工作, 1次
【2】Servletconfig
作用：为每个Servlet都提供初始化参数（设置servlet私有配置参数）；
eg:
1.web.xml配置：
<servlet>
<servlet-name>servletDemo</servlet-name>
<servlet-class>com.itheima.web.servlet.ServletDemo</servlet-class>
<!--配置初始化参数-->
<init-param>
<!--用于获取初始化参数的key-->
<param-name>key</param-name>
<!--初始化参数的值-->
<param-value>value</param-value>
</init-param>
</servlet>
2.java代码
@Override
public void init(ServletConfig config) throws ServletException {
//get config and do something
//config.getInitParameter("key");
}
【3】ServletContext
ServletContext对象，它是应用上下文对象；
每一个应用有且【只有一个】ServletContext对象；
它可以实现让应用中所有Servlet间的数据共享；
eg:
1.web.xml配置：
<!--配置应用初始化参数-->
<context-param>
<!--用于获取初始化参数的key-->
<param-name>servletContextInfo</param-name>
<!--初始化参数的值-->
<param-value>This is application scope</param-value>
</context-param>
2.java代码示例：
getServletContext();
getInitParameter("servletContextInfo");
一、SpringMVC概述
1、MVC架构概念
MVC(Model View Controller) 是一种软件设计典范。
主要作用是将视图展示和业务控制代码分离开来。
- Model（模型）数据模型，用于封装数据
- View（视图）页面视图，用于展示数据 jsp ，html，json,xml等
- Controller（控制器）处理用户交互的调度器，用于根据用户需求处理程序逻辑Servlet 、SpringMVC等
# 思考：MVC架构跟三层架构是什么关系
可以这样理解：
1.MVC把三层架构中的web层再度进行了分化，分成了控制器、视图、模型。
2.三层架构的目的是【解耦】，mvc的目的是实现web层系统的【职责划分】。
MVC架构在三层架构中的位置图示
2、SpringMVC
SpringMVC是Spring对MVC架构的一种实现，属于轻量级的WEB框架。
它通过一个简单的**注解**就可以让一个普通的Java类成为控制器，这种**低侵入性的设计**使得他备受业界欢迎
同时他还支持RestFul风格的编程风格。
SpringMVC是spring对web层进行的封装,提供的MVC架构
M（模型）:
Model可以叫做数据模型层，说白了就是用来封装数据的
例如：
用户发送注册请求，那么请求的信息会被SpingMMVC封装到User实体类中，这个实体类就属于Model层；
用户发送查询个人信息的请求，那么后台也会将个人信息封装到一个User类型，数据同样也是Model层；
V（视图）:
View说白了就是SpringMVC响应请求的一种数据展示（最终的执行结果）：
例如：
SpringMVC响应的数据方式：JSP、json、xml、html等
C（控制）:
控制层就用来处理交互的部分，接收用户请求，然后执行业务等流程，最终反馈结果；
[控制器]本质上就是一个Servlet,一切请求都访问这个Servlet,在这个Servlet中进行调度。
SpringMVC可以通过一个简单的注解,就能让浏览器访问到对应的方法。 @RequestMapping("/请求路径")
总之，这个唯一的Servlet核心控制器会【根据请求的url匹配基于注解的url】，完成请求处理；
# SpringMVC能干什么
1) 与Spring框架集成，如：(IOC,AOP)
2) 支持Restful风格
3) 进行更简洁的Web层开发
4) 支持灵活的URL到页面控制器的映射
5) 非常容易与其他视图技术集成，如:Velocity、FreeMarker等等
6) 因为模型数据不存放在特定的API里，而是放在一个Model里(Map数据结构实现，因此很容易被其他框架使用)
7) 非常灵活的数据验证、格式化和数据绑定机制、能使用任何对象进行数据绑定，不必实现特定框架的API
8) 更加简单、强大的异常处理
9) 对静态资源的支持
10) 支持灵活的本地化、主题等解析
二、SpringMVC 入门案例
1、步骤tomcat7插件运行
需求: 通过浏览器访问SpringMVC框架返回一个jsp页面
1、创建web项目，编写pom.xml（指定工程war打包方式），引入坐标
2、 配置核心Servlet编写web.xml文件，在web.xml文件中【配置核心控制器】
3 、编写SpringMVC配置文件 spring-mvc.xml约束【处理器适配器,处理器映射器,视图解析器】
**4、编写业务处理器**
**5、编写响应页面**
**6、Tomcat插件的使用**
2、代码演示
1、创建web项目， 编写pom.xml（指定工程war打包方式），引入坐标
<packaging>war</packaging>
<!-- 导入jar包依赖 -->
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.0.1</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jsp-api</artifactId>
<version>2.0</version>
<scope>provided</scope>
</dependency>
</dependencies>
2、 配置核心Servlet编写web.xml文件，在web.xml文件中【配置核心控制器】
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
version="3.0">
<!--
服务器启动时只会加载web项目的核心配置文件 web.xml
-->
<!-- 配置SpringMVC的核心Servlet: 前端控制器 (由SpringMVC框架提供)-->
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 配置SpringMVC的核心配置文件 -->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<!-- 我们给前端控制器配置的路径为 / (缺省匹配)可以匹配浏览器发送的所以请求
注意: jsp除外
-->
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
3 、编写SpringMVC配置文件 spring-mvc.xml约束【处理器适配器,处理器映射器,视图解析器】
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 开启包扫描 -->
<context:component-scan base-package="com.example"></context:component-scan>
<!-- 配置视图解析器: 生成前缀和后缀 -->
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/webapp/pages/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
<!-- 将可能使用到的处理器适配器,处理器映射器,视图解析器统统的加载到内存中 -->
<mvc:annotation-driven/>
</beans>
4、编写业务处理器
package com.example.web;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
/**
* 编写处理器方法
*/
@Controller
public class HelloController {
/**
* @RequestMapping :
* 作用: 建立请求路径与此方法的对应关系
* @return
*/
@RequestMapping("/hello")
public String hello(){
System.out.println("hello springmvc....");
// 如果直接返回字符串,则代表请求转发
return "success";
}
}
5、编写响应页面
在Webapp/pages/ 下定义success.jsp
success.jsp响应页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h1>执行成功...</h1>
</body>
</html>
6、Tomcat插件的使用
开发中，直接使用tomcat会有繁琐的配置，我们可以使用maven支持的tomcat插件，提高开发效率；
直接在pom文件中添加tomcat插件：
<build>
<plugins>
<!-- tomcat7插件,运行命令： mvn tomcat7:run -DskipTests -->
<!-- 配置Tomcat插件 -->
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.2</version>
<configuration>
<uriEncoding>UTF-8</uriEncoding>
<port>8080</port>
<path>/</path>
</configuration>
</plugin>
<!--<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>8</source>
<target>8</target>
</configuration>
</plugin>-->
</plugins>
</build>
**运行方式1：**双击运行
**运行方式2：**配置成maven命令运行
3、入门案例执行流程
【1】启动初始化顺序
资源准备阶段：
（1）打包好war包，部署到Tomcat中==》mavne的自动发布插件完成
（2）Tomcat启动，加载web.xml文件
（3）初始化【前端控制器】dispatcherServlet的配置
（4）根据<param-name>的容器配置contextConfigLocation加载springmvc.xml配置
（5）根据spring-mvc.xml配置 完成spring IOC容器的初始化；
时序图：
【2】请求处理顺序
（1）浏览器发起 http://localhost:8080/hello 请求
（2）Tomcat调用dispatcherServlet拦截/hello
（3）dispatcherServlet调用一个处理器，根据请求路径[/hello]找对对应的处理方法
（这里指被@RequestMapping注释的方法）【处理器映射器】
-处理器映射器：处理浏览器请求，根据路径映射到指定发方法；
eg: /hello --> com.heima.controller.HelloController #hello(){} 方法
（4）dispatcherServlet找到方法后，调用另外一种处理器，
执行HelloController中的hello()方法【处理器适配器】
-处理器适配器：
适配处理器handler类型（在这里对应的处理器是hello()方法）；
处理入参，把对应的参数直接封装为一个实体；
（5）HelloController中的hello()方法有返回值，创建ModelAndVIew（包含响应数据，页面）
（6）dispatcherServlet调用视图解析器，组装响应对象，然后把页面返回给浏览器【视图解析器】
-视图解析器：
把方法返回的ModelAndVIew，进行页面和数据的整合，标签根据传入的view进行页面跳转
【3】开发流程
1.创建web项目 war包
2.导入相关jar包坐标
spring-webmvc
servlet
jsp
3.web.xml文件中配置 总控制器
DispatcherServlet: 调度的Servlet
指定springmvc的配置文件
设置初始化时机
配置DispatcherServlet拦截规则
4.编写springmvc的配置文件
开启包扫描
<context:component-scan base-package="com.example">
设置视图解析器，生成前缀和后缀 org.springframework.web.servlet.view.InternalResourceViewResolver
5.编写我们的处理器 handler
@Controller
HelloController.java
处理器适配器
@RequestMapping("/hello")
public String hello(){
return "success";
}
三、核心原理分析
1、SpringMVC执行原理
1、前端控制器：DispatcherServlet
是整体流程控制的中心，调用其它组件处理用户的请求，有效的降低了组件间的耦合性；
2、处理器：Handler,业务处理的核心类。
通常由我们自己编写,比如：HelloController类等；
【处理器映射器】：负责根据URL请求找到对应的Handler处理器(请求的URL与Controller方法的关系)
【处理器适配器】：将请求参数解析转换成处理器的入参，并调用处理器执行的组件；
【视图解析器】： 将处理器执行的结果生成View视图(将逻辑视图转换成物理视图)
视图：View，最终产出结果， 常用视图如：jsp、 html
【1】服务器启动流程
SpringMVC加载流程:
1.当服务器启动时,只会加载web.xml文件
2.初始化核心控制器：DispatcherServlet
3.在核心控制器初始化方法中(initStrategies:初始化策略),完成组件的加载
处理器映射器:HandlerMapping
[建立绑定路径与方法全限定名的对应关系]
处理器适配器:HandlerAdapter
[适配处理器的实现方式,调用指定的类反射执行处理器方法]
视图解析器:ViewResolver
[根据逻辑视图生成对应的物理视图,并将物理视图返回]
【2】执行请求流程
SpringMVC执行流程:
1.浏览器发起请求给服务器
2.DispatcherServlet接收来自浏览器的请求
3.调用处理器映射器,根据请求路径找到对应的方法全限定名,并返回给核心控制器
4.调用处理器适配器,找到对应的方法实现，并调用指定的实现类反射执行方法
5.调用视图解析器,根据逻辑视图找到对应的物理视图
6.生成响应
2、SpringMVC的三大核心组件
在SpringMVC的运行流程中我们可以发现DispatcherServlet负责整体调度工作，而实际工作的是三大组件
【1】HandlerMapping处理器映射器
作用: 根据请求路径找到对应的方法(处理器)
在服务器启动,SpringMVC的配置文件加载时,会扫描指定的包,
当扫描到@RequestMapping注解时,会建立请求路径与当前方法(处理器)的对应关系
处理器: Handler
指的就是我们自己编写的java代码(web层的Controller)
【2】HandlerAdapter处理器适配器
作用: 反射调用方法执行
根据请求路径找到对应的【类或方法】时,判断(适配)当前处理器的实现方式,
并调用指定的处理器适配器类执行,处理器适配器类执行,就可以让方法执行了.
处理器的实现方式有多种
(把一个普通类变以上是关于JavaSpringMVC：核心源码映射规则参数绑定的主要内容，如果未能解决你的问题，请参考以下文章
基于JavaSpringmvc+myabtis+html的鲜花商城系统设计和实现
Springboot2之静态资源规则与定制化welcome与favicon功能Rest映射及源码解析以及改变默认的_method
Springboot2之静态资源规则与定制化welcome与favicon功能Rest映射及源码解析以及改变默认的_method