SpringMVC从入门到入土!

Albert_XZR

于 2020-10-21 14:06:50 发布

阅读量221

点赞数

文章标签： springmvc

本文链接：https://blog.csdn.net/weixin_44582959/article/details/109199919

版权

1.Web、MVC、WebMVC概述
   1)完成一次web请求的过程
       Web浏览器发起请求
       Web服务器接收请求并处理请求,最后产生响应(一般为html)。
       web服务器处理完成后,返回内容给web客户端,客户端对接收的内容进行处理并显示出来。

       从这里可以看出,在web中,都是web客户端发起请求,web服务器接收处理请求并产生响应。
       一般Web服务器是不能主动通知Web客户端更新内容。虽然有些技术可以帮我们实现
       这样的效果,如服务器推技术（Comet）、还有HTML5中的websocket等。

2)MVC模型(Model-View-Controller)
是一种架构型的模式,本身不引入新功能,只是帮助我们将开发的代码结构,组织的更加合理。

       Model(模型)
           数据模型,提供要展示的数据,因此包含数据和行为,行为是用来处理这些数据的。
       不过现在一般都分离开来:Value Object（数据）和服务层（行为）。也就是数据由实
       体类或者javabean来提供,行为由service层来提供.

       View(视图)
           负责进行模型的展示,一般就是我们见到的用户界面,客户想看到的东西。

Controller(控制器)
接收用户请求,委托给模型进行处理,处理完毕后把返回的模型数据交给给视图。也就是说控制器在中间起到一个调度的作用。

在标准的MVC中,模型能主动推数据给视图进行更新(可以采用观察者设计模式实现,在模型上注册视图,当模型更新时自动更新视图),但在Web开发中模型是无法主动推给视图,即无法主动更新用户界面,因为在Web的访问是请求-响应的模式。必须由客户端主动发出请求后,服务器才能把数据返回。

   3)WebMVC
       Web中MVC里面的模型-视图-控制器的概念和标准MVC概念一样,但是在Web MVC模式下,
       模型无法【主动】推数据给视图,如果用户想要视图更新,需要再发送一次请求(即请求-响应模型)。

在我们之前的学习中,其实就是把Servlet作为Controller(控制器),把jsp作为View(视图)
,把javabean作为Model(模型)中的数据,service层作为Model(模型)中的行为.

注意:MVC和三层架构的区别

2.SpringWebMVC概述(SpringMVC)
   1)SpringWebMVC简称SpringMVC
       SpringMVC就是Spring框架提供的一个模块,通过实现MVC模式来很好地将数据、
       业务与展现进行分离,SpringMVC框架的目的是要简化我们日常的Web开发。

       SpringMVC框架跟其他的WebMVC框架一样,都是请求驱动,并且设计围绕一个
       能够分发请求到控制器以及提供其他加快web应用开发功能的核心Servlet(叫做
       DispatcherServlet,即前端控制器)。Spring的DispatcherServlet实现比
       其他框架中还要多的功能。它和spring的ioc容器完全整合,并且允许使用spring
       中其他的所有功能。

       SpringMVC框架设计的一个核心的原则就是"开闭原则",对扩展开放,对修改关闭.
       所以SpringMVC框架中很多方法都是final的,不允许用户随意覆盖,但是却提供给用
       户很多可扩展的机制。SpringMVC目前已经成为非常流行的web应用的框架。

   2)SpringMVC框架的获取
       由于SpringMVC是Spring框架中的一个模块,所以我们下载Spring框架即可,因为里面包含了Spring框架的各个模块的相关东西,当然也包含了SpringMVC的.(jar包、API文档、源代码)

       spring-aop-3.2.4.RELEASE.jar
       spring-aspects-3.2.4.RELEASE.jar
       spring-beans-3.2.4.RELEASE.jar
       spring-context-3.2.4.RELEASE.jar
       spring-context-support-3.2.4.RELEASE.jar
       spring-core-3.2.4.RELEASE.jar
       spring-expression-3.2.4.RELEASE.jar
       spring-instrument-3.2.4.RELEASE.jar
       spring-instrument-tomcat-3.2.4.RELEASE.jar
       spring-jdbc-3.2.4.RELEASE.jar
       spring-jms-3.2.4.RELEASE.jar
       spring-orm-3.2.4.RELEASE.jar
       spring-oxm-3.2.4.RELEASE.jar
       spring-struts-3.2.4.RELEASE.jar
       spring-test-3.2.4.RELEASE.jar
       spring-tx-3.2.4.RELEASE.jar
       spring-web-3.2.4.RELEASE.jar
       spring-webmvc-3.2.4.RELEASE.jar
       spring-webmvc-portlet-3.2.4.RELEASE.jar

   3)SpringMVC框架的核心组件
       1.DispatcherServlet: 前端控制器,用来过滤客户端
       发送过来,想要进行逻辑处理的请求。

       2.Controller/Handler: 控制器/处理器。开发人员
       自定义,用来处理用户请求的,
       并且处理完成之后返回给用户指定视图的对象。

       3.HandlerMapping: 处理器映射器。DispatcherServlet接收到客户端请求的URL
       之后,根据一定的匹配规则,再把请求转发给对应的Handler,这个匹配规则由HandlerMapping决定。

       4.HandlerAdaptor:处理器适配器。处理器适配器用来适配每一个要执行的Handler对象。
       通过HandlerAdapter可以支持任意的类作为处理器

       5.ViewResolver:视图解析器。Handler返回的是逻辑视图名,需要有一个解析器能够将逻辑
       视图名转换成实际的物理视图。而且Spring的可扩展性决定了视图可以由很多种,所以需要不同
       的视图解析器,解析不同的视图。但是一般由jsp充当视图的情况居多

       SpringMVC框架提供一个核心的Servlet对象(DispatcherServlet,前端控制器)来对服务器接
       收到的请求进行解析,当这个请求被DispatcherServlet获取到之后,DispatherServlet需要根
       据HandlerMapping对象的映射关系,将这个请求转交给真正能够处理客户端请求的Controller控制
       器(我们要写的就是这个东西,相当于之前的servlet)来处理。Controller处理完成后返回
       ModelAndView对象,也就是模型和视图的结合体。ViewResolver视图解析器根据ModelAndView
       中的逻辑视图名找到真正的物理视图,同时使用ModelAndView中模型里面的数据对视图进行渲染。
       最后把准备好的视图展现给用户

