Tomcat URIEncoding、useBodyEncodingForURI 亂碼解決

時間  2019-11-13
標籤 tomcat uriencoding usebodyencodingforuri 亂碼 解決 欄目 Tomcat 简体版
原文   原文鏈接

繼續上一章節的亂碼問題。上一篇文章僅僅說了設置Tomcat的URIEncoding能夠解決亂碼問題，這篇文章便會講述這一背後的內容。首先說明下，光看是沒用的，要多實驗實驗。 

目前個人tomcat版本爲：7.0.55，spring全部文章的版本始終爲4.0.5 

本文章會從tomcat的源碼角度來解析Tomcat的兩個參數設置URIEncoding和useBodyEncodingForURI。 

對於一個請求，經常使用的有兩種編碼方式，以下： html

Java代碼  收藏代碼java

  1. <!DOCTYPE html>  
  2. <html>  
  3.     <head>  
  4.         <meta charset="utf-8" />  
  5.         <title></title>  
  6.     </head>  
  7.     <body>  
  8.         <form action="http://127.0.0.1:8080/string?name=中國" method="post">  
  9.             <input type="text" name="user" value="張三"/>  
  10.             <input type="submit" value="提交"/>  
  11.         </form>  
  12.     </body>  
  13. </html>  


首先說說結論： 
上述請求有兩處含有中文，一處是請求參數中，即？name='中國'，另外一處是請求體中，即user='張三'。對於這兩處tomcat7是分兩種編碼方式的。URIEncoding就是針對請求參數的編碼設置的，而filter的request.setCharacterEncoding('UTF-8')或者請求header中的content-type中的編碼都是針對請求體的。不要把他們搞混了。 

useBodyEncodingForURI=true是說，請求參數的編碼方式要採用請求體的編碼方式。當useBodyEncodingForURI=true時，若請求體採用utf-8解析，則請求參數也要採用utf-8來解析。這兩個屬性值的設置在tomcat的conf/server.xml文件中配置，以下： web

Java代碼  收藏代碼spring

  1. <Service name="Catalina">  
  2.   
  3.    <!--The connectors can use a shared executor, you can define one or more named thread pools-->  
  4.    <!--  
  5.    <Executor name="tomcatThreadPool" namePrefix="catalina-exec-"  
  6.        maxThreads="150" minSpareThreads="4"/>  
  7.    -->  
  8.   
  9.   
  10.    <!-- A "Connector" represents an endpoint by which requests are received  
  11.         and responses are returned. Documentation at :  
  12.         Java HTTP Connector: /docs/config/http.html (blocking & non-blocking)  
  13.         Java AJP  Connector: /docs/config/ajp.html  
  14.         APR (HTTP/AJP) Connector: /docs/apr.html  
  15.         Define a non-SSL HTTP/1.1 Connector on port 8080  
  16.    -->  
  17.    <Connector port="8080" protocol="HTTP/1.1"  
  18.               connectionTimeout="20000"  
  19.               redirectPort="8443" useBodyEncodingForURI='true' URIEncoding='UTF-8' />  
  20.    <!-- A "Connector" using the shared thread pool-->  


這樣寫只是說明這二者的配置位置，並非兩個屬性要同時配置，不要理解錯了。 
繼續說說CharacterEncodingFilter的做用。 
使用方式，將以下代碼加入web.xml文件中： apache

