首页 文章

解析Android上的查询字符串

提问于
浏览
255

Java EE有ServletRequest.getParameterValues() .

在非EE平台上,URL.getQuery()只返回一个字符串 .

在Java EE上正确解析URL中的查询字符串的常用方法是什么?


< rant >

在尝试制作自己的解析器的答案中很受欢迎 . 这是非常有趣和令人兴奋的微编码项目,但 I cannot say that it is a good idea :(

下面的代码片段通常有缺陷或破损,顺便说一下 . 打破它们对读者来说是一个有趣的练习 . 并且黑客攻击使用它们的网站 .

解析查询字符串是一个定义明确的问题,但阅读规范和理解细微差别并非易事 . 让一些平台库编码器做出艰苦的工作,并为您做好修复,这要好得多!

< /rant >

24 回答

  • 64

    使用Apache HttpComponents并将其与某些集合代码连接起来以按值访问params:http://www.joelgerard.com/2012/09/14/parsing-query-strings-in-java-and-accessing-values-by-key/

  • 25

    因为Android M的东西变得更加复杂 . android.net.URI .getQueryParameter()的答案有一个在JellyBean之前打破空格的错误 . Apache URLEncodedUtils.parse()工作,但是deprecated in Lremoved in M .

    所以现在最好的答案是UrlQuerySanitizer . 这已经存在于API级别1并且仍然存在 . 它还会让您考虑棘手的问题,例如如何处理特殊字符或重复值 .

    最简单的代码是

    UrlQuerySanitizer.ValueSanitizer sanitizer = UrlQuerySanitizer.getAllButNullLegal();
    // remember to decide if you want the first or last parameter with the same name
    // If you want the first call setPreferFirstRepeatedParameter(true);
    sanitizer.parseUrl(url);
    String value = sanitizer.getValue("paramname"); // get your value
    
  • 0

    在Android上:

    import android.net.Uri;
    
    [...]
    
    Uri uri=Uri.parse(url_string);
    uri.getQueryParameter("para1");
    
  • 3

    这是BalusC's answer,但它编译并返回结果:

    public static Map<String, List<String>> getUrlParameters(String url)
            throws UnsupportedEncodingException {
        Map<String, List<String>> params = new HashMap<String, List<String>>();
        String[] urlParts = url.split("\\?");
        if (urlParts.length > 1) {
            String query = urlParts[1];
            for (String param : query.split("&")) {
                String pair[] = param.split("=");
                String key = URLDecoder.decode(pair[0], "UTF-8");
                String value = "";
                if (pair.length > 1) {
                    value = URLDecoder.decode(pair[1], "UTF-8");
                }
                List<String> values = params.get(key);
                if (values == null) {
                    values = new ArrayList<String>();
                    params.put(key, values);
                }
                values.add(value);
            }
        }
        return params;
    }
    
  • 0

    如果你的类路径上有jetty(服务器或客户端)库,你可以使用jetty util类(参见javadoc),例如:

    import org.eclipse.jetty.util.*;
    URL url = new URL("www.example.com/index.php?foo=bar&bla=blub");
    MultiMap<String> params = new MultiMap<String>();
    UrlEncoded.decodeTo(url.getQuery(), params, "UTF-8");
    
    assert params.getString("foo").equals("bar");
    assert params.getString("bla").equals("blub");
    
  • 0

    如果你使用的是Spring 3.1或更高版本(yikes,希望支持能够进一步发展),你可以使用 UriComponentsUriComponentsBuilder

    UriComponents components = UriComponentsBuilder.fromUri(uri).build();
    List<String> myParam = components.getQueryParams().get("myParam");
    

    components.getQueryParams() 返回 MultiValueMap<String, String>

    Here's some more documentation .

  • 199

    对于servlet或JSP页面,您可以使用request.getParameter(“paramname”)获取查询字符串键/值对

    String name = request.getParameter("name");
    

    还有其他方法可以做到,但这就是我在我创建的所有servlet和jsp页面中的方式 .

  • 6

    解析查询字符串比看起来要复杂一些,具体取决于你想要的宽容程度 .

    首先,查询字符串是ascii字节 . 您可以一次读取这些字节并将它们转换为字符 . 如果角色是?或者然后它表示参数名称的开始 . 如果字符是=则它表示参数值的开始 . 如果字符是%,则它表示编码字节的开始 . 这是它变得棘手的地方 .

    当您读入%char时,您必须读取接下来的两个字节并将它们解释为十六进制数字 . 这意味着接下来的两个字节将是0-9,a-f或A-F . 将这两个十六进制数字粘在一起以获取字节值 . 但请记住, bytes are not characters . 您必须知道用于编码字符的编码 . 字符é在UTF-8中的编码与ISO-8859-1中的编码相同 . 一般来说,这是肯定的 . 一些用户代理会告诉您请求中的字符编码;如果您有完整的HTTP请求,可以尝试阅读 . 如果你只是孤立的网址,祝你好运 .

    无论如何,假设您正在使用UTF-8或其他一些多字节字符编码,现在您已经解码了一个编码字节,您必须将它放在一边,直到您捕获下一个字节 . 您需要所有编码的字节在一起,因为您不能一次正确地解码一个字节 . 将所有字节放在一起,然后一次解码它们以重建你的角色 .

    此外,如果您想要宽容并且考虑到破坏网址的用户代理,它会变得更有趣 . 例如,一些Webmail客户端对事物进行了双重编码 . 或者加倍?&=字符(例如: http://yoursite.com/blah??p1==v1&&p2==v2 ) . 如果您想尝试优雅地处理此问题,则需要向解析器添加更多逻辑 .

  • 1

    仅供参考,这是我最终得到的(基于URLEncodedUtils,并返回Map) .

    特征:

    • 它接受url的查询字符串部分(你可以使用 request.getQueryString()

    • 一个空的查询字符串将产生一个空的 Map

    • 没有值的参数(?test)将映射为空 List<String>

    码:

    public static Map<String, List<String>> getParameterMapOfLists(String queryString) {
        Map<String, List<String>> mapOfLists = new HashMap<String, List<String>>();
        if (queryString == null || queryString.length() == 0) {
            return mapOfLists;
        }
        List<NameValuePair> list = URLEncodedUtils.parse(URI.create("http://localhost/?" + queryString), "UTF-8");
        for (NameValuePair pair : list) {
            List<String> values = mapOfLists.get(pair.getName());
            if (values == null) {
                values = new ArrayList<String>();
                mapOfLists.put(pair.getName(), values);
            }
            if (pair.getValue() != null) {
                values.add(pair.getValue());
            }
        }
    
        return mapOfLists;
    }
    

    兼容性帮助程序(值存储在String数组中,就像ServletRequest.getParameterMap()中一样):

    public static Map<String, String[]> getParameterMap(String queryString) {
        Map<String, List<String>> mapOfLists = getParameterMapOfLists(queryString);
    
        Map<String, String[]> mapOfArrays = new HashMap<String, String[]>();
        for (String key : mapOfLists.keySet()) {
            mapOfArrays.put(key, mapOfLists.get(key).toArray(new String[] {}));
        }
    
        return mapOfArrays;
    }
    
  • 4

    在Android上,我尝试使用@diyism回答,但我遇到了@rpetrich引发的空格字符问题,例如:我填写一个表单,其中 username = "us+us"password = "pw pw" 导致URL字符串看起来像:

    http://somewhere?username=us%2Bus&password=pw+pw
    

    但是,@ diyism代码返回 "us+us""pw+pw" ,即它不检测空格字符 . 如果使用 %20 重写URL,则会识别空格字符:

    http://somewhere?username=us%2Bus&password=pw%20pw
    

    这导致以下修复:

    Uri uri = Uri.parse(url_string.replace("+", "%20"));
    uri.getQueryParameter("para1");
    
  • 0

    使用 Guava :

    Multimap<String,String> parseQueryString(String queryString, String encoding) {
        LinkedListMultimap<String, String> result = LinkedListMultimap.create();
    
        for(String entry : Splitter.on("&").omitEmptyStrings().split(queryString)) {
            String pair [] = entry.split("=", 2);
            try {
                result.put(URLDecoder.decode(pair[0], encoding), pair.length == 2 ? URLDecoder.decode(pair[1], encoding) : null);
            } catch (UnsupportedEncodingException e) {
                throw new RuntimeException(e);
            }
        }
    
        return result;
    }
    
  • 0

    我有方法来实现这个目标:

    1)

    public static String getQueryString(String url, String tag) {
        String[] params = url.split("&");
        Map<String, String> map = new HashMap<String, String>();
        for (String param : params) {
            String name = param.split("=")[0];
            String value = param.split("=")[1];
            map.put(name, value);
        }
    
        Set<String> keys = map.keySet();
        for (String key : keys) {
            if(key.equals(tag)){
             return map.get(key);
            }
            System.out.println("Name=" + key);
            System.out.println("Value=" + map.get(key));
        }
        return "";
    }
    

    2) and the easiest way to do this Using Uri class:

    public static String getQueryString(String url, String tag) {
        try {
            Uri uri=Uri.parse(url);
            return uri.getQueryParameter(tag);
        }catch(Exception e){
            Log.e(TAG,"getQueryString() " + e.getMessage());
        }
        return "";
    }
    

    这是如何使用两种方法之一的示例:

    String url = "http://www.jorgesys.com/advertisements/publicidadmobile.htm?position=x46&site=reform&awidth=800&aheight=120";      
    String tagValue = getQueryString(url,"awidth");
    

    tagValue的值是 800

  • -2

    在Android上,您可以使用android.net.Uri类的Uri.parse静态方法来完成繁重的工作 . 如果你想要反正使用它 .

  • 3

    这对我有用..我不确定为什么每个人都在一个 Map 之后,List>我需要的只是一个简单的名称值Map .

    为了简单起见,我使用了URI.getQuery();

    public static Map<String, String> getUrlParameters(URI uri)
        throws UnsupportedEncodingException {
        Map<String, String> params = new HashMap<String, String>();
        for (String param : uri.getQuery().split("&")) {
            String pair[] = param.split("=");
            String key = URLDecoder.decode(pair[0], "UTF-8");
            String value = "";
            if (pair.length > 1) {
                value = URLDecoder.decode(pair[1], "UTF-8");
            }
            params.put(new String(key), new String(value));
        }
        return params;
    }
    
  • 0

    在Android上它的简单如下代码:

    UrlQuerySanitizer sanitzer = new UrlQuerySanitizer(url);
    String value = sanitzer.getValue("your_get_parameter");
    

    此外,如果您不想注册每个预期的查询键,请使用:

    sanitzer.setAllowUnregisteredParamaters(true)
    

    致电之前:

    sanitzer.parseUrl(yourUrl)
    
  • 2

    Guava的Multimap更适合这种情况 . 这是一个简短的干净版本:

    Multimap<String, String> getUrlParameters(String url) {
            try {
                Multimap<String, String> ret = ArrayListMultimap.create();
                for (NameValuePair param : URLEncodedUtils.parse(new URI(url), "UTF-8")) {
                    ret.put(param.getName(), param.getValue());
                }
                return ret;
            } catch (URISyntaxException e) {
                throw new RuntimeException(e);
            }
        }
    
  • 4

    我不认为JRE中有一个 . 您可以在Apache HttpClient等其他软件包中找到类似的功能 . 如果您不使用任何其他包,您只需编写自己的包 . 这并不难 . 这是我用的,

    public class QueryString {
    
     private Map<String, List<String>> parameters;
    
     public QueryString(String qs) {
      parameters = new TreeMap<String, List<String>>();
    
      // Parse query string
         String pairs[] = qs.split("&");
         for (String pair : pairs) {
                String name;
                String value;
                int pos = pair.indexOf('=');
                // for "n=", the value is "", for "n", the value is null
             if (pos == -1) {
              name = pair;
              value = null;
             } else {
           try {
            name = URLDecoder.decode(pair.substring(0, pos), "UTF-8");
                  value = URLDecoder.decode(pair.substring(pos+1, pair.length()), "UTF-8");            
           } catch (UnsupportedEncodingException e) {
            // Not really possible, throw unchecked
               throw new IllegalStateException("No UTF-8");
           }
             }
             List<String> list = parameters.get(name);
             if (list == null) {
              list = new ArrayList<String>();
              parameters.put(name, list);
             }
             list.add(value);
         }
     }
    
     public String getParameter(String name) {        
      List<String> values = parameters.get(name);
      if (values == null)
       return null;
    
      if (values.size() == 0)
       return "";
    
      return values.get(0);
     }
    
     public String[] getParameterValues(String name) {        
      List<String> values = parameters.get(name);
      if (values == null)
       return null;
    
      return (String[])values.toArray(new String[values.size()]);
     }
    
     public Enumeration<String> getParameterNames() {  
      return Collections.enumeration(parameters.keySet()); 
     }
    
     public Map<String, String[]> getParameterMap() {
      Map<String, String[]> map = new TreeMap<String, String[]>();
      for (Map.Entry<String, List<String>> entry : parameters.entrySet()) {
       List<String> list = entry.getValue();
       String[] values;
       if (list == null)
        values = null;
       else
        values = (String[]) list.toArray(new String[list.size()]);
       map.put(entry.getKey(), values);
      }
      return map;
     } 
    }
    
  • 13

    根据BalusC的答案,我写了一些示例-Java-Code:

    if (queryString != null)
        {
            final String[] arrParameters = queryString.split("&");
            for (final String tempParameterString : arrParameters)
            {
                final String[] arrTempParameter = tempParameterString.split("=");
                if (arrTempParameter.length >= 2)
                {
                    final String parameterKey = arrTempParameter[0];
                    final String parameterValue = arrTempParameter[1];
                    //do something with the parameters
                }
            }
        }
    
  • 58
    public static Map <String, String> parseQueryString (final URL url)
            throws UnsupportedEncodingException
    {
        final Map <String, String> qps = new TreeMap <String, String> ();
        final StringTokenizer pairs = new StringTokenizer (url.getQuery (), "&");
        while (pairs.hasMoreTokens ())
        {
            final String pair = pairs.nextToken ();
            final StringTokenizer parts = new StringTokenizer (pair, "=");
            final String name = URLDecoder.decode (parts.nextToken (), "ISO-8859-1");
            final String value = URLDecoder.decode (parts.nextToken (), "ISO-8859-1");
            qps.put (name, value);
        }
        return qps;
    }
    
  • 21

    在这里回答是因为这是一个受欢迎的主题 . 这是Kotlin中使用推荐的 UrlQuerySanitizer api的干净解决方案 . See the official documentation . 我添加了一个字符串生成器来连接并显示参数 .

    var myURL: String? = null
        // if the url is sent from a different activity where you set it to a value
        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")
        }
    
  • 4

    此方法采用uri并返回par name和par值的映射

    public static Map<String, String> getQueryMap(String uri) {
    
        String queryParms[] = uri.split("\\?");
    
        Map<String, String> map = new HashMap<>();// 
    
        if (queryParms == null || queryParms.length == 0) return map;
    
        String[] params = queryParms[1].split("&");
        for (String param : params) {
            String name = param.split("=")[0];
            String value = param.split("=")[1];
            map.put(name, value);
        }
        return map;
    }
    
  • 4

    你说“Java”,但“不是Java EE” . 您是说您使用的是JSP和/或servlet而不是完整的Java EE堆栈?如果是这种情况,那么您仍然可以使用request.getParameter() .

    如果你的意思是你正在编写Java,但是你没有编写JSP或servlet,或者你只是使用Java作为参考点,但是你在其他没有内置参数解析的平台上......哇,这听起来像是一个不太可能的问题,但如果是这样,原则是:

    xparm=0
    word=""
    loop
      get next char
      if no char
        exit loop
      if char=='='
        param_name[xparm]=word
        word=""
      else if char=='&'
        param_value[xparm]=word
        word=""
        xparm=xparm+1
      else if char=='%'
        read next two chars
        word=word+interpret the chars as hex digits to make a byte
      else
        word=word+char
    

    (我可以编写Java代码,但这样做毫无意义,因为如果你有Java可用,你可以使用request.getParameters . )

相关问题