SpringMVC部署 SpringMVC框架 SpringMVC请求流程 SpringMVC统一异常处理 SpringMVC拦截流程


0x00 概述

本文主要涉及SpringMVC知识:SpringMVC部署,SpringMVC框架,请求流程,请求定制(日期和文件处理),统一异常处理,拦截流程。

 

0x01 BaseServlet

​什么是Servelet​

​Servlet功能模块化--封装BaseServlet​

BaseServlet可以让一个Servlet处理多种不同的请求,不同的请求调用Servlet的不同方法;

随着项目需求复杂化,基于BaseServlet已经无法满足项目管理和开发的需求,这时候就需要引入web开发框架了;

 

0x02 SpringMVC概述

/**

Spring MVC是由Spring官方提供的基于MVC设计理念的web框架
Spring MVC是基于Servlet封装的用于实现MVC控制的框架,实现前端和服务端的交互。

**/

2.1 SpringMVC的优势

/**

1. 严格遵守了MVC分层思想
2. 采用了松耦合、插件式结构;相比较于我们封装的BaseServlet以及其他的一些MVC框架来说更灵活、更具扩展性
3. SpringMVC是基于Spring的扩展、提供了一套完善的MVC注解
4. SpringMVC在数据绑定、视图解析都提供了多种处理方式,可灵活配置
5. SpringMVC对RESTful URL设计方法提供了良好的支持

**/

2.2 SpringMVC本质工作

/**

1. 接收并解析请求
2. 处理请求
3. 数据渲染,相应请求

**/

 

0x03 SpringMVC框架部署

3.1 基于Maven创建一个Web工程

SSM学习笔记之SpringMVC_spring

SSM学习笔记之SpringMVC_spring_02  SSM学习笔记之SpringMVC_xml_03

SSM学习笔记之SpringMVC_mvc_04

SSM学习笔记之SpringMVC_xml_05

 

3.2 添加SpringMVC依赖

/**

spring-context
spring-aspects
spring-jdbc
spring-web
spring-webmvc
spring-junit

**/
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>com.springMVCDemo</groupId>
<artifactId>springmvc-demo2</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>

<properties>
<spring.version>5.2.13.RELEASE</spring.version>
</properties>

<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dependency>
</dependencies>


</project>

 

 3.3 创建SpringMVC配置文件

/**

在resource目录下创建名为spring-servlet.xml文件

添加MVC命名空间

**/
<?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">


<!-- 声明使用注解配置-->
<context:annotation-config/>
<!-- 声明Spring工厂注解的扫描范围-->
<context:component-scan base-package="com.springMVCDemo"/>
<!-- 声明mvc使用注解驱动-->
<mvc:annotation-driven/>

</beans>

 

 3.4 在web.xml中配置SpringMVC的前端控制器

