2. 程式人生 > >Spring：一篇文章總結 Spring MVC

Spring：一篇文章總結 Spring MVC

阿新 • • 發佈：2019-01-09

1、簡介

1.1 Web MVC

在Web開發中，通常是瀏覽器傳送請求到伺服器，由伺服器接收請求並將響應傳遞給客戶端，並由客戶端渲染之後展示給使用者。因此，一般伺服器是無法主動通知客戶端更新內容的，雖然有些推送技術可以實現主動通知客戶端。

在標準的MVC裡，伺服器是可以主動將資料推送給客戶端的，但是實際的WebMVC是做不到的，如果使用者想要檢視更新，需要再發送一次請求。

Web端的開發經歷了從CGI->Servlet->JSP->Model1->Model2->Front Controller+PageController的過程：

  • CGI
    ：(Common Gateway Interface)公共閘道器介面，用於接收web使用者請求並處理，最後動態產生響應給使用者，但每次請求將產生一個程序，重量級。
  • Servlet：接收web使用者請求並處理，最後動態產生響應給使用者。但每次請求只產生一個執行緒（而且有執行緒池），輕量級。本質就是在java程式碼裡面 輸出 html流。
  • JSP：執行在標準的HTML頁面中嵌入指令碼語言，本質就是在html程式碼中嵌入java程式碼。JSP最終還是會被編譯為Servlet。
  • Model1：JSP的增強版，可以認為是jsp+javabean，使用jsp:useBean標準動作簡化javabean的獲取/建立，及將請求引數封裝到javabean。
  • Model2：Web MVC模型，只是控制器採用Servlet、模型採用JavaBean、檢視採用JSP。
  • Front Controller+PageController：即前端控制器+應用控制器+頁面控制器（也有稱其為動作）+上下文，也是Web MVC，只是責任更加明確。

1.2 Spring MVC

Spring MVC與Spring搭配可以為我們提供強大的功能，更加簡潔的配置方式。以下是Spring Web MVC處理請求的流程：

Spring Web MVC處理請求的流程

從上面的圖中，我們總結Spring MVC的請求處理流程。當用戶傳送請求之後：

  1. 使用者請求達到前端控制器，前端控制器根據URL找到處理請求的控制器
    ，並把請求委託給它；
  2. 控制器收到請求之後會呼叫業務處理物件對其進行處理，並對得到的資料模型進行處理從而得到ModelAndView，並將其返回給前端控制器；
  3. 前端控制器根據返回的檢視名選擇相應的檢視進行渲染，並把最終的響應返回給使用者。

結合Spring MVC框架中具體的類，我們又可以得到下面的這張更加詳盡的圖：

Spring Web MVC架構

在SpringMVC中的核心的類是DispatcherServlet，根據上面的分析，它可以算的上是中間排程的橋樑。我們引入Spring MVC的依賴之後看下相關的程式碼。
在DispatcherServlet中核心的方法是doDispatch()，下面是它的程式碼：

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpServletRequest processedRequest = request;
    HandlerExecutionChain mappedHandler = null;
    boolean multipartRequestParsed = false;
    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

    try {
        try {
            ModelAndView mv = null;
            Object dispatchException = null;

            try {
                // 1.首先檢視是否是Multipart，即是否包含要上傳的檔案
                processedRequest = this.checkMultipart(request);
                multipartRequestParsed = processedRequest != request;
                // 2.根據請求和handlerMappings(列表)，找到對應的HandlerExecutionChain
                mappedHandler = this.getHandler(processedRequest);
                if (mappedHandler == null || mappedHandler.getHandler() == null) {
                    this.noHandlerFound(processedRequest, response);
                    return;
                }

                // 3.同樣的方式，從一個HandlerAdapter的列表中獲取到對應的HandlerAdapter
                HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
                String method = request.getMethod();
                boolean isGet = "GET".equals(method);
                if (isGet || "HEAD".equals(method)) {
                    long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                    if (this.logger.isDebugEnabled()) {
                        this.logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
                    }

                    if ((new ServletWebRequest(request, response)).checkNotModified(lastModified) && isGet) {
                        return;
                    }
                }

                // 4.執行處理器相關的攔截器的預處理
                if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                    return;
                }

                // 5.由介面卡執行處理器（呼叫處理器相應功能處理方法），注意返回了ModelAndView
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                if (asyncManager.isConcurrentHandlingStarted()) {
                    return;
                }

                this.applyDefaultViewName(processedRequest, mv);
                // 6.執行處理器相關的攔截器的後處理
                mappedHandler.applyPostHandle(processedRequest, response, mv);
            } catch (Exception var20) {
                dispatchException = var20;
            } catch (Throwable var21) {
                dispatchException = new NestedServletException("Handler dispatch failed", var21);
            }
			
            // 7.處理分發結果，其中包含了一部分異常處理，也包括根據檢視名稱獲取檢視解析器並進行渲染等等
            this.processDispatchResult(processedRequest, response, mappedHandler, mv, (Exception)dispatchException);
        } catch (Exception var22) {
            this.triggerAfterCompletion(processedRequest, response, mappedHandler, var22);
        } catch (Throwable var23) {
            this.triggerAfterCompletion(processedRequest, response, mappedHandler, new NestedServletException("Handler processing failed", var23));
        }
    } finally {
        if (asyncManager.isConcurrentHandlingStarted()) {
            if (mappedHandler != null) {
                mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
            }
        } else if (multipartRequestParsed) {
            // 清理multipart請求佔用的資源
            this.cleanupMultipart(processedRequest);
        }
    }
}

