Spring MVC

志合者，不以山海为远；道乖者，不以咫尺为近

1. MVC简介

1.1 定义

MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范，MVC不是一种设计模式，MVC是一种架构模式

1.2 背景

Model1时代：主要分为两层，视图层和模型层。逻辑基本在jsp上。jsp本质是一个Servlet
Model2时代：MVC：模型(dao、service) 视图(jsp) 控制器(Servlet)，最典型的MVC就是JSP + servlet + javabean的模式。

1.3 功能

将url映射到java类或java类的方法
封装用户提交的数据
处理请求–调用相关的业务处理–封装响应数据
将响应的数据进行渲染 . jsp / html 等表示层数据

1.4 常见框架

常见的服务器端MVC框架有：Struts、Spring MVC、ASP.NET MVC、Zend Framework、JSF
常见前端MVC框架：vue、angularjs、react、backbone；
MVC演化出了另外一些模式如：MVP、MVVM【前后端分离核心】等

2. Spring MVC概述

2.1 定义

官网

Spring MVC是Spring Framework的一部分，是基于Java实现MVC的轻量级Web框架。

2.2 特点

与Spring无缝结合，可以将mvc的bean注册到Spring，使用人多
约定优于配置
功能多：RESTful、数据验证、格式化、本地化、主题等
Spring的web框架围绕DispatcherServlet [ 调度Servlet ] 设计，DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类）

1
2
3

