Análisis de cadenas de consulta en Android

Java EE tiene ServletRequest.getParameterValues ​​() .

En plataformas que no son EE, URL.getQuery () simplemente devuelve una cadena.

¿Cuál es la forma normal de analizar correctamente la cadena de consulta en una URL cuando no está en Java EE?

< despotricar >

Es popular en las respuestas intentar hacer su propio analizador. Este es un proyecto de microcodificación muy interesante y emocionante, pero no puedo decir que sea una buena idea :(

Los fragmentos de código a continuación son generalmente defectuosos o rotos, por cierto. Romperlos es un ejercicio interesante para el lector. Y a los piratas informáticos que atacan los sitios web que los utilizan .

Analizar cadenas de consulta es un problema bien definido, pero leer las especificaciones y comprender los matices no es trivial. ¡Es mucho mejor dejar que un codificador de la biblioteca de la plataforma haga el trabajo duro y arregle el problema por usted!

< / rant >

Desde Android M las cosas se han vuelto más complicadas. La respuesta de android.net.URI .getQueryParameter () tiene un error que rompe espacios antes de JellyBean. Apache URLEncodedUtils.parse () trabajó, pero fue en desuso en L , y elimina en M .

Entonces la mejor respuesta ahora es UrlQuerySanitizer . Esto ha existido desde el nivel 1 de API y todavía existe. También te hace pensar en cuestiones difíciles como cómo manejas caracteres especiales o valores repetidos.

El código más simple es

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

Si está satisfecho con el comportamiento de análisis predeterminado, puede hacer lo siguiente:

new UrlQuerySanitizer(url).getValue("paramName")

pero debe asegurarse de comprender cuál es el comportamiento de análisis predeterminado, ya que podría no ser lo que desea.

En Android:

import android.net.Uri;

[...]

Uri uri=Uri.parse(url_string);
uri.getQueryParameter("para1");

En Android, las bibliotecas de Apache proporcionan un analizador de consultas:

http://developer.android.com/reference/org/apache/http/client/utils/URLEncodedUtils.html y http://hc.apache.org/httpcomponents-client-ga/httpclient/apidocs/org/apache/ http / client / utils / URLEncodedUtils.html

Aquí está la respuesta de BalusC , pero compila y devuelve resultados:

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;
}

Si tiene librerías jetty (servidor o cliente) en su classpath, puede usar las clases jetty util (consulte javadoc ), por ejemplo:

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");

Si está utilizando Spring 3.1 o superior (vaya, esperaba que el soporte retrocediera más), puede usar UriComponentsy UriComponentsBuilder:

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

components.getQueryParams() devuelve un MultiValueMap<String, String>

Aquí hay más documentación .

Para un servlet o una página JSP, puede obtener pares clave / valor de cadena de consulta utilizando request.getParameter ("paramname")

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

Hay otras formas de hacerlo, pero así es como lo hago en todos los servlets y páginas jsp que creo.

En Android, traté de usar la respuesta @diyism pero encontré el problema de caracteres espaciales planteado por @rpetrich, por ejemplo: lleno un formulario donde username = "us+us"y hago password = "pw pw"que una cadena de URL se vea así:

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

Sin embargo, el código @diyism regresa "us+us"y "pw+pw", es decir, no detecta el carácter de espacio. Si la URL se reescribió con %20el carácter de espacio se identifica:

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

Esto lleva a la siguiente solución:

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

Analizar la cadena de consulta es un poco más complicado de lo que parece, dependiendo de cuán indulgente quieras ser.

Primero, la cadena de consulta son bytes ascii. Usted lee estos bytes uno a la vez y los convierte en caracteres. Si el personaje es? o & luego indica el inicio de un nombre de parámetro. Si el carácter es =, entonces señala el inicio de un valor de parámetro. Si el carácter es%, indica el inicio de un byte codificado. Aquí es donde se pone difícil.

Cuando lee en un% char, debe leer los siguientes dos bytes e interpretarlos como dígitos hexadecimales. Eso significa que los siguientes dos bytes serán 0-9, af o AF. Pegue estos dos dígitos hexadecimales para obtener su valor de byte. Pero recuerda, los bytes no son caracteres . Debe saber qué codificación se usó para codificar los caracteres. El carácter é no codifica lo mismo en UTF-8 que en ISO-8859-1. En general, es imposible saber qué codificación se usó para un conjunto de caracteres dado. Siempre uso UTF-8 porque mi sitio web está configurado para servir siempre todo usando UTF-8, pero en la práctica no puede estar seguro. Algunos agentes de usuario le indicarán la codificación de caracteres en la solicitud; puede intentar leer eso si tiene una solicitud HTTP completa. Si solo tienes una url aislada, buena suerte.

