SpringMVC配置的替代方案

自定义DispatherServlet配置

我们之前在SpittrWebAppInitializer所编写的三个方法仅仅是必须要重载的abstract方法。但还有更多的方法可以进行重载，从而实现额外的配置。

例如customizeRegistration（）。在AbstractAnnotationConfigDispatcherServletInitializer将DispatcherServlet主车道Servlet容器后，就会调用该方法，并将Servlet注册后得到的Registration.Dynamic传递进来。例如稍后我们将要计划使用Servlet3.0对multipart的支持，那么需要使用DispatcherServlet的registration来启用multipart请求。

@Override
protected void customizeRegistration(Dynamic registration) {
    registration.setMultipartConfig(
        new MultipartConfigElement("/tmp/spittr/uploads"));
}

借助customizeRegistration（）方法的ServletRegistration.Dynamic来设置MultipartConfigElement。

添加其它的Servlet和Filter

基于Java的初始化器（initializer）的一个好处就在于我们可以定义任意数量的初始化器类。

因此，如果需要定义额外的组件，只需新建相应的初始化类即可。最简单的方法就是实现Spring的WebApplicationInitializer接口。

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRegistration.Dynamic;
import org.springframework.web.WebApplicationInitializer;
import com.myapp.MyServlet;
public class MyServletInitializer implements WebApplicationInitializer {
    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        // 定义servlet
        Dynamic myServlet = servletContext.addServlet("myServlet", MyServlet.class);
        // 映射servlet
        myServlet.addMapping("/custom/**");
    }
}

这段代码注册了一个Servlet并将其映射到一个路径上。我们也可以用这个方式来手动注册DispatcherServlet。类似的我们也可以这样注册Filter和Listener。

@Override
public void onStartup(ServletContext servletContext) throws ServletException {
    // 注册一个filter
    javax.servlet.FilterRegistration.Dynamic filter = servletContext.addFilter("myFilter", MyFilter.class);
    // 添加映射
    filter.addMappingForUrlPatterns(null, false, "/custom/*");
}

WebApplicationInitializer是一个在注册servlet、filter、listener时比较推荐的方式，当然你是使用基于Java的配置方式并将应用部署在Servlet3.0容器上的。如果你仅仅需要注册一个filter并将其映射到DispatcherServlet，那么也可以使用AbstractAnnotationConfigDispatcherServletInitializer。要注册多个filter并将它们映射到DispatcherServlet，你所要做的仅仅是重写getServletFilters()方法。比如：

@Override
protected Filter[] getServletFilters() {
    return new Filter[] { new MyFilter() };
}

如你所见，该方法返回了一个javax.servlet.Filter的数组，这里仅仅返回了一个filter，但是它可以返回很多个。同时这里不再需要为这些filter去声明映射，因为通过getServletFilters()返回的filter会自动地映射到DispatcherServlet。

在web.xml中声明DispatcherServlet

在之前我们是使用AbstractAnnoatationConfigDispatcherServletInitializer自动注册DispatcherServlet和ContextLoaderListener。但也可以按传统方法在web.xml中注册。

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/spring/root-context.xml</param-value>
    </context-param>
    <listener>
        <!-- 注册ContextLoaderListener -->
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <servlet>
        <servlet-name>appServlet</servlet-name>
        <!-- 注册DispatcherServlet -->
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!-- DispatcherServlet映射 -->
    <servlet-mapping>
        <servlet-name>appServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

设置web.xml使用基于Java的配置

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    <!-- 使用Java配置 -->
    <context-param>
        <param-name>contextClass</param-name>
        <param-value>
            org.springframework.web.context.support.AnnotationConfigWebApplicationContext
        </param-value>
    </context-param>
    <!-- 指定所使用的Java配置类 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>spittr.config.RootConfig</param-value>
    </context-param>
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>
    <servlet>
        <servlet-name>appServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 使用Java配置 -->
        <init-param>
            <param-name>contextClass</param-name>
            <param-value>
                org.springframework.web.context.support.AnnotationConfigWebApplicationContext
            </param-value>
        </init-param>
        <!-- 指定DispatcherServlet的配置类 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>
                spittr.config.WebConfigConfig
            </param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>appServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

处理multipart形式的数据