3.SpringMVC框架在项目中的搭建
   第一步：构建Web项目
   第二步：导入所需jar包
   第三步：配置前端控制器DispatcherServlet
   第四步：编写Controller控制器(也称为Handler处理器)
   第五步：配置处理器映射器(可省去,有默认配置)
   第六步：配置处理器适配器(可省去,有默认配置)
   第七步：配置视图解析器(可省去,有默认配置,但是前缀和后缀都为"")
   第八步：配置处理器

   1)构建Web项目
       在自己Eclipse中创建一个动态web项目(DynamicWebProject),注意JDK版本和项目版本的选择


   2)导入所需的jar包
       在lib目录下放入如下jar包,这是初始jar包,根据后续需求会陆续加入jar包
       commons-logging-1.2.jar
       spring-beans-3.2.4.RELEASE.jar
       spring-context-3.2.4.RELEASE.jar
       spring-core-3.2.4.RELEASE.jar
       spring-expression-3.2.4.RELEASE.jar
       spring-web-3.2.4.RELEASE.jar
       spring-webmvc-3.2.4.RELEASE.jar

3)配置前端控制器DispatcherServlet
SpringMVC的核心控制器就是一个Servlet对象,继承自HttpServlet,所以需要在web.xml文件中配置。

       SpringMVC是Spring提供的一个模块,Spring所有的模块都是基于Spring IOC功能的。所以SpringMVC的DispatcherServlet
       对象在初始化之前也会去实例化Spring的容器对象（ApplicationContext）,那么就需要读取Spring的配置文件。
       默认SpringMVC会在你web应用的WEB-INF目录下查找一个名字为[servlet-name]-servlet.xml文件,
       并且创建在这个文件中定义的bean对象。如果你提供的spring配置文件的名字或者位置和默认的不同,那么需
       要在配置servlet时同时指定配置文件的位置。

       例如:
       <servlet>
           <servlet-name>SpringMVC</servlet-name>
           <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
           <load-on-startup>1</load-on-startup>
       </servlet>
       <servlet-mapping>
           <servlet-name>SpringMVC</servlet-name>
           <url-pattern>*.action</url-pattern>
       </servlet-mapping>

       如上配置,框架会自动去当前应用的WEB-INF目录下查找名字为SpringMVC-servlet.xml文件(默认前缀和<servlet-name>标签中的值一致)。
       也可以自己指定配置文件的名字和位置:

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

       注意:
           配置文件在WEB-INF下:
           <param-value>/WEB-INF/spring-web-mvc.xml</param-value>
           配置文件在classpath下:
           <param-value>classpath:spring-web-mvc.xml</param-value>

       注意:
           <url-pattern>*.action</url-pattern>
           也可以配置成注意这里是/ 不是/*
           <url-pattern>/</url-pattern>

   4)编写Controller控制器
       Controller控制器,是MVC中的部分C,因为此处的控制器主要负责功能处理部分：
       1、收集、验证请求参数并封装到对象上；
       2、将对象交给业务层,由业务对象处理并返回模型数据；
       3、返回ModelAndView(Model部分是业务层返回的模型数据,视图部分为逻辑视图名)。

       前端控制器(DispatcherServlet)主要负责整体的控制流程的调度部分：
       1、负责将请求委托给控制器进行处理；
       2、根据控制器返回的逻辑视图名选择具体的视图进行渲染(并把模型数据传入)。
       因此MVC中完整的C(包含控制逻辑+功能处理)由(DispatcherServlet + Controller)组成。

       Controller接口中只有一个需要实现的方法就是handleRequest方法,
       方法中接收两个参数,分别对应Servlet对象中的request,response对象。可以从request
       中获取客户端提交过来的请求参数。返回值ModelAndView,既包含要返回给客户端浏览
       器的逻辑视图又包含要对视图进行渲染的数据模型。

       例如:
       public class HelloWorldController implements Controller{
           @Override
           public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
               String name = request.getParameter("name");
               //ModelAndView对象中包括了要返回的逻辑视图,以及数据模型
               ModelAndView mv = new ModelAndView();
               //设置逻辑视图名称
               mv.setViewName("hello");
               //设置数据模型
               mv.addObject("name", name);

               return mv;
           }
       }

   5)配置映射器(可省去,有默认配置)
       注意:如果xml文件不能自动提示,那么可以在Eclipse中把schame配置过来即可,schame文件也在下载的spring的压缩包中
       Spring容器需要根据映射器来将用户提交的请求url和后台Controller/Handler进行绑定,所以需要配置映射器。
       例如:
       <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

       BeanNameUrlHandlerMapping：表示将请求的URL和Bean名字映射,如URL为
       "/hello",则Spring配置文件必须有一个名字为"/hello"的Bean.
       注意:这里/代表的含义是url中项目名后面的/

   6)配置适配器(可省去,有默认配置)
       想要正确运行自定义处理器,需要配置处理器适配器,在spring的配置文件中(就是本例中的SpringMVC-servlet.xml),进行如下配置：

       <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

SimpleControllerHandlerAdapter：表示所有实现了org.springframework.web.servlet.mvc.Controller
接口的Bean可以作为SpringMVC中的处理器。如果需要其他类型的处理器可以通过实现HadlerAdapter来解决。

   7)配置视图解析器(可省去,有默认配置,但是前缀和后缀都为"")
       当处理器执行完成后,返回给spring容器一个ModelAndView对象,这个对象需要能够被解析成与之相对应的视图,并且
       使用返回的Model数据对视图进行渲染。

       <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
           <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
           <property name="prefix" value="/WEB-INF/jsp/"/>
           <property name="suffix" value=".jsp"/>
       </bean>

       如果配置设置为如上操作,那么在自定义的Handler中返回的视图的名字不能有后缀.jsp,并且页面一定放在/WEB-INF目录下。

       InternalResourceViewResolver：用于支持Servlet、JSP视图解析；
       viewClass：JstlView表示JSP模板页面需要使用JSTL标签库,classpath中必须包含jstl的相关jar包；
       prefix和suffix：视图页面的前缀和后缀(前缀+逻辑视图名+后缀),比如传进来的逻辑视图名为hello,则该该jsp视图页面应该存放在"WEB-INF/jsp/hello.jsp"

       注意:放在WEB-INF下的页面,只能通过内部跳转的方式访问到,因为客户端访问不到WEB-INF目录,而且服务器端可以访问到WEB-INF目录
       注意:需要引入jstl相关jar包
       注意:页面中的路径问题
           <%
               String path = request.getContextPath();
               String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
           %>

   8)配置处理器
       把编写好的handler/controller在spring中进配置,让其接受Spring IoC容器管理
       <bean name="/hello.action" class="com.briup.web.controller.HelloWorldController"/>

注意: 对于Spring配置文件中的处理器适配器,处理器映射器,都可以省去不写,springMVC框架中会有默认配置的,视图解析器也可以不配置,因为在org.springframework.web.servlet.DispatcherServlet这个类的同包下,有一个DispatcherServlet.properties文件,里面就是SpringMVC默认的配置,是当用户的Spring配置文件中没有指定配置时使用的默认策略(你不配置那么用户默认的,你配置了,那么就使用你的配置)

   从默认的配置中可以看出DispatcherServlet在启动时会自动注册这些特殊的Bean,无需我们注册,如果我们注册了,默认的将不会注册。

   因此之前的BeanNameUrlHandlerMapping、SimpleControllerHandlerAdapter是不需要注册的,DispatcherServlet默认会注册这两个Bean。

   整个访问的流程:
   1、首先用户发送请求,前端控制器DispatcherServlet收到请求后自己不进行处理，而是委托给其他的解析器进行处理，前端控制器作为统一访问点，进行全局的流程控制；
   2、 DispatcherServlet把请求转交给HandlerMapping， HandlerMapping将会把请求映射为HandlerExecutionChain对象(包含一个Handler处理器对象、多个HandlerInterceptor拦截器)对象.(后面会学习到拦截器)
   3、 DispatcherServlet再把请求转交给HandlerAdapter，HandlerAdapter将会把处理器包装为适配器，从而支持多种类型的处理器(适配器模式).简单点说就是让我们知道接下来应该调用Handler处理器里面的什么方法
   4、 HandlerAdapter将会根据适配的结果调用真正的处理器的功能处理方法，完成功能处理；并返回一个ModelAndView对象（包含模型数据、逻辑视图名）；
   5、 ModelAndView的逻辑视图名交给ViewResolver解析器， ViewResolver解析器把逻辑视图名解析为具体的View，通过这种策略模式，很容易更换其他视图技术；
   6、 View会根据传进来的Model模型数据进行渲染，此处的Model实际是一个Map数据结构，因此很容易支持其他视图技术；
   7、最后返回到DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。

4.DispatcherServlet中的映射路径
   <servlet>
       <servlet-name>SpringMVC</servlet-name>
       <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
       <load-on-startup>1</load-on-startup>
   </servlet>
   <servlet-mapping>
       <servlet-name>SpringMVC</servlet-name>
       <url-pattern>/</url-pattern>
   </servlet-mapping>

   1)拦截所有请求
       此处需要特别强调的是 <url-pattern>/</url-pattern>使用的是/,而不是/*,
       如果使用/*,那么请求时可以通过DispatcherServlet转发到相应的Controller中,
       但是Controller返回的时候,如返回的jsp还会再次被拦截,这样导致404错误,即访问不到jsp。

   2)自定义拦截请求
       拦截*.do、*.html、*.action, 例如/user/add.do
       这是最传统的方式,最简单也最实用。不会导致静态文件（jpg,js,css）被拦截。

       拦截/,例如：/user/add
       可以实现REST风格的访问
       弊端：会导致静态文件（jpg,js,css）被拦截后不能正常显示。

拦截/*,这是一个错误的方式,请求可以走到Controller中,但跳转到jsp时再次被拦截,不能访问到jsp。

   3)静态资源的访问,如jpg,js,css
       如果DispatcherServlet拦截"*.do"这样的有后缀的URL,就不存在访问不到静态资源的问题。
   　　如果DispatcherServlet拦截"/",为了实现REST风格,拦截了所有的请求,那么同时对*.js,*.jpg等静态文件的访问也就被拦截了。
       例如:
       <link href="css/hello.css" rel="stylesheet" type="text/css"/>
       <script type="text/javascript" src="js/hello.js"></script>
       <img alt="none" src="images/logo.png">

       解决方式一：利用Tomcat的defaultServlet来处理静态文件
       <servlet-mapping>
           <servlet-name>default</servlet-name>
           <url-pattern>*.jpg</url-pattern>
       </servlet-mapping>

       <servlet-mapping>
           <servlet-name>default</servlet-name>
           <url-pattern>*.js</url-pattern>
       </servlet-mapping>

       <servlet-mapping>
           <servlet-name>default</servlet-name>
           <url-pattern>*.css</url-pattern>
       </servlet-mapping>

       特点：1.要配置多个，每种文件配置一个。
       　　 2.要写在DispatcherServlet的前面(和tomcat版本有关),让defaultServlet先拦截请求,
   这样请求就不会进入Spring了
       　　 3. 高性能。

       解决方式二: 使用<mvc:resources>标签,例如:
       <mvc:resources mapping="/images/**" location="/images/"/>
       <mvc:resources mapping="/js/**" location="/js/"/>
       <mvc:resources mapping="/css/**" location="/css/"/>

       mapping：映射
       两个*,表示映射指定路径下所有的URL,包括子路径
       location：本地资源路径

这样如果有访问/images或者/js或者/css路径下面的资源的时候,spring就不会拦截了

解决方式三: 使用<mvc:default-servlet-handler/>标签
在spring配置文件中加入此标签配置即可

5.spring提供的编码过滤器
   查看这个过滤器类源码便可知这里所传的俩个参数的作用
   <filter>
       <filter-name>CharacterEncodingFilter</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>CharacterEncodingFilter</filter-name>
       <url-pattern>/*</url-pattern>
   </filter-mapping>

1.Controller接口及其实现类
   Controller是控制器接口,此处只有一个方法handleRequest,用于进行请求的功能处理,处理完请求后返回ModelAndView(Model模型数据部分和 View视图部分)。

   如果想直接在处理器/控制器里使用response向客户端写回数据,可以通过返回null来告诉DispatcherServlet我们已经写出响应了,不需要它进行视图解析

Spring默认提供了一些Controller接口的实现类以方便我们使用,在Eclipse中选择Controller接口然后右键open type Hierarchy即可查看改接口的实现类,每个实现类都有自己特殊的功能,这里以实现类AbstractController为例简单介绍下。
查看AbstractController类中代码可知,我们写一个Controller的时候可以继承AbstractController然后实现handleRequestInternal方法即可。

   提供了【可选】的会话的串行化访问功能,例如:
   //即同一会话,线程同步
   public class HelloWorldController extends AbstractController{
       @Override
       protected ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response)
               throws Exception {

           String name = request.getParameter("name");

           //ModelAndView对象中包括了要返回的逻辑视图,以及数据模型
           ModelAndView mv = new ModelAndView();
           //设置视图名称,可以是字符串也可以是视图对象
           mv.setViewName("hello");
           //设置数据模型
           mv.addObject("name", name);

           return mv;
       }

}

   直接通过response写响应,例如:
   public class HelloWorldController extends AbstractController{
       @Override
       protected ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response)
               throws Exception {

           response.getWriter().write("Hello World!!");
           //如果想直接在该处理器/控制器写响应可以通过返回null告诉DispatcherServlet自己已经写出响应了,不需要它进行视图解析

return null;
}

}

   强制请求方法类型,例如:
   //只支持post和get方法
   <bean name="/hello" class="com.briup.web.controller.HelloWorldController">
       <property name="supportedMethods" value="POST,GET"></property>
   </bean>

当前请求的session前置条件检查,如果当前请求无session将抛出HttpSessionRequiredException异常,例如:
//在进入该控制器时,一定要有session存在,否则抛出HttpSessionRequiredException异常。

2.自定义适配器
   一般情况下,springMVCSimpleControllerHandlerAdapter会是我们常用的适配器,也是SpringMVC中默认的适配器,该适配器中的主要代码如下:
   public class SimpleControllerHandlerAdapter implements HandlerAdapter {
       public boolean supports(Object handler) {
           return (handler instanceof Controller);
       }
       public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
               throws Exception {

           return ((Controller) handler).handleRequest(request, response);
       }
   }
   从代码中可以看出,它首先会判断我们的handler是否实现了Controller接口,如果实现了,那么会调用Controller接口中的handleRequest方法

   那么根据这种方式能看出,我们也可以有自己的适配器的实现,那么就可以让任意类成为SpringMVC中的handler了,无论我们的类是否实现了Controller接口

   例如:
       自己的接口:
       public interface MyHandler {
           public ModelAndView handler_test(HttpServletRequest request, HttpServletResponse response)throws Exception;
       }
       自己的适配器:
       public class MyHandlerAdapter implements HandlerAdapter{
           @Override
           public boolean supports(Object handler) {
               return (handler instanceof MyHandler);
           }

           @Override
           public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
                   throws Exception {
               return ((MyHandler)handler).handler_test(request, response);
           }

           @Override
           public long getLastModified(HttpServletRequest request, Object handler) {
               return -1L;
           }

       }

       自己的hander:(就是我们之前写的Controller)
       public class TestController implements MyController{
           @Override
           public ModelAndView handler_test(HttpServletRequest request, HttpServletResponse response) throws Exception {
               String name = request.getParameter("name");
               ModelAndView mv = new ModelAndView("hello");
               mv.addObject("name", name);
               return mv;
           }
       }

最后在spring的配置中把我们的适配器进行配置即可正常使用.

3.处理器拦截器
   SpringMVC的处理器拦截器类似于Servlet 开发中的过滤器Filter,用于对处理器进行预处理和后处理。
   1)常见应用场景
       1、日志记录
       2、权限检查
       3、性能监控
       4、通用行为例如读取用户cookie
       5、OpenSessionInView 例如在Hibernate中,
       在进入处理器前打开Session,在完成后关闭Session。
       等
   2)拦截器接口
       public interface HandlerInterceptor {
           boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)throws Exception;

void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)throws Exception;

void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)throws Exception;
}

       preHandle方法
           预处理回调方法,实现处理器的预处理,第三个参数为的处理器(本次请求要访问的那个Controller)
           返回值:true表示继续流程(如调用下一个拦截器或处理器)
                   false表示流程中断(如登录检查失败),不会继续调用其他的拦截器或处理器,此时我们需要通过response来产生响应

       postHandle方法
           后处理回调方法,实现处理器的后处理(但在渲染视图之前),此时我们可以通过modelAndView对模型数据进行处理或对视图进行处理,modelAndView也可能为null。

       afterCompletion方法
           整个请求处理完毕回调方法,即在视图渲染完毕时回调

   3)拦截器适配器
       有时候我们可能只需要实现三个回调方法中的某一个,如果实现HandlerInterceptor 接口的话,三个方法必须实现,不管你需不需要,此时spring 提供了一个HandlerInterceptorAdapter 适配器(适配器模式),允许我们只实现需要的回调方法。
       在HandlerInterceptorAdapter中,对HandlerInterceptor 接口中的三个方法都进行了空实现,其中preHandle方法的返回值,默认是true

   4)测试一个拦截器
       拦截器代码:
       public class MyInterceptor1 extends HandlerInterceptorAdapter{
           @Override
           public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
                   throws Exception {
               System.out.println("MyInterceptor1 preHandle");
               return true;
           }
           @Override
           public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
                   ModelAndView modelAndView) throws Exception {
               System.out.println("MyInterceptor1 postHandle");
           }
           @Override
           public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
                   throws Exception {
               System.out.println("MyInterceptor1 afterCompletion");
           }
       }

配置文件:
<bean name="handlerInterceptor1" class="com.briup.web.interceptor.MyInterceptor1"/>

       访问一个测试的Controller查看结果:
       MyInterceptor1 preHandle
       TestController执行
       MyInterceptor1 postHandle
       MyInterceptor1 afterCompletion

   5)测试俩个拦截器
       俩个拦截器的代码和上面类似,只是每个输出的内容不同
       配置文件:
       <bean name="handlerInterceptor1" class="com.briup.web.interceptor.MyInterceptor1"/>
       <bean name="handlerInterceptor2" class="com.briup.web.interceptor.MyInterceptor1"/>

       访问一个测试的Controller查看结果:
       MyInterceptor1 preHandle
       MyInterceptor2 preHandle
       TestController执行
       MyInterceptor2 postHandle
       MyInterceptor1 postHandle
       MyInterceptor2 afterCompletion
       MyInterceptor1 afterCompletion

       注意:<list>标签中引用拦截器的顺序会影响结果输出的顺序

   6)如果Controller等采用的注解配置,那么拦截器需要mvc标签进行配置
       注意:每个<mvc:interceptor>只能配置一个拦截器
       <mvc:interceptors>
           <mvc:interceptor>
               <mvc:mapping path="/**"/>
               <ref bean="handlerInterceptor1"/>
           </mvc:interceptor>
       </mvc:interceptors>

例如1: 注意/*和/**的区别
       <mvc:interceptors>
           
           <bean class="com.briup.web.interceptor.MyInterceptor1" />

           <mvc:interceptor>
               <mapping path="/**"/>
               <exclude-mapping path="/admin/**"/>
               <bean class="com.briup.web.interceptor.MyInterceptor2" />
           </mvc:interceptor>
           <mvc:interceptor>
               <mapping path="/secure/*"/>
               <bean class="com.briup.web.interceptor.MyInterceptor3" />
           </mvc:interceptor>
       </mvc:interceptors>

   7)拦截器是单例
       因此不管多少用户请求多少次都只有一个拦截器实现,即线程不安全。
       所以在必要时可以在拦截器中使用ThreadLocal,它是和线程绑定,
       一个线程一个ThreadLocal,A 线程的ThreadLocal只能看到A线程的ThreadLocal,
       不能看到B线程的ThreadLocal。

   8)记录执行Controller所用时间
       public class TimeInterceptor extends HandlerInterceptorAdapter{
           //拦截器是单例,不是线程安全的,所以这里使用ThreadLocal
           private ThreadLocal<Long> local = new ThreadLocal<>();

           @Override
           public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
                   throws Exception {
               long start = System.currentTimeMillis();
               local.set(start);
               return true;
           }
           @Override
           public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
                   throws Exception {
               long end = System.currentTimeMillis();
               System.out.println("共耗时:"+(end-local.get()));
           }
       }

   9)登录检查
       public class LoginInterceptor extends HandlerInterceptorAdapter{
           @Override
           public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
                   throws Exception {
               //请求到登录页面放行
               if(request.getServletPath().startsWith("/login")) {
                   return true;
               }

               //如果用户已经登录放行
               if(request.getSession().getAttribute("username") != null) {
                   return true;
               }

//重定向到登录页面
response.sendRedirect(request.getContextPath() + "/login");

               return false;
           }
       }

注意:推荐能使用servlet规范中的过滤器Filter实现的功能就用Filter实现,因为HandlerInteceptor只有在SpringWebMVC环境下才能使用,因此Filter是最通用的、最先应该使用的。

4.基于注解的SpringMVC

   1)用于支持注解的配置
       使用基于注解的配置可以省略很多操作,更方便。我们之前所看到的所有的xml配置,如果替换成基于注解只需要在spring的xml文件中做如下配置:
       <mvc:annotation-driven/>

       在Spring中,
       处理器列可以使用 @Controller注解
       业务逻辑层可以使用 @Service注解
       数据持久层可以使用 @Repository注解

如果在处理器上使用 @Controller注解,那么还需要在配置文件中指定哪个包下面的类使用了该注解:
<context:component-scan base-package="com.briup.web.controller"></context:component-scan>

   2)基于注解的Controller
       使用注解后,就不需要再实现特定的接口,任意一个javaBean对象都可以当做处理器对象,对象中任意一个方法都可以作为处理器方法。
       只需
           在类上加上 @Controller注解
           方法上加上 @RequestMapping注解
       即可

       例如:
       web.xml中:
       <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-web-mvc.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>

       src下面的spring-web-mvc.xml中:
       <mvc:annotation-driven/>
       <context:component-scan base-package="com.briup.web.controller"></context:component-scan>

       <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
           <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
           <property name="prefix" value="/WEB-INF/jsp/"/>
           <property name="suffix" value=".jsp"/>
       </bean>

       自定义的Controller中:
       @Controller
       public class HomeController {
           @RequestMapping("/home")
           public ModelAndView home(){
               ModelAndView mv = new ModelAndView("index");
               return mv;
           }
       }

       如上代码,使用 @Controller表明HomeController类是一个处理器类,
       通过 @RequestMapping("/home")表明当url请求名为/home时,
       调用home方法执行处理,当处理完成之后返回ModelAndView对象。
       因为在spring-web-mvc.xml中配置了视图解析器的前缀和后缀,所以最后视图home.jsp被返回

3)基于注解的Controller的返回值
1.返回ModelAndView,和之前一样

       2.返回String,表示跳转的逻辑视图名字,模型可以通过参数传过来
           @Controller
           public class HomeController {
               @RequestMapping("/home")
               public String home(Model model){
                   model.addAttribute("msg", "hello world");
                   return "index";
               }
           }

       3.声明返回类型为void
           可以通过参数获取request和response，分别使用服务器内部跳转和重定向，自己来决定要跳转的位置。
           @Controller
           public class HomeController {
               @RequestMapping("/home")
               public void home(HttpServletRequest request,HttpServletResponse response){
                   String username = request.getParameter("username");
                   response.setContentType("text/html;charset=utf-8");
                   response.getWriter().write("hello world! "+username);
                   //或者使用servlet的方式进行跳转/重定向

               }
           }

5.Spring2.5中引入注解对处理器(handler)支持
   @Controller
       用于标识是处理器类；
   @RequestMapping
       请求到处理器功能方法的映射规则；
   @RequestParam
       请求参数到处理器功能处理方法的方法参数上的绑定；
   @ModelAttribute
       请求参数到命令对象的绑定；
   @SessionAttributes
       用于声明session 级别存储的属性,放置在处理器类上,通常列出模型属性(如@ModelAttribute)对应的名称,则这些属性会透明的保存到session 中
   @InitBinder
       自定义数据绑定注册支持,用于将请求参数转换到命令对象属性的对应类型；

6.Spring3引入了更多的注解,其中包含了对RESTful架构风格的支持
   @CookieValue
       cookie数据到处理器功能处理方法的方法参数上的绑定；
   @RequestHeader
       请求头数据到处理器功能处理方法的方法参数上的绑定；
   @RequestBody
       请求的body体的绑定
   @ResponseBody
       处理器功能处理方法的返回值作为响应体
   @ResponseStatus
       定义处理器功能处理方法/异常处理器返回的状态码和原因；
   @ExceptionHandler
       注解式声明异常处理器；
   @PathVariable
       请求URI 中的模板变量部分到处理器功能处理方法的方法参数上的绑定,从而支持RESTful架构风格的URI；

7.Spring3中引入的mvc命名空间
   mvc这个命名空间是在Spring3中引入的,其作用是用来支持mvc的配置
   需要在<bean>中声明出这个命名空间及其对应的schemaLocation中的值
   <mvc:annotation-driven>
       自动注册基于注解风格的处理器和适配器:
       在spring2.5中是DefaultAnnotationHandlerMapping和AnnotationMethodHandlerAdapter

在spring3中是RequestMappingHandlerMapping和RequestMappingHandlerAdapter.
同时还支持各种数据的转换器.

   <mvc:interceptors>
       配置自定义的处理器拦截器,例如:
       <mvc:interceptors>
           <mvc:interceptor>
               <mvc:mapping path="/**"/>
               <ref bean="handlerInterceptor1"/>
           </mvc:interceptor>
       </mvc:interceptors>

   <mvc:view-controller>
       收到相应请求后直接选择相应的视图,例如:
       <mvc:view-controller path="/hello" view-name="test"></mvc:view-controller>

   <mvc:resources>
       逻辑静态资源路径到物理静态资源路径的对应.例如:
       <mvc:resources mapping="/images/**" location="/images/"/>
       <mvc:resources mapping="/js/**" location="/js/"/>
       <mvc:resources mapping="/css/**" location="/css/"/>

   <mvc:default-servlet-handler>
       当在web.xml中DispatcherServlet使用<url-pattern>/</url-pattern> 映射的时候,会静态资源也映射了,如果配置了这个mvc标签,那么再访问静态资源的时候就转交给默认的Servlet来响应静态文件,否则报404 找不到静态资源错误。

8.@Controller和@RequestMapping注解
   1)声明处理器
   @Controller
   public class HelloWorldController {

   }

   2)映射处理器中的【功能处理方法】
   @Controller
   public class HelloWorldController {
       @RequestMapping("/home")
       public ModelAndView home(){
           ModelAndView mv = new ModelAndView("index");
           return mv;
       }
   }

   表明该方法映射的url路径为/home

   3)@RequestMapping也可以写在处理器类上
   @RequestMapping("/test")
   @Controller
   public class HomeController {
       @RequestMapping("/home")
       public ModelAndView home(){
           ModelAndView mv = new ModelAndView("index");
           return mv;
       }
   }
   表明该方法映射的url路径为/test/home

   注意:功能处理方法的方法可以是String类型,表示逻辑视图的名字,可以不用返回ModelAndView对象
   例如:
   @Controller
   public class HelloWorldController {
       @RequestMapping("/home")
       public String home(){
           return "index";
       }
   }

9.请求映射
   假设浏览器发送了一个请求如下:
   -------------------------------
   POST /login   HTTP1.1
   Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
   Accept-Encoding: gzip, deflate
   Accept-Language: zh-CN,en;q=0.8,zh;q=0.5,en-US;q=0.3
   Connection: keep-alive
   Cookie: JSESSIONID=DBC6367DEB1C024A836F3EA35FCFD5A2
   Host: 127.0.0.1:8989
   Upgrade-Insecure-Requests: 1
   User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:49.0) Gecko/20100101 Firefox/49.0

username=tom&password=123
--------------------------------

   http协议的请求格式如下:
   ---------------------------------
   请求方法 URL 协议版本号
   请求头信息
   请求头信息
   请求头信息
   ..
   回车换行
   请求正文
   ---------------------------------

   从格式中我们可以看到【请求方法、URL、请求头信息、请求正文】这四部分一般是可变的,
   因此我们可以把请求中的这些信息在处理器的【功能处理方法】中进行的映射,因此请求的映射分为如下几种:
       URL路径映射
           使用URL映射到处理器的功能处理方法；
       请求方法映射限定
           例如限定功能处理方法只处理GET请求；
       请求参数映射限定
           例如限定只处理包含username参数的请求；
       请求头映射限定
           例如限定只处理"Accept=application/json"的请求。

10.URL路径映射
   1)普通URL路径映射
       @RequestMapping(value="/test")
       @RequestMapping("/hello")
           注解中只出现一个参数且参数名为value的话,可以将参数名去掉
       @RequestMapping(value={"/test", "/user/hello"})
           多个URL路径可以映射到同一个处理器的功能处理方法。

   2)URI模板模式映射
       @RequestMapping(value="/users/{userId}")
           {XXX}占位符, 请求的URL可以是"/users/123456"或"/users/abcd",之后可以通过@PathVariable可以提取URI模板模式中的{XXX}中的值
       @RequestMapping(value="/users/{userId}/create")
           这样也是可以的,请求的URL可以是"/users/123/create"
       @RequestMapping(value="/users/{userId}/topics/{topicId}")
           这样也是可以的,请求的URL可以是"/users/123/topics/123"

   3)Ant风格的URL路径映射
       @RequestMapping(value="/users/**")
           可以匹配"/users/abc/abc",但"/users/123"将会被【URI模板模式映射中的"/users/{userId}"模式优先映射到】
       @RequestMapping(value="/product/?")
           可匹配"/product/1"或"/product/a",但不匹配"/product"或"/product/aa";
           ?代表有且只有一个字符
       @RequestMapping(value="/product*")
           可匹配"/productabc"或"/product",但不匹配"/productabc/abc";
           *代表0~n个字符
       @RequestMapping(value="/product/*")
           可匹配"/product/abc",但不匹配"/productabc";
       @RequestMapping(value="/products/**/{productId}")
           可匹配"/products/abc/abc/123"或"/products/123",也就是Ant风格和URI模板变量风格可混用;
           **代表所有的子路径

   4)正则表达式风格的URL路径映射
       从Spring3.0 开始支持正则表达式风格的URL路径映射,格式为{变量名:正则表达式},
       之后通过@PathVariable可以提取{XXX:正则表达式匹配的值}中的XXX这个变量的值。

       @RequestMapping(value="/products/{categoryCode:\\d+}-{pageNumber:\\d+}")
           可以匹配"/products/123-1",但不能匹配"/products/abc-1",这样可以设计更加严格的规则。
       @RequestMapping(value="/user/{userId:^\\d{4}-[a-z]{2}$}")
           可以匹配"/user/1234-ab"

       注意:\d表示数字,但是\在java的字符串中是特殊字符,所以需要再加一个\进行转义即可
       (参照之前js的学习文档,和java的正则几乎一致,js正则中的一个/变为java中的俩个/即可)
           括号:
               [abc]    查找方括号之间的任何字符。
               [^abc]    查找任何不在方括号之间的字符。
               [0-9]    查找任何从 0 至 9 的数字。
               [a-z]    查找任何从小写 a 到小写 z 的字符。
               [A-Z]    查找任何从大写 A 到大写 Z 的字符。
               [A-z]    查找任何从大写 A 到小写 z 的字符。
               (red|blue|green)    查找任何指定的选项。

           元字符:
               .    查找单个任意字符,除了换行和行结束符.如果要表示.这个字符,需要转义
               \w    查找单词字符。字母数字 _
               \W    查找非单词字符。非字母数字 _
               \d    查找数字。
               \D    查找非数字字符。
               \s    查找空白字符。
               \S    查找非空白字符。
               \b    匹配单词边界。
               \B    匹配非单词边界。
               \0    查找 NUL 字符。
               \n    查找换行符。
               \f    查找换页符。
               \r    查找回车符。
               \t    查找制表符。
               \v    查找垂直制表符。

           量词:
               n+        匹配任何包含至少一个 n 的字符串。
               n*        匹配任何包含零个或多个 n 的字符串。
               n?        匹配任何包含零个或一个 n 的字符串。
               n{X}    匹配包含 X 个 n 的序列的字符串。
               n{X,Y}    匹配包含 X 到 Y 个 n 的序列的字符串。
               n{X,}    匹配包含至少 X 个 n 的序列的字符串。
               n$        匹配任何结尾为 n 的字符串。
               ^n        匹配任何开头为 n 的字符串。
               ?=n    匹配任何其后紧接指定字符串 n 的字符串。
               ?!n    匹配任何其后没有紧接指定字符串 n 的字符串。

       正则表达式风格的URL路径映射是一种特殊的URI模板模式映射
       URI模板模式映射不能指定模板变量的数据类型,如是数字还是字符串；
       正则表达式风格的URL路径映射,可以指定模板变量的数据类型,可以将规则写的相当复杂。