// 該方法用來處理從處理器拿到的結果，不論是異常還是得到的ModelAndView都會被處理
private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
        HandlerExecutionChain mappedHandler, ModelAndView mv, Exception exception) throws Exception {
    boolean errorView = false;
	
    // 處理異常資訊
    if (exception != null) {
        if (exception instanceof ModelAndViewDefiningException) {
            this.logger.debug("ModelAndViewDefiningException encountered", exception);
            mv = ((ModelAndViewDefiningException)exception).getModelAndView();
        } else {
            Object handler = mappedHandler != null ? mappedHandler.getHandler() : null;
            mv = this.processHandlerException(request, response, handler, exception);
            errorView = mv != null;
        }
    }

    // 解析檢視並進行檢視的渲染 
    if (mv != null && !mv.wasCleared()) {
        // 實際的渲染方法，會根據ModelAndView的名稱找到對應的檢視解析器，並渲染得到一個檢視View
        this.render(mv, request, response);
        if (errorView) {
            WebUtils.clearErrorRequestAttributes(request);
        }
    } else if (this.logger.isDebugEnabled()) {
        this.logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + this.getServletName() + "': assuming HandlerAdapter completed request handling");
    }

    if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
        if (mappedHandler != null) {
            mappedHandler.triggerAfterCompletion(request, response, (Exception)null);
        }
    }
}

所以，我們可以總結Spriung MVC的工作原理如下：

  1. 使用者傳送的請求首先會到達DispatcherServlet，並由它進行處理；
  2. DispatcherServlet先通過HandlerMapping找到該請求對應的HandlerExecutionChain（包含一個Handler處理器、多個HandlerInterceptor攔截器），通過這種策略模式，很容易新增新的對映策略；
  3. 然後DispatcherServlet繼續將請求傳送給HandlerAdapter，HandlerAdapter會把處理器包裝為介面卡，從而支援多種型別的處理器，即介面卡設計模式，從而很容易支援很多型別的處理器；
  4. HandlerAdapter將會根據適配的結果呼叫真正的處理器的功能處理方法，完成功能處理，並返回一個ModelAndView物件（包含模型資料、邏輯檢視名）；
  5. 再由DispatcherServlet根據ModelAndView找到對應的ViewResolver，並由它把邏輯檢視名解析為具體的View，通過這種策略模式，很容易更換其他檢視技術；
  6. 接下來會對View進行渲染，View會根據傳進來的Model模型資料進行渲染，Model實際是一個Map資料結構，因此很容易支援其他檢視技術；
  7. 返回控制權給DispatcherServlet，由DispatcherServlet返回響應給使用者，到此一個流程結束。

2、使用Spring MVC

2.1 Spring MVC基於XML的配置方式

首先，要使用Spring MVC需要加入相關的依賴：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>${spring.version}</version>
</dependency>

我們上面分析過的DispatcherServlet是註冊到web.xml裡面的，我們需要加入如下的配置：

