springMVC

一个有灵魂的搬运工

已于 2023-02-17 10:34:08 修改

阅读量1.3k

点赞数

文章标签： servlet java mvc

于 2022-12-26 10:51:52 首次发布

本文链接：https://blog.youkuaiyun.com/qq_45885060/article/details/128441211

版权

文章目录

一、SpringMVC

1.1 引言

java开源框架，Spring Framework的一个独立模块。

MVC框架,在项目中开辟MVC层次架构

对控制器中的功能包装简化扩展践行工厂模式，功能架构在工厂之上

1.2 MVC架构

1.2.1 概念

名称	职责
Model	模型：即业务模型，负责完成业务中的数据通信处理，对应项目中的 service和dao
View	视图：渲染数据，生成页面。对应项目中的Jsp
Controller	控制器：直接对接请求，控制MVC流程，调度模型，选择视图。对应项目中的Servlet

1.2.2 好处

MVC是现下软件开发中的最流行的代码结构形态;
人们根据负责的不同逻辑，将项目中的代码分成 M V C 3个层次;
层次内部职责单一，层次之间耦合度低;
符合低耦合高内聚的设计理念。也实际有利于项目的长期维护。

1.2.3 执行流程

Springmvc执行流程
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ggfLInDP-1672022572626)(Pictures\springmvc1.bmp)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Il0EO2K3-1672022572627)(Pictures\springmvc2.png)]

1、用户发送请求至前端控制器DispatcherServlet

2、DispatcherServlet收到请求调用HandlerMapping处理器映射器。

3、处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。

4、DispatcherServle通过HandlerAdapter处理器适配器调用处理器

5、执行处理器(Controller，也叫后端控制器)。

6、Controller执行完成返回ModelAndView

7、HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet

8、DispatcherServlet将ModelAndView传给ViewReslover视图解析器

9、ViewReslover解析后返回具体View

10、DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）。

11、DispatcherServle响应用户

二、开发流程

2.1 导入依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.1.6.RELEASE</version>
</dependency>

2.2 配置核心(前端)控制器

作为一个MVC框架，首先要解决的是：如何能够收到请求！

所以MVC框架大都会设计一款前端控制器，选型在 Servlet 或 Filter两者之一,在框架最前沿率先工作，接收所有请求。

此控制器在接收到请求后，还会负责springMVC的核心的调度管理，所以既是前端又是核心。

<servlet>
    <servlet-name>mvc</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启动时刻：可选(先于服务器启动。更快的处理请求) -->
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>mvc</servlet-name>
    <url-pattern>/</url-pattern>//处理所有请求
</servlet-mapping>

2.3 后端控制器

等价于之前定义的Servlet

@Controller //声明这是一个控制器
@RequestMapping("/hello")  //访问路径 ，等价于url-pattern
public class HelloController {
	@RequestMapping("/test1")  //访问路径
	public String hello1(){
		System.out.println("hello world");
		return "index"; // 跳转:/index.jsp  
	}
	@RequestMapping("/test2") //访问路径
	public String hello2(){
		System.out.println("hello c9");
		return "views/users";//  跳转:/views/user.jsp
	}
}

2.4 配置文件

默认名称：核心控制器名-servet.xml 默认位置：WEB-INF

随意名称：springmvc.xml 随意位置：resources 但需要配置在核心控制器中

<beans 	xmlns="http://www.springframework.org/schema/beans"
		xmlns:context="http://www.springframework.org/schema/context"
		xmlns:mvc="http://www.springframework.org/schema/mvc" 
		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
		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/mvc
							http://www.springframework.org/schema/mvc/spring-mvc.xsd">

	<!-- 告知springmvc  哪些包中 存在 被注解的类 -->
	<context:component-scan base-package="com.qf.controller"></context:component-scan>
	<!-- 注册注解开发驱动 -->
	<mvc:annotation-driven></mvc:annotation-driven>
	<!-- 视图解析器
	     作用：1.捕获后端控制器的返回值="index"
	          2.解析： 在返回值的前后 拼接 ==> "/index.jsp"
	 -->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<!-- 前缀 -->
		<property name="prefix" value="/"></property>
		<!-- 后缀 -->
		<property name="suffix" value=".jsp"></property>
	</bean>
</beans>

2.5 访问

http://localhost：8080/hello/test1
http://localhost：8080/hello/test2

三、接收请求参数

3.1 基本类型参数

请求参数和方法的形参同名即可

springMVC默认可以识别的日期字符串格式为： YYYY/MM/dd HH:mm:ss
通过@DateTimeFormat可以修改默认日志格式

// id  name gender
// http://localhost:8080/../test1?id=1&name=zzz&gender=false&birth=2018-12-12 12:20:30
@RequestMapping("/test1")
public String testParam1(Integer id,
                         String name,
                         Boolean gender,
                         @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")Date birth){
    System.out.println("test param1");
    return "index";
}

3.2 实体收参【`重点`】

