+ (NSString *)encodeToPercentEscapeString: (NSString *) input

{

    // Encode all the reserved characters, per RFC 3986

    // ()

    NSString *outputStr = (NSString *)

    CFBridgingRelease(CFURLCreateStringByAddingPercentEscapes(kCFAllocatorDefault,

                                                              (CFStringRef)input,

                                                              
NULL,

                                                              (CFStringRef)@"!*'();:@&=+$,/?%#[]",

                                                              
kCFStringEncodingUTF8));

    return outputStr;

}




+ (NSString *)decodeFromPercentEscapeString: (NSString *) input

{

    NSMutableString *outputStr = [NSMutableString
stringWithString:input];

    [outputStr replaceOccurrencesOfString:@"+"

                               withString:@" "

                                  options:NSLiteralSearch

                                    range:NSMakeRange(0, [outputStr
length])];

    

    return [outputStr 
stringByReplacingPercentEscapesUsingEncoding:NSUTF8StringEncoding];

}

问题发生于，我想用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"));


至于为什么，查看一下两个类的源代码就一清二楚了。
至于为什么要这样做，我想是出于减少浏览器和服务器之间的传输数据量的考虑。

最近在研究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;
	}

}

1.URLEncoed编码使用场景
在Http协议的请求URI，协议标头，POST的窗体数据中，必须采用UrlEncoded编码方式。

2.何为URLEncoed编码
URLEncoded编码中，所有的字符均为ANSCII码。编码原理如下：编码前的所有字符可以分成两类，（1）安全字符；（2）不安全字符。
 对于安全字符，其必然是ANSCII码，但是ANSCII码不全是安全字符。安全字符在转变过程中不变化，仍为ANSCII。
 对于安全字符，包括所有的非ANSCII字符和部分ANSCII字符，采用（%原字符十六进制表示）组成。如：GB2312编码的“登”，URLEncoded编码后为“%B5%C7”。而UTF8编码的“登”，URLEncoded后为"%e7%99%bb"。还有一些特殊，如空格被变为"+"。

3 如何实现？
如果从头实现URLEncoded编码，必须熟悉各种编码，相当复杂。幸好System.Web.HttpUtility为我们提供了几个静态函数用于URLEncoed编码。具体如下：

string HttpUtility.UrlEncode(string str, Encoding e);
首先要说明的是在.net的世界里，char和string永远都是采用UNICODE编码。
参数：str，编码前的UNICODE字符串，如"好人hehe";
 e，进行编码前，把str中的字符先有UNICODE变为e。e为转换后的编码方式，
如GB2312；
返回值:编码后的字符串的UNICODE表示。什么意思呢？URLEncoded编码为ANSCII编码，但是string是UNICODE，所以string是URLEncoded字符串的UNICODE表示。

string HttpUtility.UrlDecode(string str, Encoding e);
参数： str,URLEncoded编码字符串的UNICODE表示；
 e，原来字符串的编码方式，如GB2312,UTF8等。
返回值：解码后的字符串的UNICODE表示。比如如果解码后为GB2312的"登"，则实际返回的字符串中包含的是转化为UNICODE的“登”。

需要说明的是，真正在网络上传输的是UrlEncoded字符串流，而不是它的UNICODE表示，然而.net中的大多数API却都是接收UNICODE表示字符串，实际发送时，会自动转化为ANCII版本，所以这种转换程序员不用操心。然而窗体数据需要转化：
 StreamWriter sw = new StreamWriter(requsetStream, 
 Encoding.ASCII); //编码方式
sw.Write(formdata); //写入窗体数据(urlencoded)