/**

SpringMVC中提供了一个名为DispatcherServlet的类(SpringMVC前端控制器),用于拦截用户请求,然后交由SpringMVC处理

webapp/WEB-INF/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">

<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:spring-servlet.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>SpringMVC</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>

<!-- /* 拦截所有的HTTP请求,包括.jsp的请求,都做为控制器类的请求路径来处理-->
<!-- / 拦截所有的HTTP请求,但不包括.jsp的请求,但不会放行静态资源请求,html/js/css/图片-->


</web-app>

  

0x04 SpringMVC框架使用

4.1 控制器Controller

在SpringMVC中,我们把接收用户请求,处理用户请求的类称之为Controller(控制器) 

4.1.1 创建控制器

  • 创建一个名为com.springMVCDemo.controllers的包(包需要在Spring注解扫描的范围内)
  • 创建一个类(无需做任何的继承和实现)
  • 在类上添加@Controller注解声明此类为SpringMVC的控制器
  • 在类上添加@RequeMapping("/url")声明此控制器类的请求url
package com.springMVCDemo.controllers;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/book")
public class BookController {
}

4.1.2 在控制器类中定义处理请求的方法

  • 在一个控制器类中可以定义多个方法处理不同的请求
  • 在每个方法上添加@RequestMapping("/url")用于声明当前方法请求url

4.1.3 访问

4.2 静态资源配置

静态资源:就是项目中的HTML,CSS,JS,图片等

4.2.1 /* 和 / 区别

<!--    /* 拦截所有的HTTP请求,包括.jsp的请求,都做为控制器类的请求路径来处理-->
<!-- / 拦截所有的HTTP请求,但不包括.jsp的请求,但不会放行静态资源请求(html/js/css/图片)-->
<servlet-mapping>
<servlet-name>SpringMVC</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>

 4.2.2 静态资源放行配置

  • 在SpringMVC的配置文件中,添加如下静态资源放行配置

spring-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">


<!-- 声明使用注解配置-->
<context:annotation-config/>
<!-- 声明Spring工厂注解的扫描范围-->
<context:component-scan base-package="com.springMVCDemo"/>
<!-- 声明mvc使用注解驱动-->
<mvc:annotation-driven/>

------------------------------------------------
<!--放行资源-->
<mvc:resources mapping="/css/**" location="/css/"/>
<mvc:resources mapping="/pages/**" location="/pages/"/>
<mvc:resources mapping="/imgs/**" location="/imgs/"/>
<mvc:resources mapping="/js/**" location="/js/"/>

</beans>

 

4.3 前端提交数据到控制器

4.3.1 表单提交

表单提交:输入框需要提供name属性,springMVC控制器是通过name属性取值的

<%--
Created by IntelliJ IDEA.
User: LT2
Date: 2022/3/05
Time: 21:33
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>

<h3>添加图书</h3>
<form action="book/add" method="post">
<p>图书名称:<input type="text"></p>
<p>图书作者:<input type="text"></p>
<p>图书价格:<input type="text"></p>
<p><input type="submit" value="提交"></p>
</form>

</body>
</html>

4.3.2 URL提交

URL提交: <a href="book/add?bookName=java">url提交</a>

4.3.3 AJAX提交

AJAX提交:请求行,请求头,请求体都可以用来传值

<h3>AJAX提交</h3>
<input type="button" value="ajax提交"/>
<script type="text/javascript" src="js/jquery-3.4.1.min.js"></script>
<script type="text/javascript">
$("#btn1").click(function (){
var obj ={};
obj.bookName="Java";
obj.bookAuthor="张三";
obj.bookPrice=3.33;
$.ajax({
url:"book/add",
type:"post",
headers:{

},
contentType:"application/json",
data:obj,
success:function (res){
console.log(res);
}
});
});
</script>

 

4.4 控制器中接收前端提交的数据

4.4.1 请求行传值

  • 表单提交method="get"
  • URL提交
  • $.ajax请求的url传值
$.ajax({
url:这里拼接url,把参数放url就是请求行传值,
type:"post",
headers:{
},
contentType:"application/json",
data:obj,
success:function (res){
console.log(res);
}
});
  • $.post() / $.get()中的{}传值

@RequestParam注解用于接收请求行传递的数据

  • 前端提交的数据
<h3>表单提交</h3>
<form action="book/add" method="post">
<p>图书名称:<input type="text" name="name"></p>
<p>图书作者:<input type="text" name="author"></p>
<p>图书价格:<input type="text" name="price"></p>
<p><input type="submit" value="提交"></p>
</form>
  • 控制器接收的数据
package com.springMVCDemo.controllers;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
@RequestMapping("/book")
public class BookController {

// <form action="book/add" method="post">
// <p>图书名称:<input type="text" name="name"></p>
// <p>图书作者:<input type="text" name="author"></p>
// <p>图书价格:<input type="text" name="price"></p>
// <p><input type="submit" value="提交"></p>
// </form>
/*接收请求行数据*/
@RequestMapping("/add")
public void add(@RequestParam("name") String a,
@RequestParam("author") String b,
@RequestParam("price") double c){
System.out.println("~~~~~book add");
System.out.println(a);
System.out.println(b);
System.out.println(c);
}

}

注意:

如果控制器方法中接收数据的参数名与请求行传值的key是一致的,则@RequetParam注解可以省略 

@RequestMapping("/add")
public void add(String name, String author, double price){
System.out.println("~~~~~book add");
System.out.println(name);
System.out.println(author);
System.out.println(price);
}

 4.4.2 请求头传值

  • $.ajax封装请求头数据
$.ajax({
url:"book/add",
type:"post",
headers:{
这里请求头传值
},
contentType:"application/json",
data:obj,
success:function (res){
console.log(res);
}
});

演示代码:(这里的请求头里如果写中文是不支持的)

@RequestHeader用于接收请求头传递的数据