在WEB应用中用户经常会上传内容。而Spittr应用在两个地方需要文件上传。当新用户注册应用的时候，会需要他们上传一张图片。而当他们提交新的Spittle时可能会上传图片。一般表单提交形成的请求结果很简单，就是以&为分割符的多个name-value。尽管这种编码形式很简单，但对像图片这样的二进制数据就不合适了。而multipart格式的数据会将一个表单后拆分为多个部分，每个部分对应一个输入域。下面展现mulrtipart的请求体：

------WebKitFormBoundaryqgkaBn8IHJCuNmiW
Content-Disposition: form-data; name="firstName"
Charles
------WebKitFormBoundaryqgkaBn8IHJCuNmiW
Content-Disposition: form-data; name="lastName"
Xavier
------WebKitFormBoundaryqgkaBn8IHJCuNmiW
Content-Disposition: form-data; name="email"
charles@xmen.com
------WebKitFormBoundaryqgkaBn8IHJCuNmiW
Content-Disposition: form-data; name="username"
professorx
------WebKitFormBoundaryqgkaBn8IHJCuNmiW
Content-Disposition: form-data; name="password"
letmein01
------WebKitFormBoundaryqgkaBn8IHJCuNmiW
Content-Disposition: form-data; name="profilePicture"; filename="me.jpg"
Content-Type: image/jpeg
[[ Binary image data goes here ]]
------WebKitFormBoundaryqgkaBn8IHJCuNmiW--

尽管multipart看起来复杂，但在SpringM中处理却很容易。而首先需要要我们配置一个multipart解析器。

配置multipart解析器

DispatcherServlet并没有任何实现解析multipart请求数据的功能。他将这任务委托给Spring中MultipartResolver策略接口的实现，从Spring3.1开始，Spring内置了两个MultipartResolver的实现供我们选择：

CommonMultipartResolver:使用Jakarta Commons FileUpload解析multipart请求；
StandardServletMultipartResolver：依赖于Servlet3.0对multipart请求的支持（始于Spring3.1）

一般选用StandardServletMultipartResolver。兼容Servlet3.0的StandardServletMultipartResolver没有构造器参数，也没有要设的属性。因此在Spring上下文中将其声明为bean会非常简单，如下所示：

 @Bean
    public MultipartResolver multipartResolver() throws IOException {
        return new StandardServletMultipartResolver();
    }

那么如何配置StandardServletMultipartResolver的限制条件呢？我们会在Servlet中指定multipart的限定条件。至少也要写入文件上传的过程中所写入得临时文件路径。如果不设定这个最基本配置的话，StandardServletMultipartResolver就无法正常工作。所以我们会在web.xml或Servlet初始化类中将multipart的具体细节作为DispatcherServlet配置的一部分。采用Servlet初始化类的方式来配置：

DispatcherServlet ds=new DispatcherServlet();
Dynamic registration=context.addServlet("appServlet",ds);
registration.addMapping("/");
registration.asetMultipartConfig(
    new MultipartCofigElement("/tmp/spittr/upolads"));

如果配置的Servlet初始化类继承了AbstractAnnotationConfigDispatcherServletInitializer或AbstractDispatcherServletInitializer的话，可以重载customizeRegistration()方法来配置multipart的具体细节。

//设置multipart上传配置，路径，文件不超过2MB，请求不超过4MB
    @Override
    protected void customizeRegistration(ServletRegistration.Dynamic registration){
        registration.setMultipartConfig(
                new MultipartConfigElement("C:/test",2097152,4194304,0));
    }

MultipartConfigElement构造器也可以进行其他一些设置：

文件上传的最大值（byte），默认没有限制；
所有multipart请求的文件最大值（byte），不管有多少个请求，默认无限制；
直接上传文件（不需存储到临时目录）的最大值（byte），默认是0，也就是所有的文件都要写入硬盘；

如果你是使用的传统的web.xml的方式来设置的DispatcherServlet，那么就需要使用多个元素，其默认值和MultipartConfigElement相同，并且是必填项：

<servlet>
    <servlet-name>appServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
    <multipart-config>
        <location>/tmp/spittr/uploads</location>
        <max-file-size>2097152</max-file-size>
        <max-request-size>4194304</max-request-size>
    </multipart-config>
</servlet>

处理multipart请求

当配置好了对multipart请求的处理，接下来要编写控制器方法来接受上传的文件。实现这点最常见的方法就是在某个控制器方法参数上添加@Requestpart注解。

假设你想让用户可以在注册时上传图像，那么就需要对注册表单进行更改从而用户可以选择一个图片，同时还需要更改SpitterController中的processRegistration()方法以获取上传的文件。现在所需做的就是更新processRegistration()方法：