Java代碼  收藏代碼數組

  1. <filter>  
  2.         <filter-name>encoding</filter-name>  
  3.         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
  4.         <init-param>  
  5.             <param-name>encoding</param-name>  
  6.             <param-value>UTF-8</param-value>  
  7.         </init-param>  
  8.         <init-param>  
  9.             <param-name>forceEncoding</param-name>  
  10.             <param-value>true</param-value>  
  11.         </init-param>  
  12.     </filter>  
  13.   
  14.     <filter-mapping>  
  15.         <filter-name>encoding</filter-name>  
  16.         <url-pattern>/*</url-pattern>  
  17.     </filter-mapping>  


做用是，當forceEncoding爲false的前提下（默認爲false），當request沒有指定content-type或content-type不含編碼時，該filter將會爲這個request設定請求體的編碼爲filter的encoding值。 
當forceEncoding爲true的前提下，就會爲request的請求體和response都設定爲這個filter的encoding值。 
CharacterEncodingFilter源碼以下： tomcat

Java代碼  收藏代碼app

  1. public class CharacterEncodingFilter extends OncePerRequestFilter {  
  2.   
  3.     private String encoding;  
  4.   
  5.     private boolean forceEncoding = false;  
  6.   
  7.   
  8.     /** 
  9.      * Set the encoding to use for requests. This encoding will be passed into a 
  10.      * {@link javax.servlet.http.HttpServletRequest#setCharacterEncoding} call. 
  11.      * <p>Whether this encoding will override existing request encodings 
  12.      * (and whether it will be applied as default response encoding as well) 
  13.      * depends on the {@link #setForceEncoding "forceEncoding"} flag. 
  14.      */  
  15.     public void setEncoding(String encoding) {  
  16.         this.encoding = encoding;  
  17.     }  
  18.   
  19.     /** 
  20.      * Set whether the configured {@link #setEncoding encoding} of this filter 
  21.      * is supposed to override existing request and response encodings. 
  22.      * <p>Default is "false", i.e. do not modify the encoding if 
  23.      * {@link javax.servlet.http.HttpServletRequest#getCharacterEncoding()} 
  24.      * returns a non-null value. Switch this to "true" to enforce the specified 
  25.      * encoding in any case, applying it as default response encoding as well. 
  26.      * <p>Note that the response encoding will only be set on Servlet 2.4+ 
  27.      * containers, since Servlet 2.3 did not provide a facility for setting 
  28.      * a default response encoding. 
  29.      */  
  30.     public void setForceEncoding(boolean forceEncoding) {  
  31.         this.forceEncoding = forceEncoding;  
  32.     }  
  33.   
  34.   
  35.     @Override  
  36.     protected void doFilterInternal(  
  37.             HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)  
  38.             throws ServletException, IOException {  
  39.   
  40.         if (this.encoding != null && (this.forceEncoding || request.getCharacterEncoding() == null)) {  
  41.             request.setCharacterEncoding(this.encoding);  
  42.             if (this.forceEncoding) {  
  43.                 response.setCharacterEncoding(this.encoding);  
  44.             }  
  45.         }  
  46.         filterChain.doFilter(request, response);  
  47.     }  
  48.   
  49. }  


這個filter有兩個屬性,encoding和forceEncoding，咱們能夠在web.xml文件中來設定這兩個屬性值。 
每次request請求到來執行方法doFilterInternal，首先調用request.getCharacterEncoding()，本質就是從請求header content-type中獲取編碼值，若是沒有，則調用request.setCharacterEncoding(this.encoding)將該filter的encoding值設置爲請求體的編碼方式，記住該編碼方式只對請求體，不針對請求參數。當forceEncoding=true時，無論請求header content-type有沒有編碼方式，始終將該filter的encoding值設置到request和response中，一樣只針對request的請求體。 

以上的結論說完了，下面就要看看源代碼了。不想看的就算了不影響使用，想看看原理的請繼續： 

首先是三個名詞： 
org.apache.coyote.Request：這是一個最底層的request，包含各類參數信息。暫且稱爲coyoteRequest。 
org.apache.catalina.connector.Request：實現了HttpServletRequest接口，稱它爲request，同時包含了一個coyoteRequest，一個connector,待會你就會發現這個connector的編碼傳遞做用。 
org.apache.catalina.connector.RequestFacade：一樣實現了HttpServletRequest接口，它僅僅是一個裝飾類，稱它爲requestFacade，構造函數爲： ide

Java代碼  收藏代碼函數

  1. /** 
  2.      * Construct a wrapper for the specified request. 
  3.      * 
  4.      * @param request The request to be wrapped 
  5.      */  
  6.     public RequestFacade(Request request) {  
  7.   
  8.         this.request = request;  
  9.   
  10.     }  


該構造函數將一個org.apache.catalina.connector.Request傳進來，requestFacade的工做全是靠它內部的org.apache.catalina.connector.Request來完成的，org.apache.catalina.connector.Request又是依據它所包含的org.apache.coyote.Request這個最底層的類來完成的。經過org.apache.catalina.connector.Request，咱們能夠設定org.apache.coyote.Request的一些工做方式，如經過什麼編碼來解析數據。 

