将URI字符串解析为Name-Value集合


273

我有这样的URI:

https://google.com.ua/oauth/authorize?client_id=SS&response_type=code&scope=N_FULL&access_type=offline&redirect_uri=http://localhost/Callback

我需要一个具有解析元素的集合:

NAME               VALUE
------------------------
client_id          SS
response_type      code
scope              N_FULL
access_type        offline
redirect_uri       http://localhost/Callback

确切地说,我需要C#/。NET HttpUtility.ParseQueryString方法的Java等效

请给我一个建议。

谢谢。



@MattBall如果OP使用的是Android,则为
Juan Mendes

156
难道这不是java.net.URI/ 的核心API的一部分java.net.URL吗?
Dilum Ranatunga

请检查此解决方案-解析和格式化操作的可靠库和工作示例:stackoverflow.com/a/37744000/1882064
arcseldon 2016年

Answers:


341

如果您正在寻找一种无需使用外部库即可实现的方法,以下代码将为您提供帮助。

public static Map<String, String> splitQuery(URL url) throws UnsupportedEncodingException {
    Map<String, String> query_pairs = new LinkedHashMap<String, String>();
    String query = url.getQuery();
    String[] pairs = query.split("&");
    for (String pair : pairs) {
        int idx = pair.indexOf("=");
        query_pairs.put(URLDecoder.decode(pair.substring(0, idx), "UTF-8"), URLDecoder.decode(pair.substring(idx + 1), "UTF-8"));
    }
    return query_pairs;
}

您可以使用来访问返回的Map <map>.get("client_id"),并在问题中提供URL,这将返回“ SS”。

添加了更新 URL解码

更新由于此答案仍然很受欢迎,因此我对上述方法进行了改进,该方法可以处理具有相同键的多个参数以及没有值的参数。

public static Map<String, List<String>> splitQuery(URL url) throws UnsupportedEncodingException {
  final Map<String, List<String>> query_pairs = new LinkedHashMap<String, List<String>>();
  final String[] pairs = url.getQuery().split("&");
  for (String pair : pairs) {
    final int idx = pair.indexOf("=");
    final String key = idx > 0 ? URLDecoder.decode(pair.substring(0, idx), "UTF-8") : pair;
    if (!query_pairs.containsKey(key)) {
      query_pairs.put(key, new LinkedList<String>());
    }
    final String value = idx > 0 && pair.length() > idx + 1 ? URLDecoder.decode(pair.substring(idx + 1), "UTF-8") : null;
    query_pairs.get(key).add(value);
  }
  return query_pairs;
}

UPDATE Java8版本

public Map<String, List<String>> splitQuery(URL url) {
    if (Strings.isNullOrEmpty(url.getQuery())) {
        return Collections.emptyMap();
    }
    return Arrays.stream(url.getQuery().split("&"))
            .map(this::splitQueryParameter)
            .collect(Collectors.groupingBy(SimpleImmutableEntry::getKey, LinkedHashMap::new, mapping(Map.Entry::getValue, toList())));
}

public SimpleImmutableEntry<String, String> splitQueryParameter(String it) {
    final int idx = it.indexOf("=");
    final String key = idx > 0 ? it.substring(0, idx) : it;
    final String value = idx > 0 && it.length() > idx + 1 ? it.substring(idx + 1) : null;
    return new SimpleImmutableEntry<>(key, value);
}

使用网址运行上述方法

https://stackoverflow.com?param1=value1&param2=&param3=value3&param3

返回此地图:

{param1=["value1"], param2=[null], param3=["value3", null]}

13
您忘记了解码名称和参数,这是通常让库执行常见任务更好的原因之一。
Juan Mendes 2012年

10
确实,您是对的……但是我个人更喜欢自己编写这样的“简单”任务,而不是对自己要做的每个任务都使用自己的库。
Pr0gr4mm3r 2012年