@RequestMapping(value = "/register", method = RequestMethod.POST)
public String processRegistration(@RequestPart("profilePicture") byte[] profilePicture, @Valid Spitter spitter,
        Errors errors) {
            ···
        }

当注册表单提交时，请求部分的数据就会赋予到profilePicture属性中，如果用户没有选中一个文件，那么该数组就会是一个空值（不是null）。既然已经获取到上传的文件，下面所需要的就是将文件保存。

处理异常

不管发生什么事情Servlet请求的输出都是一个Servlet响应，所以如果出现异常，那么它的输出依旧是Servlet响应，一场必须是以某种方式转换为响应。Spring提供了多种方式将一场转换为响应：

某些Spring异常会自动的映射为特定的HTTP状态码；
使用@ResponseStatus注解将一个异常映射为HTTP状态码；
使用ExceptionHandler注解的方法可以用来处理异常

将异常映射为HTTP状态码

在默认情况下，Spring将自身的一些异常转换为合适的状态码。

Spring异常	HTTP状态码
BindException	400 - Bad Request
ConversionNotSupportedException	500 - Internal Server Error
HttpMediaTypeNotAcceptableException	406 - Not Acceptable
HttpMediaTypeNotSupportedException	415 - Unsupported Media Type
HttpMessageNotReadableException	400 - Bad Request
HttpMessageNotWritableException	500 - Internal Server Error
HttpRequestMethodNotSupportedException	405 - Method Not Allowed
MethodArgumentNotValidException	400 - Bad Request
MissingServletRequestParameterException	400 - Bad Request
MissingServletRequestPartException	400 - Bad Request
NoSuchRequestHandlingMethodException	404 - Not Found
TypeMismatchException	400 - Bad Request

将异常映射为特定的状态码

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;
@ResponseStatus(value=HttpStatus.NOT_FOUND, reason="Spittle Not Found")
public class SpittleNotFoundException extends Exception {
}

编写异常处理的方法

将异常映射为状态码大多数情况下是比较简单有效的，但是如果想让响应不仅仅只有一个状态码呢？也许你想对异常进行一些处理，就行处理请求一样。

例如，SpittleRepository的save()方法在用户重复创建Spittle时抛出了一个DuplicateSpittleException，那么SpittleController的saveSpittle()方法就需要处理该异常。如下面的代码所示，saveSpittle()方法可以直接处理该异常：

@RequestMapping(method = RequestMethod.POST)
public String saveSpittle(SpittleForm form, Model model) {
    try {
        spittleRepository.save(new Spittle(null, form.getMessage(),
                new Date(), form.getLongitude(), form.getLatitude()));
        return "redirect:/spittles";
    } catch (DuplicateSpittleException e) {
        return "error/duplicate";
    }
}

这个方法有两个路径，我们可以用别的方法处理异常，那这个方法可以简单点。首先处理正确路径的saveSpittle方法：

@RequestMapping(method = RequestMethod.POST)
public String saveSpittle(SpittleForm form, Model model) {
        spittleRepository.save(new Spittle(null, form.getMessage(),
                new Date(), form.getLongitude(), form.getLatitude()));
        return "redirect:/spittles";
}

现在在SpittleController中添加一个新的方法：

@ExceptionHandler(DuplicateSpittleException.class)
public String handleDuplicateSpittle() {
    return "error/duplicate";
}

@ExceptionHandler注解应用在handleDuplicateSpittle()方法上，用来指定在有DuplicateSpittleException异常抛出时执行。而值得注意的是，@ExceptionHandler注解的方法在同一个控制器里是通用的额，即无论SpittleController的哪一个方法抛出DuplicateSpittleException异常，handleDuplicateSpittle()方法都可以对其进行处理，而不再需要在每一个出现异常的地方进行捕获。那么，@ExceptionHandler注解的方法能不能捕获其他controller里的异常啊？在Spring3.2里是可以的，但仅仅局限于定义在控制器通知类里的方法。

那什么是控制器通知类呢？这就是接下来要介绍的

为控制器添加通知

如果controller类的特定切面可以跨越应用的所有controller进行使用，那么这将会带来极大的便捷。例如，@ExceptionHandler方法就可以处理多个controller抛出的异常了。如果多个controller类都抛出同一个异常，也许你会在这些controller进行重复的@ExceptionHandler方法编写。或者，你也可以编写一个异常处理的基类，供其他@ExceptionHandler方法进行继承。

