最近在研究java原生方法实现http服务，但网上一直没有找到可靠的x-www-form-urlencoded编码/解码代码，要么找到的就是简单的一维key-value转换，无法实现复杂对象的转换，例如提交以下参数：
 
 我写的代码提供两个静态方法，分别是实现编码的方法public static String urlencode(Object params, String key)，和实现解码的方法public static Map<String, Object> urldecode(String param)。
 编码方法传入的params参数支持包含String、Number、Map、List或者上述类型的数组对象。
 解码方法输出统一是map对象，如传入的参数包含有数组或者list对象，则输出时统一转化为list对象。
 
代码中已经提供了测试方法，运行main方法即可看到结果。
 
 
package com.util;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.lang3.ArrayUtils;

public class HttpUrlParams {
	
	public static void main(String args[]) {
		Map<String, Object> map = new HashMap<String, Object>();
			List<Object> list = new ArrayList<Object>();
			list.add("aa");
			list.add(123);
			list.add(new Object[] {"qq", 11});
		map.put("list", list);
			Map<String, Object> childMap = new HashMap<String, Object>();
			childMap.put("num", 78);
			childMap.put("str", "str?!+-str");
			childMap.put("array", new int[] {44,55});
		map.put("childMap", childMap);
		map.put("array", new String[] {"ss", "Kk"});
		
		System.out.println(map);
		String encodeStr = urlencode(map, "");
		System.out.println(encodeStr);
		Object decodeObj = urldecode(encodeStr);
		System.out.println(decodeObj);
	}
	
	public static String urlencode(Object params, String key) {
		String res = "";
		if(params instanceof Map) {
			Map<String, Object> _params = (Map<String, Object>) params;
			for(String i : _params.keySet()) {
				String k = key.isEmpty() ? i : (key +"["+ i +"]");
				String encodeValue = urlencode(_params.get(i), k);
				if(!encodeValue.isEmpty()) {
					res += '&'+ encodeValue;
				}
			}
		}
		else if(params instanceof List) {
			List<Object> _params = (List<Object>) params;
			for(Integer i = 0; i < _params.size(); i++) {
				String k = key.isEmpty() ? i.toString() : (key +"["+ i.toString() +"]");
				String encodeValue = urlencode(_params.get(i), k);
				if(!encodeValue.isEmpty()) {
					res += '&'+ encodeValue;
				}
			}
		}
		else if(params.getClass().isArray()) {
			Object[] _params;
			if(params instanceof Object[]) {
				_params = (Object[]) params;
			}
			else if(params instanceof String[]) {
				_params = (String[]) params;
			}
			else if(params instanceof int[]) {
				_params = ArrayUtils.toObject((int[]) params);
			}
			else if(params instanceof double[]) {
				_params = ArrayUtils.toObject((double[]) params);
			}
			else {
				_params = new Object[] {};
			}
			for(Integer i = 0; i < _params.length; i++) {
				String k = key.isEmpty() ? i.toString() : (key +"["+ i.toString() +"]");
				String encodeValue = urlencode(_params[i], k);
				if(!encodeValue.isEmpty()) {
					res += '&'+ encodeValue;
				}
			}
		}
		else if(params instanceof String) {
			String _params = (String) params;
			try {
				res += '&'+ URLEncoder.encode(key, "UTF-8") +'='+ URLEncoder.encode(_params, "UTF-8");
			} catch (UnsupportedEncodingException e) {
				e.printStackTrace();
			}
		}
		else if(params instanceof Number) {
			Number _params = (Number) params;
			try {
				res += '&'+ URLEncoder.encode(key, "UTF-8") +'='+ URLEncoder.encode(_params.toString(), "UTF-8");
			} catch (UnsupportedEncodingException e) {
				e.printStackTrace();
			}
		}
		else {
			return "";
		}
		return res.substring(1);
	}
	
	
	public static Map<String, Object> urldecode(String param) {
		if(param == null || param.isEmpty()) {
			return null;
		}
		//解码
		String[] params = param.split("&");
		Map<String, String> key2value = new TreeMap<String, String>();
		for(int i = 0; i < params.length; i++) {
			String[] p = params[i].split("=");
			if(p.length == 0) {
				continue;
			}
			try {
				String keyStr = URLDecoder.decode(p[0], "UTF-8");
				if(keyStr.isBlank()) {
					continue;
				}
				String valueStr;
				if(p.length == 2) {
					valueStr = URLDecoder.decode(p[1], "UTF-8");
				} else {
					valueStr = "";
				}
				key2value.put(keyStr, valueStr);
			} catch (UnsupportedEncodingException e) {
				e.printStackTrace();
			}
		}
		//遍历每一行传参
		Map<String, Object> map = new HashMap<String, Object>();
		for(Map.Entry<String, String> entry : key2value.entrySet()) {
			String keyStr = entry.getKey();
			String value = entry.getValue();
			//根目录的key
			Matcher keyMatcher = Pattern.compile("^[a-zA-Z\\_]{1}[\\w]*").matcher(keyStr);
			if(!keyMatcher.find()) {
				continue;
			}
			String key = keyMatcher.group(0);
			if(!map.containsKey(key)) {
				map.put(key, new HashMap<String, Object>());
			}
			
			//二级以及二级目录以上的key
			String pattern = "\\[([\\w]+?)\\]";
			Matcher filterMatcher = Pattern.compile(pattern, Pattern.CASE_INSENSITIVE).matcher(keyStr);
			//获取所有的patternKey
			List<String> patternKeyList = new ArrayList<String>();
			while(filterMatcher.find()) {
				String patternKey = filterMatcher.group(1);
				patternKeyList.add(patternKey);
			}
			//有子元素
			if(!patternKeyList.isEmpty()) {
				//遍历并写入
				Object childMap = map.get(key);
				int patternKeyListSize = patternKeyList.size();
				for(int j = 0; j < patternKeyListSize; j++) {
					String patternKey = patternKeyList.get(j);
					Map<String, Object> _childMap = (HashMap<String, Object>) childMap;
					if(!_childMap.containsKey(patternKey)) {
						//是否是最后一个节点，是的话直接赋值
						if(j == patternKeyListSize-1) {
							_childMap.put(patternKey, value);
							break;
						}
						_childMap.put(patternKey, new HashMap<String, Object>());
					}
					childMap = _childMap.get(patternKey);
				}
			}
			//只有一级元素
			else {
				map.put(key, value);
			}
		}
		map = (Map<String, Object>) map2list(map);
		return map;
	}
	
