Java的WEB框架中，Struts2应该是最著名的，不过最近试了试Spring3 MVC，感觉好爽啊，几乎像ASP.Net MVC3一样舒服，以后就用它了。简单记录一下过程，没有技术含量。

1、准备包

下载的是spring framework 3.2.0，从中抽取以下jar到工程的WEB-INF/lib下：

 
    
     
         
  1. spring-beans-3.2.0.RELEASE.jar 
    2.  
         
  2. spring-context-3.2.0.RELEASE.jar 
    3.  
         
  3. spring-core-3.2.0.RELEASE.jar 
    4.  
         
  4. spring-expression-3.2.0.RELEASE.jar 
    5.  
         
  5. spring-web-3.2.0.RELEASE.jar 
    6.  
         
  6. spring-webmvc-3.2.0.RELEASE.jar 
    7.  
        
 
    
另外还需要几个第三方jar包，记录日志和处理json：
 
    
 
    
     
         
  1. commons-logging-1.1.1.jar 
    2.  
         
  2. jackson-core-als-1.9.11.jar 
    3.  
         
  3. jackson-mapper-asl-1.9.11.jar 
    4.  
        
 
    
2、WEB-INF/web.xml
 
    
 
    
     
         
  1. <?xml version="1.0" encoding="UTF-8"?> 
    2.  
         
  2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    3.  
         
  3.  xmlns="http://java.sun.com/xml/ns/javaee" 
    4.  
         
  4.  xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" 
    5.  
         
  5.  xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    6.  
         
  6.  http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" 
    7.  
         
  7.  id="WebApp_ID" version="2.5"> 
    8.  
         
  8.  
    9.  
         
  9.     <!--站点名--> 
    10.  
         
  10.     <display-name>mvc</display-name> 
    11.  
         
  11.    
    12.  
         
  12.     <!--指定spring配置文件--> 
    13.  
         
  13.     <context-param> 
    14.  
         
  14.         <param-name>contextConfigLocation</param-name> 
    15.  
         
  15.         <param-value>/WEB-INF/spring-servlet.xml</param-value> 
    16.  
         
  16.     </context-param> 
    17.  
         
  17.   
    18.  
         
  18.     <listener>      
    19.  
         
  19.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>      
    20.  
         
  20.     </listener>  
    21.  
         
  21.    
    22.  
         
  22.     <servlet> 
    23.  
         
  23.         <!--servlet名字，随意--> 
    24.  
         
  24.         <servlet-name>spring</servlet-name>      
    25.  
         
  25.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>      
    26.  
         
  26.         <load-on-startup>1</load-on-startup>      
    27.  
         
  27.     </servlet>      
    28.  
         
  28.  
    29.  
         
  29.     <servlet-mapping> 
    30.  
         
  30.         <!--servlet名字--> 
    31.  
         
  31.         <servlet-name>spring</servlet-name>    
    32.  
         
  32.         <!--拦截所有请求，对静态文件会有问题，在spring-servlet.xml中解决--> 
    33.  
         
  33.         <url-pattern>/</url-pattern>      
    34.  
         
  34.     </servlet-mapping>  
    35.  
         
  35.    
    36.  
         
  36.     <welcome-file-list> 
    37.  
         
  37.         <welcome-file>index.htm</welcome-file> 
    38.  
         
  38.         <welcome-file>index.jsp</welcome-file> 
    39.  
         
  39.     </welcome-file-list> 
    40.  
         
  40. </web-app> 
    41.  
        
 
    