@RequestMapping("/list")
public void list(@RequestHeader("token") String token){
System.out.println(token);
System.out.println("~~~~~book list");
}
<h3>AJAX提交</h3>
<input type="button" value="ajax提交" id="btn1"/>
<script type="text/javascript" src="js/jquery-3.4.1.min.js"></script>
<script type="text/javascript">
$("#btn1").click(function (){
console.log("进入方法");
var obj ={};
obj.bookName="Java";
obj.bookAuthor="张三";
obj.bookPrice=3.33;
console.log("obj");
$.ajax({
url:"book/list",
type:"post",
headers:{
token:"Eqeqeq"
},
// contentType:"application/json",
// data:obj,
success:function (res){
console.log(res);
}
});
console.log("结束");
});
</script>

4.4.3 请求体传值

  • $.ajax封装请求体数据
$.ajax({
url:"book/add",
type:"post",
headers:{
这里请求头传值
},
contentType:"application/json",
data:{
这里放请求体数据
},
success:function (res){
console.log(res);
}
});

@RequestBody注解用于接收请求体传递的数据

  • 前端
<input type="button" value="ajax提交" id="btn1"/>
<script type="text/javascript" src="js/jquery-3.4.1.min.js"></script>
<script type="text/javascript">
$("#btn1").click(function (){
console.log("进入方法");
var obj ={};
obj.bookName="pytone";
obj.bookAuthor="woshinidie";
obj.bookPrice=3.33;
console.log("obj");
$.ajax({
url:"book/update",
type:"post",
// headers:{
// token:"Eqeqeq"
// },
contentType:"application/json",
data: JSON.stringify(obj), //data的值为json格式字符串, contentType:"application/json"
success:function (res){
console.log(res);
}
});
console.log("结束");
});
</script>

@RequestBody将前端请求的JSON格式数据转换为Java对象,依赖jackson包

  • 导入jackson的依赖
<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.13.0</version>
</dependency>
  • 控制器
@RequestMapping("/update")
public void update(@RequestBody Book book){
System.out.println("~~~~~book update");
try{
System.out.println(book);
} catch (Exception e) {
e.printStackTrace();
}
}
----------------------------------
// @RequestMapping("/update")
// public void update(HttpServletRequest request){
// System.out.println("~~~~~book update");
// try{
//// Servlet的处理方法: 使用request 的输入流接收请求体数据
// ServletInputStream is = request.getInputStream();
// StringBuffer stringBuffer = new StringBuffer();
// byte[] bs = new byte[100];
// int len = -1;
// while ((len = is.read(bs)) != -1){
// String s = new String(bs,0,len);
// stringBuffer.append(s);
// }
// System.out.println(stringBuffer.toString());
//
// } catch (IOException e) {
// e.printStackTrace();
// }
// }

 

4.5 控制器响应前端请求

4.5.1 控制器响应同步请求


同步请求: from,超链接


  • 处理同步请求的方法返回类型定义为String或者ModelAndView,以实现页面的跳转
  • 返回类型为String

转发

@RequestMapping("/add")
public String add(@RequestParam("name") String a,
@RequestParam("author") String b,
@RequestParam("price") double c){
System.out.println("~~~~~book add");
System.out.println(a);
System.out.println(b);
System.out.println(c);

//如何挑战到指定的页面呢?
return "/tips.jsp";
}

重定向

@RequestMapping("/add")
public String add(@RequestParam("name") String a,
@RequestParam("author") String b,
@RequestParam("price") double c){
System.out.println("~~~~~book add");
System.out.println(a);
System.out.println(b);
System.out.println(c);

//如何挑战到指定的页面呢?
return "redirect:/tips.jsp";
}
  • 返回类型为ModelAndView

转发

@RequestMapping("/add")
public ModelAndView add(@RequestParam("name") String a,
@RequestParam("author") String b,
@RequestParam("price") double c){
System.out.println("~~~~~book add");
System.out.println(a);
System.out.println(b);
System.out.println(c);
//如何挑战到指定的页面呢?
ModelAndView modelAndView = new ModelAndView("/tips.jsp");
return modelAndView;
}

重定向

@RequestMapping("/add")
public ModelAndView add(@RequestParam("name") String a,
@RequestParam("author") String b,
@RequestParam("price") double c){
System.out.println("~~~~~book add");
System.out.println(a);
System.out.println(b);
System.out.println(c);
//如何挑战到指定的页面呢?
ModelAndView modelAndView = new ModelAndView("redirect/tips.jsp");
return modelAndView;
}

