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"
@InitBinder
public 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內）

  @ExceptionHandler
  public 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）

  @ControllerAdvice
  public 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>