3、WEB-INF/spring-servlet.xml
 
    
 
    
     
         
  1. <?xml version="1.0" encoding="UTF-8"?> 
    2.  
         
  2. <beans xmlns="http://www.springframework.org/schema/beans" 
    3.  
         
  3.  xmlns:context="http://www.springframework.org/schema/context" 
    4.  
         
  4.  xmlns:p="http://www.springframework.org/schema/p" 
    5.  
         
  5.  xmlns:mvc="http://www.springframework.org/schema/mvc" 
    6.  
         
  6.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    7.  
         
  7.  xsi:schemaLocation="http://www.springframework.org/schema/beans 
    8.  
         
  8.       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
    9.  
         
  9.       http://www.springframework.org/schema/context 
    10.  
         
  10.       http://www.springframework.org/schema/context/spring-context.xsd 
    11.  
         
  11.       http://www.springframework.org/schema/mvc 
    12.  
         
  12.       http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd"> 
    13.  
         
  13.        
    14.  
         
  14.      <!-- 启动注解驱动的Spring MVC功能，注册请求url和注解POJO类方法的映射--> 
    15.  
         
  15.      <mvc:annotation-driven /> 
    16.  
         
  16.  
    17.  
         
  17.      <!-- 启动包扫描功能，以便注册带有@Controller、@Service、@repository、@Component等注解的类成为spring的bean --> 
    18.  
         
  18.      <context:component-scan base-package="com.test.mvc.web" /> 
    19.  
         
  19.  
    20.  
         
  20.      <!-- 对模型视图名称的解析，在WEB-INF/jsp目录下找对应的jsp文件 --> 
    21.  
         
  21.      <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" p:prefix="/WEB-INF/jsp/" p:suffix=".jsp" /> 
    22.  
         
  22.       
    23.  
         
  23.     <!--放过/scripts下的静态文件--> 
    24.  
         
  24.     <mvc:resources mapping="/scripts/**" location="/scripts/" /> 
    25.  
         
  25. </beans> 
    26.  
        
 
    
4、WEB-INF/applicationContext.xml
 
    
spring的配置文件，由于我们不使用它的其它功能，暂时放个空的就好了。
 
    
 
    
     
         
  1. <?xml version="1.0" encoding="UTF-8"?> 
    2.  
         
  2. <beans  
    3.  
         
  3.     xmlns="http://www.springframework.org/schema/beans" 
    4.  
         
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    5.  
         
  5.     xmlns:util="http://www.springframework.org/schema/util" 
    6.  
         
  6.     xsi:schemaLocation="http://www.springframework.org/schema/beans 
    7.  
         
  7.             http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
    8.  
         
  8.             http://www.springframework.org/schema/util 
    9.  
         
  9.             http://www.springframework.org/schema/util/spring-util-3.0.xsd"> 
    10.  
         
  10. </beans> 
    11.  
        
 
    
 
     
5、写Controller
 
     
 
     
     
          
  1. package com.test.mvc.web; 
    2.  
          
  2.  
    3.  
          
  3. import org.springframework.stereotype.*; 
    4.  
          
  4. import org.springframework.web.bind.annotation.*; 
    5.  
          
  5. import org.springframework.web.servlet.*; 
    6.  
          
  6.  
    7.  
          
  7. /** 
    8.  
          
  8.  * 控制器，用Controller注解 
    9.  
          
  9.  */ 
    10.  
          
  10. @Controller 
    11.  
          
  11. public class HomeController { 
    12.  
          
  12.  
    13.  
          
  13.     /** 
    14.  
          
  14.      * 映射到/welcome 
    15.  
          
  15.      */ 
    16.  
          
  16.     @RequestMapping(value = "/welcome") 
    17.  
          
  17.     public ModelAndView welcome(){ 
    18.  
          
  18.          
    19.  
          
  19.          ModelAndView mv = new ModelAndView("welcome");     //使用welcome.jsp，如果不写，根据url默认也是welcome.jsp 
    20.  
          
  20.          mv.addObject("hello", "Hello");    //model中增加一个名为hello的字符串 
    21.  
          
  21.           
    22.  
          
  22.          Client client = new Client(); 
    23.  
          
  23.          client.setName("User"); 
    24.  
          
  24.          mv.addObject("client", client);    //再增加一个名为client的自定义对象 
    25.  
          
  25.  
    26.  
          
  26.          return mv; 
    27.  
          
  27.     } 
    28.  
          
  28.      
    29.  
          
  29.     /** 
    30.  
          
  30.      * 如果不需要Model，直接返String更简单，对应的view为login_page.jsp 
    31.  
          
  31.      */ 
    32.  
          
  32.     @RequestMapping(value = "/login") 
    33.  
          
  33.     public String login(){ 
    34.  
          
  34.         return "login_page"; 
    35.  
          
  35.     } 
    36.  
          
  36.      
    37.  
          
  37.     /** 
    38.  
          
  38.      * 一个返回json的方法，用ResponseBody标识 
    39.  
          
  39.      * 可以在url中定义参数中，实现RESTful真是太简单了 
    40.  
          
  40.      * 传参很灵活，可以从url中取，也可以定义普通的 
    41.  
          
  41.      */ 
    42.  
          
  42.     @RequestMapping(value="/client/{name}", method = RequestMethod.GET) 
    43.  
          
  43.     @ResponseBody 
    44.  
          
  44.     public Client getClient(@PathVariable String name, String title){ 
    45.  
          
  45.         Client client = new Client(); 
    46.  
          
  46.         client.setName(title+ " " + name); 
    47.  
          
  47.          
    48.  
          
  48.         return client; 
    49.  
          
  49.     } 
    50.  
          
  50. } 
    51.  
         
 
     