请求参数和实体的属性同名即可

public class User {
	private Integer id;
	private String name;
	@DateTimeFormat(pattern="yyyy-MM-dd")
	private Date birth;
	private Boolean gender;
	//set/get ...
}

//http://localhost:8080/.../test2?id=1&name=zzz&gender=false&birth=2018-12-12
@RequestMapping("/test2")
public String testParam2(User user){
    System.out.println("test param2");
    System.out.println("user:"+user);
    return "index";
}

3.3 数组收参

简单类型的数组

<form>
    ......
    <input type="checkbox" name="hobby" value="fb"/>足球 
    <input type="checkbox" name="hobby" value="bb"/>篮球 
    <input type="checkbox" name="hobby" value="vb"/>排球
    
</form>

//http://localhost:8080/.../test3?hobby=football&hobby=basketball
@RequestMapping("/test3")
public String testParam3(String[] hobby){
    for(String h:hobby){
        System.out.print(h+" ");
    }
    return "index";
}

3.4 集合收参【了解】

public class UserList {
	private List<User> users;
	//set/get..
}

// <input type="text" name="users[0].id"/>
// 请求：http://localhost:8080/hello/test4?users[0].id=2&users[0].name=lisi&users[0].gender=true&users[0].birth=1990-10-10&users[1].id=3&users[1].name=ww&users[1].gender=false&users[1].birth=1999-11-10
@RequestMapping("/test4")
public String testParam4(UserList userList){
    for(User user:userList.getUsers()){
        System.out.println(user);
    }
    return "index";
}

3.5 路径参数

// {id} 定义名为id的路径；【/hello/{id}】的匹配能力和【/hello/*】等价
// http://localhost:8080/hello/hello/10   {id}匹配到10
@RequestMapping("/hello/{id}") //restful风格  hello?id=1&name=zs  hello/1
// @PathVariable将{id}路径匹配到值赋给id参数
// 路径名和参数名相同则@PathVariable("id")可简写为 @PathVariable
public String testParam5(@PathVariable("id") Integer id){
    System.out.println("id:"+id);            
    return "index";
}

// http://localhost:8080/hello/hello/zsf   {username}匹配到zsf
@RequestMapping("/hello/{username}")
public String testParam6(@PathVariable("username") String name){//将{username}路径匹配到的值赋给name参数
    System.out.println("username:"+name);
    return "index";
}

3.6 中文乱码

首先，页面中字符集统一

JSP : <%@page  pageEncoding="utf-8" %>
HTML : <meta charset="UTF-8">

其次，tomcat中字符集设置，对get请求中，中文参数乱码有效

Tomcat配置：URIEncoding=utf-8

最后，设置此filter，对post请求中，中文参数乱码有效

<!-- 此过滤器会进行：request.setCharactorEncoding("utf-8"); -->
<filter>
    <filter-name>encoding</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>
</filter>
<filter-mapping>
    <filter-name>encoding</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

四、跳转

4.1 转发

@Controller
@RequestMapping("/forw")
class ForwardController{
    @RequestMapping("/test1")
    public String testForward(){
        System.out.println("test forward1");
        // 转发跳转 /views/users.jsp
        // return "views/users";//和下一行等价
        return "forward:/views/users.jsp";
    }
    
    @RequestMapping("/test2")
    public String testForward2(){
        System.out.println("test forward2");
        return "forward:/forw/test1"; //转到另一个请求地址
    }
}

4.2 重定向

@Controller
@RequestMapping("redir")
public class RedirectController {

    @RequestMapping("/test1")
    public String testRedirect1(){
        System.out.println("test redirect1");
        //重定向到 /views/users.jsp
        return "redirect:/views/users.jsp";
    }

    @RequestMapping("/test2")
    public String testRedirect2(){
        System.out.println("test redirect2");
        return "redirect:/redir/test1";
    }
}

4.3 跳转细节

在增删改之后，为了防止请求重复提交，重定向跳转

在查询之后，可以做转发跳转

五、传值

C得到数据后，跳转到V，并向V传递数据。进而V中可以渲染数据，让用户看到含有数据的页面

转发跳转：Request作用域

重定向跳转：Session作用域

5.1 Request和Session

@Controller
@RequestMapping("/save")
public class SaveDataController {
    
	//形参中 即可获得 request 和 session对象
    @RequestMapping("/test")
    public String testData(HttpSession session, HttpServletRequest req,Integer id){
        session.setAttribute("user",new User(1,"haha",new Date(),true));
        session.setAttribute("age", 18);
        return "data";
    }
}

5.2 JSP中取值

建议：重点复习 EL JSTL

添加<%@ taglib prefix=“fmt” uri=“http://java.sun.com/jsp/jstl/fmt” %>标签库

引入jstl依赖

//jsp中用EL表达式 取值即可
<fmt:formatDate value="${sessionScope.user.birth}" pattern="yyyy-MM-dd"/> <br/>
${sessionScope.user.birth} <br>
${sessionScope.age}