De todos modos, suponiendo que está utilizando UTF-8 o alguna otra codificación de caracteres de varios bytes, ahora que ha decodificado un byte codificado, debe dejarlo a un lado hasta que capture el siguiente byte. Necesita todos los bytes codificados que están juntos porque no puede decodificar url correctamente un byte a la vez. Ponga a un lado todos los bytes que están juntos y luego descifrelos todos a la vez para reconstruir su personaje.

Además, se vuelve más divertido si quieres ser indulgente y tener en cuenta a los agentes de usuario que destruyen las URL. Por ejemplo, algunos clientes de correo web codifican dos cosas. O duplique los caracteres? & = (Por ejemplo:) http://yoursite.com/blah??p1==v1&&p2==v2. Si desea tratar de resolverlo con gracia, deberá agregar más lógica a su analizador.

En Android es simple como el código a continuación:

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

Además, si no desea registrar cada clave de consulta esperada, use:

sanitzer.setAllowUnregisteredParamaters(true)

Antes de llamar:

sanitzer.parseUrl(yourUrl)

Tengo métodos para lograr esto:

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) y la forma más fácil de hacer esto usando la clase Uri :

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 "";
}

y este es un ejemplo de cómo usar cualquiera de los dos métodos:

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

el valor de tagValue es 800

En Android, puede usar el método estático Uri.parse de la clase android.net.Uri para hacer el trabajo pesado. Si está haciendo algo con URI e Intentos, querrá usarlo de todos modos.

Solo como referencia, esto es con lo que terminé (basado en URLEncodedUtils, y devolviendo un Mapa).

caracteristicas:

• acepta la parte de la cadena de consulta de la url (puede usar request.getQueryString())
• una cadena de consulta vacía producirá un vacío Map
• un parámetro sin un valor (? prueba) se asignará a un vacío List<String>

Código:

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;
}

Un asistente de compatibilidad (los valores se almacenan en una matriz de cadenas al igual que en 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;
}

Esto funciona para mí. No estoy seguro de por qué todos buscaban un Mapa, Lista> Todo lo que necesitaba era un simple nombre de valor Mapa.

Para simplificar las cosas, utilicé la compilación en 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;
}

El multimapa de guayaba es más adecuado para esto. Aquí hay una versión corta y limpia:

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);
        }
    }

Apache AXIS2 tiene una implementación autónoma de QueryStringParser.java. Si no está utilizando Axis2, simplemente descargue el código fuente y el caso de prueba desde aquí:

http://svn.apache.org/repos/asf/axis/axis2/java/core/trunk/modules/kernel/src/org/apache/axis2/transport/http/util/QueryStringParser.java

http://svn.apache.org/repos/asf/axis/axis2/java/core/trunk/modules/kernel/test/org/apache/axis2/transport/http/util/QueryStringParserTest.java

Originalmente respondido aquí

En Android, hay una clase Uri en el paquete android.net . Tenga en cuenta que Uri es parte de android.net, mientras que URI es parte de java.net.

La clase Uri tiene muchas funciones para extraer pares de clave-valor de consulta.

La siguiente función devuelve pares clave-valor en forma de HashMap.

En 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;
}

En Kotlin:

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
    }

No creo que haya uno en JRE. Puede encontrar funciones similares en otros paquetes como Apache HttpClient. Si no utiliza ningún otro paquete, solo tiene que escribir el suyo. No es tan dificil. Esto es lo que uso

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;
 } 
}

Basado en la respuesta de BalusC, escribí un código Java de ejemplo:

    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
            }
        }
    }

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;
}

Use Apache HttpComponents y conéctelo con algún código de colección para acceder a los parámetros por valor: http://www.joelgerard.com/2012/09/14/parsing-query-strings-in-java-and-accessing-values-by -llave/

usando guayaba:

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;
}

Respondiendo aquí porque este es un hilo popular. Esta es una solución limpia en Kotlin que utiliza la UrlQuerySanitizerAPI recomendada . Ver la documentación oficial . He agregado un generador de cadenas para concatenar y mostrar los parámetros.

    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")
    }

este método toma la uri y el mapa de retorno del nombre y valor nominal

  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;
}

Dices "Java" pero "no Java EE". ¿Quiere decir que está utilizando JSP y / o servlets pero no una pila Java EE completa? Si ese es el caso, entonces aún debería tener request.getParameter () disponible para usted.

Si quiere decir que está escribiendo Java pero no está escribiendo JSP ni servlets, o que solo está utilizando Java como punto de referencia, pero está en otra plataforma que no tiene un análisis de parámetros incorporado ... Wow , eso suena como una pregunta poco probable, pero si es así, el principio sería:

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

(Podría escribir código Java, pero eso no tendría sentido, porque si tiene Java disponible, puede usar request.getParameters).