4.5.2 控制器应异步请求


异步请求:ajax请求


使用response中的输出流进行响应

/**

控制器方法的返回类型为void
控制器方法添加HttpServletResponse response 参数
在方法中通过response 获取输出流,使用流响应ajax请求

**/
@RequestMapping("/update")
public void update(@RequestBody Book book, HttpServletResponse response){
System.out.println("~~~~~book update");
try{
System.out.println(book);

//使用ObjectMapper将对象转换成json格式字符串
String s = new ObjectMapper().writeValueAsString(book);

response.setCharacterEncoding("utf-8");
response.setContentType("application/json");
PrintWriter out = response.getWriter();
out.println();
out.close();

} catch (Exception e) {
e.printStackTrace();
}
}

直接在控制器方法返回相应的对象

  • 控制器方法的返回类型设置为响应给ajax请求的对象类型
  • 在控制器方法前添加一个@ResponseBody注解,将返回的对象转换成json格式返回给ajax请求
  • 如果一个控制器类中的所有方法都是响应ajax请求,则可以直接在控制器类前添加@ResponseBody注解
@RequestMapping("/update")
@ResponseBody
public List<Book> update(){
System.out.println("~~~~~book update");

ArrayList<Book> books = new ArrayList<Book>();
books.add(new Book(1,"我朝","嘿嘿",2.33));
books.add(new Book(2,"到店","顶顶",2.33));
return books;

}

 4.5.3 控制器响应同步请求的数据传递


对于同步请求的转发响应,我们可以传递参数到转发的页面


  • 返回类型为String:
//1:在控制器方法中定义一个Model类型的参数
//2:在return页面之前,向model中添加键值对,添加的键值对就会被传递到转发的页面
@RequestMapping("/add1")
public String add1(@RequestParam("name") String a,
@RequestParam("author") String b,
@RequestParam("price") double c,
Model model){
model.addAttribute("key1","value1");
model.addAttribute("key1",new Book(1,"Java","老张",2.33));
return "/tips.jsp";

}

//除了使用Model对象传值外还可以直接使用HttpServletRequest对象
@RequestMapping("/add1")
public String add1(@RequestParam("name") String a,
@RequestParam("author") String b,
@RequestParam("price") double c,
HttpServletRequest request){
request.addAttribute("key1","value1");
request.addAttribute("key1",new Book(1,"Java","老张",2.33));
return "/tips.jsp";

}
  • 返回类型为ModelAndView
@RequestMapping("/add2")
public ModelAndView add2(@RequestParam("name") String a,
@RequestParam("author") String b,
@RequestParam("price") double c){
System.out.println("~~~~~book add");
ModelAndView modelAndView = new ModelAndView("/tips.jsp");
modelAndView.addObject("key1","value");
modelAndView.addObject("key2",new Book(1,"Java","老张",2.35));
return modelAndView;
}

 

4.6 解决中文乱码问题

4.6.1 前端编码

  • JSP页面
<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="utf-8" %>
  • HTML页面
<meta charset="UTF-8">

4.6.2 服务器编码

  • tomcat/conf/server.xml
<Connector port="8081" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443" URIEncoding="UTF-8"/>

4.6.3 设置SpringMVC的编码方式

  • 在web.xml中配置SpringMVC编码过滤器的编码方式
<filter>
<filter-name>EncodingFilter</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>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>EncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

 

0x05 SpringMVC的请求处理流程

5.1 SpringMVC的请求处理流程


 SpringMVC通过前端控制器DispatcherServlet拦截并处理用户请求


 SSM学习笔记之SpringMVC_spring_06

 

5.2 SpringMVC的核心组件

  • DispatcherServlet前端控制器,总控制器
  • 作用:接收请求,协同各个组件工作,响应请求
  • HandlerMapping处理器映射
  • 作用:负责根据用户请求的URL找到对应的Handler
  • 可以自定义配置SpringMVC提供多个处理器映射的实现,可以根据需要进行配置
  • HandlerAdapter处理器适配器
  • 作用:根据HandlerMapping解析用户请求后产生的调用链,通过适配器模式完成Handler的调用
  • Handler控制器
  • 由开发人员根据业务的需求进行开发
  • 作用:处理请求
  • ModelAndView视图模型
  • 作用:用于封装处理器返回的数据以及响应的视图
  • ModelAndView = Model + View
  • ViewResolver视图解析器
  • 作用:对ModelAndView进行解析
  • 可以自定义配置SpringMVC提供多个视图解析器的实现,可以根据需要进行配置
  • View视图
  • 作用:完成数据渲染

 