1. public class DispatcherServlet extends FrameworkServlet
2. public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {
3. public abstract class HttpServletBean extends HttpServlet implements EnvironmentCapable, EnvironmentAware {

2.3 Spring MVC原理和流程

当发起请求时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图渲染视图结果，将结果返回给中心控制器，再将结果返回给请求者

Spring MVC原理和流程图

DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。
- 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">

    <!--配置DispatcherServlet ：这个是SpringMVC的核心：请求分发器，前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--DispatcherServlet要绑定Spring 的配置文件-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--启动级别：1-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!--
       在SpringMVC中 ，/  /*
       /：只匹配所有的请求，不包括jsp页面
       /*：匹配所有的请求，包括jsp页面,可能会404不建议
   -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

<!--    <servlet>-->
<!--        <servlet-name>hello</servlet-name>-->
<!--        <servlet-class>cn.xxy.servlet.HelloServlet</servlet-class>-->
<!--    </servlet>-->
<!--    <servlet-mapping>-->
<!--        <servlet-name>hello</servlet-name>-->
<!--        <url-pattern>/hello</url-pattern>-->
<!--    </servlet-mapping>-->
    
<!--    <session-config>-->
<!--        <session-timeout>15</session-timeout>-->
<!--    </session-config>-->
<!--    -->
    <welcome-file-list>
        <welcome-file>form.jsp</welcome-file>
    </welcome-file-list>
</web-app>

HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url查找Handler。
- springmvc-servlet.xml【接口版】
缺点：一个控制器中只有一个方法handleRequest，不方便

@FunctionalInterface
public interface Controller {
    @Nullable
    ModelAndView handleRequest(HttpServletRequest var1, HttpServletResponse var2) throws Exception;
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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">

    <!--添加 处理映射器-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    <!--添加 处理器适配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
    <!--视图解析器:DispatcherServlet给他的ModelAndView
     视图解析器：模板引擎 Thymeleaf  Freemarker ...
     -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
    <!--Handler-->
    <bean id="/hello" class="cn.xxy.controller.HelloController"/>

</beans>

springmvc-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:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="1http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        https://www.springframework.org/schema/mvc/spring-mvc.xsd">
 
    <!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
    <context:component-scan base-package="com.kuang.controller"/>
    <!-- 让Spring MVC不处理静态资源 -->
    <mvc:default-servlet-handler />
    <!--
    支持mvc注解驱动
        在spring中一般采用@RequestMapping注解来完成映射关系
        要想使@RequestMapping注解生效
        必须向上下文中注册DefaultAnnotationHandlerMapping
        和一个AnnotationMethodHandlerAdapter实例
        这两个实例分别在类级别和方法级别处理。
        而annotation-driven配置帮助我们自动完成上述两个实例的注入。
     -->
    <mvc:annotation-driven />
 
    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/" />
        <!-- 后缀 -->
        <property name="suffix" value=".jsp" />
    </bean>
 
 </beans>

HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为：hello
HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。
HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。
Handler让具体的Controller执行。
- HelloController【接口版】

package cn.xxy.controller;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

//注意：这里我们先导入Controller接口
public class HelloController implements Controller {

    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //ModelAndView 模型和视图
        ModelAndView mv = new ModelAndView();
        //调用业务层
        //封装对象，放在ModelAndView中。Model
        mv.addObject("msg", "HelloSpringMVC!");
        //封装要跳转的视图，放在ModelAndView中
        mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
        return mv;
    }

}

HelloController【注解版】

package cn.xxy.controller;

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


@Controller
@RequestMapping("/hello2")
public class HelloController2 {
    @RequestMapping("/h2")
    public String hello(Model model) {
        model.addAttribute("msg", "helloannotion");
        return "hello";
    }

}

Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。
HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。
DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名
视图解析器将解析的逻辑视图名传给DispatcherServlet。
DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。
最终视图呈现给用户

2.4 RestFul 风格【不是标准】

Restful就是一个资源定位及资源操作的风格。请求地址一样，但是功能可以不同！不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制

资源操作：使用POST、DELETE、PUT、GET，使用不同方法对资源进行操作，分别对应添加、删除、修改、查询。
注解有：

@PathVariable //路经变量，放参数旁边
@RequestMapping(value = "/add/{p1}/{p2}")
    @GetMapping("/add/{p1}/{p2}") // 等同于   @RequestMapping(value = "/add/{p1}/{p2}",method = RequestMethod.GET)，下面同理
    @PostMapping("/add/{p1}/{p2}")
    @DeleteMapping("/add/{p1}/{p2}")
    @PutMapping("/add/{p1}/{p2}")

2.5 页面跳转方式

ModelAndView： {视图解析器前缀} + viewName +{视图解析器后缀}

没有解耦

<!-- 视图解析器 -->
 <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
      id="internalResourceViewResolver">
    <!-- 前缀 -->
    <property name="prefix" value="/WEB-INF/jsp/" />
    <!-- 后缀 -->
    <property name="suffix" value=".jsp" />
 </bean>

public class ControllerTest1 implements Controller {
 
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //返回一个模型视图对象
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","ControllerTest1");
        mv.setViewName("test");
        return mv;
   }
 }

ServletAPI

不需要视图解析器 ,不建议使用,通过HttpServletResponse进行输出,通过HttpServletResponse实现重定向,通过HttpServletResponse实现转发

@Controller
 public class ResultGo {
 
    @RequestMapping("/result/t1")
    public void test1(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
        rsp.getWriter().println("Hello,Spring BY servlet API");
   }
 
    @RequestMapping("/result/t2")
    public void test2(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
        rsp.sendRedirect("/index.jsp");
   }
 
    @RequestMapping("/result/t3")
    public void test3(HttpServletRequest req, HttpServletResponse rsp) throws Exception {
        //转发
        req.setAttribute("msg","/result/t3");
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,rsp);
   }
 
 }

SpringMVC

无视图解析器

@Controller
 public class ResultSpringMVC {
    @RequestMapping("/rsm/t1")
    public String test1(){
        //转发
        return "/index.jsp";
   }
 
    @RequestMapping("/rsm/t2")
    public String test2(){
        //转发二
        return "forward:/index.jsp";
   }
 
    @RequestMapping("/rsm/t3")
    public String test3(){
        //重定向
        return "redirect:/index.jsp";
   }
 }

有视图解析器

@Controller
 public class ResultSpringMVC2 {
    @RequestMapping("/rsm2/t1")
    public String test1(){
        //转发
        return "test";
   }
 
    @RequestMapping("/rsm2/t2")
    public String test2(){
        //重定向
        return "redirect:/index.jsp";
        //return "redirect:hello.do"; //hello.do为另一个请求/
   }
 
 }

对比Model ，ModelMap ，ModelAndView

序号	名称	功能
1	Model	只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解；
2	ModelMap	继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特性
3	ModelAndView	可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转，但没有解耦

2.6 接收参数并绑定

注解

通过如HttpServletRequest等API得到请求数据，但推荐使用注解方式

序号	注解	功能
1	@RequestParam	绑定单个请求参数值
2	@PathVariable	绑定URI模板变量值
3	@CookieValue	绑定Cookie数据值
4	@RequestHeader	绑定请求头数据
5	@ModelValue	绑定参数到命令对象
6	@SessionAttributes	绑定命令对象到session
7	@RequestBody	绑定请求的内容区数据并能进行自动类型转换等,例如JSON和RESTful风格
8	@RequestPart	绑定“multipart/data”数据，一般上传和下载

单个请求参数值

@RequestParam(value=”user_id”)

@RequestMapping("/selectUser")
public String selectUser(@RequestParam(value="user_id")Integer id) {
    System.out.println("id="+id);
    return "success";
}

对象实体

直接对象放入参数User user,前端传递的参数名和对象名必须一致

@RequestMapping("/registerUser")
public String registerUser(User user) {
    	System.out.println(user);
       return "success";
}

2.7 乱码

前端乱码【过滤器】

<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>

Tomcat乱码【修改配置文件】

1
2
3

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

json乱码

<mvc:annotation-driven>
    <mvc:message-converters register-defaults="true">
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
            <constructor-arg value="UTF-8"/>
        </bean>
        <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            <property name="objectMapper">
                <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                    <property name="failOnEmptyBeans" value="false"/>
                </bean>
            </property>
        </bean>
    </mvc:message-converters>
 </mvc:annotation-driven>

自定义编码

package cn.xxy.filter;
 
 import javax.servlet.*;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletRequestWrapper;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.io.UnsupportedEncodingException;
 import java.util.Map;
 
 /**
 * 解决get和post请求 全部乱码的过滤器
 */
 public class GenericEncodingFilter implements Filter {
 
    @Override
    public void destroy() {
   }
 
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        //处理response的字符编码
        HttpServletResponse myResponse=(HttpServletResponse) response;
        myResponse.setContentType("text/html;charset=UTF-8");
 
        // 转型为与协议相关对象
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        // 对request包装增强
        HttpServletRequest myrequest = new MyRequest(httpServletRequest);
        chain.doFilter(myrequest, response);
   }
 
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
   }
 
 }
 
 //自定义request对象，HttpServletRequest的包装类
 class MyRequest extends HttpServletRequestWrapper {
 
    private HttpServletRequest request;
    //是否编码的标记
    private boolean hasEncode;
    //定义一个可以传入HttpServletRequest对象的构造函数，以便对其进行装饰
    public MyRequest(HttpServletRequest request) {
        super(request);// super必须写
        this.request = request;
   }
 
    // 对需要增强方法 进行覆盖
    @Override
    public Map getParameterMap() {
        // 先获得请求方式
        String method = request.getMethod();
        if (method.equalsIgnoreCase("post")) {
            // post请求
            try {
                // 处理post乱码
                request.setCharacterEncoding("utf-8");
                return request.getParameterMap();
           } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
           }
       } else if (method.equalsIgnoreCase("get")) {
            // get请求
            Map<String, String[]> parameterMap = request.getParameterMap();
            if (!hasEncode) { // 确保get手动编码逻辑只运行一次
                for (String parameterName : parameterMap.keySet()) {
                    String[] values = parameterMap.get(parameterName);
                    if (values != null) {
                        for (int i = 0; i < values.length; i++) {
                            try {
                                // 处理get乱码
                                values[i] = new String(values[i]
                                       .getBytes("ISO-8859-1"), "utf-8");
                           } catch (UnsupportedEncodingException e) {
                                e.printStackTrace();
                           }
                       }
                   }
               }
                hasEncode = true;
           }
            return parameterMap;
       }
        return super.getParameterMap();
   }
 
    //取一个值
    @Override
    public String getParameter(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        if (values == null) {
            return null;
       }
        return values[0]; // 取回参数的第一个值
   }
 
    //取所有值
    @Override
    public String[] getParameterValues(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        return values;
   }
 }