2
如果您有多个具有相同名称/键的参数,则使用此功能将覆盖具有相似键的值。
snowball147

4
@Chris您将xml / html转义与URL编码混淆了。您的示例网址应为:a.com/q?
a%26b&2

3
最好指出使用了哪些函数:Collectors.mapping(...)和Collectors.toList(...)
Thomas Rebele

311

org.apache.http.client.utils.URLEncodedUtils

是一个可以为您做的著名图书馆

import org.apache.hc.client5.http.utils.URLEncodedUtils

String url = "http://www.example.com/something.html?one=1&two=2&three=3&three=3a";

List<NameValuePair> params = URLEncodedUtils.parse(new URI(url), Charset.forName("UTF-8"));

for (NameValuePair param : params) {
  System.out.println(param.getName() + " : " + param.getValue());
}

产出

one : 1
two : 2
three : 3
three : 3a

我可以不通过所有元素就通过名称接收值吗?我的意思是这样的:System.out.print(params [“ one”]);
谢尔盖·沙菲耶夫

3
@SergeyShafiev将a List<NameValuePair>转换为Map<String,String>Java没有哈希映射的括号访问权限是很简单的,看起来好像map.get("one")如果您不知道如何操作,那应该是另一个问题(但是请先自己尝试) 。我们喜欢在所以要保持苗条的问题在这里
胡安·门德斯

6
请注意,如果您的URL中有两次相同的参数(即?a = 1&a = 2),URLEncodedUtils将抛出IllegalArgumentException
Crystark 2014年

10
@Crystark从httpclient 4.3.3开始,名称重复的查询字符串不会引发任何异常。它按预期工作。System.out.println(URLEncodedUtils.parse(new URI("http://example.com/?foo=bar&foo=baz"), "UTF-8"));将打印[foo = bar,foo = baz]
2014年