5.3 处理器映射器


不同的处理器映射器对URL处理的方式也不相同,使用对应的处理器映射器之后,我们的前端请求规则也需要发生响应的变化

SpringMVC提供的处理器映射器:

1. BeanNameUrlHandlerMappering 根据控制器的Id访问控制器

2. SimpleUrlHandlerMapping 根据控制器配置的URL访问(默认配置)


配置处理器映射器:

  • 在SpringMVC的配置文件中通过Bean标签声明处理器映射器
  • 配置BeanNameUrlHandlerMapping
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean>
  • 配置SimpleHandlerMapping
<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="mappings">
<props>
//这里也可以通过注解的方式在controller上进行配置@RequestMapping("/aaa")
<prop key="/aaa">bookController</prop>
<prop key="/bbb">studentController</prop>
</props>
</property>
</bean>

 

5.4 视图解析器


SpringMVC提供了多个视图解析器:

1. UrlBasedViewResolver

2. InternalResourceViewResolver


  • UrlBasedViewResolver需要依赖jstl包
  • 添加JSTL的依赖

pom.xml

<!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
  • 配置视图解析器

spring-servlet.xml

<bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">
<property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
<property name="prefix" value="/"/>
<property name="suffix" value=".jsp"/>
</bean>
  • InternalResourceViewResolver

<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/"/>
<property name="suffix" value=".jsp"/>
</bean>

 

0x06 SpringMVC中的日期格式处理

6.1 在控制器中使用对象接收数据

  • 前端
<form action="test/add" method="post">
<p>图书名称:<input type="text" name="bookId"></p>
<p>图书作者:<input type="text" name="bookName"></p>
<p>图书价格:<input type="text" name="bookPrice"></p>
<p>图书出版时间:<input type="text" name="publish"></p>
<p><input type="submit" value="提交"></p>
</form>
  • 后端
package com.springMVCDemo.beans;

import java.util.Date;

public class Book {
private int bookId;
private String bookName;
private String bookAuthor;
private double bookPrice;
private Date publish;

public Book(int bookId, String bookName, String bookAuthor, double bookPrice) {
this.bookId = bookId;
this.bookName = bookName;
this.bookAuthor = bookAuthor;
this.bookPrice = bookPrice;
}

@Override
public String toString() {
return "Book{" +
"bookId=" + bookId +
", bookName='" + bookName + '\'' +
", bookAuthor='" + bookAuthor + '\'' +
", bookPrice=" + bookPrice +
", publish=" + publish +
'}';
}

public int getBookId() {
return bookId;
}

public void setBookId(int bookId) {
this.bookId = bookId;
}

public String getBookName() {
return bookName;
}

public void setBookName(String bookName) {
this.bookName = bookName;
}

public String getBookAuthor() {
return bookAuthor;
}

public void setBookAuthor(String bookAuthor) {
this.bookAuthor = bookAuthor;
}

public double getBookPrice() {
return bookPrice;
}

public void setBookPrice(double bookPrice) {
this.bookPrice = bookPrice;
}

public Date getPublish() {
return publish;
}

public void setPublish(Date publish) {
this.publish = publish;
}

public Book(int bookId, String bookName, String bookAuthor, double bookPrice, Date publish) {
this.bookId = bookId;
this.bookName = bookName;
this.bookAuthor = bookAuthor;
this.bookPrice = bookPrice;
this.publish = publish;
}

public Book() {
}
}
--------------------------
package com.springMVCDemo.controllers;

import com.springMVCDemo.beans.Book;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.Date;

@Controller
@RequestMapping("/test")
public class TestController {

@RequestMapping("/add")
//表单提交的多个参数,在控制器方法中可以使用对象接收,
//但是提交的数据的key必须要与对象的属性一致
public String addBook(Book book){
System.out.println(book);
return "tips";
}

}
  • spring-servlet.xml
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/"/>
<property name="suffix" value=".jsp"/>
</bean>

 