2.8 JSON

定义

JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式,独立于编程语言的文本格式来存储和表示数据

格式

var obj = {a: 'Hello', b: 'World'}; //这是一个对象，注意键名也是可以使用引号包裹的
 var json = '{"a": "Hello", "b": "World"}'; //这是一个 JSON 字符串，本质是一个字符串
var obj = JSON.parse('{"a": "Hello", "b": "World"}');//JSON字符串转换为JavaScript 对象
var json = JSON.stringify({a: 'Hello', b: 'World'});//JavaScript 对象转换为JSON字符串

注解

序号	名称	功能
1	@ResponseBody	直接返回json对象，用于method
2	@RequestBody	用于请求的数据绑定到方法的形参中，用于形参上
3	@RestController	里面所有的方法都只会返回 json 字符串，不用再每一个方法都添加@ResponseBody

开发测试

导包【jackson\fastjson】

<dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson-databind.version}</version>
        </dependency>

实体类

package cn.xxy.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private int age;
    private String sex;

}

Controller类

package cn.xxy.controller;


import cn.xxy.pojo.User;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/json1")
    //不会走视图解析器，会直接返回一个字符串,配合Controller使用！
    @ResponseBody
    public String json1() throws JsonProcessingException {
        //创建一个jackson的对象映射器，用来解析数据 jackson  ObjectMapper
        ObjectMapper mapper = new ObjectMapper();
        //创建一个对象
        User user = new User("xxy", 3, "男");
        //将我们的对象解析成为json格式
        String str = mapper.writeValueAsString(user);
        //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
        return str;
    }
}

