百木园1、什么是 SpringMVC？
SpringMVC 是基于 MVC 开发模式的框架，用来优化控制器。它是 Spring 家族的一员，它也具备 IOC 和 AOP。
- 什么是MVC?
MVC 是一种开发模式，它是模型视图控制器的简称，所有的 web 应用都是基于 MVC 开发。
1）M：模型层，包含实体类，业务逻辑层，数据访问层
2）V：视图层，html，javaScript，vue 等都是视图层，用来显现数据
3）C：控制器，它是用来接收客户端的请求，并返回响应到客户端的组件，Servlet就是组件
2、SpringMVC 框架的优点？
1)轻量级，基于 MVC 的框架
2)易于上手，容易理解，功能强大
3)它具备 IOC 和 AOP
4)完全基于注解开发
3、Springmvc 的执行流程：
执行流程说明：
1）向服务器发送HTTP请求，请求被前端控制器 DispatcherServlet 捕获。
2）DispatcherServlet 根据<servlet-name>中的配置对请求的URL进行解析，得到请求资源标识符（URI）。然后根据该URI，调用 HandlerMapping 获得该Handler配置的所有相关的对象（包括Handler对象以及Handler对象对应的拦截器），最后以 HandlerExecutionChain 对象的形式返回。
3）DispatcherServlet 根据获得的 Handler，选择一个合适的 HandlerAdapter。
4）提取 Request 中的模型数据，填充 Handler 入参，开始执行 Handler（Controller)。在填充 Handler的入参过程中，根据你的配置，Spring 将帮你做一些额外的工作：
HttpMessageConveter：将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定的响应信息。
数据转换：对请求消息进行数据转换。如String转换成Integer、Double等。
数据格式化：对请求消息进行数据格式化。如将字符串转换成格式化数字或格式化日期等。
数据验证：验证数据的有效性（长度、格式等），验证结果存储到BindingResult或Error中。
5）Handler(Controller)执行完成后，向 DispatcherServlet 返回一个 ModelAndView 对象。
6）根据返回的ModelAndView，选择一个适合的 ViewResolver（必须是已经注册到Spring容器中的ViewResolver)返回给DispatcherServlet。
7）ViewResolver 结合Model和View，来渲染视图。
8）视图负责将渲染结果返回给客户端
4、基于注解的 SpringMVC 框架开发的步骤：
1)新建项目，选择 webapp 模板
2)修改目录，添加缺失的 test 目录，java目录，resources目录(两套)，并修改目录属性
3)修改 pom.xml 文件，添加 SpringMVC 的依赖，添加 Servlet 的依赖
<!--添加springmvc的依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
<!--添加servlet的依赖-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
</dependency>
4)添加 springmvc.xml 配置文件，指定包扫描，添加视图解析器.
SpringMVC 框架为了避免请求资源路径与扩展名上的冗余，在视图解析器 InternalResouceViewResolver 中引入了请求的前辍与后辍。而 action 中只需给出要跳转页面的文件名即可，对于具体的文件路径与文件扩展名，视图解析器会自动完成拼接；
<context:component-scan>:用来进行包扫描，这里用于指定@Controller注解所在的包路径。
<!--添加包扫描-->
<context:component-scan base-package=\"com.bjpowernode.controller\"></context:component-scan>
<!--添加视图解析器-->
<bean class=\"org.springframework.web.servlet.view.InternalResourceViewResolver\">
<!--配置前缀-->
<property name=\"prefix\" value=\"/admin/\"></property>
<!--配置后缀-->
<property name=\"suffix\" value=\".jsp\"></property>
</bean>
5)删除 web.xml 文件，新建 web.xml
6)在 web.xml 文件中注册 springMVC 框架(所有的 web 请求都是基于 servlet 的)
<!--注册SpringMVC框架-->
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<!--
指定拦截什么样的请求
<a href=\"${pageContext.request.contextPath}/demo.action\">访问服务器</a>
-->
<!--指定拦截以.action结尾的请求，交给核心处理器DispatcherServlet处理。-->
<url-pattern>*.action</url-pattern>
</servlet-mapping>
7)在 webapp 目录下新建 admin 目录，在 admin 目录下新建 main.jsp 页面，删除 index.jsp 页面，并新建
8)开发控制器(Servlet)，这是一个普通的类，不用继承和实现接口。类中的每个方法就是一个具体的action控制器。
@Controller //表示当前类为处理器,交给Spring去创建对象
public class DemoAction {
/**
* 以前的Servlet的规范
* protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {}
* action中所有的功能实现都是由方法来完成的
* action方法的规范
* 1)访问权限是public
* 2)方法的返回值任意
* 3)方法名称任意
* 4)方法可以没有参数,如果有可是任意类型
* 5)要使用@RequestMapping注解来声明一个访问的路径(名称)
*
*/
@RequestMapping(\"/demo\")
public String demo(){
System.out.println(\"服务器被访问到了.......\");
return \"main\"; //可以直接跳到/admin/main.jsp页面上
}
}
9)添加 tomcat 进行测试功能
5、分析 web 请求：
web请求执行的流程：
index.jsp<--------------->DispatcherServlet<------------------->SpringMVC的处理器（加了@Controller的类中的方法）
one.jsp <--------------->DispatcherServlet<------------------->SpringMVC的处理器（加了@Controller的类中的方法）
- DispatcherServlet 要在 web.xml 文件中注册才可用
6、@RequestMapping 注解详解：
- 此注解就是来映射服务器访问的路径。@RequestMapping 的 value 属性用于定义所匹配请求的 URI。
1)此注解可加在方法上，是为此方法注册一个可以访问的名称(路径)。
@RequestMapping(\"/demo\")
public String demo(){
System.out.println(\"服务器被访问到了.......\");
return \"main\"; //可以直接跳到/admin/main.jsp页面上
}
//<a href=\"${pageContext.request.contextPath}/demo.action\">访问服务器</a>
2)此注解可以加在类上，相当于是包名(虚拟路径)，区分不同类中相同的 action 的名称。URI 的请求是相对于 Web 的根目录。换个角度说，要访问处理器的指定方法，必须要在方法指定 URI 之前加上处理器类前定义的模块名称。
@RequestMapping(\"/user\")
public class DemoAction1 {..}
//<a href=\"${pageContext.request.contextPath}/user/demo.action\">访问服务器</a>
3)此注解可区分 get 请求和 post 请求:
- 对于@RequestMapping，其有一个属性 method，用于对被注解方法所处理请求的提交方式进行限制，即只有满足该 method 属性指定的提交方式的请求，才会执行该被注解方法。
@Controller
public class ReqAction {
@RequestMapping(value = \"/req\",method = RequestMethod.GET)
public String req(){
System.out.println(\"我是处理get请求的........\");
return \"main\";
}
@RequestMapping(value = \"/req\" ,method = RequestMethod.POST)
public String req1(){
System.out.println(\"我是处理post请求的........\");
return \"main\";
}
}
7、五种数据提交方式：
- 前四种数据注入的方式，会自动进行类型转换。但无法自动转换日期类型。
1)单个提交数据
- 在方法中声明一个和表单提交的参数名称相同的参数，由框架按照名称直接注入。
栗子：
/*
<form action=\"${pageContext.request.contextPath}/one.action\">
姓名:<input name=\"myname\"><br>
年龄:<input name=\"age\"><br>
<input type=\"submit\" value=\"提交\">
</form>
*/
@RequestMapping(\"/one\")
public String one(String myname,int age){ ===>自动注入,并且类型转换
System.out.println(\"myname=\"+myname+\",age=\"+(age+100));
return \"main\";
}
2)对象封装提交数据：
-
声明一个自定义的实体类参数，框架调用实体类中相应的setter方法注入属性值，只要保证实体类中成员变量的名称与提交请求的name属性值一致即可。
实体类:
public class Users {
private String name;
private int age;
//构造方法，setter方法等省略。。。
}
页面:
<form action=\"${pageContext.request.contextPath}/two.action\" method=\"post\">
姓名:<input name=\"name\"><br>
年龄:<input name=\"age\"><br>
<input type=\"submit\" value=\"提交\">
</form>
action:
@RequestMapping(\"/two\")
public String two(Users u){
System.out.println(u);
return \"main\";
}
3)动态占位符提交
- 仅限于超链接或地址拦提交数据，它是一杠一值，一杠一大括号，使用注解 @PathVariable 来解析。
//<a href=\"${pageContext.request.contextPath}/three/张三/22.action\">动态提交</a>
@RequestMapping(\"/three/{uname}/{uage}\")
public String three(@PathVariable(\"uname\") //用来解析路径中的请求参数
String name,
@PathVariable(\"uage\")
int age){
System.out.println(\"name=\"+name+\",age=\"+(age+100));
return \"main\";
}
4)映射名称不一致
- 提交请求参数与action方法的形参的名称不一致,使用注解@RequestParam来解析
/**
* 姓名:<input name=\"name\"><br>
* 年龄:<input name=\"age\"><br>
*/
@RequestMapping(\"/four\")
public String four(@RequestParam(\"name\") //专门用来解决名称不一致的问题
String uname,
@RequestParam(\"age\")
int uage){
System.out.println(\"uname=\"+uname+\",uage=\"+(uage+100));
return \"main\";
}
5)使用HttpServletRequest对象提取；
/**
* 姓名:<input name=\"name\"><br>
* 年龄:<input name=\"age\"><br>
*/
@RequestMapping(\"/five\")
public String five(HttpServletRequest request){
String name = request.getParameter(\"name\");
int age = Integer.parseInt(request.getParameter(\"age\"));
System.out.println(\"name=\"+name+\",age=\"+(age+100));
return \"main\";
}
8、中文乱码解决方案：
- 对于前面所接收的请求参数，若含有中文，则会出现中文乱码问题。Spring 对于请求参数中的中文乱码问题，给出了专门的字符集过滤器：
- spring-web-5.2.5.RELEASE.jar 的 org.springframework.web.filter 包下的 CharacterEncodingFilter 类。
解决方案：
- 在 web.xml 中注册字符集过滤器，即可解决 Spring 的请求参数的中文乱码问题。不过，最好将该过滤器注册在其它过滤器之前。因为过滤器的执行是按照其注册顺序进行的。
<filter>
<filter-name>encode</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<!--
配置参数
private String encoding;
private boolean forceRequestEncoding;
private boolean forceResponseEncoding;
-->
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceRequestEncoding</param-name>
<param-value>true</param-value>
</init-param>
<init-param>
<param-name>forceResponseEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encode</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
9、action方法的返回值：
1)String：
处理器方法返回的字符串可以指定逻辑视图名，通过视图解析器解析可以将其转换为物理视图地址；
可以自动拼接前缀和后缀，可以指定返回的路径；
当然，也可以直接返回资源的物理视图名。不过，此时就不需要再在视图解析器中再配置前辍与后辍了。
2)Object：
返回 json 格式的对象，自动将对象或集合转为 json，使用的 jackson 工具进行转换，必须要添加 jackson 依赖，一般用于 ajax 请求；
处理器方法也可以返回 Object 对象，这个 Object 可以是 Integer，自定义对象，Map，List 等。但返回的对象不是作为逻辑视图出现的，而是作为直接在页面显示的数据出现的。返回对象，需要使用@ResponseBody 注解，将转换后的 JSON 数据放入到响应体中。Ajax请求多用于Object返回值类型。
3)void：
无返回值,一般用于ajax请求；
若处理器对请求处理后，无需跳转到其它任何资源，此时可以让处理器方法返回 void。
4)基本数据类型，用于 ajax 请求。
5)ModelAndView：返回数据和视图对象,现在用的很少。
10、完成 ajax 请求访问服务器，返回学生集合：
1)添加jackson依赖
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.8</version>
</dependency>
2)在 webapp 目录下新建 js目录,添加 jQuery 函数库
3)在 index.jsp 页面上导入函数库:
4)在 action 上添加注解@ResponseBody，用来处理ajax请求
@Controller
public class AjaxAction {
//处理ajax请求,一定要加@ResponseBody
@ResponseBody
@RequestMapping(\"/ajax\")
public List<Student> ajax(){
Student stu1 = new Student(\"张三\",22);
Student stu2 = new Student(\"李四\",24);
Student stu3 = new Student(\"王五\",23);
List<Student> list = new ArrayList<>();
list.add(stu1);
list.add(stu2);
list.add(stu3);
//调用json转换工具ObjectMapper进行转换
return list; //===>springmvc负责转换成json
}
}
5)在 springmvc.xml 文件中添加注解驱动 <mvc:annotationdriven/>，它用来解析 @ResponseBody 注解
<mvc:annotation-driven></mvc:annotation-driven>
11、SpringMVC 的四种跳转方式：
- 本质就是两种跳转：请求转发和重定向，衍生出四种是请求转发页面,转发action,重定向页面,重定向action；
- 默认的跳转是请求转发，直接跳转到 jsp 页面展示；
可以使用框架提供的关键字 redirect: ，进行一个重定向操作，包括重定向页面和重定向action；
可以使用框架提供的关键字forward:，进行服务器内部转发操作，包括转发页面和转发action；
- 当使用 redirect: 和 forward: 关键字时，视图解析器中前缀后缀的拼接就无效了。
栗子：
@RequestMapping(\"/one\")
public String one(){
System.out.println(\"这是请求转发页面跳转.........\");
return \"main\"; //默认是请求转发,使用视图解析器拼接前缀后缀进行页面跳转
}
@RequestMapping(\"/two\")
public String two(){
System.out.println(\"这是请求转发action跳转.........\");
// /admin/ /other.action .jsp
//forward: 这组字符串可以屏蔽前缀和后缀的拼接.实现请求转发跳转
return \"forward:/other.action\"; //默认是请求转发,使用视图解析器拼接前缀后缀进行页面跳转
}
@RequestMapping(\"/three\")
public String three(){
System.out.println(\"这是重定向页面.......\");
//redirect: 这组字符串可以屏蔽前缀和后缀的拼接.实现重定向跳转
return \"redirect:/admin/main.jsp\";
}
@RequestMapping(\"/four\")
public String four(){
System.out.println(\"这是重定向action.......\");
//redirect: 这组字符串可以屏蔽前缀和后缀的拼接.实现重定向跳转
return \"redirect:/other.action\";
}
@RequestMapping(\"/five\")
public String five(){
System.out.println(\"这是随便跳.......\");
return \"forward:/fore/login.jsp\";
}
12、SpringMVC 默认的参数类型：
不需要去创建，直接拿来使用即可。
1)HttpServletRequest
2)HttpServletResponse
3)HttpSession
4)Model
5)Map
6)ModelMap
栗子：
//做一个数据,传到main.jsp页面上
Users u = new Users(\"张三\",22);
//传递数据
request.setAttribute(\"requestUsers\",u);
session.setAttribute(\"sessionUsers\",u);
model.addAttribute(\"modelUsers\",u);
map.put(\"mapUsers\",u);
modelMap.addAttribute(\"modelMapUsers\",u);
注意：Map，Model，ModelMap 和 request 一样，都使用请求作用域进行数据传递，所以服务器端的跳转必须是请求转发，页面才可以得到值。
13.日期处理：
1)日期的提交处理
A、单个日期处理
- 要使用注解@DateTimeFormat，此注解必须搭配 springmvc.xml 文件中的 <mvc:annotationdriven标签>
在方法的参数上使用@DateTimeFormat注解；
在类的成员setXXX()方法上使用@DateTimeFormat注解
- 但这种解决方案要在每个使用日期类型的地方都去添加使用@DateTimeFormat注解，比较麻烦，我们可以使用@InitBinder注解来进行类中统一日期类型的处理。
B.类中全局日期处理
注册一个注解,用来解析本类中所有的日期类型,自动转换
@InitBinder；
public void initBinder(WebDataBinder dataBinder){
dataBinder.registerCustomEditor(Date.class,new CustomDateEditor(sf,true));
}
2)日期的显示处理：
- 在页面上显示好看的日期，必须使用 JSTL
步骤：
A)添加依赖 jstl
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
B)在页面上导入标签库 ：
- 如果是单个日期对象，直接转为好看的格式化的字符串进行显示
如果是 list 中的实体类对象的成员变量是日期类型，则必须使用 jstl 进行显示。
<%--导入jstl核心标签库--%>
<%@taglib prefix=\"c\" uri=\"http://java.sun.com/jsp/jstl/core\" %>
<%--导入jstl格式化标签库--%>
<%@taglib prefix=\"fmt\" uri=\"http://java.sun.com/jsp/jstl/fmt\" %>
C)使用标签显示数据：
<table width=\"800px\" border=\"1\">
<tr>
<th>姓名</th>
<th>生日</th>
</tr>
<c:forEach items=\"${list}\" var=\"stu\">
<tr>
<td>${stu.name}</td>
<td>${stu.birthday}------ <fmt:formatDate value=\"${stu.birthday}\" pattern=\"yyyy-MM-dd\"></fmt:formatDate></td>
</tr>
</c:forEach>
</table>
14、SpringMVC 的拦截器：
- 针对请求和响应进行的额外的处理，在请求和响应的过程中添加预处理，后处理和最终处理
拦截器执行的时机：
1)preHandle()：在请求被处理之前进行操作（预处理）
2)postHandle()：在请求被处理之后，但结果还没有渲染前进行操作,可以改变响应结果（后处理）
3)afterCompletion：所有的请求响应结束后执行善后工作，清理对象，关闭资源（最终处理）
拦截器实现的两种方式：
1)继承 HandlerInterceptorAdapter 的父类
2)实现 HandlerInterceptor 接口
拦截器实现的步骤：
1)创建登录方法，在 session 中存储用户信息，用于进行权限验证
@RequestMapping(\"/login\")
public String login(String name, String pwd, HttpServletRequest request){
if(\"zar\".equalsIgnoreCase(name) && \"123\".equalsIgnoreCase(pwd)){
//在session中存储用户信息,用于进行权限验证
request.getSession().setAttribute(\"users\",name);
return \"main\";
}else{
request.setAttribute(\"msg\",\"用户名或密码不正确!\");
return \"login\";
}
}
2)开发拦截器的功能，实现 HandlerInterceptor 接口，重写 preHandle() 方法：
public class LoginInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//是否登录过的判断
if(request.getSession().getAttribute(\"users\") == null){
//此时就是没有登录,打回到登录页面,并给出提示
request.setAttribute(\"msg\",\"您还没有登录,请先去登录!\");
request.getRequestDispatcher(\"/WEB-INF/jsp/login.jsp\").forward(request,response);
return false;
}
return true;//放行请求
}
}
3)在 springmvc.xml 文件中注册拦截器：
<mvc:interceptors>
<mvc:interceptor>
<!--映射要拦截的请求-->
<mvc:mapping path=\"/**\"/>
<!--设置放行的请求-->
<mvc:exclude-mapping path=\"/showLogin\"></mvc:exclude-mapping>
<mvc:exclude-mapping path=\"/login\"></mvc:exclude-mapping>
<!--配置具体的拦截器实现功能的类-->
<bean class=\"com.bjpowernode.interceptor.LoginInterceptor\"></bean>
</mvc:interceptor>
</mvc:interceptors>
资源在WEB-INF目录下：
很多企业会将动态资源放在WEB-INF目录下，这样可以保证资源的安全性，因为在WEB-INF目录下的动态资源不可以直接访问，必须要通过请求转发的方式进行访问，这样避免了通过地址栏直接对资源的访问，重定向也无法访问动态资源。
栗子：
@Controller
public class WebInfAction {
@RequestMapping(\"/showMain\")
public String showMain(){//通过请求转发的方式访问webapp目录下的WEB-INF目录下的main.jsp
System.out.println(\"访问main.jsp\");
return \"main\";
}
@RequestMapping(\"/showLogin\")
public String showLogin(){////通过请求转发的方式访问webapp目录下的WEB-INF目录下的login.jsp
System.out.println(\"访问login.jsp\");
return \"login\";
}
}
来源：https://www.cnblogs.com/Burning-youth/p/16342656.html
本站部分图文来源于网络，如有侵权请联系删除。