5.3 Model(存在request作用域中)

//model中的数据，会在V渲染之前，将数据复制一份给request
@RequestMapping("/test2")
public String testData2(Model model){
    model.addAttribute("name", "张三");
    return "data";
}

//jsp中用EL表达式 取值即可
${requestScope.name}

5.4 ModelAndView(存在request作用域中)

//modelandview 可以集中管理 跳转和数据
@RequestMapping("/test3")
public ModelAndView testData(){//返回值类型为ModelAndView
    //新建ModelAndView对象
    ModelAndView mv = new ModelAndView();
    // 设置视图名，即如何跳转
    mv.setViewName("data");
    // 增加数据
    mv.addObject("name","lisi");
    return mv;
}

//jsp中用EL表达式 取值即可
${requestScope.name} / ${name}

5.5 @SessionAttributes

@SessionAttributes({“gender”,“love”}) ：model中的 love和gender 会存入session中,request中也会有

SessionStatus 移除session

@Controller
@SessionAttributes({"gender","love"}) // model中的 love和gender 也会存入session中
public class UserController {

    @RequestMapping("/hello")
    public String hello(Model m){
        m.addAttribute("gender",true); // 会存入session
        m.addAttribute("love","basketball"); // 会存入session
        return "index";
    }
    
    @RequestMapping("/hello2")
    public String hello(SessionStatus status){
        // 移除通过SessionAttributes存入的session
        status.setComplete();
        return "index";
    }
}

六、静态资源

6.1 静态资源问题

静态资源：html，js文件，css文件，图片文件

静态文件没有url-pattern,所以默认是访问不到的，之所以可以访问，是因为，tomcat中有一个全局的servlet：org.apache.catalina.servlets.DefaultServlet，它的url-pattern是 “/”,是全局默认的Servlet. 所以每个项目中不能匹配的静态资源的请求，由这个Servlet来处理即可。

但，在SpringMVC中DispatcherServlet也采用了 “/” 作为url-pattern, 则项目中不会再使用全局的Serlvet，则静态资源不能完成访问。

6.2 解决方案1

DispathcerServlet采用其他的url-pattern

此时，所有访问handler的路径都要以 action结尾！！

<servlet>
  	<servlet-name>mvc9</servlet-name>
  	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>mvc9</servlet-name>
    <url-pattern>*.action</url-pattern>   
</servlet-mapping>

6.3 解决方案2(推荐)

DispathcherServlet的url-pattern依然采用 “/”,但追加配置

<!-- 
  额外的增加一个handler，且其requestMapping:  "/**" 可以匹配所有请求，但是优先级最低
  所以如果其他所有的handler都匹配不上，请求会转向 "/**" ,恰好，这个handler就是处理静态资源的
  处理方式：将请求转回到tomcat中名为default的Servlet
  -->
springmvc.xml中:
<mvc:default-servlet-handler/>

6.4 解决方案3