json乱码
- 第一种解决

1 2	//produces:指定响应体返回类型和编码 @RequestMapping(value = "/json1",produces = "application/json;charset=utf-8")

第二种解决

<mvc:annotation-driven>
    <mvc:message-converters register-defaults="true">
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
            <constructor-arg value="UTF-8"/>
        </bean>
        <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            <property name="objectMapper">
                <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                    <property name="failOnEmptyBeans" value="false"/>
                </bean>
            </property>
        </bean>
    </mvc:message-converters>
 </mvc:annotation-driven>

日期优化(getjson作为一个工具类)

package cn.xxy.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

import java.text.SimpleDateFormat;
import java.util.logging.SimpleFormatter;

public class JsonUtil {
//重载
    public static String getJson(Object object) {
        return getJson(object,"yyyy-MM-dd HH:mm:ss");
    }

    private static String getJson(Object object, String s) {
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(s);
        objectMapper.setDateFormat(simpleDateFormat);
        try {
            return objectMapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
}

fastjson
- 导包

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>${fastjson.version}</version>
</dependency>

测试

package cn.xxy.controller;


import cn.xxy.pojo.User;
import cn.xxy.utils.JsonUtil;
import com.alibaba.fastjson.JSON;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;

@RestController
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/json1")
    //不会走视图解析器，会直接返回一个字符串,配合Controller使用！
    public String json1() throws JsonProcessingException {
        //创建一个对象
//        User user = new User("xxy", 3, "男");
        Date date = new Date();
        //将我们的对象解析成为json格式
        String str = JsonUtil.getJson(date);
        //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
        return str;
    }
    @RequestMapping("/json2")
    public String json2() {
        User user = new User("xxy", 3, "男");
        return JSON.toJSONString(user);
    }
}

2.9 Ajax【 Asynchronous JavaScript and XML】

概述

使用ajax技术的网页，通过在后台服务器进行少量的数据交换，就可以实现异步局部更新,框架一般用AXIOS库来使用ajax

jQuery库的ajax

jQuery Ajax本质就是 XMLHttpRequest，对他进行了封装，

jQuery.ajax(...)
       部分参数：
             url：请求地址
             type：请求方式，GET、POST(1.9.0之后用method)
         headers：请求头
             data：要发送的数据
     contentType：即将发送信息至服务器的内容编码类型(默认: "application/x-www-form-urlencoded; charset=UTF-8")
           async：是否异步
         timeout：设置请求超时时间(毫秒)
       beforeSend：发送请求前执行的函数(全局)
         complete：完成之后执行的回调函数(全局)
         success：成功之后执行的回调函数(全局)
           error：失败之后执行的回调函数(全局)
         accepts：通过请求头发送给服务器，告诉服务器当前客户端可接受的数据类型
         dataType：将服务器端返回的数据转换成指定类型
           "xml": 将服务器端返回的内容转换成xml格式
           "text": 将服务器端返回的内容转换成普通文本格式
           "html": 将服务器端返回的内容转换成普通文本格式，在插入DOM中时，如果包含JavaScript标签，则会尝试去执行。
         "script": 尝试将返回值当作JavaScript去执行，然后再将服务器端返回的内容转换成普通文本格式
           "json": 将服务器端返回的内容转换成相应的JavaScript对象
         "jsonp": JSONP 格式使用 JSONP 形式调用函数时，如 "myurl?callback=?" jQuery 将自动替换 ? 为正确的函数名，以执行回调函数

测试

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
  <title>$Title$</title>
  <%--加载动态的JQ资源--%>
  <script src="https://code.jquery.com/jquery-3.4.1.js"></script>
  <script>
    /*
    AJax后盾必须懂的东西：
    url：后端接受的地址
    data：后端接受到的请求参数，json数据格式=前后端分离时候，后端传的数据便于前端接受就是json数据
    success:后端接受成功返回的函数
    error:后盾失败接受返回的函数
    */
    function username() {
      $.post({
        url: "${pageContext.request.contextPath}/a1",
        data: {"name": $("#username").val()},
        success: function (data, status) {
          alert(data);
          console.log("data:" + data);
          console.log("status:" + status);
        },
        error:function (e){
          alert("error" + e);
        }
      })
    }