	private static Object map2list(Map<String, Object> map) {
		Set<String> keySet = map.keySet();
		boolean all_is_number = true;
		for(String key : keySet) {
			//不是数字
			if(!Pattern.matches("^[0-9]+$", key)) {
				all_is_number = false;
			}
			Object childNode = map.get(key);
			if(childNode instanceof Map) {
				childNode = map2list((Map<String, Object>) childNode);
				map.put(key, childNode);
			}
		}
		Object res;
		if(all_is_number) {
			res = new ArrayList<Object>();
			for(String key : keySet) {
				Object value = map.get(key);
				((List<Object>) res).add(value);
			}
		} else {
			res = map;
		}
		return res;
	}

}

问题发生于，我想用tcpmon拦截页面提交数据。

由于post的数据都是经过urlencoded编码的，所以看到的数据如果是日文的话都是类似于“%8Ex%95%A5%8B%E0%8Az%8D%87%8Cv”这个样子的。

我想把它解码成原始数据，以便于调查。

于是使用了URLDecoder.decode方法进行解码，发现解码回来的数据有误



System.out.println(URLDecoder.decode("%8Ex%95%A5%8B%E0%8Az%8D%87%8Cv","windows-31j"));


输出结果为

[code]支?金?合?[/code]

正确结果应该为

[code]支払金額合計[/code]

于是使用


System.out.println(URLEncoder.encode("支払金額合計","windows-31j"));

把这几个字符编码了一下，得到的结果是

[code]%8E%78%95%A5%8B%E0%8A%7A%8D%87%8C%76[/code]

和上面的比较了一下确实有些不一样

下面几个编码好像变成了字幕

[code]

%78 ->x

%7A ->z

%76 ->z

[/code]

用下面代码解码一下也确实如此



        System.out.println(URLDecoder.decode("%78","windows-31j"));
        System.out.println(URLDecoder.decode("%7A","windows-31j"));
        System.out.println(URLDecoder.decode("%76","windows-31j"));