mapping是访问路径，location是静态资源存放的路径
将/static/** 中 /**匹配到的内容，拼接到 /static/后
http://…/static/a.html 访问 /static/a.html

springmvc.xml中:
<mvc:resources mapping="/static/**" location="/static/"/>

@Controller
@RequestMapping("/forw")
public class ForwardController {
    @RequestMapping("/test1")
    public String testForward(){
        System.out.println("test forward1");
        return "forward:/static/html/haha.html";
    }
 }

静态资源的位置
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Mujtm7Ar-1672022572628)(Pictures\静态资源所在位置.png)]

七、Json处理

7.1 导入依赖

<!-- Jackson springMVC默认的Json解决方案选择是 Jackson，所以只需要导入jackson的jar，即可使用。-->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.8</version>
</dependency>

7.2 使用@ResponseBody

@Controller
@RequestMapping("json")
public class JsonController {

    @RequestMapping("/test1")
    @ResponseBody //将handler的返回值，转换成json(jackson),并将json响应给客户端。
    public User hello1(){
        System.out.println("hello world");
        User user = new User(22,"yes",new Date(),true);
        return user;
    }

    // @ResponseBody还可以用在handler的返回值上
    @RequestMapping("/test2")
    public @ResponseBody List<User> hello2(){
        System.out.println("hello world");
        List<User> users = Arrays.asList(new User(22,"yes",new Date(),true),
                new User(23,"no",new Date(),false));
        return users;
    }

    // 如果返回值已经是字符串，则不需要转json，直接将字符串响应给客户端
    @RequestMapping(value="/test3",produces = "text/html;charset=utf-8") //produces 防止中文乱码
    @ResponseBody
    public String hello3(){
        System.out.println("hello world");
        return "你好";
    }
}

7.3 使用@RestController

Controller类上加了@RestController注解，等价于在类中的每个方法上都加了@ResponseBody

@RestController
@RequestMapping("json")
public class JsonController {

    @RequestMapping("/test1")
    public User hello1(){
        System.out.println("hello world");
        User user = new User(22,"yes",new Date(),true);
        return user;
    }

    @RequestMapping("/test2")
    public List<User> hello2(){
        System.out.println("hello world");
        List<User> users = Arrays.asList(new User(22,"yes",new Date(),true),
                new User(23,"no",new Date(),false));
        return users;
    }

    @RequestMapping(value="/test3",produces = "text/html;charset=utf-8") //produces 防止中文乱码
    public String hello3(){
        System.out.println("hello world");
        return "你好";
    }
}

7.4 使用@RequestBody

@RequestBody, 接收Json参数

7.4.1 定义Handler

class User{
    private Integer id;
    private String name;
    private Boolean gender;
    private Date birth;
    //set get
}

@RequestMapping("/users")
public String addUser(@RequestBody User user){//@RequestBody将请求体中的json数据转换为java对象
    System.out.println("cap2");
    System.out.println("Post user :"+user);
    return "index";
}

7.4.2 发送json数据

通过Postman发送json数据
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ttgfEw2N-1672022572628)(Pictures\postman发送ajax请求.png)]

7.5 Jackson常用注解

7.5.1 日期格式化

@JsonFormat(pattern=“yyyy-MM-dd HH:mm:ss”,timezone = “GMT+8”)

public class User{
	private Integer id;
	private String name;
	@JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
	private Date birth;
    ....
    get/set
}

7.5.2 属性名修改

@JsonProperty(“new_name”)

public class User{
	@JsonProperty("new_id") //不再使用原属性名，而是 "new_id"
    private Integer id;
	private String name;
    ....
    get/set
}
输出的json：{“new_id”:xx,"name":"xx"}

7.5.3 属性忽略

@JsonIgnore

public class User{
    private Integer id;
    @JsonIgnore // 生成json时，忽略此属性
	private String name;
    ....
    get/set
}
输出json时: {"id":xx}

测试代码

@Controller
@RequestMapping("json")
public class JsonController {

    @RequestMapping("/test1")
    @ResponseBody //将handler的返回值，转换成json(jackson),并将json响应给客户端。
    public User hello1(){
        System.out.println("hello world");
        User user = new User(22,"yes",new Date(),true);
        return user;
    }
 }

测试输出结果

{
birth: "1999-03-28 11:00:14",
gender: true,
new_id: 22
}

7.5.4 null和empty属性排除

Jackson 默认会输出null值的属性，如果不需要，可以排除。

@JsonInclude(JsonInclude.Include.NON_NULL) //null值属性不输出
@JsonInclude(value= JsonInclude.Include.NON_EMPTY) // empty属性不输出( 空串，长度为0的集合，null值)

public class User{
    private Integer id;
    @JsonInclude(JsonInclude.Include.NON_NULL) // 若"name==null" 忽略此属性
	private String name;
    @JsonInclude(value= JsonInclude.Include.NON_EMPTY)  // 若hobby长度为0或==null 忽略此属性
    private List<String> hobby;
    ....
    get/set
}
如果name=null,且 hobby长度为0，则输出json时：{"id":xx}

7.5.5 自定义序列化

@JsonSerialize(using = MySerializer.class) // 使用MySerializer输出某属性

public class User {
    private Integer id;
    private String name;
    @JsonSerialize(using = MySerializer.class)
    private Double salary = 10000.126;//在输出此属性时，使用MySerializer输出
    ....
    get/set
}
则输出json时：{"id":xx,"name":"xxx","salary":10000.13}

public class MySerializer extends JsonSerializer<Double> {

    // value即 Double salary的值
    @Override 
    public void serialize(Double value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        // 将Double salary的值 四舍五入
        String number = BigDecimal.valueOf(value).setScale(2, BigDecimal.ROUND_HALF_UP).toString();
        // 输出 四舍五入后的值
        gen.writeNumber(number);
    }
}

7.6 FastJson

7.6.1 导入依赖

<!-- FastJson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.54</version>
</dependency>

7.6.2 安装FastJson

springmvc.xml中

<mvc:annotation-driven>
    <!-- 安装FastJson,转换器 -->
    <mvc:message-converters>
        <bean class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">
            <!-- 声明转换类型:json -->
            <property name="supportedMediaTypes">
                <list>
                    <value>application/json</value>
                </list>
            </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

7.6.3 使用

@ResponseBody @RequestBody @RestController 使用方法不变

7.6.4 常用注解

日期格式化：@JSONField(format=“yyyy/MM/dd”)
属性名修改：@JSONField(name=“birth”）
忽略属性：@JSONField(serialize = false)
包含null值：@JSONField(serialzeFeatures = SerializerFeature.WriteMapNullValue) 默认会忽略所有null值,有此注解会输出null
@JSONField(serialzeFeatures = SerializerFeature.WriteNullStringAsEmpty) null的String输出为""

自定义序列化：@JSONField(serializeUsing = MySerializer2.class)

public class Student implements Serializable {
    @JSONField(serialize = false) //忽略此属性
    private Integer id;
    @JSONField(name = "NAME",serialzeFeatures = SerializerFeature.WriteNullStringAsEmpty)//null的String输出为""
    private String name;
    @JSONField(serialzeFeatures = SerializerFeature.WriteMapNullValue) //默认会忽略所有null值,有此注解会输出null
    private String city;
    @JSONField(format = "yyyy/MM/dd") //日期格式化
    private Date birth;
    @JSONField(serializeUsing= MySerializer2.class) //自定义序列化
    private Double salary;

    public Student() {
    }

    public Student(Integer id, String name, String city, Date birth, Double salary) {
        this.id = id;
        this.name = name;
        this.city = city;
        this.birth = birth;
        this.salary = salary;
    }

public class MySerializer2 implements ObjectSerializer {
    @Override
    public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType,
                      int features) throws IOException {
        Double value = (Double) object; // salary属性值
        String text = value + "元";// 在salary后拼接 “元”
        serializer.write(text); // 输出拼接后的内容
    }
}

测试代码

@RequestMapping("/fast")
@ResponseBody
public Student hello4(){
    Student student = new Student(1,null,null,new Date(),100.5);
    return student;
}

测试结果

// 如上对象，转换json：
{NAME:""，city:null，"birth":"2020/12/12"，"salary":"100.5元"}

八、异常解析器

8.1 现有方案，分散处理

Controller中的每个Handler自己处理异常

此种处理方案，异常处理逻辑，分散在各个handler中，不利于集中管理

public String xxx(){
    try{
    	...
    }catch(Exception1 e){
    	e.printStackTrace();
        return "redirect:/xx/error1";
    }catch(Exception2 e){
    	e.printStackTrace();
        return "redirect:/xx/error2";
    }
}

8.2 异常解析器，统一处理

Controller中的每个Handler不再自己处理异常，而是直接throws所有异常。

定义一个“异常解析器” 集中捕获处理所有异常

此种方案，在集中管理异常方面，更有优势！

public class MyExResolver implements HandlerExceptionResolver{
	/**
	 * 异常解析器：主体逻辑
	 * 执行时刻：当handler中抛出异常时，会执行：捕获异常，并可以跳到错误页面
	 */
	@Override
	public ModelAndView resolveException(HttpServletRequest request,
			HttpServletResponse response, Object handler, Exception ex) {
		ex.printStackTrace();//打印异常栈
		//创建一个ModelAndView
		ModelAndView mv = new ModelAndView();
		//识别异常
        if(e instanceof NullPointerException){
            mv.setViewName("redirect:/error/error1.jsp");
        }else if(e instanceof ArithmeticException){
            mv.setViewName("redirect:/error/error2.jsp");
        }else{
            mv.setViewName("redirect:/error/error.jsp");
        }
		return mv;
	}
}