  </script>
</head>
<body>
<%--实现Ajax异步请求
1 绑定单击事件
2 单击事件函数使用Jq：$.post({})
--%>
用户名:<input type="text" id="username" onclick="username()">
</body>
</html>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
  <title>$Title$</title>
  <%--加载动态的JQ资源--%>
  <script src="https://code.jquery.com/jquery-3.4.1.js"></script>
  <script>
    /*
    AJax后盾必须懂的东西：
    url：后端接受的地址
    data：后端接受到的请求参数，json数据格式=前后端分离时候，后端传的数据便于前端接受就是json数据
    success:后端接受成功返回的函数
    error:后盾失败接受返回的函数
    */
    function username() {
      $.post({
        url: "${pageContext.request.contextPath}/a1",
        data: {"name": $("#username").val()},
        success: function (data, status) {
          alert(data);
          console.log("data:" + data);
          console.log("status:" + status);
        },
        error:function (e){
          alert("error" + e);
        }
      })
    }

  </script>
</head>
<body>
<%--实现Ajax异步请求
1 绑定单击事件
2 单击事件函数使用Jq：$.post({})
--%>
用户名:<input type="text" id="username" onclick="username()">
</body>
</html>

@Controller
public class AjaxController {
    @RequestMapping("/a1")
    public void ajax1(String name , HttpServletResponse response) throws IOException {
        if ("admin".equals(name)){
            response.getWriter().print("true");
        }else{
            response.getWriter().print("false");
        }
    }
}

2.10 拦截器

必须实现 HandlerInterceptor 接口

概述

拦截器类似于Servlet开发中的过滤器Filter,用于对处理器进行预处理和后处理

2.过滤器与拦截器的区别

拦截器是AOP思想的具体应用
过滤器在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截，任何java web工程都可以使用
拦截器只会拦截访问的控制器方法，如果访问的是jsp/html/css/image/js是不会进行拦截的，只有使用了SpringMVC框架才能使用

测试

public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //return true：执行下一个拦截器
        System.out.println("===========处理前,这里进行拦截处理=================");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("===========处理后，通常进行日志管理=================");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("===========清洁中=================");
    }
}