但是问题是，为什么浏览器编码时和URLEncoder.encode编码是不一样的呢？为什么Tomcat可以正确的解码呢？

调查了一下才发现Tomcat根本不是用的URLDecoder.decode来解码的，而是用的org.apache.catalina.util.RequestUtil类。

这样解码一下发现都能得到正确的结果



        System.out.println(RequestUtil.URLDecode("%8Ex%95%A5%8B%E0%8Az%8D%87%8Cv","windows-31j"));
        System.out.println(RequestUtil.URLDecode("%8E%78%95%A5%8B%E0%8A%7A%8D%87%8C%76","windows-31j"));




至于为什么，查看一下两个类的源代码就一清二楚了。

至于为什么要这样做，我想是出于减少浏览器和服务器之间的传输数据量的考虑。

Url编解码
 
URL编码(URL encoding)，也称作百分号编码(Percent-encoding)， 是特定上下文的统一资源定位符 (URL)的编码机制。 
 适用于统一资源标识符(URI)的编码，也用于为”application/x-www-form-urlencoded” MIME准备数据， 因为它用于通过HTTP的请求操作(request)提交HTML表单数据。 
 是因为当字符串数据以url的形式传递给web服务器时,字符串中是不允许出现空格和特殊字符的。urlencode 就是处理这些问题的。常见特殊字符如下表；
 
!
#
+
?
@
:
$
空格
%21
%23
%2b
%3F
%40
%3A
%24
%20
 
为什么进行url编解码 
 下面内容摘自别人博客 
 网页中的表单使用POST方法提交时，数据内容的类型是 application/x-www-form-urlencoded，这种类型会： 
 1.字符”a”-“z”，”A”-“Z”，”0”-“9”，”.”，”-“，”*”，和”_” 都不会被编码; 
 2.将空格转换为加号 (+) ; 
 3.将非文本内容转换成”%xy”的形式,xy是两位16进制的数值; 
 4.在每个 name=value 对之间放置 & 符号。 
 URLEncoder类包含将字符串转换为application/x-www-form-urlencoded MIME 格式的静态方法 
 web 设计者面临的众多难题之一便是怎样处理不同操作系统间的差异性。这些差异性能引起URL方面的问题：例如，一些操作系统允许文件名中含有空格符，有些又不允许。大多数操作系统不会认为文件名中含有符号“#”会有什么特殊含义；但是在一个URL中，符号“#”表示该文件名已经结束，后面会紧跟一个 fragment（部分）标识符。其他的特殊字符，非字母数字字符集，它们在URL或另一个操作系统上都有其特殊的含义，表述着相似的问题。为了解决这些问题，我们在URL中使用的字符就必须是一个ASCII字符集的固定字集中的元素，具体如下： 
 1.大写字母A-Z 
 2.小写字母a-z 
 3.数字 0-9 
 4.标点符 - _ . ! ~ * ’ (和 ,) 
 诸如字符: / & ? @ # ; $+ = 和 %也可以被使用，但是它们各有其特殊的用途，如果一个文件名包括了这些字符（ / & ? @ # ;$ + = %），这些字符和所有其他字符就应该被编码。 
 编码过程非常简单，任何字符只要不是ASCII码数字，字母，或者前面提到的标点符，它们都将被转换成字节形式，每个字节都写成这种形式：一个“%”后面跟着两位16进制的数值。空格是一个特殊情况，因为它们太平常了。它除了被编码成“%20”以外，还能编码为一个“+”。加号（+）本身被编码为%2B。当/ # = & 和?作为名字的一部分来使用时，而不是作为URL部分之间的分隔符来使用时，它们都应该被编码。 
 WARNING这种策略在存在大量字符集的异构环境中效果不甚理想。例如：在U.S. Windows 系统中, é 被编码为 %E9. 在 U.S. Mac中被编码为%8E。这种不确定性的存在是现存的URI的一个明显的不足。所以在将来URI的规范当中应该通过国际资源标识符(IRIs)进行改善。(摘自别人博客)
 
java urlEncode urlDecode
 
import java.net.URLDecoder;

import java.net.URLEncoder;

public class URLDecoderTest {