<!DOCTYPE web-app PUBLIC
		"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
		"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
	<display-name>Archetype Created Web Application</display-name>

	<servlet>
		<servlet-name>spring_is_coming</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>spring_is_coming</servlet-name>
		<url-pattern>*.mvc</url-pattern>
	</servlet-mapping>
</web-app>

這裡我們註冊了一個servlet，即上面提到的DispatcherServlet，併為其指定一個名稱為spring_is_coming。對應的，我們還要為其指定一個servlet-mapping。
如上所示，我們在url-pattern中指定了該servlet要處理的url的模式，即所有以*.mvc結尾的url。load-on-startup表示啟動容器時初始化該Servlet。

預設情況下，DispatcherServlet會載入WEB-INF/[DispatcherServlet的Servlet名字]-servlet.xml下面的配置檔案。根據上面的配置我們需要在當前專案的WEB-INF目錄下面加入spring_is_coming-servlet.xml檔案。並在該檔案中加入如下的程式碼：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"
       xmlns:p="http://www.springframework.org/schema/p">

    <!-- HandlerMapping -->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

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

    <!-- ViewResolver -->
    <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>

    <bean name="/hello.mvc" class="me.shouheng.spring.mvc.HelloController"/>

</beans>

這裡我們聲明瞭幾個Bean，即HandlerMapping和HandlerAdapter的預設實現。然後，我們還定義了一個檢視解析器InternalResourceViewResolver。
它是一個預設的檢視解析器，在它的屬性配置中，我們指定了載入的檔案的字首和字尾路徑。實際上，當我們指定某個檢視名字為hello，那麼該檢視解析器就會載入檔案
/WEB-INF/jsp/hello.jsp。

接下來我們定義了一個控制器，該控制器的名字對應於指定的url。因為之前我們使用了Bean的對映規則是BeanNameUrlHandlerMapping，也就是說Bean的名稱和url對應。

然後就是上面定義的那個控制器的程式碼：

public class HelloController implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView mv = new ModelAndView();
        // 新增模型資料 可以是任意的POJO物件
        mv.addObject("message", "Hello Spring MVC!");
        // 設定邏輯檢視名，檢視解析器會根據該名字解析到具體的檢視頁面
        mv.setViewName("hello");
        return mv;
    }
}

這裡我們用了ModelAndView.setViewName()為該ModelAndView指定了對應的jsp檔案的名稱，會按照我們上面配置的檢視解析的規則到指定目錄下記載指定名稱的檔案。

啟動伺服器，在瀏覽器中輸入地址：http://localhost:8080/hello.mvc，進行測試即可。

2.2 使用過濾器

我們還可以在分發器處理請求之前對其進行處理，我們通過過濾器來實現。我們可以用過濾器來做一些基礎的工作，比如字串編碼之類的問題。下面我們通過一個自定義的簡單的例子來演示一下過濾器的使用：

首先，我們自定義一個簡單的過濾器，並在其中輸出一些資訊到控制檯上：

public class TheFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("init, filterConfig" + filterConfig);
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("==================================== doFilter, servletRequest: "
                + servletRequest
                + "\nservletResponse: "
                + servletResponse
                + "\nfilterChain: " + filterChain);
        // 必須呼叫這個方法，否則請求就要在這裡被攔截了
        filterChain.doFilter(servletRequest, servletResponse);
    }

    @Override
    public void destroy() {
        System.out.println("destroy");
    }
}

這裡我們要實現Fileter介面的三個與宣告週期相關的方法。然後，將其配置到web.xml中就可以了：

<filter>
    <filter-name>the_filter</filter-name>
    <filter-class>me.shouheng.spring.mvc.TheFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>the_filter</filter-name>
    <url-pattern>*.mvc</url-pattern>
</filter-mapping>

這樣我們就可以對所有以*.mvc結尾的請求進行處理了。

2.3 DispatcherServlet詳解

實際上DispatcherServlet是Servlet的一種，也就是當我們使用Spring MVC的時候需要配置該類，因為它是Spring MVC的核心配置類。而當我們不打算使用Spring MVC而想要為其他客戶端提供介面的時候就需要配置其他型別的Servlet，不過它們的配置和在Servlet種被使用的原理都是一樣的。。

上面我們已經提到過了DispatcherServlet的兩個引數的意義，並且使用了配置檔案spring_is_coming-servlet.xml。而實際上為DispatcherServlet指定配置檔案的方式可以有多種：