SpringMVC中的数据验证
通常在项目中使用较多的是前端校验，比如页面中js校验。对于安全要求较高的建议在服务端同时校验

   SpringMVC使用hibernate的实现的校验框架validation，所以需要导入相关依赖的jar包
       classmate-1.1.0.jar
       hibernate-validator-5.1.3.Final.jar
       jboss-logging-3.1.4.GA.jar
       validation-api-1.1.0.Final.jar

   数据校验之后,如果有错误信息,那么需要使用spring提供的标签库中的标签在页面中显示校验信息
   <%@taglib prefix="sf" uri="http://www.springframework.org/tags/form" %>

   例如:
       valid.jsp页面主要代码:
       <sf:form method="post" modelAttribute="teacher">
           <sf:label path="name">用户名:</sf:label>
           <sf:input path="name"/>
           <sf:errors path="name" cssStyle="color:red"></sf:errors><br>

           <sf:label path="age"> 年龄:</sf:label>
           <sf:input path="age"/>
           <sf:errors path="age" cssStyle="color:red"></sf:errors><br>

           <sf:label path="dob"> 生日:</sf:label>
           <sf:input path="dob"/>
           <sf:errors path="dob" cssStyle="color:red"></sf:errors><br>

       注意:
       1.需要访问一个Controller再跳转到这个页面,同时需要向模型中添加一个名字叫teacher的对象(这就是我们之前说的命令/表单对象),否则跳转到这个页面的时候会报错
       2.表单中没有这种action属性值,那么默认把数据提交给当前页面,但是提交方式是post
       3.input标签中的path属性的值对应的是表单对象中的属性
       4.Controller中映射的url为:/valid/user/add , 如果是get方式访问这个url那么就把valid.jsp显示给用户,如果是post方式访问这个url,就表示要提交表单的数据。
       5.在Controller中,在需要验证的参数前面加入@Valid注解
       6.方法参数列表中,加入BindingResult对象,用来接收验证的错误信息,并根据这个进行不同情况的跳转
       7.在被验证的表单对象所属类中,给需要验证的属性上加入指定注解

       Controller中代码:

       @Controller
       @RequestMapping("/valid")
       public class ValidController {

           @RequestMapping(value="/user/add", method = {RequestMethod.GET})
           public String test(Model model){
               if(!model.containsAttribute("teacher")){
                   model.addAttribute("teacher", new Teacher());
               }
               return "valid";
           }

           @RequestMapping(value="/user/add",method = {RequestMethod.POST})
           public String addTeacher(@Valid Teacher teacher,BindingResult bindingResult){
               //如果验证数据中有错误信息,将保存在bindingResult对象中
               if(bindingResult.hasErrors()){
                   List<ObjectError> errorList = bindingResult.getAllErrors();
                   for(ObjectError error : errorList){
                       System.out.println(error.getDefaultMessage());
                   }
                   //验证不通过在跳到valid页面,因为页面上有显示错误的标签
                   return "valid";
               }

               //没有错误则跳到hello页面
               return "hello";
           }

       }

       Teacher类中代码:
       public class Teacher {

           private long id;
           @Size(min=5,max=8)
           private String name;
           private Integer age;
           private Date dob;

           get/set
       }


   常用的数据校验的注解

       @Null       值只能为null
       @NotNull   值不能为null
       @NotEmpty   值不为null且不为空
       @NotBlank   值不为null且不为空(先去除首尾空格)
       @Pattern   正则表达式验证
       @Size       限制长度在x和y之间

