URIEncoding和useBodyEncodingForURI区别

最新推荐文章于 2020-03-20 23:52:24 发布
最新推荐文章于 2020-03-20 23:52:24 发布
阅读量7.4k 收藏 6
点赞数 1
文章标签： URIEncoding useBodyEncodingForUR

转载：http://www.360doc.com/content/14/1024/23/18637323_419613639.shtml


本文章会从tomcat的源码角度来解析Tomcat的两个参数设置URIEncoding和useBodyEncodingForURI。

对于一个请求，常用的有两种编码方式，如下：
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文件中配置，如下：
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" useBodyEncodingForURI='true' URIEncoding='UTF-8' />  
  20.    <!-- A "Connector" using the shared thread pool-->  

这样写只是说明这两者的配置位置，并不是两个属性要同时配置，不要理解错了。
继续说说CharacterEncodingFilter的作用。
使用方式，将如下代码加入web.xml文件中：
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源码如下：
Java代码   收藏代码
  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，构造函数为：
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的值，即请求参数采用请求体的编码方式。

交流学习
关注
request.getParameter()在get和post方法中文乱码问题
易天海
10-19 3704
乱码原因：Http请求传输时将url以ISO-8859-1编码，服务器收到字节流后默认会以ISO-8859-1编码来解码成字符流（造成中文乱码） post请求： 假设提交请求的jsp页面是UTF-8编码 &lt;%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%&gt; 解...
springmvc处理get/post请求乱码的多种方式【过滤器重新包装HttpServletRequest,配置tomcat的server.xml文件,获取数据时重新编码】
summer_style的博客
09-15 251
方式一 使用装饰着模式重新包装HttpServletRequest类。只修改Request的getParameter和getParameterValues方法 package com.omp.comm.getEncoding; import org.springframework.http.client.support.HttpRequestWrapper; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.
SpringMVC源码总结（五）Tomcat的URIEncoding、useBodyEncodingForURI和CharacterEncodingFilter
weixin_34148340的博客
02-07 175
2019独角兽企业重金招聘Python工程师标准>>> ...
URIEncoding与useBodyEncodingForURI 在tomcat中文乱码处理上的区别
星.云计算
07-16 300
大家知道tomcat5.0开始，对网页的中文字符的post或者get，经常会出现乱码现象。 具体是因为Tomcat默认是按ISO-8859-1进行URL解码，ISO-8859-1并未包括中文字符，这样的话中文字符肯定就不能被正确解析了。 常见的解决方法是在tomcat的server.xml下的connetor属性中增加URIEncoding或者useBodyEncodingForURI属性。 ...
在URL中传递中文的解决方式
热门推荐
ThinkingLink的专栏
05-13 1万+
在URL中传递中文的解决方式；服务器和浏览器客户端配置，额外对不兼容情况下进行前端编码然后再发送请求
Tomcat服务器配置URIEncoding
promote的博客
12-15 2319
URIEncoding 指的就是浏览器中地址栏中的编码格式。 配置代码： 在server.xml文件中，Connector标签下 添加 URIEncoding="UTF-8" <Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirect...
URL传中文参数导致乱码的解决方案之encodeURI
zhxtpray的专栏
09-05 1万+
[size=large]       通过URL传中文参数时，在服务端后台获取到的值往往会出现乱码。解决方案有很多种。本文介绍如何通过encodeURI来解决中文乱码问题。 首先，在前端页面准备参数的时候，需要对中文参数进行encode处理： var url = 'HelloWorldServlet?star_name='+ encodeURI(encodeURI("刘德华")); win
关于\"form表单提交数据编码方式和tomcat接受数据解码方式的思考\"一文的纠错
04-02
另外，Tomcat的配置文件`server.xml`中的`Connector`元素可以设置解码参数，比如`useBodyEncodingForURI`和`URIEncoding`。`useBodyEncodingForURI`设定是否使用请求体中的字符集来解码URL，而`URIEncoding`则用于...
毕设部分——准备项目bookstore项目
weixin_43773038的博客
03-20 1017
MySQL安装配置部分 MySQL下载——百度网盘 &nbsp &emsp 提取码：2rq4 Navicat premium下载——百度网盘 提取码：e5xm MySQL5.7安装
Tomcat和jsp的乱码处理和Myeclipse光标跳动的解决
08-11
1. **修改Tomcat配置**：打开Tomcat的`server.xml`文件，找到`Connector`标签，添加`useBodyEncodingForURI="true"`和`URIEncoding="UTF-8"`属性，确保请求和响应都以UTF-8编码。 2. **设置JSP页面编码**：在每个...
spring mvc 框架URL接收中文参数的乱码解决方案
qq_34078119的博客
08-02 592
在传值过程中，经常会碰到中文乱码的问题，处理我上篇文章中在web.xml中加入过滤器之外，还有一种更彻底的方法：配置tomcat目录下的service.xml文件 tomcat7/conf/server.xml给该行代码加上 URIEncoding=”UTF-8” 的编码属性 <Connector port="8080" protocol="HTTP/1.1" co
史上最全springboot配置，踩坑，注解，使用手册（持续更新中）
jsbintask的博客
02-15 1372
springboot 春节在家长了几斤肉，今天开始减肥了（工作了）。19年的第一篇文章，本篇文章将覆盖springboot所有配置（本人实际工作中所遇到问题以及学习总结），后续将会持续更新！话不多说，直接开始。 详细配置 注意：本演示全部基于springboot最新版本，现在是**2.1.2.RELEASE**，并且所有配置将全部使用yaml格式！ 如何配置springboot监听端口？ 通...
解决URL中参数乱码问题
刘振锋的博客
12-28 1457
Get提交方式，传递参数乱码例如：想使用重定向URL，response.sendRedirect(req.getContextPath()+"/index.jsp?info=请您先登录");这样，在index.jsp中显示info内容时，往往会出现乱码，这是由于tomcat默认采用ISO-8859-1对URL进行编码，而浏览器默认不采用任何编码；另外还有除了字母，数字，以及一些标点
关于Tomcat的URIEncoding以及GET乱码
weixin_33713350的博客
09-07 635
最近在维护着Linux上的服务器，当然，开发和前期测试是在windows上执行的。 在做意见反馈的时候，出现了windows上正常，Linux下却是乱码的问题。 先排查了web服务器与mysql的连接，确认问题处在前端页面和web之间的乱码交互。 前端的代码如下：是jQuery的跨域提交。 $(function(){ // var $btn_green = $(".btn_gr...
使用RESTful风格开发Java Web
anye0005的博客
05-29 277
什么是RESTful风格？ REST是REpresentational State Transfer的缩写（一般中文翻译为表述性状态转移），REST 是一种体系结构，而 HTTP 是一种包含了 REST 架构属性的协议，为了便于理解，我们把它的首字母拆分成不同的几个部分： 表述性（REpresentational）： REST 资源实际上可以用各种形式来进行表述，包括 XML、JSO...
encodeURIComponent为什么使用两遍
01-02 2500
从使用上看来，javascript使用encodeURIComponent编码一次，如果是作为Url请求发送，浏览器是自动会作一次解码，编码方式为浏览器默认。这样在一次编码后，请求到后台后，比如中文就成为乱码了。中间即使编码方式是一致也会乱码。解决方法是在前台javascript使用encodeURIComponentg两次，这样浏览器解码一次后，还是一种编码后的字符，传递到后台就不会是乱码，当然
知识积累1：tomcat的URIEncoding的作用
shixing_11的专栏
09-14 1477
tomcat5中，为了保证get数据采用UTF8编码，在server.xml中进行了如下设置： maxSpareThreads="75" enableLookups="false" redirectPort="8443"  acceptCount="100" debu
Tomcat与Servlet乱码问题深度解析及解决方案
- 检查并更新`server.xml`配置，确保`Connector`元素的`URIEncoding`和`useBodyEncodingForURI`属性符合需求。 通过理解这些编码机制和配置，我们可以有效地避免和解决Tomcat和Servlet环境下的乱码问题，确保数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值