org.apache.coyote.Request含有的屬性： 
String charEncoding：針對請求體的編碼(在第一次解析參數時會傳遞給Parameters的encoding) 
Parameters ：用於處理和存放請求參數和請求體參數的類 
            （1）含String encoding：針對請求體的編碼 
            （2）含String queryStringEncoding：針對請求參數的編碼 
            （3）含Map<String,ArrayList<String>> paramHashValues：存放解析後的參數 
Parameters的兩個編碼是最最重要的編碼，直接參與解析數據的編碼，不像其餘對象的編碼大部分都是起傳遞做用，最終做用到Parameters的兩個編碼上 
 

Java代碼  收藏代碼

  1. public class MyCharacterEncodingFilter extends CharacterEncodingFilter{  
  2.   
  3.     @Override  
  4.     protected void doFilterInternal(HttpServletRequest request,  
  5.             HttpServletResponse response, FilterChain filterChain)  
  6.             throws ServletException, IOException {  
  7.         request.setCharacterEncoding("UTF-8");  
  8.         String name=request.getParameter("user");  
  9.         System.out.println(name);  
  10.         request.setCharacterEncoding("UTF-8");  
  11.         String name1=request.getParameter("user");  
  12.         System.out.println(name1);  
  13.         super.doFilterInternal(request, response, filterChain);  
  14.     }  
  15. }  


傳給過濾器filter的HttpServletRequest request實際上是org.apache.catalina.connector.RequestFacade類型的，咱們看下獲取參數的具體過程： 
requestFacade.getParameter("user")會傳遞到org.apache.catalina.connector.Request的相應方法，以下： 

Java代碼  收藏代碼

  1. public String getParameter(String name) {  
  2.   
  3.         if (!parametersParsed) {  
  4.             parseParameters();  
  5.         }  
  6.   
  7.         return coyoteRequest.getParameters().getParameter(name);  
  8.   
  9.     }  


parametersParsed是org.apache.catalina.connector.Request的屬性，用於標示是否已經解析過參數，若是解析過，便再也不解析，直接從coyoteRequest的Parameters參數中取出。因此當已經解析事後，你再去設置編碼，會無效的，由於它會直接返回第一次的解析結果。而且解析過程僅僅發生在第一次獲取參數的時候。 
咱們來看下parseParameters()這個解析參數的過程： 