Spring3.2带来了另外一种解决方法：控制器通知。控制器通知是任意带有@ControllerAdvice注解的类，这个类会包含一个或多个如下类型的方法：

@ExceptionHandler注解的
@InitBinder注解的
@ModelAttribute注解的

@ControllerAdvice注解的类中的这些方法会在整个应用中的所有controller的所有@RequestMapping注解的方法上应用。

@ControllerAdvice注解本身是使用了@Component注解的，因此，使用@ControllerAdvice注解的类会在组件扫描时进行提取，就行使用@Controller注解的类一样。@ControllerAdvice的最实用的一个功能就是将所有的@ExceptionHandler方法集成在一个类中，从而可以在一个地方处理所有controller中的异常。例如，假设你想处理应用中所有的DuplicateSpittleException异常，可以采用下面的方法：

import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
// 声明控制器增强
@ControllerAdvice
public class AppWideExceptionHandler {
    // 定义异常处理方法
    @ExceptionHandler(DuplicateSpittleException.class)
    public String handleDuplicateSpittle() {
        return "error/duplicate";
    }
    @ExceptionHandler(SpittleNotFoundException.class)
    public String handleSpittleNotFound() {
        return "error/duplicate";
    }
}

跨重定向请求传递数据

在处理完POST请求过后通常应该执行重定向。这样可以避免用户点击浏览器的刷新按钮或后退按钮时，客户端重新执行危险的POST请求。在第五章中，已经在控制器方法返回的视图名称中使用了redirect:前缀，这时返回的String不是用来寻找视图，而是浏览器进行跳转的路径：

return "redirect:/spitter/" + spitter.getUsername();

也许你认为Spring处理重定向只能这样了，但是：Spring还可以做得更多。

特别是一个重定向方法如何向处理重定向的方法发送数据呢？一般的，当一个处理函数结束后，方法中的model数据都会作为request属性复制到request中，并且request会传递到视图中进行解析。因为控制器和视图面对的是同一个request，因此request属性在forward时保留了下来。

但是，当一个控制器返回的是一个redirect时，原来的request会终止，并且会开启一个新的HTTP请求。原来request中所有的model数据都会清空。新的request不会有任何的model数据。

aaarticlea/png;base64,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" alt="image">

明显的，现在不能再redirect时使用model来传递数据了。但是还有其他方法用来从重定向的方法中获取数据：

将数据转换为路径参数或者查询参数
在flash属性中发送数据

通过URL模版进行重定向

@RequestMapping(value="/",method=POST)
public String processRegistration(Spitter spitter,Model model){
  spitterRepository.save(spitter);
  model.addAttribute("username",spitter.getUsername());
  model.addAttribute("spitterId",spitter.getId());
  return "redirect:/spitter/{username}";
}

返回的重定向String并没有什么变化，但是由于model中的spitterId属性并没有映射到URL中的占位符，它会自动作为查询参数。

如果username是habuma，spitterId是42，那么返回的重定向路径将是/spitter/habuma?spitterId=42。

使用路径参数和查询参数传递数据比较简单，但是它也有局限性。它只适用于传递简单值，比如String和数字，不能传递比较复杂的东西，那么我们就需要flash属性来帮忙。

使用flash属性

@RequestMapping(value="/",method=POST)
public String processRegistration(Spitter spitter,RedirectAttributes model){
  spitterRepository.save(spitter);
  model.addAttribute("username",spitter.getUsername());
  model.addFlashAttribute("spitter",spitter);
  return "redirect:/spitter/{username}";
}

我们传递了一个Spitter对象给addFlashAttribute()方法,在重定向之前，所有的flash属性都会复制到会话中，在重定向之后，存在会话中的flash属性会被取出，并从会话转移到模型之中。处理重定向的方法就能从模型中访问Spitter对象了

Spring实战第七章————SpringMVC配置的替代方案的更多相关文章