6.2 日期格式处理


如果前端需要输入日期数据,在控制器中转换成Date对象,SpringMVC要求前端输入的日期格式必须为yyyy/MM/DD

如果甲方要求日期格式必须为指定的格式,而这个指定格式SpringMVC不接受,该如何处理?

自定义日期转换器:


6.2.1 创建自定义日期转换器

package com.springMVCDemo.utils;

import org.springframework.core.convert.converter.Converter;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
* 1:创建一个类实现Converter接口,泛型指定从什么类型转换为什么类型
* 2:实现Converter准换方法
* */
public class MyDateConverter implements Converter<String,Date> {

SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");

public Date convert(String s) {
Date date = null;
try {
date = sdf.parse(s);
} catch (ParseException e) {
e.printStackTrace();
}
return date;
}
}

 6.2.2 配置自定义转换器

<?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">


<!-- 声明使用注解配置-->
<context:annotation-config/>
<!-- 声明Spring工厂注解的扫描范围-->
<context:component-scan base-package="com.springMVCDemo"/>
--------------------------------------------------------------------------------
<!-- 声明mvc使用注解驱动-->
<mvc:annotation-driven conversion-service="converterFactory"/>
------------------------------------------------------------------------

<!--放行资源-->
<mvc:resources mapping="/css/**" location="/css/"/>
<mvc:resources mapping="/pages/**" location="/pages/"/>
<mvc:resources mapping="/imgs/**" location="/imgs/"/>
<mvc:resources mapping="/js/**" location="/js/"/>

<!--HandlerMapping-->
<!-- <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean>-->

<!-- <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">-->
<!-- <property name="mappings">-->
<!-- <props>-->
<!-- <prop key="/aaa">bookController</prop>-->
<!-- <prop key="/bbb">studentController</prop>-->
<!-- </props>-->
<!-- </property>-->
<!-- </bean>-->


<!-- <bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">-->
<!-- <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>-->
<!-- <property name="prefix" value="/"/>-->
<!-- <property name="suffix" value=".jsp"/>-->
<!-- </bean>-->

<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/"/>
<property name="suffix" value=".jsp"/>
</bean>

-----------------------------------------------------------
<!--自定义转换器-->
<bean id="converterFactory" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
<property name="converters">
<set>
<!-- //这里可以配置多个-->
<bean class="com.liguoqing.utils.MyDateConverter"/>
</set>
</property>
</bean>
----------------------------------------------

</beans>
//自己定义一个转换类
//MyDateConverter.class
package com.springMVCDemo.utils;

import org.springframework.core.convert.converter.Converter;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
* 1:创建一个类实现Converter接口,泛型指定从什么类型转换为什么类型
* 2:实现Converter准换方法
* */
public class MyDateConverter implements Converter<String,Date> {

SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");

public Date convert(String s) {
Date date = null;
try {
date = sdf.parse(s);
} catch (ParseException e) {
e.printStackTrace();
}
return date;
}
}

 

0x07 SpringMVC中的文件上传和下载

7.1 SpringMVC框架部署

  • 基于Maven创建web工程
  • 添加SpringMVC所需的依赖
  • Spring-context
  • aspects
  • jdbc
  • test
  • web
  • webmvc
  • jackson
  • 创建SpringMVC配置文件
  • 在web.xml中配置SpringMVC的前端控制器
  • 在web.xml中配置SpringMVC的编码过滤器
  • 配置静态资源处理策略

 

7.2 文件上传


案例:添加图书,同时提交图书的封面图片


7.2.1 前端提交文件

表单提交方式必须为post

表单enctype属性,设置为multipart/form-data

<form action="book/add" method="post" enctype="multipart/form-data">
<p>图书名称:<input type="text" name="bookName"></p>
<p>图书作者:<input type="text" name="bookAuthor"></p>
<p>图书价格:<input type="text" name="bookPrice"></p>
<p>图书封面:<input type="file" name="ImgFile"></p>
<p>提交:<input type="submit" name="提交"></p>
</form>

 7.2.2 控制器接收数据和文件


SpringMVC处理上传文件需要借助CommonsMultipartResolver文件解析器


SSM学习笔记之SpringMVC_xml_07

  • 添加依赖:
  • commons-io
  • commons-fileupload

<!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.4</version>
</dependency>