4
从Android 6开始,Apache HTTP客户端库已被删除。这意味着URLEncodedUtils and NameValuePair`不再可用(除非你添加一个依赖于传统的Apache库作为描述在这里)。
泰德·霍普

108

如果您使用的是Spring Framework:

public static void main(String[] args) {
    String uri = "http://my.test.com/test?param1=ab&param2=cd&param2=ef";
    MultiValueMap<String, String> parameters =
            UriComponentsBuilder.fromUriString(uri).build().getQueryParams();
    List<String> param1 = parameters.get("param1");
    List<String> param2 = parameters.get("param2");
    System.out.println("param1: " + param1.get(0));
    System.out.println("param2: " + param2.get(0) + "," + param2.get(1));
}

你会得到:

param1: ab
param2: cd,ef

1
网址使用UriComponentsBuilder.fromHttpUrl(url)
Lu55

51

使用谷歌番石榴,并做到两行:

import java.util.Map;
import com.google.common.base.Splitter;

public class Parser {
    public static void main(String... args) {
        String uri = "https://google.com.ua/oauth/authorize?client_id=SS&response_type=code&scope=N_FULL&access_type=offline&redirect_uri=http://localhost/Callback";
        String query = uri.split("\\?")[1];
        final Map<String, String> map = Splitter.on('&').trimResults().withKeyValueSeparator('=').split(query);
        System.out.println(map);
    }
}

这给你

{client_id=SS, response_type=code, scope=N_FULL, access_type=offline, redirect_uri=http://localhost/Callback}

18
所选答案中描述的URL解码如何?
克林特·伊斯特伍德

7
也怀疑具有相同名称的多个键。根据javadocs,这将引发IllegalArgumentException
jontro 2014年

5
与其手动分割urinew java.net.URL(uri).getQuery()不如使用它,因为它可以为您提供免费的URL输入验证。
avgvstvs 2015年

1
对于解码:最终Map <String,String> queryVars = Maps.transformValues(map,new Function <String,String>(){@Override public String apply(String value){试试{返回URLDecoder.decode(value,“ UTF- 8“);} catch(UnsupportedEncodingException e){// TODO自动生成的catch块e.printStackTrace();}返回值;}});
phreakhead 2015年

11
警告!!执行此操作并不安全,因为如果查询字符串中有重复的键,splitter.split()则会抛出该错误IllegalArgumentException。参见stackoverflow.com/questions/1746507/…–
安德森

31

我发现的最短的方法是:

MultiValueMap<String, String> queryParams =
            UriComponentsBuilder.fromUriString(url).build().getQueryParams();

更新: UriComponentsBuilder来自Spring。这里的链接


3
不知道此UriComponentsBuilder类的来源不是很有用。
托马斯·莫塔涅

3
可能值得注意的是,如果您已经在使用Spring,那么这只是一个好主意。如果您不使用Spring,则需要避免。samatkinson.com/why-i-hate-spring
Nick

1
注意:这需要URI。Java的URI版本不是URL的超集(这就是toURI可以引发异常的原因)。
亚当·根特

18

对于Android,如果您在项目中使用OkHttp。您可能会对此有所了解。它简单而有用。

final HttpUrl url = HttpUrl.parse(query);
if (url != null) {
    final String target = url.queryParameter("target");
    final String id = url.queryParameter("id");
}

HttpUrl有点怪异的名字,但这正是我所需要的。谢谢。
GuiSim

10

Java 8一句话

给定要分析的URL:

URL url = new URL("https://google.com.ua/oauth/authorize?client_id=SS&response_type=code&scope=N_FULL&access_type=offline&redirect_uri=http://localhost/Callback");

此解决方案收集对的列表:

List<AbstractMap.SimpleEntry<String, String>> list = 
        Pattern.compile("&").splitAsStream(url.getQuery())
        .map(s -> Arrays.copyOf(s.split("="), 2))
        .map(o -> new AbstractMap.SimpleEntry<String, String>(decode(o[0]), decode(o[1])))
        .collect(toList());

另一方面,此解决方案收集一个映射(假设url中可以有更多名称相同但值不同的参数)。

Map<String, List<String>> list = 
        Pattern.compile("&").splitAsStream(url.getQuery())
        .map(s -> Arrays.copyOf(s.split("="), 2))
        .collect(groupingBy(s -> decode(s[0]), mapping(s -> decode(s[1]), toList())));

两种解决方案都必须使用实用程序功能来正确解码参数。

private static String decode(final String encoded) {
    try {
        return encoded == null ? null : URLDecoder.decode(encoded, "UTF-8");
    } catch(final UnsupportedEncodingException e) {
        throw new RuntimeException("Impossible: UTF-8 is a required encoding", e);
    }
}

4
这更多是Java 8 方法而不是Java 8 oneliner。
斯蒂芬

@斯蒂芬好:)也许两者都有。但是,我更想了解您是否喜欢这种解决方案。
Freedev

3
IMO,oneliner应该很短,并且不能跨越多条线。
Stephan

1
这里涉及多个语句。
斯蒂芬

2
我想您可以在一行上写一个完整的类,但这并不是通常所说的“单线”。
Abhijit Sarkar,

10

如果您正在使用servlet doGet,请尝试以下操作

request.getParameterMap()

返回此请求的参数的java.util.Map。

返回:一个不可变的java.util.Map,其中包含作为键的参数名称和作为映射值的参数值。参数映射中的键的类型为String。参数映射中的值是String数组类型。

Java文档


该作品具有Spring Web以及在你的控制器,你可以有类型的参数HttpServletRequest,它与工作MockHttpServletRequest以及在模拟MVC单元测试。
GameSalutes

8

如果您使用的是Java 8,并且愿意编写一些可重用的方法,则可以一行完成。

private Map<String, List<String>> parse(final String query) {
    return Arrays.asList(query.split("&")).stream().map(p -> p.split("=")).collect(Collectors.toMap(s -> decode(index(s, 0)), s -> Arrays.asList(decode(index(s, 1))), this::mergeLists));
}

private <T> List<T> mergeLists(final List<T> l1, final List<T> l2) {
    List<T> list = new ArrayList<>();
    list.addAll(l1);
    list.addAll(l2);
    return list;
}

private static <T> T index(final T[] array, final int index) {
    return index >= array.length ? null : array[index];
}

private static String decode(final String encoded) {
    try {
        return encoded == null ? null : URLDecoder.decode(encoded, "UTF-8");
    } catch(final UnsupportedEncodingException e) {
        throw new RuntimeException("Impossible: UTF-8 is a required encoding", e);
    }
}

但这是一条相当残酷的路线。


3

在Android上,包android.net中有一个Uri类。请注意,Uriandroid.net的一部分,而URIjava.net的一部分。

Uri类具有许多从查询中提取键/值对的功能。 在此处输入图片说明

以下函数以HashMap的形式返回键值对。

在Java中:

Map<String, String> getQueryKeyValueMap(Uri uri){
    HashMap<String, String> keyValueMap = new HashMap();
    String key;
    String value;

    Set<String> keyNamesList = uri.getQueryParameterNames();
    Iterator iterator = keyNamesList.iterator();

    while (iterator.hasNext()){
        key = (String) iterator.next();
        value = uri.getQueryParameter(key);
        keyValueMap.put(key, value);
    }
    return keyValueMap;
}

在科特林:

fun getQueryKeyValueMap(uri: Uri): HashMap<String, String> {
        val keyValueMap = HashMap<String, String>()
        var key: String
        var value: String

        val keyNamesList = uri.queryParameterNames
        val iterator = keyNamesList.iterator()

        while (iterator.hasNext()) {
            key = iterator.next() as String
            value = uri.getQueryParameter(key) as String
            keyValueMap.put(key, value)
        }
        return keyValueMap
    }

2

使用上述注释和解决方案,我使用Map <String,Object>存储所有查询参数,其中Objects可以是string或Set <String>。解决方案如下。建议先使用某种URL验证程序来验证URL,然后再调用convertQueryStringToMap方法。

private static final String DEFAULT_ENCODING_SCHEME = "UTF-8";

public static Map<String, Object> convertQueryStringToMap(String url) throws UnsupportedEncodingException, URISyntaxException {
    List<NameValuePair> params = URLEncodedUtils.parse(new URI(url), DEFAULT_ENCODING_SCHEME);
    Map<String, Object> queryStringMap = new HashMap<>();
    for(NameValuePair param : params){
        queryStringMap.put(param.getName(), handleMultiValuedQueryParam(queryStringMap, param.getName(), param.getValue()));
    }
    return queryStringMap;
}

private static Object handleMultiValuedQueryParam(Map responseMap, String key, String value) {
    if (!responseMap.containsKey(key)) {
        return value.contains(",") ? new HashSet<String>(Arrays.asList(value.split(","))) : value;
    } else {
        Set<String> queryValueSet = responseMap.get(key) instanceof Set ? (Set<String>) responseMap.get(key) : new HashSet<String>();
        if (value.contains(",")) {
            queryValueSet.addAll(Arrays.asList(value.split(",")));
        } else {
            queryValueSet.add(value);
        }
        return queryValueSet;
    }
}

2

我试用了Kotlin版本,看看这是Google的最佳结果。

@Throws(UnsupportedEncodingException::class)
fun splitQuery(url: URL): Map<String, List<String>> {

    val queryPairs = LinkedHashMap<String, ArrayList<String>>()

    url.query.split("&".toRegex())
            .dropLastWhile { it.isEmpty() }
            .map { it.split('=') }
            .map { it.getOrEmpty(0).decodeToUTF8() to it.getOrEmpty(1).decodeToUTF8() }
            .forEach { (key, value) ->

                if (!queryPairs.containsKey(key)) {
                    queryPairs[key] = arrayListOf(value)
                } else {

                    if(!queryPairs[key]!!.contains(value)) {
                        queryPairs[key]!!.add(value)
                    }
                }
            }

    return queryPairs
}

和扩展方法

fun List<String>.getOrEmpty(index: Int) : String {
    return getOrElse(index) {""}
}

fun String.decodeToUTF8(): String { 
    URLDecoder.decode(this, "UTF-8")
}

1
同样感谢stackoverflow.com/users/1203812/matthew-herod 50/50的努力,但不能共同创作。
Graham Smith

2

URI查询部分解码的即用型解决方案(包括解码和多参数值)

注释

我对@ Pr0gr4mm3r在https://stackoverflow.com/a/13592567/1211082中提供的代码不满意。基于流的解决方案不执行URLDecoding(可变版本笨拙)。

因此,我制定了一个解决方案

  • 可以将URI查询部分分解为 Map<String, List<Optional<String>>>
  • 可以处理同一个参数名称的多个值
  • 可以正确表示没有值的参数Optional.empty()而不是null
  • 通过正确解码参数名称URLdecode
  • 基于Java 8流
  • 直接可用(请参见下面的代码,包括导入)
  • 允许进行适当的错误处理(此处通过将检查后的异常UnsupportedEncodingException转换为RuntimeUnsupportedEncodingException允许与流相互作用的运行时异常。(将常规函数包装为引发检查后的异常的函数很痛苦。Scala Try在Java语言默认情况下不可用。)

Java代码

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.*;
import static java.util.stream.Collectors.*;

public class URIParameterDecode {
    /**
     * Decode parameters in query part of a URI into a map from parameter name to its parameter values.
     * For parameters that occur multiple times each value is collected.
     * Proper decoding of the parameters is performed.
     * 
     * Example
     *   <pre>a=1&b=2&c=&a=4</pre>
     * is converted into
     *   <pre>{a=[Optional[1], Optional[4]], b=[Optional[2]], c=[Optional.empty]}</pre>
     * @param query the query part of an URI 
     * @return map of parameters names into a list of their values.
     *         
     */
    public static Map<String, List<Optional<String>>> splitQuery(String query) {
        if (query == null || query.isEmpty()) {
            return Collections.emptyMap();
        }

        return Arrays.stream(query.split("&"))
                    .map(p -> splitQueryParameter(p))
                    .collect(groupingBy(e -> e.get0(), // group by parameter name
                            mapping(e -> e.get1(), toList())));// keep parameter values and assemble into list
    }

    public static Pair<String, Optional<String>> splitQueryParameter(String parameter) {
        final String enc = "UTF-8";
        List<String> keyValue = Arrays.stream(parameter.split("="))
                .map(e -> {
                    try {
                        return URLDecoder.decode(e, enc);
                    } catch (UnsupportedEncodingException ex) {
                        throw new RuntimeUnsupportedEncodingException(ex);
                    }
                }).collect(toList());

        if (keyValue.size() == 2) {
            return new Pair(keyValue.get(0), Optional.of(keyValue.get(1)));
        } else {
            return new Pair(keyValue.get(0), Optional.empty());
        }
    }

    /** Runtime exception (instead of checked exception) to denote unsupported enconding */
    public static class RuntimeUnsupportedEncodingException extends RuntimeException {
        public RuntimeUnsupportedEncodingException(Throwable cause) {
            super(cause);
        }
    }

    /**
     * A simple pair of two elements
     * @param <U> first element
     * @param <V> second element
     */
    public static class Pair<U, V> {
        U a;
        V b;

        public Pair(U u, V v) {
            this.a = u;
            this.b = v;
        }

        public U get0() {
            return a;
        }

        public V get1() {
            return b;
        }
    }
}

Scala代码

...为了完整起见,我无法抗拒在Scala中提供以简洁和美观为主导的解决方案

import java.net.URLDecoder

object Decode {
  def main(args: Array[String]): Unit = {
    val input = "a=1&b=2&c=&a=4";
    println(separate(input))
  }

  def separate(input: String) : Map[String, List[Option[String]]] = {
    case class Parameter(key: String, value: Option[String])

    def separateParameter(parameter: String) : Parameter =
      parameter.split("=")
               .map(e => URLDecoder.decode(e, "UTF-8")) match {
      case Array(key, value) =>  Parameter(key, Some(value))
      case Array(key) => Parameter(key, None)
    }

    input.split("&").toList
      .map(p => separateParameter(p))
      .groupBy(p => p.key)
      .mapValues(vs => vs.map(p => p.value))
  }
}

1

只是Java 8版本的更新

public Map<String, List<String>> splitQuery(URL url) {
    if (Strings.isNullOrEmpty(url.getQuery())) {
        return Collections.emptyMap();
    }
    return Arrays.stream(url.getQuery().split("&"))
            .map(this::splitQueryParameter)
            .collect(Collectors.groupingBy(SimpleImmutableEntry::getKey, LinkedHashMap::new, **Collectors**.mapping(Map.Entry::getValue, **Collectors**.toList())));
}

映射和toList()方法必须与Collector一起使用,而最佳答案中没有提到。否则会在IDE中引发编译错误


看起来您还需要分享您的splitQueryParameters()方法吗?那是什么**Collectors**
柯比

1

Kotlin的答案来自https://stackoverflow.com/a/51024552/3286489的初始参考,但是通过整理代码来提供改进的版本并提供2个版本,并使用不可变的收集操作

使用java.net.URI提取查询。然后使用下面提供的扩展功能

  1. 假设您只需要查询的最后一个值,即page2&page3get {page=3},请使用以下扩展功能
    fun URI.getQueryMap(): Map<String, String> {
        if (query == null) return emptyMap()

        return query.split("&")
                .mapNotNull { element -> element.split("=")
                        .takeIf { it.size == 2 && it.none { it.isBlank() } } }
                .associateBy({ it[0].decodeUTF8() }, { it[1].decodeUTF8() })
    }

    private fun String.decodeUTF8() = URLDecoder.decode(this, "UTF-8") // decode page=%22ABC%22 to page="ABC"
  1. 假设您想要查询的所有值的列表,page2&page3即将{page=[2, 3]}
    fun URI.getQueryMapList(): Map<String, List<String>> {
        if (query == null) return emptyMap()

        return query.split("&")
                .distinct()
                .mapNotNull { element -> element.split("=")
                        .takeIf { it.size == 2 && it.none { it.isBlank() } } }
                .groupBy({ it[0].decodeUTF8() }, { it[1].decodeUTF8() })
    }

    private fun String.decodeUTF8() = URLDecoder.decode(this, "UTF-8") // decode page=%22ABC%22 to page="ABC"

使用方法如下

    val uri = URI("schema://host/path/?page=&page=2&page=2&page=3")
    println(uri.getQueryMapList()) // Result is {page=[2, 3]}
    println(uri.getQueryMap()) // Result is {page=3}

1

Netty还提供了一个名为的漂亮查询字符串解析器QueryStringDecoder。在一行代码中,它可以解析问题中的URL。我喜欢,因为它不需要捕捉或抛出java.net.MalformedURLException

一行:

Map<String, List<String>> parameters = new QueryStringDecoder(url).parameters();

在此处查看javadocs:https : //netty.io/4.1/api/io/netty/handler/codec/http/QueryStringDecoder.html

这是一个简短的,自包含的正确示例:

import io.netty.handler.codec.http.QueryStringDecoder;
import org.apache.commons.lang3.StringUtils;

import java.util.List;
import java.util.Map;

public class UrlParse {

  public static void main(String... args) {
    String url = "https://google.com.ua/oauth/authorize?client_id=SS&response_type=code&scope=N_FULL&access_type=offline&redirect_uri=http://localhost/Callback";
    QueryStringDecoder decoder = new QueryStringDecoder(url);
    Map<String, List<String>> parameters = decoder.parameters();
    print(parameters);
  }

  private static void print(final Map<String, List<String>> parameters) {
    System.out.println("NAME               VALUE");
    System.out.println("------------------------");
    parameters.forEach((key, values) ->
        values.forEach(val ->
            System.out.println(StringUtils.rightPad(key, 19) + val)));
  }
}

产生

NAME               VALUE
------------------------
client_id          SS
response_type      code
scope              N_FULL
access_type        offline
redirect_uri       http://localhost/Callback

0

在这里回答,因为这是一个受欢迎的话题。这是Kotlin中使用推荐UrlQuerySanitizerapi 的干净解决方案。请参阅官方文档。我添加了一个字符串生成器来连接和显示参数。

    var myURL: String? = null

    if (intent.hasExtra("my_value")) {
        myURL = intent.extras.getString("my_value")
    } else {
        myURL = intent.dataString
    }

    val sanitizer = UrlQuerySanitizer(myURL)
    // We don't want to manually define every expected query *key*, so we set this to true
    sanitizer.allowUnregisteredParamaters = true
    val parameterNamesToValues: List<UrlQuerySanitizer.ParameterValuePair> = sanitizer.parameterList
    val parameterIterator: Iterator<UrlQuerySanitizer.ParameterValuePair> = parameterNamesToValues.iterator()

    // Helper simply so we can display all values on screen
    val stringBuilder = StringBuilder()

    while (parameterIterator.hasNext()) {
        val parameterValuePair: UrlQuerySanitizer.ParameterValuePair = parameterIterator.next()
        val parameterName: String = parameterValuePair.mParameter
        val parameterValue: String = parameterValuePair.mValue

        // Append string to display all key value pairs
        stringBuilder.append("Key: $parameterName\nValue: $parameterValue\n\n")
    }

    // Set a textView's text to display the string
    val paramListString = stringBuilder.toString()
    val textView: TextView = findViewById(R.id.activity_title) as TextView
    textView.text = "Paramlist is \n\n$paramListString"

    // to check if the url has specific keys
    if (sanitizer.hasParameter("type")) {
        val type = sanitizer.getValue("type")
        println("sanitizer has type param $type")
    }

0

这是我使用reduceOptional的解决方案:

private Optional<SimpleImmutableEntry<String, String>> splitKeyValue(String text) {
    String[] v = text.split("=");
    if (v.length == 1 || v.length == 2) {
        String key = URLDecoder.decode(v[0], StandardCharsets.UTF_8);
        String value = v.length == 2 ? URLDecoder.decode(v[1], StandardCharsets.UTF_8) : null;
        return Optional.of(new SimpleImmutableEntry<String, String>(key, value));
    } else
        return Optional.empty();
}

private HashMap<String, String> parseQuery(URI uri) {
    HashMap<String, String> params = Arrays.stream(uri.getQuery()
            .split("&"))
            .map(this::splitKeyValue)
            .filter(Optional::isPresent)
            .map(Optional::get)
            .reduce(
                // initial value
                new HashMap<String, String>(), 
                // accumulator
                (map, kv) -> {
                     map.put(kv.getKey(), kv.getValue()); 
                     return map;
                }, 
                // combiner
                (a, b) -> {
                     a.putAll(b); 
                     return a;
                });
    return params;
}
  • 我忽略重复的参数(我取了最后一个)。
  • Optional<SimpleImmutableEntry<String, String>>以后会忽略垃圾
  • 约简从一个空的地图开始,然后在每个SimpleImmutableEntry上填充它

如果您询问,reduce在最后一个参数中需要此奇怪的组合器,该参数仅在并行流中使用。其目标是合并两个中间结果(此处为HashMap)。


-1

如果您使用的是Spring,则将type类型的参数添加@RequestParam Map<String,String> 到控制器方法中,Spring将为您构造映射!

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.