Java代碼  收藏代碼

  1. /** 
  2.      * Parse request parameters. 
  3.      */  
  4.     protected void parseParameters() {  
  5.   
  6.         //解析發生後，便將是狀態置爲已解析  
  7.         parametersParsed = true;  
  8.   
  9.         Parameters parameters = coyoteRequest.getParameters();  
  10.         boolean success = false;  
  11.         try {  
  12.             // Set this every time in case limit has been changed via JMX  
  13.             parameters.setLimit(getConnector().getMaxParameterCount());  
  14.   
  15.             // getCharacterEncoding() may have been overridden to search for  
  16.             // hidden form field containing request encoding  
  17.             //重點1  
  18.             String enc = getCharacterEncoding();  
  19.             //重點2  
  20.             boolean useBodyEncodingForURI = connector.getUseBodyEncodingForURI();  
  21.             if (enc != null) {  
  22.                 parameters.setEncoding(enc);  
  23.                 if (useBodyEncodingForURI) {  
  24.                     parameters.setQueryStringEncoding(enc);  
  25.                 }  
  26.             } else {  
  27.                 parameters.setEncoding  
  28.                     (org.apache.coyote.Constants.DEFAULT_CHARACTER_ENCODING);  
  29.                 if (useBodyEncodingForURI) {  
  30.                     parameters.setQueryStringEncoding  
  31.                         (org.apache.coyote.Constants.DEFAULT_CHARACTER_ENCODING);  
  32.                 }  
  33.             }  
  34.             //重點3  
  35.             parameters.handleQueryParameters();  
  36.   
  37.             if (usingInputStream || usingReader) {  
  38.                 success = true;  
  39.                 return;  
  40.             }  
  41.   
  42.             if( !getConnector().isParseBodyMethod(getMethod()) ) {  
  43.                 success = true;  
  44.                 return;  
  45.             }  
  46.   
  47.             String contentType = getContentType();  
  48.             if (contentType == null) {  
  49.                 contentType = "";  
  50.             }  
  51.             int semicolon = contentType.indexOf(';');  
  52.             if (semicolon >= 0) {  
  53.                 contentType = contentType.substring(0, semicolon).trim();  
  54.             } else {  
  55.                 contentType = contentType.trim();  
  56.             }  
  57.   
  58.             if ("multipart/form-data".equals(contentType)) {  
  59.                 parseParts();  
  60.                 success = true;  
  61.                 return;  
  62.             }  
  63.   
  64.             if (!("application/x-www-form-urlencoded".equals(contentType))) {  
  65.                 success = true;  
  66.                 return;  
  67.             }  
  68.   
  69.             int len = getContentLength();  
  70.   
  71.             if (len > 0) {  
  72.                 int maxPostSize = connector.getMaxPostSize();  
  73.                 if ((maxPostSize > 0) && (len > maxPostSize)) {  
  74.                     if (context.getLogger().isDebugEnabled()) {  
  75.                         context.getLogger().debug(  
  76.                                 sm.getString("coyoteRequest.postTooLarge"));  
  77.                     }  
  78.                     checkSwallowInput();  
  79.                     return;  
  80.                 }  
  81.                 byte[] formData = null;  
  82.                 if (len < CACHED_POST_LEN) {  
  83.                     if (postData == null) {  
  84.                         postData = new byte[CACHED_POST_LEN];  
  85.                     }  
  86.                     formData = postData;  
  87.                 } else {  
  88.                     formData = new byte[len];  
  89.                 }  
  90.                 try {  
  91.                     if (readPostBody(formData, len) != len) {  
  92.                         return;  
  93.                     }  
  94.                 } catch (IOException e) {  
  95.                     // Client disconnect  
  96.                     if (context.getLogger().isDebugEnabled()) {  
  97.                         context.getLogger().debug(  
  98.                                 sm.getString("coyoteRequest.parseParameters"), e);  
  99.                     }  
  100.                     return;  
  101.                 }  
  102.                //重點4  
  103.                 parameters.processParameters(formData, 0, len);  
  104.             } else if ("chunked".equalsIgnoreCase(  
  105.                     coyoteRequest.getHeader("transfer-encoding"))) {  
  106.                 byte[] formData = null;  
  107.                 try {  
  108.                     formData = readChunkedPostBody();  
  109.                 } catch (IOException e) {  
  110.                     // Client disconnect or chunkedPostTooLarge error  
  111.                     if (context.getLogger().isDebugEnabled()) {  
  112.                         context.getLogger().debug(  
  113.                                 sm.getString("coyoteRequest.parseParameters"), e);  
  114.                     }  
  115.                     return;  
  116.                 }  
  117.                 if (formData != null) {  
  118.                     parameters.processParameters(formData, 0, formData.length);  
  119.                 }  
  120.             }  
  121.             success = true;  
  122.         } finally {  
  123.             if (!success) {  
  124.                 parameters.setParseFailed(true);  
  125.             }  
  126.         }  
  127.   
  128.     }  


上面有四處咱們須要關注的重點。 

重點1：getCharacterEncoding()實際上是經過底層的coyoteRequest來獲取header content-type中的編碼。 
以下： 

Java代碼  收藏代碼

  1. /** 
  2.      * Return the character encoding for this Request. 
  3.      */  
  4.     @Override  
  5.     public String getCharacterEncoding() {  
  6.       return coyoteRequest.getCharacterEncoding();  
  7.     }  

 

Java代碼  收藏代碼

  1. public String getCharacterEncoding() {  
  2.   
  3.        if (charEncoding != null)  
  4.            return charEncoding;  
  5.   
  6.        charEncoding = ContentType.getCharsetFromContentType(getContentType());  
  7.        return charEncoding;  
  8.   
  9.    }  


若無，則返回空。 

重點2： 
boolean useBodyEncodingForURI = connector.getUseBodyEncodingForURI();這裏就是咱們在tomcat的server中配置的useBodyEncodingForURI屬性的值。 

常量值org.apache.coyote.Constants.DEFAULT_CHARACTER_ENCODING="ISO-8859-1"； 