<!--拦截器配置-->
<mvc:interceptors>
    <mvc:interceptor>
        <!--
                /**是拦截之后所有的请求，比如/admin/a1/2131
            -->
        <mvc:mapping path="/**"/>
        <bean class="com.ssl.config.MyInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

2.11 文件上传下载

Spring MVC为文件上传提供了直接的支持，这种支持是用即插即用的MultipartResolver实现的。

概述

前端表单设置enctype为multipart/form-data，浏览器即会采用二进制流的方式来处理表单数据，而对于文件上传的处理则涉及在服务器端解析原始的HTTP响应。在2003年，Apache Software Foundation发布了开源的Commons FileUpload组件，其很快成为Servlet/JSP程序员上传文件的最佳选择。

测试上传

pom.xml

<!--文件上传-->
 <dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.3</version>
 </dependency>
 <!--servlet-api导入高版本的-->
 <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
 </dependency>

index.jsp

<form action="/upload" enctype="multipart/form-data" method="post">
  <input type="file" name="file"/>
  <input type="submit" value="upload">
 </form>

springmvc-servlet.xml

id不能变，必须是multipartResolver

<!--文件上传配置-->
 <bean id="multipartResolver"  class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <!-- 请求的编码格式，必须和jSP的pageEncoding属性一致，以便正确读取表单的内容，默认为ISO-8859-1 -->
    <property name="defaultEncoding" value="utf-8"/>
    <!-- 上传文件大小上限，单位为字节(10485760=10M) -->
    <property name="maxUploadSize" value="10485760"/>
    <property name="maxInMemorySize" value="40960"/>
 </bean>

序号	CommonsMultipartResolver类的方法	功能
1	String getOriginalFilename()	获取上传文件的原名
2	InputStream getInputStream()	获取文件流
3	void transferTo(File dest)	将上传文件保存到一个目录文件中

FileController

package cn.xxy.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.commons.CommonsMultipartFile;
import javax.servlet.http.HttpServletRequest;
import java.io.*;

@Controller
public class FileController {
    //@RequestParam("file") 将name=file控件得到的文件封装成CommonsMultipartFile 对象
    //批量上传CommonsMultipartFile则为数组即可
    @RequestMapping("/upload")
    public String fileUpload(@RequestParam("file") CommonsMultipartFile file, HttpServletRequest request) throws IOException {
        //获取文件名 : file.getOriginalFilename();
        String uploadFileName = file.getOriginalFilename();
        //如果文件名为空，直接回到首页！
        if ("".equals(uploadFileName)) {
            return "redirect:/WEB-INF/jsp/shangchuan.jsp";
        }
        System.out.println("上传文件名：" + uploadFileName);
        //上传路径保存设置
        String path = request.getServletContext().getRealPath("/upload");
        //如果路径不存在，创建一个
        File realPath = new File(path);
        if (!realPath.exists()) {
            realPath.mkdir();
        }
        System.out.println("上传文件保存地址：" + realPath);
        InputStream is = file.getInputStream(); //文件输入流
        OutputStream os = new FileOutputStream(new File(realPath, uploadFileName)); //文件输出流
        //读取写出
        int len = 0;
        byte[] buffer = new byte[1024];
        while ((len = is.read(buffer)) != -1) {
            os.write(buffer, 0, len);
            os.flush();
        }
        os.close();
        is.close();
        return "redirect:/index.jsp";
    }
    /*
     * 采用file.Transto 来保存上传的文件
     */
    @RequestMapping("/upload2")
    public String  fileUpload2(@RequestParam("file") CommonsMultipartFile file, HttpServletRequest request) throws IOException {
        //上传路径保存设置
        String path = request.getServletContext().getRealPath("/upload");
        File realPath = new File(path);
        if (!realPath.exists()){
            realPath.mkdir();
        }
        //上传文件地址
        System.out.println("上传文件保存地址：" + realPath);
        //通过CommonsMultipartFile的方法直接写文件(注意这个时候)
        file.transferTo(new File(realPath + "/" + file.getOriginalFilename()));
        return "redirect:/index.jsp";
    }
}

测试下载

@RequestMapping(value = "/download")
  public String downLoad(HttpServletResponse response, HttpServletRequest request) throws IOException {
      //手动设置，要下载的图片地址
      String path = request.getServletContext().getRealPath("/upload");
      String fileName = "1.png";
      //设置响应头
      response.reset();//设置页面不缓存，清空buffer
      response.setCharacterEncoding("UTF-8");
      response.setContentType("multipart/form-data");//二进制传输数据
      response.setHeader("Content-Disposition", "attachment;fileName=" + URLEncoder.encode(fileName, "UTF-8"));
      File file = new File(path, fileName);
      //读取文件-输入流
      InputStream input = new FileInputStream(file);
      //写入文件-输出流
      OutputStream out = response.getOutputStream();
      byte[] buff = new byte[1024];
      int index = 0;
      while ((index = input.read(buff)) != -1) {
          out.write(buff,0,index);
          out.flush();
      }
      input.close();
      out.close();
      return "redirect:/index.jsp";
  }

1	<a href="${pageContext.request.contextPath}/static/1.png">图片下载</a>

3. 总结

本次完成Spring MVC的复习，重点在原理和流程的掌握，三部分：映射器+适配器+前端显示