第一種，預設會使用[DispatcherServlet的Servlet名字]-servlet.xml這種命名規則到WEB-INF目錄下面載入該檔案，這也是我們上面使用的方式。

第二種方式是在配置servlet的時候，在<servlet>標籤中使用contextClass，並且指定一個配置類，該配置類需要實現WebApplicationContext介面的類。如果這個引數沒有指定， 預設使用XmlWebApplicationContext。

第三種方式是與第二種類似，都是在配置servlet的時候指定，不過這裡使用的是contextConfigLocation，並用字串來指定上下文的位置。這個字串可以被分成多個字串（使用逗號作為分隔符） 來支援多個上下文（在多上下文的情況下，如果同一個bean被定義兩次，後面一個優先）。如下所示：

   <servlet>
        <servlet-name>chapter2</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-servlet-config.xml</param-value>
        </init-param>
    </servlet>

通常在我們配置上下文的時候會指定多個上下文，各個上下文也有自己的職責範圍。除了之前我們配置的Servlet的上下文，在使用Spring的時候，我們還需要配置整個應用的上下文：

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>
         classpath:spring-common-config.xml,
         classpath:spring-budget-config.xml
    </param-value>
</context-param>
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

這裡配置的就是整個應用的上下文，配置的ContextLoaderListener會在容器啟動的時候自動初始化應用程式上下文。而該應用程式上下文的配置檔案就由上面的context-param來指定。應用程式上下文通常用來載入整個程式的基礎類，比如DAO層和Service層等。這樣它們就可以與任何其他的Web層配合使用。而Servlet配置的上下文通常用來載入Web層需要的類，比如Controller、HandlerMapping、HandlerAdapter等等。

2.4 攔截器