當重點1中的enc爲空時，則會設置底層coyoteRequest的parameters對象的encoding=s上述"ISO-8859-1"，即請求體採用"ISO-8859-1"來解析。當useBodyEncodingForURI=true時，請求參數和請求體的編碼設置的都是同一個值，即"ISO-8859-1"。當useBodyEncodingForURI=false時，不改變queryStringEncoding即請求參數的編碼，queryStringEncoding默認是爲null的，當解析時遇見queryStringEncoding也會採用默認的編碼"ISO-8859-1"，然而咱們能夠經過org.apache.catalina.connector.Request所包含的connector配置來給queryStringEncoding賦值。以下： 
當你在tomcat的server.xml文件中加入URIEncoding="UTF-8"時，它將會爲queryStringEncoding賦值此值。 
在tomcat的server.xml中配置此值 

Java代碼  收藏代碼

  1. <Service name="Catalina">  
  2.   
  3.     <!--The connectors can use a shared executor, you can define one or more named thread pools-->  
  4.     <!--  
  5.     <Executor name="tomcatThreadPool" namePrefix="catalina-exec-"  
  6.         maxThreads="150" minSpareThreads="4"/>  
  7.     -->  
  8.   
  9.   
  10.     <!-- A "Connector" represents an endpoint by which requests are received  
  11.          and responses are returned. Documentation at :  
  12.          Java HTTP Connector: /docs/config/http.html (blocking & non-blocking)  
  13.          Java AJP  Connector: /docs/config/ajp.html  
  14.          APR (HTTP/AJP) Connector: /docs/apr.html  
  15.          Define a non-SSL HTTP/1.1 Connector on port 8080  
  16.     -->  
  17.     <Connector port="8080" protocol="HTTP/1.1"  
  18.                connectionTimeout="20000"  
  19.                redirectPort="8443" URIEncoding='UTF-8'/>  


connector將這個值爲queryStringEncoding賦值的過程以下： 

Java代碼  收藏代碼

  1. public void log(org.apache.coyote.Request req,  
  2.            org.apache.coyote.Response res, long time) {  
  3.   
  4.        Request request = (Request) req.getNote(ADAPTER_NOTES);  
  5.        Response response = (Response) res.getNote(ADAPTER_NOTES);  
  6.   
  7.        if (request == null) {  
  8.            // Create objects  
  9.            request = connector.createRequest();  
  10.            request.setCoyoteRequest(req);  
  11.            response = connector.createResponse();  
  12.            response.setCoyoteResponse(res);  
  13.   
  14.            // Link objects  
  15.            request.setResponse(response);  
  16.            response.setRequest(request);  
  17.   
  18.            // Set as notes  
  19.            req.setNote(ADAPTER_NOTES, request);  
  20.            res.setNote(ADAPTER_NOTES, response);  
  21.   
  22.            // Set query string encoding  
  23.            //重點重點重點重點重點重點重點重點重點重點重點重點重點重點重點  
  24.            req.getParameters().setQueryStringEncoding  
  25.                (connector.getURIEncoding());  
  26.        }  

connector.getURIEncoding()即是咱們配置的URIEncoding值  req.getParameters().setQueryStringEncoding                  (connector.getURIEncoding());  這句代碼即是將咱們在tomcat的server.xml文件中配置的URIEncoding值設置進最重要的Parameters的queryStringEncoding中。  當重點1中的enc不爲空時,爲Parameters請求體的的編碼encoding設置爲enc。  至此，Parameters的encoding和queryStringEncoding都有相應的值了，而後便按照對應的編碼來解析字節數組。  重點3和4：有個相應的編碼方式，分別執行請求參數的解析過程和請求體的解析過程。  總結下一些設置的做用：  request.setCharacterEncoding(encoding) ：暴漏給咱們的request爲requestFacade，最終調用request->調用coyoteRequest->設置到coyoteRequest的charEncoding，因此coyoteRequest的charEncoding有兩種來源，一種多是content-type中的編碼，另外一種就是調用request.setCharacterEncoding(encoding) 方法。此方法最好在第一次解析參數以前調用，否則就無效。  URIEncoding：直接設置Parameters的queryStringEncoding的值。即針對請求參數的編碼。  useBodyEncodingForURI：設置queryStringEncoding的值=encoding的值，即請求參數採用請求體的編碼方式。 

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程