    public static void main(String[] args) throws Exception {

       //将application/x-www-form-urlencoded字符串

       //转换成普通字符串

       //必须强调的是编码方式必须正确，如baidu的是gb2312，而google的是UTF-8

       String keyWord = URLDecoder.decode("%E6%96%87%E6%A1%A3", "gb2312");

       System.out.println(keyWord);



       //将普通字符串转换成

       //application/x-www-form-urlencoded字符串

       //必须强调的是编码方式必须正确，如baidu的是gb2312，而google的是UTF-8

       String urlStr = URLEncoder.encode("文档", "gb2312");

       System.out.println(urlStr);

    }

}
 
c++ urlEncode urlDecode
 
#include <iostream>  
#include <assert.h>  

using namespace std;  



unsigned char ToHex(unsigned char x)   
{   
    return  x > 9 ? x + 55 : x + 48;   
}  

unsigned char FromHex(unsigned char x)   
{   
    unsigned char y;  
    if (x >= 'A' && x <= 'Z') y = x - 'A' + 10;  
    else if (x >= 'a' && x <= 'z') y = x - 'a' + 10;  
    else if (x >= '0' && x <= '9') y = x - '0';  
    else assert(0);  
    return y;  
}  

std::string UrlEncode(const std::string& str)  
{  
    std::string strTemp = "";  
    size_t length = str.length();  
    for (size_t i = 0; i < length; i++)  
    {  
        if (isalnum((unsigned char)str[i]) ||   
            (str[i] == '-') ||  
            (str[i] == '_') ||   
            (str[i] == '.') ||   
            (str[i] == '~'))  
            strTemp += str[i];  
        else if (str[i] == ' ')  
            strTemp += "+";  
        else  
        {  
            strTemp += '%';  
            strTemp += ToHex((unsigned char)str[i] >> 4);  
            strTemp += ToHex((unsigned char)str[i] % 16);  
        }  
    }  
    return strTemp;  
}  

std::string UrlDecode(const std::string& str)  
{  
    std::string strTemp = "";  
    size_t length = str.length();  
    for (size_t i = 0; i < length; i++)  
    {  
        if (str[i] == '+') strTemp += ' ';  
        else if (str[i] == '%')  
        {  
            assert(i + 2 < length);  
            unsigned char high = FromHex((unsigned char)str[++i]);  
            unsigned char low = FromHex((unsigned char)str[++i]);  
            strTemp += high*16 + low;  
        }  
        else strTemp += str[i];  
    }  
    return strTemp;  
}  





int main(int argc,char *argv[])  
{  

    string unencode_url(argv[1]);  
    cout << "unencode_url: " << unencode_url << endl;  
    string   encode_url = UrlEncode(unencode_url);  
    cout << "encode_url: " << encode_url << endl;   
    string   decode_url = UrlDecode(encode_url);  
    cout << "decode_url: " << decode_url << endl;      
}  
 
希望对你有所帮助

 
 
万分感谢原文作者：何必等明天
 原文出处：http://www.cnblogs.com/xzwblog/
 
 
1 为什么要URL编码
 
在因特网上传送URL，只能采用ASCII字符集
 也就是说URL只能使用英文字母、阿拉伯数字和某些标点符号，不能使用其他文字和符号，即
 只有字母和数字[0-9a-zA-Z]、一些特殊符号$-_.+!*'()[不包括双引号]、以及某些保留字（空格转换为+），才可以不经过编码直接用于URL
 这意味着 如果URL中有汉字，就必须编码后使用。 但是麻烦的是 标准的国际组织并没有规定具体的编码方法，而是交给应用程序（浏览器）自己决定。 这导致"URL编码"成为了一个混乱的领域。
 　　如果包含中文，其实会自动编码的，比如Chrome和火狐，“文"和"章"的utf-8编码分别是"E6 96 87"和"E7 AB A0” ,下图所示的"%e6%96%87%e7%ab%a0"就是按照顺序，在每个字节前加上%而得到的:
 　　
 但是不同的浏览器可能会有不同的编码方式，不要将编码交给浏览器。应该用JS在前端对URL编码，这样就实现了统一
如果key=value这种传参方式中，value中包含?``=或者&等符号，url的解析会变得很困难
不同的操作系统、浏览器、不同的网页字符集（charset）有不同的默认编码方式，要有一个统一格式来发送url，参考文章中举了4个例子（很有读的必要）！
 