springmvc.xml中：
<!-- 声明异常解析器 -->	
<bean class="com.qf.exception.MyExResolver"></bean>

九、拦截器

9.1 作用

作用：抽取handler中的冗余功能

9.2 定义拦截器

SpringMVC中的Interceptor拦截器是链式的，可以同时存在多个Interceptor，然后SpringMVC会根据声明的前后顺序一个接一个的执行，而且所有的Interceptor中的preHandle方法都会在Controller方法调用之前调用

执行顺序： preHandle–postHandle–afterCompletion

public class MyInterceptor implements HandlerInterceptor{
	//主要逻辑：在handler之前执行：抽取handler中的冗余代码
	@Override
	public boolean preHandle(HttpServletRequest request,
			HttpServletResponse response, Object handler) throws Exception {
		System.out.println("pre~~~");
        /*
        response.sendRedirect("/springMVC_day2/index.jsp");//响应
        return false;//中断请求
        */
		return true;//放行，后续的拦截器或handler就会执行
	}
	//在handler之后执行:进一步的响应定制
	@Override
	public void postHandle(HttpServletRequest request,
			HttpServletResponse response, Object handler,
			ModelAndView modelAndView) throws Exception {
		System.out.println("post~~");
	}
	//在页面渲染完毕之后，执行：资源回收
	@Override
	public void afterCompletion(HttpServletRequest request,
			HttpServletResponse response, Object handler, Exception ex)
			throws Exception {
		System.out.println("after~~");
	}
}

9.3 配置拦截路径

springmvc.xml中：