里面用到了Client，很简单的POJO：
 
     
 
     
     
          
  1. package com.test.mvc.web; 
    2.  
          
  2.  
    3.  
          
  3. /** 
    4.  
          
  4.  * 自定义一个POJO 
    5.  
          
  5.  */ 
    6.  
          
  6. public class Client { 
    7.  
          
  7.     private String name; 
    8.  
          
  8.     public String getName() { 
    9.  
          
  9.         return name; 
    10.  
          
  10.     } 
    11.  
          
  11.     public void setName(String name) { 
    12.  
          
  12.         this.name = name; 
    13.  
          
  13.     } 
    14.  
          
  14. } 
    15.  
         
 
     
6、写视图
 
     
根据spring-servlet.xml中的配置，视图要放到WEB-INF/jsp下，新建welcome.jsp：
 
     
 
     
     
          
  1. <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> 
    2.  
          
  2. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> 
    3.  
          
  3. <html> 
    4.  
          
  4. <head> 
    5.  
          
  5. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> 
    6.  
          
  6. <title>Spring MVC</title> 
    7.  
          
  7. <script src="scripts/jquery-1.4.2.js"></script> 
    8.  
          
  8. <script> 
    9.  
          
  9. $(function(){ 
    10.  
          
  10.     $("#btnGet").click(function(){ 
    11.  
          
  11.         $.ajax({ 
    12.  
          
  12.             type: 'GET', 
    13.  
          
  13.             url : 'client/Tian',   //通过url传递name参数
    14.  
          
  14.             dataType : 'json', 
    15.  
          
  15.             data: {title: "Mr"},  //通过data传递title参数
    16.  
          
  16.             success : function(data) { 
    17.  
          
  17.                 alert(data.name);   
    18.  
          
  18.             }, 
    19.  
          
  19.             error : function(data) {   
    20.  
          
  20.                 alert(data.responseText); 
    21.  
          
  21.             }   
    22.  
          
  22.         });  
    23.  
          
  23.     }); 
    24.  
          
  24. }); 
    25.  
          
  25. </script> 
    26.  
          
  26. </head> 
    27.  
          
  27. <body> 
    28.  
          
  28. <!-- 显示model中的hello字符串和client对象的name -->
    29.  
          
  29. ${hello} 
    30.  
          
  30. ${client.name} 
    31.  
          
  31. <br/> 
    32.  
          
  32. <input id="btnGet" type="button" value="get client" /> 
    33.  
          
  33. </body> 
    34.  
          
  34. </html> 
    35.  
         
 
     
 一切就绪，把Tomcat跑起来吧，用浏览器访问 localhost:8080/mvc/welcome 就能看到页面了。
 
     
Spring MVC的实现原理与Struts2不同，底层基于servlet，在方法上进行拦截，因此理论上性能比Struts2要高，有兴趣的可以阅读这篇文章：http://elf8848.iteye.com/blog/698217