2 如何编码
 
URL编码通常也被称为百分号编码（percent-encoding），是因为它的编码方式非常简单：
 使用%加上两位的字符——0123456789ABCDEF——代表一个字节的十六进制形式。URL编码要做的，就是将每一个非安全的ASCII字符都被替换为“%xx”格式，
 对于非ASCII字符，RFC文档建议使用utf-8对其进行编码得到相应的字节，然后对每个字节执行百分号编码。
 如"中文"使用UTF-8字符集得到的字节为0xE4 0xB8 0xAD 0xE6 0x96 0x87，经过Url编码之后得到"%E4%B8%AD%E6%96%87"。
 
一些常见的特殊字符换成相应的十六进制的值：
 
+   %20   
/   %2F   
?   %3F   
%   %25   
#   %23   
&   %26  
 
2.1 JS的三种编码函数
 
上面说了编码方式的混乱，那么如何统一呢？
 **使用Javascript先对URL编码，或者将可以在后台编码的参数编码后再发送给前端使用。然后再向服务器提交，不要给浏览器插手的机会，这样就能保证客户端只用一种编码方法向服务器发出请求 **
 
escape
 　　js中编码出生最早的一个，不提倡使用，真正作用是:
 返回一个字符的Unicode编码值，为的是方便他们能在所有计算机上可读，规则：
 所有空格、标点以及其他非ASCII字符都用%xx编码替换; 例如空格返回的是%20 字符值大于255的字符以%uxxxx格式储存
 
encodeURI函数(推荐使用)
 　　这个函数才是javascript中真正用来对URL编码的函数
 它着眼于对整个URL进行编码，因此除了常见的符号以外，对其他一些在网址中有特殊含义的符号"; / ? : @ & = + $ , #"，也不进行编码。编码后，它输出符号的utf-8形式，并且在每个字节前加上%。
 需要注意的是，它不对单引号’编码
 它对应的解码函数是decodeURI()。
 
规则就是我上面第二部分所说的，采用utf-8编码。比如：
 
 encodeURIComponent函数（推荐使用）
 与encodeURI()的区别是，它用于对URL的组成部分进行个别编码，而不用于对整个URL进行编码。
 因此，"; / ? : @ & = + $ , #"，这些在encodeURI()中不被编码的符号，在encodeURIComponent()中统统会被编码，具体的编码规则是和encodeURI函数是一样的
 它对应的解码函数是decodeURIComponent()。
 
实验：
 利用chrome的开发者工具：
 
 可以看到第一种，对需要url编码的部分用encodeURIComponent函数，其他部分不编码符合要求,即对需要编码的参数用encodeURIComponent函数最推荐
 
2.2 我们的问题
 
遇到的问题：
 get请求的路径参数filePath为：/image/5cf4adbe16ad4fc18ab2259cb86bb14d.png，
 
在相应的控制器Controller中：
 
@RequestMapping(path = "/admin/{filePath}")
 
那么这个请求就变成了：
 
http://localhost/admin//image/5cf4adbe16ad4fc18ab2259cb86bb14d.png
 
由于服务器无法解析上面的url，导致400 bad request错误
 
2.3 Java的URLEncoder.encode(“需要编码的参数”,“UTF-8”)
 
比较JS的encodeURIComponent函数和Java的URLEncoder.encode(“需要编码的参数”,“UTF-8”)函数：
 对//中国/images/head_tripletown.png//!@#$%^&*()进行URL编码：
 
//JS的encodeURIComponent函数
javascript:encodeURIComponent("//中国/images/head_tripletown.png//!@#$%^&*()")
"%2F%2F%E4%B8%AD%E5%9B%BD%2Fimages%2Fhead_tripletown.png%2F%2F!%40%23%24%25%5E%26*()"

//Java的URLEncoder.encode("需要编码的参数","UTF-8")函数
URLEncoder.encode("//中国/images/head_tripletown.png//!@#$%^&*()","UTF-8")
%2f%2f%e4%b8%ad%e5%9b%bd%2fimages%2fhead_tripletown.png%2f%2f!%40%23%24%25%5e%26*()
 