<!--配置拦截器-->
<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/**"/>  <!--拦截多层的请求路径 -->
        <mvc:exclude-mapping path="/json/fast"/>   <!--不拦截此路径-->
        <bean class="com.qf.interceptor.MyInterceptor"></bean>   <!--拦截器类-->
    </mvc:interceptor>
</mvc:interceptors>

十、上传

10.1 导入jar

<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.4</version>
</dependency>

<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.3</version>
    <exclusions>
        <exclusion>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
        </exclusion>
    </exclusions>
</dependency>

10.2 表单

<form action="${pageContext.request.contextPath }/upload/test1" method="post" 
      enctype="multipart/form-data">
  file: <input type="file" name="source"/> <br>
  <input type="submit" value="提交"/>
</form>

10.3 上传解析器

spring.xml中:

<!-- 上传解析器 
	     id必须是：“multipartResolver”
 -->
<bean id="multipartResolver" 
      class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <!-- 最大可上传的文件大小  单位：byte  超出后会抛出MaxUploadSizeExceededException异常，可以异常解析器捕获 -->
    <property name="maxUploadSize" value="1048576"></property>
</bean>

10.4 Handler

@RequestMapping("/test1")
public String upload(MultipartFile source,HttpSession session) {
    //文件的原始名称
    String filename = source.getOriginalFilename();
    //定制全局唯一的命名
    String unique = UUID.randomUUID().toString();
    //获得文件的后缀
    String ext = FilenameUtils.getExtension(filename);//abc.txt   txt    hello.html  html
    //定制全局唯一的文件名
    String uniqueFileName = unique+"."+ext;
    System.out.println("唯一的文件名:"+uniqueFileName);

    //文件的类型
    String type = source.getContentType();
    System.out.println("filename:"+filename+" type:"+type);

    //获得 upload_file的磁盘路径 ==> 在webapp目录下创建一个目录"upload_file",且此目录初始不要为空，否则编译时被忽略
    String real_path = session.getServletContext().getRealPath("/upload_file");
    System.out.println("real_path:"+real_path);

    //将上传的文件，存入磁盘路径中
    //source.transferTo(new File("d:/xxxx/xxxx/xx.jpg"))
    source.transferTo(new File(real_path+"\\"+uniqueFileName));
    return "index";
}

十一、下载

11.1 超链

<a href="${pageContext.request.contextPath}/download/test1?name=Koala.jpg">下载</a>

11.2 Handler

@RequestMapping("/test1")
public void hello1(String name,HttpSession session,HttpServletResponse response){
    System.out.println("name:"+name);
    //获得要下载文件的绝对路径
    String path = session.getServletContext().getRealPath("/upload_file");
    //文件的完整路径
    String real_path = path+"\\"+name;

    //设置响应头  告知浏览器，要以附件的形式保存内容   filename=浏览器显示的下载文件名
    response.setHeader("content-disposition","attachment;filename="+name);

    //读取目标文件，写出给客户端
    IOUtils.copy(new FileInputStream(real_path), response.getOutputStream());

    //上一步，已经是响应了,所以此handler直接是void
}

十二、验证码

12.1 作用

防止暴力攻击，前端安全保障

12.2 导入jar

<!-- Kaptcha -->
<dependency>
    <groupId>com.github.penggle</groupId>
    <artifactId>kaptcha</artifactId>
    <version>2.3.2</version>
    <exclusions>
        <exclusion>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
        </exclusion>
    </exclusions>
</dependency>

12.3 声明验证码组件

https://www.cnblogs.com/louis80/p/5230507.html

<servlet>
    <servlet-name>cap</servlet-name>
    <servlet-class>com.google.code.kaptcha.servlet.KaptchaServlet</servlet-class>
    <init-param>
      <param-name>kaptcha.border</param-name>
      <param-value>no</param-value>
    </init-param>
    <init-param>
      <param-name>kaptcha.textproducer.char.length</param-name>
      <param-value>4</param-value>
    </init-param>
    <init-param>
      <param-name>kaptcha.textproducer.char.string</param-name>
      <param-value>abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789</param-value>
    </init-param>
    <init-param>
      <param-name>kaptcha.background.clear.to</param-name>
      <param-value>211,229,237</param-value>
    </init-param>
    <init-param>
      <!-- session.setAttribute("captcha","验证码") -->
      <param-name>kaptcha.session.key</param-name>
      <param-value>captcha</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>cap</servlet-name>
    <url-pattern>/captcha</url-pattern>
  </servlet-mapping>

12.4 Page

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <script src="${pageContext.request.contextPath}/static/js/jquery-1.8.2.js"></script>
    <script type="text/javascript">
        $(function(){
            $("#cap").click(function(){
                alert("1111");
                //刷新验证码
                path = $(this).attr("src")+"?"+new Date().getTime();
                $(this).attr("src",path);
            });
        });
    </script>
</head>
<body>
<img src="${pageContext.request.contextPath}/captcha" style="width:85px" id="cap"/>
</body>
</html>

十三、REST

13.1 开发风格

是一种开发风格，遵从此风格开发软件，符合REST风格，则RESTFUL。

两个核心要求：

每个资源都有唯一的标识(URL)
不同的行为，使用对应的http-method

访问标识	资源
http://localhost:8989/xxx/users	所有用户
http://localhost:8989/xxx/users/1	用户1
http://localhost:8989/xxx/users/1/orders	用户1的所有订单

请求方式	标识	意图
GET	http://localhost:8989/xxx/users	查询所有用户
POST	http://localhost:8989/xxx/users	在所有用户中增加一个
PUT	http://localhost:8989/xxx/users	在所有用户中修改一个
DELETE	http://localhost:8989/xxx/users/1	删除用户1
GET	http://localhost:8989/xxx/users/1	查询用户1
GET	http://localhost:8989/xxx/users/1/orders	查询用户1的所有订单
POST	http://localhost:8989/xxx/users/1/orders	在用户1的所有订单中增加一个

13.3 使用

13.3.1 定义Rest风格的 Controller

@RequestMapping(value=“/users”,method = RequestMethod.GET)

等价

@GetMapping(“/users”)

@RestController
@RequestMapping("rest")
public class RestfulController {

    @GetMapping("/users")
    public List<User> queryAllUsers(){
        System.out.println("get");
        List<User> users = new ArrayList<>();
        users.add(new User(11,"zs","sz",new Date(),110.0));
        return users;
    }

    @PostMapping("/users")
    public String addUser(@RequestBody User user){
        System.out.println("Post user :"+user);
        return "{status:1}";
    }

    @PutMapping("/users")
    public String updateUser(@RequestBody User user){
        System.out.println("Put user:"+user);
        return "{status:1}";
    }

    @GetMapping("/users/{id}")
    public String queryOneUser(@PathVariable Integer id){//@PathVariable 接收路径中的值
        System.out.println("Get user id:"+id);
        return "{status:1}";
    }

    @DeleteMapping("/users/{id}")
    public String deleteOneUser(@PathVariable Integer id){//@PathVariable 接收路径中的值
        System.out.println("delete user id:"+id);
        return "{status:1}";
    }
}

13.3.2 Ajax请求

<script>    
	function putUser(){ // 发送更新请求 （增加请求发送方式也是如此）
        var xhr = new XMLHttpRequest();
    	//定义 put，delete,get,post方式 即可，不用定义_method
        xhr.open("put","${pageContext.request.contextPath}/rest/users");
    	// 设置请求头
        xhr.setRequestHeader("content-type","application/json")；
        // 设置请求参数
        var user = {id:1，NAME:"shine"，city:"bj"，"birth":"2020/12/12"，"salary":100.5};
        /*将对象转成字符串*/
        xhr.send(JSON.stringify(user));
        xhr.onreadystatechange=function(){
            if(xhr.readyState==4 && xhr.status==200){
                var ret = xhr.responseText;
                // 解析json，将字符串转成对象，并输出
                console.log(JSON.parse(ret));
            }
        }
    	/*$.ajax({
            url:'${pageContext.request.contextPath}/rest04/users',
            type:'put',
            contentType:"application/json",//声明请求参数类型为 json
            data:JSON.stringify(user),// 转换js对象成json
            success:function(ret){
                console.log(JSON.parse(ret));
            }
        });*/
    }

	function delUser(){  // 发送删除请求
        var xhr = new XMLHttpRequest();
        //定义 put，delete,get,post方式 即可，不用定义_method
        xhr.open("delete","${pageContext.request.contextPath}/rest/users/1");
        xhr.send();
        xhr.onreadystatechange=function(){
            if(xhr.readyState==4 && xhr.status==200){
                var ret = xhr.responseText;
                console.log(JSON.parse(ret));
            }
        }
    }