在DispatcherServlet種攔截器處理的邏輯是非常簡單易懂的。
DispatcherServlet會在的核心方法doDispatch()的不同的處理階段呼叫HandlerExecutionChain的三個方法（在新版本的Spring中相關的邏輯被抽取出來封裝成了獨立的方法）。

  1. HandlerExecutionChain.applyPreHandle()會在Contoller的方法被執行之前呼叫；
  2. HandlerExecutionChain.applyPostHandle()會在Contoller的方法被執行之後，並且檢視被渲染之前呼叫，如果中間出現異常則不會被呼叫；`
  3. HandlerExecutionChain.triggerAfterCompletion()會在Contoller的檢視被渲染之後呼叫，無論是否異常，總是被呼叫；

那麼，在這三個方法中又做了什麼呢？下面就是相關的邏輯，實際上三個方法是類似的，即從一個數組中取出定義的攔截器進行遍歷呼叫：

boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HandlerInterceptor[] interceptors = this.getInterceptors();
    if (!ObjectUtils.isEmpty(interceptors)) {
        for(int i = 0; i < interceptors.length; this.interceptorIndex = i++) {
            HandlerInterceptor interceptor = interceptors[i];
            if (!interceptor.preHandle(request, response, this.handler)) {
                this.triggerAfterCompletion(request, response, (Exception)null);
                return false;
            }
        }
    }
    return true;
}

所以，這部分的邏輯也不復雜。那麼，那麼我們看下如何在Spring MVC中使用攔截器：

<bean name="interceptor" class="me.shouheng.spring.mvc.TestInterceptor"/>

<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/hello2.mvc"/>
        <ref bean="interceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

我們還是在之前的spring_is_coming-servlet.xml中加入上面的幾行程式碼，這裡我們用到了一個自定義的攔截器，下面我們給出它的定義：

public class TestInterceptor extends HandlerInterceptorAdapter {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("=========preHandle");
        return super.preHandle(request, response, handler);
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("=========postHandle");
        super.postHandle(request, response, handler, modelAndView);
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("=========afterCompletion");
        super.afterCompletion(request, response, handler, ex);
    }

    @Override
    public void afterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("=========afterConcurrentHandlingStarted");
        super.afterConcurrentHandlingStarted(request, response, handler);
    }
}

然後，我們使用<mvc:interceptor>標籤定義了對應的攔截器及其要匹配的路徑。這樣當訪問指定的url時，在觸發響應的Controller的時候就會呼叫到我們定義的攔截器。

這裡我們還要說明一下HandlerInterceptorAdapter中的幾個方法。
實際上所有的攔截器最終都是實現了介面HandlerInterceptor，而上面的類中的前三個方法實際上就是來自於該介面。
在preHandle()的返回值預設是true，表示當前攔截器處理完畢之後會繼續讓下一個攔截器來處理。
實際上參考上面的HandlerExecutionChain.applyPreHandle()方法也能看出這一點。

2.5 基於註解的配置方式

在基於註解的配置方式中，我們需要對上面的配置做一些修改。首先，我們使用基於註解的介面卡和對映機制。在spring_is_coming-servlet.xml中，我們將之前的程式碼替換為：

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/>

注意上面的這兩行程式碼是Spring 3.1之後的配置方式，而3.1之前的程式碼在最新的Spring版本中已經移除，不再贅訴。

然後，我們定義如下的Controller：

@Controller
public class HelloController3 {

    @RequestMapping(value = "/hello3")
    public ModelAndView handle() {
        ModelAndView mv = new ModelAndView();
        // 新增模型資料 可以是任意的POJO物件
        mv.addObject("message", "Hello Spring MVC!");
        // 設定邏輯檢視名，檢視解析器會根據該名字解析到具體的檢視頁面
        mv.setViewName("hello3");
        return mv;
    }
}

這裡的配置方式和之前基於Bean名稱對映的機制類似，只是這裡使用都是基於註解的配置方式。在作為Controller使用的類上面，我們要使用@Controller註解，具體的業務層方法上面使用@RequestMapping註解並指定對映的路徑。然後，我們將該Bean註冊到上下文當中：

<bean class="me.shouheng.spring.mvc.HelloController3"/>

這樣基本的配置方式就已經完成了。然後，執行Web容器並輸入url:http://localhost:8080/hello3即可。還要注意下，還要修改web.xml中的Servlet的匹配路徑，如果是*.mvc的話要改成/。

其實這裡的配置方式和之前的配置方式唯一的區別也就在於，將對映的規則從之前的Bean名到url轉換成了註解到url。

除了上面的那種方式配置url路徑，我們還可以新增各種子路徑。比如：

@Controller
@RequestMapping("/user")
public class HelloController3 {

    @RequestMapping(value = "/hello3")
    public ModelAndView handle() {
        ModelAndView mv = new ModelAndView();
        // 新增模型資料 可以是任意的POJO物件
        mv.addObject("message", "Hello Spring MVC!");
        // 設定邏輯檢視名，檢視解析器會根據該名字解析到具體的檢視頁面
        mv.setViewName("hello3");
        return mv;
    }
}

按照上面的方式，將會匹配到：/user/hello3。

2.6 RequestMapping註解

從上面看出使用註解的配置方式中，核心的配置應該屬於@RequestMapping註解。下面是該註解的定義：

public @interface RequestMapping {
    String name() default "";
    @AliasFor("path") String[] value() default {};
    @AliasFor("value") String[] path() default {};
    RequestMethod[] method() default {};
    String[] params() default {};
    String[] headers() default {};
    String[] consumes() default {};
    String[] produces() default {};
}

其中:

  1. name用來為當前的控制器指定一個名稱；
  2. value和path是等價的，都是用來指定url的匹配規則的；
  3. method用來指定匹配的方法，比如POST, GET等等；
  4. consumes用來指定請求的提交內容型別（Content-Type），例如application/json, text/html；
  5. params：指定request中必須包含某些引數值是，才讓該方法處理；
  6. headers：指定request中必須包含某些指定的header值，才能讓該方法處理請求；
  7. produces：指定request中必須包含某些指定的header值，才能讓該方法處理請求；

下面我們對其中的幾個方法進行簡單說明。

2.6.1 value和path

這兩個引數的效果是等價的，因為它們相互之間只是一個別名的關係。這兩個引數用來指定該控制器要對映的url，這裡我們列舉一下常見的url對映配置方式：

  1. @RequestMapping(value={"/test1", "/user/create"})：多個URL路徑對映到同一個處理器；
  2. @RequestMapping(value="/users/{userId}")：使用url佔位符，如"/users/123456"或"/users/abcd"，通過@PathVariable可以提取URI模板模式中的變數；
  3. @RequestMapping(value="/users/**")：可以匹配“/users/abc/abc”，但“/users/123”將會被2中的模式優先對映到；
  4. @RequestMapping(value="/product?")：可匹配“/product1”或“/producta”，但不匹配“/product”或“/productaa”；
  5. @RequestMapping(value="/product*")：可匹配“/productabc”或“/product”，但不匹配“/productabc/abc”；
  6. @RequestMapping(value="/product/*")：可匹配“/product/abc”，但不匹配“/productabc”
  7. @RequestMapping(value="/products/**/{productId}")：可匹配“/products/abc/abc/123”或“/products/123”；
  8. 基於正則表示式的方式。

配置方式2方式的特別說明，指定路徑中的引數並在方法中獲取引數的具體示例：

@RequestMapping("/testPathVariable/{id}")
public String testPathVariable(@PathVariable("id") Integer id2) {
    System.out.println("testPathVariable: " + id2);
    return SUCCESS;
}

2.6.2 params

該引數用來限制只有當請求中包含指定引數名的資料時才會被處理，比如:

@Controller
@RequestMapping("/parameter1")                                      //①處理器的通用對映字首
public class RequestParameterController1 {
    @RequestMapping(params="create", method=RequestMethod.GET) 
    public String showForm() {
	    ....
    }
    @RequestMapping(params="create", method=RequestMethod.POST)  
    public String submit() {
	    ....       
    }
}

其中的第一個方法表示請求中有“create”的引數名且請求方法為“GET”即可匹配，如可匹配的請求URL“http://×××/parameter1?create”；
第二個方法表示請求中有“create”的引數名且請求方法為“POST”即可匹配。

當然你還可以進一步限制當請求中包含指定的引數並且為指定的值時才能被處理，比如@RequestMapping(params="submitFlag=create", method=RequestMethod.GET)：表示請求中有“submitFlag=create”且請求方法為“GET”才可匹配。

還要注意，從@RequestMapping中的params定義中可以看出，它是一個數組，當指定多個值的時候，這些值之間屬於’且’的關係，即兩個引數同時包含才行。

2.6.3 consumes

consumes用來指定該控制器要處理的請求的資料型別，所謂媒體型別就是指text/plain application/json等等。
它們會被放在請求的請求頭中，比如Content-Type: application/x-www-form-urlencoded表示請求的資料為key/value資料，
只有當請求資料與控制器在@RequestMapping中指定的資料相同的時候，指定的請求才會被該控制器處理。

@RequestMapping(value = "/testMethod", method = RequestMethod.POST,consumes="application/json")
public String testMethod() {
    System.out.println("testMethod");
    return SUCCESS;
}

比如以上控制器只接受json型別的資料。當請求的資料非json的時候是不會被其處理的。

2.6.4 produces

produces用來指定當前的請求希望得到什麼型別的資料，這個引數在請求的時候會被放到請求頭的Accept中。
只有當請求的Accept型別與控制器中使用produces指定的型別相同的時候才會被該控制器接受並處理。

2.6.5 headers

如果說前面的consumes和produces用來指定請求的和希望得到的資料型別是一種特例的話，
那麼這裡的headers則是可以用來更加靈活地指定headers中需要包含那些資訊才能被當前的控制器處理。
比如：

@RequestMapping(value = "testParamsAndHeaders", params = { "username","age!=10" }, headers = { "Accept-Language=US,zh;q=0.8" })
public String testParamsAndHeaders() {
    System.out.println("testParamsAndHeaders");
    return SUCCESS;
}

用來設定請求頭中第一語言必須為US。

3、其他

3.1 攔截器和過濾器的區別

  1. 攔截器是基於java的反射機制的，過濾器是基於函式回撥；
  2. 攔截器不依賴於servlet容器，過濾器依賴於servlet容器，因為過濾器是Servlet規範規定的，只用於Web程式中，而攔截器可以用在Appliaction和Swing等中；
  3. 在Action的生命週期中，攔截器可以多次被呼叫，而過濾器只能在容器初始化時被呼叫一次；
  4. 攔截器可以獲取IOC容器中的各個bean，而過濾器就不行，這點很重要，在攔截器裡注入一個service，可以呼叫業務邏輯;
  5. 過濾器是在請求進入容器後，但請求進入servlet之前進行預處理的。請求結束返回也是，是在servlet處理完後，返回給前端之前。

實際上從上面的配置中也可以看出來，過濾器在請求達到Servlet之前被呼叫的，它屬於Servlet而不屬於Spring。

我是 WngShhng. 如果您喜歡我的文章，可以在以下平臺關注我：

相關推薦

Spring：一篇文章總結 Spring MVC

1、簡介 1.1 Web MVC 在Web開發中，通常是瀏覽器傳送請求到伺服器，由伺服器接收請求並將響應傳遞給客戶端，並由客戶端渲染之後展示給使用者。因此，一般伺服器是無法主動通知客戶端更新內容的，雖然有些推送技術可以實現主動通知客戶端。 在標準的MVC裡，伺服器是可以主動將

五分鐘學Java：一篇文章搞懂spring和springMVC

原創宣告 本文作者：黃小斜 轉載請務必在文章開頭註明出處和作者。 本文思維導圖 什麼是Spring，為什麼你要學習spring？ 你第一次接觸spring框架是在什麼時候？相信很多人和我一樣，第一次瞭解spring都不是做專案的時候用到，而是在網上看到或者是聽到過一個叫做spring的框架，這個框架號稱完

五分鐘學Java：一篇文章帶你搞懂spring全家桶套餐

原創宣告 本文首發於微信公眾號【程式設計師黃小斜】 本文作者：黃小斜 轉載請務必在文章開頭註明出處和作者。 本文思維導圖 什麼是Spring，為什麼你要學習spring？ 你第一次接觸spring框架是在什麼時候？相信很多人和我一樣，第一次瞭解spring都不是做專案的時候用到，而是在網上看到或者是聽到過

一篇文章概括Spring Cloud微服務教程

現在流行的是Spring Cloud基於NetFlix解決方案提供的解決方案。那麼讓我們來演示如何使用它。   一、 註冊中心 基於Spring Cloud的MicroServices的Hearth是Eureka Server。也稱為Discovery Server。因為該伺服

一篇文章學會Spring+SpringMVC+Mybatis+Maven搭建和部署，記一次Spring+SpringMVC+Mybatis+Maven的整合

之前一直沒有用過maven和Mybatis最近自己搭建一個基於Maven的Spring+SpringMVC+Mybatis開發環境。注：有的時候沒有自己動手真正搭過環境（脫離教學的方式），可能有些地方的問題注意不到的。會在介紹搭建的同時記錄一些遇見的坑和一些知識點。首先放上M

JAVA：一篇文章理清多態

Java 多態 很多人總是喜歡，或者說錯誤地將JAVA中的多態理解得很復雜，最常見的錯誤說法就是所謂“方法的多態”，他們會給出類似下面的例子來佐證“多態是指方法的多態”： 復制代碼 //Enginner和Mechanic是Employee的子類，構造函數參數均為月薪salaryEmployee a=n

螞蟻技術專家：一篇文章帶你學習分布式事務

自己實現 鎖定 ons 快速 事務管理器 獲取 currency 定性 能力 小螞蟻說： 分布式事務是企業集成中的一個技術難點，也是每一個分布式系統架構中都會涉及到的一個東西，特別是在這幾年越來越火的微服務架構中，幾乎可以說是無法避免，本文就圍繞分布式事務各方面與大家進行介

阿裏雲周源：一篇文章讀懂四代視頻加密技術演進

阿裏 私鑰 png 優缺點 一點 比較 一定的 nag 希望 摘要： 在剛剛圓滿落幕的LiveVideoStackCon峰會上，阿裏雲高級技術專家周源進行了《視頻加密和DRM的實施實踐》主題分享。周源，有十多年音視頻研發經驗，之前在淘寶視頻負責開放平臺，目前在阿裏雲視頻雲部

#Java乾貨分享：一篇文章讓你深入瞭解Java中的包和介面

很多新手程式設計師對於Java中兩個具創新性的特徵————包與介面不是非常清楚，所以我特意發了這篇文章來闡述什麼是包，什麼是介面。 包（package）是多個類的容器，它們用於保持類的名稱空間相互隔離。 如果有想學習java的程式設計師，可來我們的java學習扣qun：79979，2590免

阿里雲周源：一篇文章讀懂四代視訊加密技術演進

摘要： 在剛剛圓滿落幕的LiveVideoStackCon峰會上，阿里雲高階技術專家周源進行了《視訊加密和DRM的實施實踐》主題分享。周源，有十多年音視訊研發經驗，之前在淘寶視訊負責開放平臺，目前在阿里雲視訊雲部門負責媒體處理，在大規模系統建設和雲端計算方面都有非常豐富的實戰

新媒體推廣：一篇文章學會全平臺資訊流優化 ！你get到了嗎？ | 黎想

想必大家都有這樣的思考：我做新媒體優化一年，仍然有很多問題，比如多久更新一次賬戶創意，有規律可循嗎？展點消之間存在什麼關係呢？賬戶出價到底有什麼訣竅嗎？ 本次將由藝形藝意工作室創始人，新媒體運營老司機，IT行業觀察者，騰訊網、百度網、今日頭條、搜狐網、網易新聞網、鳳凰新聞網等網站知名專欄作者，《新媒體推廣運

YH12：一篇文章讀懂SCAN

單客戶端訪問名稱（SCAN）是Oracle RAC環境中使用的功能，為客戶端提供訪問叢集中執行的任何Oracle資料庫的單一名稱。 使用者可以將SCAN視為RAC資料庫的叢集別名。 使用SCAN的好處是，如果在叢集中新增或刪除節點或資料庫，則客戶端的連線資訊不需要更改。 SCAN首次引入了Oracl

水滴動態IP：一篇文章告訴你，IP地址是如何劃分的

IP地址分為五類，A類保留給政府機構，B類分配給中等規模的公司，C類分配給任何需要的人，D類用於組播，E類用於實驗，各類可容納的地址數目不同。     A類地址 （1）A類地址第1位元組為網路地址，其它3個位元組為主機地址。它的第1個位元組的第一位固定為0. （2）A類地址網路號

用一篇文章總結Javascript

JS是由以下三個組成部分，下面我也會按這三個部分依次總結，只需掌握這些基本語法，再學會如何查JS文件，基本上就差不多了，不要強記，用的時候不記得都在文件裡了，多動手敲敲自然就熟透於心啦！文末有JS文件下載連結，最好備一個。 ECMAScript：js基礎語法

功能測試之一：一篇文章帶你領略專業的功能測試基礎

本文主要介紹；顯式功能性需求（Functional requirement）顯式功能性需求（Functional requirement）的含義從字面上就可以很好地理解，指的是軟體本身需要實現的具體功能， 比如“正常使用者使用正確的使用者名稱和密碼可以成功登入”、非註冊使用者

探祕Netty7：一篇文章，讀懂Netty的高效能架構之道

Netty是一個高效能、非同步事件驅動的NIO框架，它提供了對TCP、UDP和檔案傳輸的支援，作為一個非同步NIO框架，Netty的所有IO操作都是非同步非阻塞的，通過Future-Listener機制，使用者可以方便的主動獲取或者通過通知機制獲得IO操作結果。 作為當前最流

一篇文章總結了JVM執行緒安全

繼上一篇文章的知識點，繼續總結JVM裡面的執行緒安全 一、什麼是執行緒安全 一個老生常談的問題，如果一個物件可以安全的被多個執行緒同時使用，那它就是執行緒安全的。 當多個執行緒訪問一個物件時，如果不用考慮這些執行緒在執行時環境下的排程和交替執行

Python高級語法之：一篇文章了解yield與Generator生成器

而不是 xrange 需要 num 是不是 兩個 ack 第一次 進行 Python高級語法中，由一個yield關鍵詞生成的generator生成器，是精髓中的精髓。它雖然比裝飾器、魔法方法更難懂，但是它強大到我們難以想象的地步：小到簡單的for loop循環，大到代替多線

精辟：一篇文章帶你看懂數據儲存！

安全問題 mark cap 伸縮 雲盤 增長 租戶 影響 圖片 前言：日益火熱的雲服務 小米組織架構調整上了熱搜，如同阿裏巴巴、華為和騰訊一樣，小米組織架構調整中也將雲平臺單獨成為一個部門。自2018年以來，各大企業調整組織架構的動作中，其實可以窺見大企業對雲平臺的重視程度

宜信-運維-資料庫|SQL優化：一篇文章說清楚Oracle Hint的正確使用姿勢

一、提示（Hint）概述 1、為什麼引入Hint? Hint是Oracle資料庫中很有特色的一個功能，是很多DBA優化中經常採用的