Spring实战第六章学习笔记————渲染Web视图
Spring实战第六章学习笔记----渲染Web视图理解视图解析在之前所编写的控制器方法都没有直接产生浏览器所需的HTML.这些方法只是将一些数据传入到模型中然后再将模型传递给一个用来渲染的视图. ...
Spring实战第五章学习笔记————构建Spring Web应用程序
Spring实战第五章学习笔记----构建Spring Web应用程序 Spring MVC基于模型-视图-控制器(Model-View-Controller)模式实现,它能够构建像Spring框架那 ...
Spring实战第四章学习笔记————面向切面的Spring
Spring实战第四章学习笔记----面向切面的Spring 什么是面向切面的编程我们把影响应用多处的功能描述为横切关注点.比如安全就是一个横切关注点,应用中许多方法都会涉及安全规则.而切面可以帮我 ...
Spring Cloud（七）：配置中心（Git 版与动态刷新）【Finchley 版】
Spring Cloud(七):配置中心(Git 版与动态刷新)[Finchley 版] 发表于 2018-04-19 | 更新于 2018-04-24 | Spring Cloud Confi ...
RxJava2实战---第七章合并操作符和连接操作符
RxJava2实战---第七章合并操作符和连接操作符 RxJava的合并操作符: startWith():在数据序列的开头增加一项数据. merge:将多个Observable合并为一个. merg ...
2017.2.28 activiti实战--第七章--Spring容器集成应用实例（五）普通表单
学习资料:<Activiti实战> 第七章 Spring容器集成应用实例(五)普通表单第六章中介绍了动态表单.外置表单.这里讲解第三种表单:普通表单. 普通表单的特点: 把表单内容写在 ...
2017.2.21 activiti实战--第七章--Activiti与spring集成（一）配置文件
学习资料:<Activiti实战> 第七章 Activiti与容器集成本章讲解activiti-spring可以做的事情,如何与现有系统集成,包含bean的注入.统一事务管理等. 7.1 ...
一起来学Spring Cloud | 第七章：分布式配置中心(Spring Cloud Config)
上一章节,我们讲解了服务网关zuul,本章节我们从git和本地两种存储配置信息的方式来讲解springcloud的分布式配置中心-Spring Cloud Config. 一.Spring Cloud ...
【Spring Security】七、RememberMe配置
一.概述 RememberMe 是指用户在网站上能够在 Session 之间记住登录用户的身份的凭证,通俗的来说就是用户登陆成功认证一次之后在制定的一定时间内可以不用再输入用户名和密码进行自动登录.这 ...

随机推荐

【luogu P2024 食物链】题解
题目链接:https://www.luogu.org/problemnew/show/P2024 摘吊打集训队的九日dalao一句话关于带有多个相对集合的全集,我们可以多开几倍的空间.每一倍的元素表 ...
Android学习笔记_79_ Android 使用搜索框
1.在资源文件夹下创建xml文件夹,并创建一个searchable.xml: android:searchSuggestAuthorityshux属性的值跟实现SearchRecentSuggesti ...
mysql 综合
一.库操作二.表操作 1.存储引擎介绍 show engines; 查看数据库支持的引擎 MySQL 使用 InnoDB 指定表类型/存储引擎 create table t1(id int)engi ...
JS JavaScript事件循环机制
区分进程和线程进程是cpu资源分配的最小单位(系统会给它分配内存) 不同的进程之间是可以同学的,如管道.FIFO(命名管道).消息队列一个进程里有单个或多个线程浏览器是多进程的,因为系统给它的进 ...
Restframework中常见API的编写方式
1.框架一(继承APIView) 这里的第一部分使用骨架请参考我的博客(第三篇),它采用了restframework中最基础的办法(APIView)实现了相关请求,以下的框架都是基于它的 2.框架二( ...
SpingMVC前置控制器过滤问题
/<servlet-mapping> <servlet-name>Springmvc</servlet-name> <url-pattern>/< ...
bzoj2982: combination（lucas）
Description LMZ有n个不同的基友,他每天晚上要选m个进行[河蟹],而且要求每天晚上的选择都不一样.那么LMZ能够持续多少个这样的夜晚呢?当然,LMZ的一年有10007天,所以他想知道答案 ...
Mysql升级过程的问题
升级安装5.6版本mysql linux环境下的yum默认mysql版本是5.1的,由于项目需要保存表情等4个字节的数据,版本受限,需要升级到5.6版本支持utf8mb4格式的编码. 升级过程大概就是 ...
xpath技术解析xm文件（php）
1.结合php dom技术的学习,得出一个结论:php dom技术可以跨层取出节点,但是不能保持层次关系,使用xpath可以很好地解决问题. *** xpath技术的核心思想:迅速简洁的定位你需要查找 ...
Tornado学习
为什么用Tornado? 异步编程原理服务器同时要对许多客户端提供服务,他的性能至关重要.而服务器端的处理流程,只要遇到了I/O操作,往往需要长时间的等待. 屏幕快照 2018-10-31 上午 ...

Spring实战第七章————SpringMVC配置的替代方案