</script>

十四、跨域请求

14.1 域

域：协议+IP+端口

http://localhost:8989

http://localhost:8080

http://www.baidu.com:80

14.2 Ajax跨域问题

Ajax发送请求时，不允许跨域，以防用户信息泄露。

当Ajax跨域请求时，响应会被浏览器拦截(同源策略)，并报错。即浏览器默认不允许ajax跨域得到响应内容。

互相信任的域之间如果需要ajax访问，(比如前后端分离项目中，前端项目和后端项目之间)，则需要额外的设置才可正常请求。

14.3 解决方案

允许其他域访问
在被访问方的Controller类上，添加注解
例如：访问hello-springmvc项目中的接口

@RequestMapping("json")
@CrossOrigin(allowCredentials = "true") //加此注解允许跨域访问
public class JsonController {

    @RequestMapping(value = "/test1")
    @ResponseBody
    public User hello1(){
        System.out.println("hello world");
        User user = new User(22,null,new Date(),true,new ArrayList<>());
        return user;
    }
}

携带对方cookie，使得session可用

在访问方，ajax中添加属性：withCredentials: true

 $.ajax({
     type: "GET",
     url: "http://localhost:8989/json/test1",
     xhrFields: {
         // 跨域携带cookie
         withCredentials: true
     },
     success:function(data){
         console.log(data);
     }
  });
或
var xhr = new XMLHttpRequest();
// 跨域携带cookie
xhr.withCredentials=true;

十五、Spring整合

15.1 整合思路

此时项目中有两个工厂