<!-- https://mvnrepository.com/artifact/commons-fileupload/commons-fileupload -->
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.3.1</version>
</dependency>
  • 在spring-servlet.xml中配置文件解析器
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<!--一些属性,自己百度-->
<property name="maxUploadSize" value="10240000"/>
<property name="maxInMemorySize" value="10240"/>
<property name="defaultEncoding" value="utf-8"/>
</bean>
  • 在控制器接收文件
  • 在处理文件上传的方法中定义一个MultipartFile类型的对象,就可以接收图片了

package com.springMVCDemo.controller;

import com.springMVCDemo.beans.Book;
import org.springframework.http.HttpRequest;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.io.IOException;

@Controller
@RequestMapping("/book")
public class BookController {

@RequestMapping("/add")
public String addBook(Book book, MultipartFile ImgFile, HttpServletRequest request) throws IOException {
System.out.println("~~~~addBook");
System.out.println(book);
System.out.println(ImgFile);
//ImgFile表示上传的图片
//1:截取上传文件的后缀名,生成新的文件名
String originalFilename = ImgFile.getOriginalFilename();
String ext = originalFilename.substring( originalFilename.lastIndexOf(".") );// .jpg
String filename = System.currentTimeMillis()+ext;

//2:获取imgs目录在服务器的路径
String dir = request.getServletContext().getRealPath("imgs");
String savePath = dir + "/" + filename;//存储路径(C:/asd/ad/asdf/img.jpg)

//3:保存文件
ImgFile.transferTo(new File(savePath));

//4:将图片的访问路径设置到对象
book.setBookImg("imgs/"+ filename);

//5:调用service保存book到数据库

return "/tips.jsp";
}

}

 

7.3 文件下载

7.3.1 文件下载流程

SSM学习笔记之SpringMVC_xml_08

@RequestMapping("/list")
@ResponseBody
public String[] listImgs(HttpServletRequest request){
//1:从imgs目录下获取所有的图片信息
String dir = request.getServletContext().getRealPath("imgs");
File imgDir = new File(dir);
String[] filenames = imgDir.list();
return filenames;
}

7.3.2 实现文件下载

SSM学习笔记之SpringMVC_mvc_09

 

0x08 SpringMVC中的统一异常处理


在我们的应用系统运行的过程中,可能由于运行环境,用户操作,资源不足等各个方面的原因导致系统出现异常

(HTTP状态异常,Java异常Exception);如果系统出现了异常,这些异常将会通过浏览器呈现给用户,而这种异常的显示是没有必要的,

因此我们可以在服务器进行特定的处理--当系统出现异常之后,呈现给用户一个统一的可读的提示页面


8.1 HTTP异常状态统一处理


HTTP Status 404


  • 创建一个用于异常提示的页面: 404.jsp
  • 在web.xml中进行配置
<error-page>
<error-code>404</error-code>
<location>/404.jsp</location>
</error-page>

 

8.2 Java代码异常的统一处理

8.2.1 基于Servlet-api的处理

  • 创建异常提示页面: err.jsp
  • 在web.xml中进行配置
<error-page>
<exception-type>java.lang.NullPointerException</exception-type>
<location>/err.jsp</location>
</error-page>

 8.2.2 SpringMVC处理

  • 使用异常处理类进行统一处理

SSM学习笔记之SpringMVC_spring_10

 

0x09 SpringMVC的拦截器

9.1 拦截器介绍


SpringMVC提供的拦截器类似与Servlet-api中的过滤器,可以对控制器的请求进行拦截实现相关的预处理和后处理


  • 过滤器
  • 是Servlet规范的一部分,所有web项目都可以使用
  • 过滤器在web.xml配置(可以使用注解),能够拦截所有web请求
  • 拦截器
  • 是SpringMVC框架的实现,只有在SpringMVC框架中才能使用
  • 拦截器在SpringMVC配置文件进行配置,不会拦截SpringMVC放行的资源(js/html/css....)

 

9.2 自定义拦截器

SSM学习笔记之SpringMVC_mvc_11

 9.2.1 创建拦截器

SSM学习笔记之SpringMVC_mvc_12

 9.2.2 配置拦截器

SSM学习笔记之SpringMVC_spring_13

 

9.3 拦截器链


将多个拦截器按照一定的顺序构成一个拦截器链


SSM学习笔记之SpringMVC_spring_14