可以看到一模一样，因此:
 使用Javascript先对URL编码，或者将可以在后台编码的参数编码后再发送给前端使用。
 
3 为什么两次编码
 
首先看例子，原始请求：
 
http://localhost/admin/image/filePath//images/head_tripletown.png/200/200
 
其中，Controller中的映射文件:
 
@RequestMapping(path = "/admin/image/filePath/{filePath}/{width}/{height}")
 
对filePath参数一次编码后，发起URL请求：
 请求为：http://localhost/admin/image/filePath/%2fimages%2fhead_tripletown.png/200/200
 在拦截器加断点：
 

 毫无反应。。。所以应该在拦截器工作前就对URL进行了解码
 
对filePath参数两次编码后，发起URL请求：
 请求为：http://localhost/admin/image/filePath/%252fimages%252fhead_tripletown.png/200/200
 在拦截器加断点：
 
 一次解码之前：
 
 一次解码之后：
 
 获得了正常回应：
 
 两次编码的原因：（重点）
 
 
一般的原因：解决服务器解码后乱码问题
 
如果只进行一次encodeURI，得到的是UTF-8形式的URL，服务器端通过request.getParameter()解码查询参数(通常是iso-8859-1)就会得到乱码。
 
如果进行两次encodeURI,第一次编码得到的是UTF-8形式的URL，第二次编码得到的依然是UTF-8形式的URL，但是在效果上相当于首先进行了一次UTF-8编码(此时已经全部转换为ASCII字符)，再进行了一次iso-8859-1编码，因为对英文字符来说UTF-8编码和ISO-8859-1编码的效果相同。在服务器端，首先通过request.getParameter()自动进行第一次解码(可能是gb2312,gbk,utf-8,iso-8859-1等字符集,对结果无影响)得到ascii字符，然后再使用UTF-8进行第二次解码，通常使用java.net.URLDecoder("",“UTF-8”)方法。
 
两次编码两次解码的过程为：
 
UTF-8编码->UTF-8(iso-8859-1)编码->iso-8859-1解码->UTF-8解码，编码和解码的过程是对称的，所以不会出现乱码。
 
 
我们的原因：解决400 bad request错误
 
由于我们发送的请求为：
 
 
http://localhost/admin/image/filePath/%2fimages%2fhead_tripletown.png/200/200
 
服务器端首先进行一次解码，变为:
 
http://localhost/admin/image/filePath//images/head_tripletown.png/200/200
 
在dispatcherservlet（前端控制器，用来查询映射文件，转发请求和转发回应）中查询映射文件，发现没有匹配的RequestMapping，就会报400 bad request错误
 
如果两次编码：
 
http://localhost/admin/image/filePath/%252fimages%252fhead_tripletown.png/200/200
 
服务器端首先进行一次解码，变为:
 
http://localhost/admin/image/filePath/%2fimages%2fhead_tripletown.png/200/200
 
查询映射文件可以正常转发，在接收请求后在手动进行一次解码。
 
4 扩展
 
什么是application/x-www-form-urlencoded
 
它是一种编码类型。当URL地址里包含非西欧字符的字符串时，系统会将这些字符转换成application/x-www-form-urlencoded字符串。表单里提交时也是如此，当包含非西欧字符的字符串时，系统也会将这些字符转换成application/x-www-form-urlencoded字符串，然后在服务器端自动解码。FORM元素的enctype属性指定了表单数据向服务器提交时所采用的编码类型，默认的缺省值是“application/x-www-form-urlencoded。
 
然而，在向服务器发送大量的文本、包含大量非ASCII字符的文本或二进制数据时这种编码方式效率很低。这个时候我们就要使用另一种编码类型“multipart/form-data”，比如在我们在做上传的时候，表单的enctype属性一般会设置成“multipart/form-data”。 Browser端<form>表单的ENCTYPE属性值为multipart/form-data，它告诉我们传输的数据要用到多媒体传输协议，由于多媒体传输的都是大量的数据，所以规定上传文件必须是post方法，<input>的type属性必须是file。
 
 
关于某些Web容器自动解码问题
 
 
 
参考
 https://blog.csdn.net/qq_27886773/article/details/95078589?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task
 https://blog.csdn.net/vickyway/article/details/46375971?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task