DispatcherServlet 启动的springMVC工厂==负责生产C及springMVC自己的系统组件
ContextLoaderListener 启动的spring工厂==负责生产其他所有组件
springMVC的工厂会被设置为spring工厂的子工厂，可以随意获取spring工厂中的组件
整合过程，就是累加：代码+依赖+配置。然后将service注入给controller即可

15.2 整合技巧

两个工厂不能有彼此侵入，即，生产的组件不能有重合。

<!-- 告知SpringMVC  哪些包中 存在 被注解的类
	use-default-filters=true 凡是被 @Service  @Repository注解的类，都会被扫描
	use-default-filters=false 默认不扫描包内的任何类, 只扫描include-filter中指定的类
	只扫描被@Controller注解的类
-->
<context:component-scan base-package="com.qf" use-default-filters="false">
 	<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

<!-- 告知Spring
     唯独不扫描@Controller注解的类 -->
<context:component-scan base-package="com.qf" use-default-filters="true">
	<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

applicationContext.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:tx="http://www.springframework.org/schema/tx"
       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/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 告知Spring
     唯独不扫描@Controller注解的类 -->
    <context:component-scan base-package="com.qf" use-default-filters="true">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!--配置文件参数化（参数占位符）-->
    <context:property-placeholder location="classpath:jdbc.properties" />

    <!--与DruidDataSource集成（二选一）-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <!--基本配置-->
        <property name="driverClassName" value="${jdbc.driverClass}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!-- 工厂bean：生成SqlSessionFactory -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 注入连接池 -->
        <property name="dataSource" ref="dataSource"></property>
        <!-- 注入dao-mapper文件信息 ,如果映射文件和dao接口 同包且同名，则此配置可省略-->
        <property name="mapperLocations">
            <list>
                <value>classpath:com/qf/dao/*.xml</value>
            </list>
        </property>

        <property name="typeAliasesPackage" value="com.qf.entity"></property>
        
        <!--分页插件-->
        <property name="plugins">
            <array>
                <bean class="com.github.pagehelper.PageInterceptor"/>
            </array>
        </property>
    </bean>

    <!-- mapperScannerConfigurer -->
    <bean id="mapperScannerConfigurer9" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- dao接口所在的包  如果有多个包，可以用逗号或分号分隔
           <property name="basePackage" value="com.a.dao,com.b.dao"></property>
        -->
        <property name="basePackage" value="com.qf.dao"></property>
        <!-- 如果工厂中只有一个SqlSessionFactory的bean，此配置可省略 -->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
    </bean>

    <!-- 1. 引入一个事务管理器，其中依赖DataSource,借以获得连接，进而控制事务逻辑 -->
    <bean id="tx" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <tx:advice id="txManager" transaction-manager="tx">
        <tx:attributes>
            <!-- 切入此方法时，采用对应事务实行-->
            <tx:method name="get*" read-only="true"/>
            <tx:method name="query*" read-only="true"/>
            <!-- 剩余所有方法 -->
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>


    <aop:config>
        <aop:pointcut expression="execution(* com.qf.service..*.*(..))" id="pc"/>
        <!-- 组织切面 -->
        <aop:advisor advice-ref="txManager" pointcut-ref="pc"/>
    </aop:config>

</beans>

springmvc.xml配置文件

<beans 	xmlns="http://www.springframework.org/schema/beans"
          xmlns:context="http://www.springframework.org/schema/context"
          xmlns:mvc="http://www.springframework.org/schema/mvc"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          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/mvc
         http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 告知springmvc  哪些包中 存在 被注解的类 -->
    <context:component-scan base-package="com.qf" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!--放行静态资源 -->
    <mvc:default-servlet-handler/>

    <!-- 注册注解开发驱动 -->
    <mvc:annotation-driven/>
    <!-- 视图解析器
         作用：1.捕获后端控制器的返回值="index"
              2.解析： 在返回值的前后 拼接 ==> "/index.jsp"
     -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/"></property>
        <!-- 后缀 -->
        <property name="suffix" value=".jsp"></property>
    </bean>

</beans>

jdbc.properties文件

#jdbc.properties
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis_orm
jdbc.username=root
jdbc.password=123

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_3_1.xsd"
         version="3.1">

  <!-- 加载spring主配置文件，启动spring容器 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

  <servlet>
    <servlet-name>mvc</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启动时刻：可选 -->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>mvc</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

  <!-- 此过滤器会进行：request.setCharactorEncoding("utf-8"); -->
  <filter>
    <filter-name>encoding</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>
  </filter>
  <filter-mapping>
    <filter-name>encoding</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

</web-app>

jdbc.password=123

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_3_1.xsd"
         version="3.1">

  <!-- 加载spring主配置文件，启动spring容器 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

  <servlet>
    <servlet-name>mvc</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启动时刻：可选 -->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>mvc</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

  <!-- 此过滤器会进行：request.setCharactorEncoding("utf-8"); -->
  <filter>
    <filter-name>encoding</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>
  </filter>
  <filter-mapping>
    <filter-name>encoding</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

</web-app>