@Max 最大值
@Min 最小值

@Future 必须是一个将来的日期(和现在比)
@Past 必须是一个过去的日期(和现在比)

@Email 校验email格式

注意:日期属性上要加@DateTimeFormat(pattern="yyyy-MM-dd"),否则页面传的字符串是不能自动转为为日期的,这个注解既能按照我们要求的格式把String转为Date,又能把Date转为String

   SpringMVC中上传
   使用上传功能需要引入俩个jar包:
       commons-fileupload-1.2.2.jar
       commons-io-2.0.1.jar

   利用spring中提供的MultipartFile接口实现上传功能
   MultipartFile类中两个方法区别：
   getName : 获取表单中文件组件的名字
   getOriginalFilename : 获取上传文件的原名
   transferTo(File newFile);把上传的文件转存到指定文件中

spring配置文件中加入以下配置:
   
   
   <bean name="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
   <property name="defaultEncoding" value="UTF-8"/>
   
   <property name="maxUploadSize" value="20000000"/>
   </bean>

   jsp页面代码:
   <form action="upload/test" method="post" enctype="multipart/form-data">
       <input type="file" name="file"><br>
       <input type="file" name="file"><br>
       <input type="submit" value="上传">
   </form>

   Controller中的代码:
   @Controller
   @RequestMapping("/upload")
   public class UploadController {

       @RequestMapping("/show")
       public String showUploadPage(){
           return "upload";
       }

       @RequestMapping("/test")
       public String upload(@RequestParam("file") MultipartFile[] files, HttpServletRequest request) {
           if (files != null && files.length > 0) {
               for (MultipartFile file : files) {
                   // 保存文件
                   saveFile(request, file);
               }
           }
           // 重定向
           return "redirect:/upload/show";
       }

       private void saveFile(HttpServletRequest request, MultipartFile file) {
           // 判断文件是否为空
           if (!file.isEmpty()) {
               try {
                   //保存的文件路径
                   //需要的话可以给文件名上加时间戳
                   String filePath = request.getServletContext().getRealPath("/") + "upload/"
                           + file.getOriginalFilename();
                   File newFile = new File(filePath);
                   //文件所在目录不存在就创建
                   if (!newFile.getParentFile().exists()){
                       newFile.getParentFile().mkdirs();
                   }

                   // 转存文件
                   file.transferTo(newFile);
               } catch (Exception e) {
                   e.printStackTrace();
               }
           }

}

注意:在上传文件的同时,还可以接收其他正常的单个的值,例如username、age等,同时也可以把这些单个的值自动封装成User对象

6.SpringMVC中下载
SpringMVC的下只需要自己设置response信息中的各个部分就可以,可以使用之前学习过的ResponseEntity<T>来完成

   @RequestMapping("/show")
   public String showDownLoadPage(){
       return "download";
   }

   @RequestMapping("/test")
   public ResponseEntity<byte[]> test(String fileName,HttpServletRequest request) throws IOException {
       //获得下载文件所在路径可以指向系统中的任意一个有权访问的路径
       String downLoadPath = request.getServletContext().getRealPath("/download");

//创建要下载的文件对象
File file = new File(downLoadPath,fileName);

//处理一下要下载的文件名字,解决中文乱码
String downFileName = new String(fileName.getBytes("UTF-8"), "iso-8859-1");

       //创建响应头信息的对象
       HttpHeaders headers = new HttpHeaders();
       //设置下载的响应头信息,通过浏览器响应正文的内容是用户要下载的,不用浏览器解析
       headers.setContentDispositionFormData("attachment", downFileName);
       headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);

       //通过响应内容、响应头信息、响应状态来构建一个响应对象并返回
       return new ResponseEntity<byte[]>(FileUtils.readFileToByteArray(file), headers, HttpStatus.CREATED);
   }

   页面代码:
   <a href="download/test?fileName=测试.txt">点击下载</a>

Albert_XZR

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringMVC从入门到入土!

1.Web、MVC、WebMVC概述 1)完成一次web请求的过程 Web浏览器发起请求 Web服务器接收请求并处理请求,最后产生响应(一般为html)。 web服务器处理完成后,返回内容给web客户端,客户端对接收的内容进行处理并显示出来。从这里可以看出,在web中,都是web客户端发起请求,web服务器接收处理请求并产生响应。一般Web服务器是不能主动通知Web客户端更新内容。虽然有些技术可以帮我们实现 ...
复制链接

扫一扫