聊一聊古老的 x-www-form-urlencoded

{
    "title": "t",
    "author": "a"
}

https://host/path/to/api?title=t&author=a

{
    "title": "t",
    "author": "a",
    "categories": ["c1", "c2"]
}

# Percent-encoding 之前
https://host/path/to/api?title=t&author=a&categories=["c1", "c2"]

# percent-encoding 之后
https://host/path/to/api?title=t&author=a&categories=%5B%22c1%22,%20%22c2%22%5D

def url_decode_stream(stream, charset='utf-8', decode_keys=False,
                      include_empty=True, errors='replace', separator='&',
                      cls=None, limit=None, return_iterator=False):
    from werkzeug.wsgi import make_chunk_iter
    if return_iterator:
        cls = lambda x: x
    elif cls is None:
        cls = MultiDict
    pair_iter = make_chunk_iter(stream, separator, limit)
    return cls(_url_decode_impl(pair_iter, charset, decode_keys,
                                include_empty, errors))

    `MultiDict` is a dictionary subclass customized to deal with
    multiple values for the same key which is for example used by the parsing
    functions in the wrappers.  This is necessary because some HTML form
    elements pass multiple values for the same key.

    :class:`MultiDict` implements all standard dictionary methods.
    Internally, it saves all values for a key as a list, but the standard dict
    access methods will only return the first value for a key. If you want to
    gain access to the other values, too, you have to use the `list` methods as
    explained below.

    Basic Usage:

    >>> d = MultiDict([('a', 'b'), ('a', 'c')])
    >>> d
    MultiDict([('a', 'b'), ('a', 'c')])
    >>> d['a']
    'b'
    >>> d.getlist('a')
    ['b', 'c']

def _url_decode_impl(pair_iter, charset, decode_keys, include_empty, errors):
    for pair in pair_iter:
        if not pair:
            continue
        s = make_literal_wrapper(pair)
        equal = s('=')
        if equal in pair:
            key, value = pair.split(equal, 1)
        else:
            if not include_empty:
                continue
            key = pair
            value = s('')
        key = url_unquote_plus(key, charset, errors)
        if charset is not None and PY2 and not decode_keys:
            key = try_coerce_native(key)
        yield key, url_unquote_plus(value, charset, errors)

{
    "title": "t",
    "author": "a",
    "categories": ["c1", "c2"]
}

https://host/path/to/api?title=t&author=a&categories=c1&categories=c2

	private MultiValueMap<String, String> parseFormData(Charset charset, String body) {
		String[] pairs = StringUtils.tokenizeToStringArray(body, "&");
		MultiValueMap<String, String> result = new LinkedMultiValueMap<>(pairs.length);
		try {
			for (String pair : pairs) {
				int idx = pair.indexOf('=');
				if (idx == -1) {
					result.add(URLDecoder.decode(pair, charset.name()), null);
				}
				else {
					String name = URLDecoder.decode(pair.substring(0, idx),  charset.name());
					String value = URLDecoder.decode(pair.substring(idx + 1), charset.name());
					result.add(name, value);
				}
			}
		}
		catch (UnsupportedEncodingException ex) {
			throw new IllegalStateException(ex);
		}
		return result;
	}

The application/x-www-form-urlencoded parser takes a byte sequence input, and then runs these steps:

    Let sequences be the result of splitting input on 0x26 (&).

    Let output be an initially empty list of name-value tuples where both name and value hold a string.

    For each byte sequence bytes in sequences:

        If bytes is the empty byte sequence, then continue.

        If bytes contains a 0x3D (=), then let name be the bytes from the start of bytes up to but excluding its first 0x3D (=), and let value be the bytes, if any, after the first 0x3D (=) up to the end of bytes. If 0x3D (=) is the first byte, then name will be the empty byte sequence. If it is the last, then value will be the empty byte sequence.

        Otherwise, let name have the value of bytes and let value be the empty byte sequence.

        Replace any 0x2B (+) in name and value with 0x20 (SP).

        Let nameString and valueString be the result of running UTF-8 decode without BOM on the percent decoding of name and value, respectively.

        Append (nameString, valueString) to output.

    Return output.