Spring MVC(下)

SpringMVC Controller控制器详解

Controller控制器作用

• 收集、验证请求参数并绑定到命令对象；
• 将命令对象交给业务对象，由业务对象处理并返回模型数据；
• 返回ModelAndView（Model部分是业务对象返回的模型数据，视图部分为逻辑视图名）。

核心注解

@Controller ： 用于标记在一个类上，使用它标记的类就是一个SpringMVC Controller 对象。分发处理器将会扫描使用了该注解的类的方法，并检测该方法是否使用了@RequestMapping 注解。

/**  * @Controller，类级别上的注解。我们定义的类可以只是一个 javabean，不需要实现任何接口。标注了  * @Controller，借助 <context:component-scan>，框架能自动识别到这就是一个 Controller  */  @Controller  public class MyController {    // ......  }  

@RequestMapping ： @RequestMapping 来映射URL 到控制器类，或者是到Controller 控制器的处理方法上。当@RequestMapping 标记在Controller 类上的时候，里面使用@RequestMapping 标记的方法的请求地址都是相对于类上的@RequestMapping 而言的；当Controller 类上没有标记@RequestMapping 注解时，方法上的@RequestMapping 都是绝对路径。这种绝对路径和相对路径所组合成的最终路径都是相对于根路径“/ ”而言的。

• value: 路径地址
• method：请求方法的规则，比如：如果设置了RequestMethod.POST，那么你的表单提交就必须使用POST提交，否则将报405错误
• params： 提交中的数据中一定要有配置的参数（如id），否则将报400的错误

/**  * @RequestMapping 可以出现在类级别上，也可以出现在方法上。如果出现在类级别上，那请求的 url 为 类级别  * 上的 @RequestMapping + 方法级别上的 @RequestMapping，否则直接取方法级上的 @RequestMapping。  * 类级别的 @RequestMapping 不是必需的。  */   @Controller  @RequestMapping("/my")  public class MyController {    /**        * 由于类级别上定义了 @RequestMapping，那么想匹配到这个方法来处理请求，url 必须为 /my/somelist。    * 如果没有定义类级别上的 @RequestMapping，url 为 /somelist 即可。同时，请求方法必须为 POST    */    @RequestMapping(value="/somelist", method=RequestMethod.POST);    public String getSomeList() {...}    /**      * 在方法级别使用 @RequestMapping 来限定请求处理的时候，可以指定两个属性。除了我们在上面刚使用过的      * method 属性，还有一个 params 属性。使用 params 属性，可以达到与使用      * ParameterMethodNameResolver 作为 MethodResolver的 MultiActionController 类似的功能。      *      * params 有两种表达形式，这里先说第一种："parameterName=parameterValue"      *      * 请求方法为 GET 或 POST，且具有 hello 参数，且值为 world 的请求才能匹配到该方法，如：      *   /my?hello=world      */      @RequestMapping(params="hello=world", method={RequestMethod.GET, RequestMethod.POST})      public String helloworld() {...}      /**      * 请求方法为 GET 或 POST，且具有 hello 参数，且值为 java 的请求才能匹配到该方法，如：      *   /my?hello=java      */      @RequestMapping(params="hello=java", method={RequestMethod.GET, RequestMethod.POST})      public String hellojava() {...}      /**      * params 属性的另外一种表达形式为："parameter"      *      * 请求方法为 GET，且具有请求参数 java 即匹配此方法，而不管 java 参数的值是什么，如：      *   /my?java=anything      */      @RequestMapping(params="java", method={RequestMethod.GET})      public String java() {...}       /**      * 请求方法为 GET，且具有请求参数 cplusplus 即匹配此方法，而不管 cplusplus 参数的值是什么，如：      *   /my?cplusplus=anything      */      @RequestMapping(params="cplusplus", method={RequestMethod.GET})      public String cplusplus() {...}      /**      * @RequestMapping 还有一个参数化 headers，它和 params 非常相似，也有两种表达式，只不过它是对      * 请求头做限制罢了。大家可以通过 telnet 或 http-client 来发类似的请求以检验。以 telnet 为例：      *       * telnet localhost 8080      * POST /contextPath/my HTTP/1.1      * Host: localhost      * hello: world # 这个就是自定义请求头，和标准的请求头的写法别无二致      */      @RequestMapping(headers="hello=world", method={RequestMethod.POST})      public String cplusplus() {...}  }

@RequestBody : 将请求正文绑定到方法参数

@Controller  @RequestMapping("/my")  public class MyController {      /**    * 我们定义的 body 的数据类型是 String，请求体嘛，肯定是 String。实际上，@RequestBody 是用于将请    * 求体的内容绑定到方法参数上，数据类型不一定是 String。Spring MVC 是通过 HttpMessageConverter    * 来完成这种转换的。AnnotationMethodHandlerAdapter 默认注册了一些 HttpMessageConverters：    *   ByteArrayHttpMessageConverter - converts byte arrays    *   StringHttpMessageConverter - converts strings    *   FormHttpMessageConverter - converts form data to/from MultiValueMap< String,String>    *   SourceHttpMessageConverter - convert to/from a javax.xml.transform.Source    *   MappingJacksonHttpMessageConverter - converts json    *   MarshallingHttpMessageConverter - convert to/from an object using the     * 正如上所述，HttpMessageConverter 用于从请求正文绑定到对象和把对象序列化成 String 予客户端响应。    * 即 HttpMessageConverter is responsible for converting from the HTTP request message to    * an object and converting from an object to the HTTP response body    *    * 我们可以在 AnnotationMethodHandlerAdapter 定义任意多的 HttpMessageConverters。    *    * 既然 HttpMessageConverter 可以用于双向 convert，这里讨论的是 @RequestBody，那这部分我们只讲     * converting from the HTTP request message to an object。    *    * 假设我们只向 AnnotationMethodHandlerAdapter 注入了 MappingJacksonHttpMessageConverter 和    * MarshallingHttpMessageConverter。处理请求的方法有如下签名：    *     public String test(@RequestBody User user) { ... }    *    * 不管请求正文的内容是什么，对于客户端和服务器而言，它们只是用文本来互相通信。把字符串转为 User 对    * 象，该用哪个 HttpMessageConverter 来完成此项工作呢？    *    * 在定义 HttpMessageConverters 时，我们可以为其指定 supportedMediaTypes。对于将请求正文转为对象    * 这个方向的操作，HttpMessageConverters 会从请求头得到 Content-Type 头信息，看其是否隶属于其定义    * 的 supportedMediaTypes。若没有匹配上，则会使用下一个 HttpMessageConverter 做同样的判断。只要    * 某个 HttpMessageConverter 支持请求头中的 Content-Type，那么就会应用此 HttpMessageConverter    * 来将 String 转为 Object。当然，若请求正文并没有按照 Content-Type 所规定的格式来编写，必然要收到    * 500 的响应。同时请注意，请求头中还必须提供 Content-Length，否则拿不到请求正文。    *    * 如果所有的 HttpMessageConverters 中定义的 supportedMediaTypes 均不能匹配上 Content-Type 请    * 求头中的类型，那么就会收到 415 Unsupported Media Type 响应。    */    @RequestMapping("/user/body");    public String getBody(@RequestBody String body) {      // 这里的 body 的内容就是 hello      System.out.println(body);      return null;    }  }  

@ResponseBody : 将返回的数据改为json格式。

@Controller  @RequestMapping("/my")  public class MyController {    /**    * 该方法的返回类型是 User，并不符合含有 @RequestMapping 的注解所需的签名方式。但它仍然是合法的，因    * 为在返回类型前有 @ResponseBody 注解，此注解将告知框架，将 User 对象作为影响正文返回？什么？对象    * 作为响应正文！所以，HttpMessageConverter 在这里就起到作用了。这里讨论的是 @ResponseBody，所以    * 这里我们只讲 converting from an object to the HTTP response body。    *    * User 对象要转成什么样的 String，或者说要转成什么格式的 String？这个时候需要从请求头中获得此信息    * 了，这里，就是请求头的 Accept 头。Accept 头可以使用逗号分隔定义多个类型，用以告知服务器我只接受    * 哪些类型的响应。AnnotationMethodHandlerAdapter 中同样注入了多个 HttpMessageConverter，每个     * HttpMessageConverter 都可以定义各自的 supportedMediaTypes。这个时候该用哪个     * HttpMessageConverter 来完成对象到文本的序列化操作呢？    *    * 遍历 Accept 头中的每种媒体类型，在定义的多个 HttpMessageConverters 中依次去匹配，若匹配上，就使    * 用该 HttpMessageConverter 来完成序列化操作，并且响应头的 Content-Type 并不是请求头 Accept 头    * 的诸多类型中第一个被匹配的类型，而是匹配到的 HttpMessageConverter 定义的 supportedMediaTypes    * 中的第一个类型。    *    * 如果所有的 HttpMessageConverters 中定义的 supportedMediaTypes 均不能匹配上 Accept 请求头中    * 的诸多的类型，那么就会收到 406 Not Acceptable 响应。    */    @RequestMapping("/user")    public @ResponseBody User getUser() {      return new User(18, "Jack", "计算机");    }  }  

@RequestParam ： 绑定 HttpServletRequest 请求参数到控制器方法参数。

@Controller  @RequestMapping("/my")  public class MyController {    /**    * 注意，这里的方法有一个参数。若请求 url 为 /my/test，会匹配此方法。这里的方法的参数名为 userId，    * 那么请求参数中一定有名为 userId 的参数，且值为整数。这也是默认的绑定行为，它是根据名称匹配原则进行    * 的数据绑定。当请求中的参数名与方法名一致的时候，相应的参数值将被绑定到相应的方法参数上。    *     * 如果没有传递 userId 参数，框架会传入 null。可是这里我们定义的是 primitive type，异常伺候！若    * 要解决此问题，需要将 primitive type 定义成相应的 wrapper type 即可，这里使用 Integer 就行了。    *    * 如果传递了 userId 参数，但值不是整数，你叫 test 怎么办呢？这种情况下，框架借助 PropertyEditor     * 数据类型转换失败，ExceptionResolver 会接手处理，请求是不会进入 test 方法的。    *    * 这种方式下，默认的绑定行为需要我们严格遵守命名一致性原则。如果我们对此不满，想自定义绑定关系，可以求    * 助于 @RequestParam。    */    @RequestMapping("/test")    public String test(int userId) { ... }    /**    * 当我们不想使用 userId 作为方法的参数名，即不想使用默认的数据绑定方式。如果我们要使用 id 作为方法    * 的参数，为了保证名称为 userId 的请求参数可以绑定到新的名称为 id 的方法参数上，我们就可以使用     * @RequestParam 对这一参数进行标注。@RequestParam 只可以标注于方法参数上。    * 如果请求参数中有 age，和方法的参数名称一致，故 age 参数不需要 @RequestParam 标注。如果没有传递    * age，我们又不想定义成 Integer，很显然框架会注入 null 值，报错是必然的。这是由于 @RequestParam     * 的 required 属性决定的，默认就是 true。如果我们定义成 false，    * 即 @RequestParam(required=false) int age    * 这个时候定义成 int 型的 age，即便请求参数没有 age 参数，也是没问题的。    * 同时，这里还能绑定 Date 类型，User 对象类型等等。如 date=2011-01-01&userName=Tom&userAge=18    * 这里，User 类的属性需要为 userName 和 userAge，以免和 age，name 混淆。所以，Spring MVC 对对象    * 的数据绑定就没有 Struts2 做的那么好了，Strtus2 可以这样：user.age=18&user.name=Tom    */    @RequestMapping("/test2")    public String test2(@RequestParam("userId") int id, int age, Date date, User user) { ... }  }  

@PathVariable : 将 url template 里的参数绑定到方法参数

@Controller  @RequestMapping("/my")  public class MyController {    /**    * @PathVariable 是 url 模板，需要和 @RequestMapping 配合起来使用，这是 Spring 3.0 之后引入的。    *    * 在这个例子中，请求的 url 必须满足类似 /my/user/zhangsan/18 这样的格式才能匹配方法。url 模板里    * 的参数名和方法参数名的绑定规则和 @RequestParam 类似，这里就不再赘述了。    *    * @PathVariable 和 @RequestParam 的区别在于：    *   @PathVariable 的 url：/my//user/zhangsan/18    *   @RequestParam 的 url：/my//user?nickname=zhangsan&age=18    */    @RequestMapping("/user/{nickname}/{age}");    public String getUserInfo(@PathVariable("nickname") String name, @PathVariable int age) {...}  }  

ModelAttribute :

/**  * @ModelAttribute 可以为视图渲染提供更多的模型数据，而不需要在处理请求的方法里添加 ModelMap 或  * Model 类型的参数。  *  * @ModelAttribute 可以标注在方法(存数据)上，也可以标注在方法参数(取数据)上。  */  @Controller  @RequestMapping("/my")  public class MyController {    /**    * 在处理该请求时，方法的返回类型是 User，貌似不符合返回类型的规范。由于这里使用了 @ModelAttribute    * 注解，表示将返回的对象以 "user" 为 key 放入模型数据里。这里的 key 值默认值是返回的数据类型首字母    * 小写的结果。如果想自定义 key，可以写成 @ModelAttribute("myAttribute")，那么模型数据将会将     * User 对象绑定到 key 为 "myAttribute" 上。    *     * jsp 里可以这样访问模型里的数据：    *   age: ${user.age}    *   name: ${user.name}    *   job: ${user.job}    *    * 当然，这里只是提到了 @ModelAttribute 存数据的操作。    */    @RequestMapping("/user")    @ModelAttribute    public User getUser() {      return new User(18, "Jack", "计算机");    }    /**    * 这里将 @ModelAttribute 标注在方法参数上，表示要从模型数据里取 key 为 "user" 的对象，绑定在方法    * 参数上。如果这样做的话，其实你是得不到上面的那个请求放入的 User 对象，得到的是另外一个对象。其实    * 也好理解，这是两个互相独立的请求，作用域不一样。要想达到我们的目的，即能够从模型数据里取数据，需要    * 求助于 @SessionAttributes    */    @RequestMapping("/user2")    public String showUser(@ModelAttribute User user) {      System.out.println(user);      return null;    }  }  

@SessionAttributes

/**  * @SessionAttributes 和 @ModelAttribute 类似，只不过 @SessionAttributes 是将数据存放于 session   * 中或从 session 中取数据。  *  * @SessionAttributes 只能应用在类型声明上。比如下面的类的声明中，只有属性名为 "the-attribute" 的数  * 据才会纳入到 session 的管理。  *  * @SessionAttributes 允许以属性名名称或者类型两种方法，来表明将哪些数据通过 session 进行管理。这里  * 我们使用的是指定属性名称的方式，但通过类型来指定也是可行的，如：  *   @SessionAttributes(types=User.class)  */  @Controller  @RequestMapping("/my")  @SessionAttributes("the-attribute")  public class MyController {    @RequestMapping("/getUser")    public String getUser(int userId, Model model) {      /**      * 注意，这里将 User 对象添加到属性名为 "the-attribute" 上，所以 User 对象将纳入到 session 的      * 管理。如果这里添加的对象的属性名不是 "the-attribute"，那么它只会作用于当前请求，而不会纳入到       * session 的管理中。      */      User user = userService.getUserById(userId);      model.addAtrribute("the-attribute", user);      return "userinfo";    }     /**    * 将模型里的 "the-attribute" 为 key 的对象绑定到 User 类上。由于在类级别上声明了只有 "the-    * attribute" 的属性名才会纳入到 session 的管理，所以就解决了在 @ModelAttribute 注解中讲解中最    * 后提到的问题。    *    * 另外，这个方法还有两个参数，BindingResult 和 SessionStatus。由于这里有绑定数据的动作，我们可以    * 根据 BindingResult 对象获得数据绑定结果以决定后继流程该如何处理。SessionStatus 在这里用于处理    * 完请求后，清空 session 里的数据。    */    @RequestMapping("/updateUser")    public String updateUser(@ModelAttribute("the-attribute") User user,               BindingResult result, SessionStatus status) {      if (result.hasErrors) {        return "error";      }         userService.updateUser(user);      // 我们通过调用 status.setComplete() 方法，该 Controller 所有放在 session 级别的模型属性数据      // 将从 session 中清空      status.setComplete();      return "redirect:getUser?userId=" + user.getId();    }  }  

@CookieValue ： 绑定 cookie 的值到 Controller 方法参数。
@RequestHeader ：注解绑定 HttpServletRequest 头信息到 Controller 方法参数。

使用示例

自动匹配参数

@RequestMapping("/person")public String toPerson(String name,double age){    System.out.println(name+" "+age);    return "hello";}

使用InitBinder来处理Date类型的参数

@RequestMapping("/date")public String date(Date date){    System.out.println(date);    return "hello";}//At the time of initialization,convert the type "String" to type "date"@InitBinderpublic void initBinder(ServletRequestDataBinder binder){    binder.registerCustomEditor(Date.class, new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"),            true));}

自动装箱

package test.SpringMVC.model;public class Person {    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    private String name;    private int age;  }

@RequestMapping("/person1")public String toPerson(Person p){    System.out.println(p.getName()+" "+p.getAge());    return "hello";}

向前台传递参数

@RequestMapping("/show")public String showPerson(Map<String,Object> map){    Person p =new Person();    map.put("p", p);    p.setAge(20);    p.setName("jayjay");    return "show";}

在Controller中使用redirect方式处理请求

@RequestMapping("/redirect")public String redirect(){    return "redirect:hello";}

文件上传

@RequestMapping(value="/upload",method=RequestMethod.POST)public String upload(HttpServletRequest req) throws Exception{    MultipartHttpServletRequest mreq = (MultipartHttpServletRequest)req;    MultipartFile file = mreq.getFile("file");    String fileName = file.getOriginalFilename();    SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");            FileOutputStream fos = new FileOutputStream(req.getSession().getServletContext().getRealPath("/")+            "upload/"+sdf.format(new Date())+fileName.substring(fileName.lastIndexOf('.')));    fos.write(file.getBytes());    fos.flush();    fos.close();    return "hello";}

使用@RequestParam注解指定参数的name

@Controller@RequestMapping("/test")public class mvcController1 {    @RequestMapping(value="/param")    public String testRequestParam(@RequestParam(value="id") Integer id,            @RequestParam(value="name")String name){        System.out.println(id+" "+name);        return "/hello";    }    }

RESTFul风格的SringMVC

@Controller@RequestMapping("/rest")public class RestController {    @RequestMapping(value="/user/{id}",method=RequestMethod.GET)    public String get(@PathVariable("id") Integer id){        System.out.println("get"+id);        return "/hello";    }    @RequestMapping(value="/user/{id}",method=RequestMethod.POST)    public String post(@PathVariable("id") Integer id){        System.out.println("post"+id);        return "/hello";    }    @RequestMapping(value="/user/{id}",method=RequestMethod.PUT)    public String put(@PathVariable("id") Integer id){        System.out.println("put"+id);        return "/hello";    }    @RequestMapping(value="/user/{id}",method=RequestMethod.DELETE)    public String delete(@PathVariable("id") Integer id){        System.out.println("delete"+id);        return "/hello";    }}

返回json格式的字符串

@Controller@RequestMapping("/json")public class jsonController {    @ResponseBody    @RequestMapping("/user")    public  User get(){        User u = new User();        u.setId(1);        u.setName("jayjay");        u.setBirth(new Date());        return u;    }}

异常的处理

• 处理局部异常（Controller内）

  @ExceptionHandlerpublic ModelAndView exceptionHandler(Exception ex){    ModelAndView mv = new ModelAndView("error");    mv.addObject("exception", ex);    System.out.println("in testExceptionHandler");    return mv;}@RequestMapping("/error")public String error(){    int i = 5/0;    return "hello";}

• 处理全局异常（所有Controller）

  @ControllerAdvicepublic class testControllerAdvice {    @ExceptionHandler    public ModelAndView exceptionHandler(Exception ex){        ModelAndView mv = new ModelAndView("error");        mv.addObject("exception", ex);        System.out.println("in testControllerAdvice");        return mv;    }}

• 在SpringMVC配置文件中配置全局异常

  <!-- configure SimpleMappingExceptionResolver --><bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">    <property name="exceptionMappings">        <props>            <prop key="java.lang.ArithmeticException">error</prop>        </props>    </property></bean>

整体示例

实体类

package com.heqing.ssm.entity;public class Test {    private int id;    private String name;    public int getId() {        return id;    }    public void setId(int id) {        this.id = id;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    @Override      public String toString() {          return "test = {id:"+id+",name:"+name+"}";      }}

控制层

package com.heqing.ssm.controller;@Controller@RequestMapping("/springMVC")public class TestController {    @ModelAttribute       public void modelAttribute() {           System.out.println("===Controller.before===");    }       @ExceptionHandler      public void exceptionHandler(Exception e) {           System.out.println("===Controller.@ExceptionHandler==="+e.getMessage());    }       @InitBinder    public void initBinder(ServletRequestDataBinder binder){        binder.registerCustomEditor(Date.class, new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"),true));    }    @RequestMapping("/index")    public String index(Map<String,Object> map) {        System.out.println("===Controller.springMVC===");        map.put("message", "Hello World!");        return "springMVC.html";    }       @RequestMapping("/view")    public ModelAndView view(HttpServletRequest req, HttpServletResponse resp) throws Exception {         //1、收集参数、验证参数         //2、绑定参数到命令对象         //3、将命令对象传入业务对象进行业务处理         //4、选择下一个页面         ModelAndView mv = new ModelAndView();         //添加模型数据 可以是任意的POJO对象         mv.addObject("message", "Hello World!");         //设置逻辑视图名，视图解析器会根据该名字解析到具体的视图页面         mv.setViewName("springMVC");         return mv;      }       @RequestMapping("/jsonUtil")    public void jsonUtil(HttpServletResponse response,HttpServletRequest request, int id, String name) {        Test test = new Test();        test.setId(id);        test.setName(name);        List<String> list = new ArrayList<>();        list.add("test1"); list.add("test2");        Map<String,Object> paramsMap=new LinkedHashMap<String,Object>();        paramsMap.put("id", 1);        paramsMap.put("message", "Hello World!");        paramsMap.put("test", test);        paramsMap.put("list", list);        JsonUtil.outPutJsonMessage(log, "test", response, paramsMap);    }       @RequestMapping(value = "/requestBody", method = {RequestMethod.POST })    @ResponseBody    public void requestBody(@RequestBody List<Test> tests) {        System.out.println("===Controller.requestBody===");        System.out.println("size="+tests.size()+"   name1="+tests.get(0).getName());    }      @RequestMapping("/responseBody")      @ResponseBody    public Map<String, Object> responseBody() throws IOException {          System.out.println("===Controller.responseBody===");        Map<String,Object> paramsMap = new LinkedHashMap<String,Object>();        paramsMap.put("id", 1);        paramsMap.put("name", "name1");        return paramsMap;    }      /**     * value: 路径地址     * method：请求方法的规则，比如：如果设置了RequestMethod.POST，那么你的表单提交就必须使用POST提交，否则将报405错误      * params： 提交中的数据中一定要有配置的参数（如id），否则将报400的错误     * */    @RequestMapping(value = "/requestParam", method = {RequestMethod.POST }, params="id")     @ResponseBody    public void requestParam(@RequestParam int id, @RequestParam String name) {          System.out.println("===Controller.requestParam===");          System.out.println("id="+id+", name="+name);      }    @RequestMapping("/requestParamAuto")    @ResponseBody    public void toPerson(String id, String name){        System.out.println("===Controller.requestParamAuto===");         System.out.println("id="+id+", name="+name);      }    @RequestMapping("/requestBeanAuto")    @ResponseBody    public void requestBeanAuto(Test test){        System.out.println("===Controller.requestBeanAuto===");         System.out.println("id="+test.getId()+", name="+test.getName());      }    @RequestMapping("/pathVariable/{id}")     @ResponseBody    public void pathVariable(@PathVariable("id") String id) {          System.out.println("===Controller.pathVariable===");          System.out.println("id="+id);      }    @RequestMapping("/initBinder")     @ResponseBody    public void initBinder(Date date) {          System.out.println("===Controller.initBinder===");          System.out.println("date="+date);      }    @RequestMapping("/upload")      @ResponseBody    public void upload(HttpServletRequest request) throws IllegalStateException, IOException {        System.out.println("===upload===");        //创建一个通用的多部分解析器         CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver(request.getSession().getServletContext());          //判断 request 是否有文件上传,即多部分请求          if(multipartResolver.isMultipart(request)){              //转换成多部分request                MultipartHttpServletRequest multiRequest = (MultipartHttpServletRequest)request;              //取得request中的所有文件名              Iterator<String> iter = multiRequest.getFileNames();            while(iter.hasNext()){                  //记录上传过程起始时的时间，用来计算上传时间                  int pre = (int) System.currentTimeMillis();                  //取得上传文件                  MultipartFile file = multiRequest.getFile(iter.next());                  if(file != null){                      //取得当前上传文件的文件名称                      String myFileName = file.getOriginalFilename();                      //如果名称不为“”,说明该文件存在，否则说明该文件不存在                      if(myFileName.trim() !=""){                          //重命名上传后的文件名                          String fileName = file.getOriginalFilename();                          //定义上传路径                          String path = "D:/test/" + fileName;                          File localFile = new File(path);                          file.transferTo(localFile);                      }                }                //记录上传该文件后的时间                  int finaltime = (int) System.currentTimeMillis();                  System.out.println("上传用时："+(finaltime - pre)+"秒");              }          }      }  }

显示层

< !DOCTYPE html>< html>  < head>    < base href="<%=basePath%>">    < title>springMVC< /title>    < meta http-equiv="pragma" content="no-cache">    < meta http-equiv="cache-control" content="no-cache">    < meta http-equiv="expires" content="0">        < meta http-equiv="keywords" content="springMVC">    < meta http-equiv="description" content="This is my test page">    < script src="../js/jquery-3.1.1.min.js"></script>     < script src="../js/ajaxfileupload.js"></script>   < /head>  < body>             后台传递过来的消息：${message}  <br/>    < spring:message code="start"/><br/>    < button id="RequestBody"     type="button">测试  @RequestBody< /button>    < button id="ResponseBody"    type="button">测试  @ResponseBody< /button>    < button id="RequestParam"    type="button">测试  @RequestParam< /button>    < button id="RequestParamAuto" type="button">测试  自动匹配参数< /button>    < button id="RequestBeanAuto"  type="button">测试  自动装箱< /button>    < button id="PathVariable"    type="button">测试  @PathVariable< /button>    < button id="InitBinder"      type="button">测试  @InitBinder< /button>    < button id="JsonUtil"        type="button">测试 JsonUtil< /button>    < input type="file" id="uFile" name="uFile" multiple="multiple"/>        < button id="uploadAll" type="button">上传文件< /button>  < /body>  < script>   $("#RequestBody").click(function(){        var testAry=[];          var test1={"id":1,"name":"name1"};          var test2={"id":2,"name":"name2"};          testAry.push(test1);          testAry.push(test2);               $.ajax({            type: "POST",            url: "/Demo_SSM/springMVC/requestBody",            data:JSON.stringify(testAry),            dataType: "json",             contentType: "application/json;",            success: function(data){                console.info(data);            }       });    });    $("#JsonUtil").click(function(){        $.ajax({            type: "POST",            url: "/Demo_SSM/springMVC/jsonUtil",            data: {                 "id" : 1,                "name" : "name"            },            success: function(data){                console.info(data);            }       });    });    $("#ResponseBody").click(function(){        $.ajax({            type: "POST",            url: "/Demo_SSM/springMVC/responseBody",            success: function(data){                console.info(data);            }       });    });    $("#RequestParam").click(function(){        $.ajax({            type: "POST",            url: "/Demo_SSM/springMVC/requestParam",            data: {                 "id" : 3,                "name" : "name3"            },            success: function(data){                console.info(data);            }       });    });    $("#RequestParamAuto").click(function(){        $.ajax({            type: "POST",            url: "/Demo_SSM/springMVC/requestParamAuto",            data: {                 "id" : 3,                "name" : "name3"            },            success: function(data){                console.info(data);            }       });    });    $("#RequestBeanAuto").click(function(){        $.ajax({            type: "POST",            url: "/Demo_SSM/springMVC/requestBeanAuto",            data: {                 "id" : 3,                "name" : "name3"            },            success: function(data){                console.info(data);            }       });    });    $("#PathVariable").click(function(){        $.ajax({            type: "POST",            url: "/Demo_SSM/springMVC/pathVariable/4",            success: function(data){                console.info(data);            }       });    });    $("#InitBinder").click(function(){        $.ajax({            type: "POST",            url: "/Demo_SSM/springMVC/initBinder",            data: {                 "date" : "2017-01-16"            },            success: function(data){                console.info(data);            }       });    });    $("#uploadAll").click(function(){        $.ajaxFileUpload({           url:"/Demo_SSM/springMVC/upload",           fileElementId:"uFile",           success: function (data, status){                alert("上传成功");           },        });    });  </script></html>