Analizowanie ciągów zapytań na Androidzie

Java EE ma ServletRequest.getParameterValues ​​() .

Na platformach innych niż EE funkcja URL.getQuery () po prostu zwraca ciąg znaków.

Jaki jest normalny sposób, aby poprawnie parsować ciąg zapytania w adresie URL, gdy nie ma Java EE?

< rant >

Popularnym w odpowiedziach jest próba stworzenia własnego parsera. To bardzo interesujący i ekscytujący projekt mikrokodowania, ale nie mogę powiedzieć, że to dobry pomysł :(

Fragmenty kodu poniżej są ogólnie wadliwe lub uszkodzone, przy okazji. Złamanie ich jest ciekawym ćwiczeniem dla czytelnika. I hakerom atakującym witryny, które ich używają .

Analiza ciągów zapytań jest dobrze zdefiniowanym problemem, ale czytanie specyfikacji i rozumienie niuansów nie jest trywialne. O wiele lepiej jest pozwolić, aby jakiś programista biblioteki platform wykonał ciężką pracę i dokonał naprawy!

< / rant >

Od Androida M sprawy stały się bardziej skomplikowane. Odpowiedź android.net.URI .getQueryParameter () zawiera błąd, który łamie spacje przed JellyBean. Apache URLEncodedUtils.parse () działa, ale przestarzałe w L i usunięto M .

Więc najlepszą odpowiedzią jest teraz UrlQuerySanitizer . Istnieje od 1 poziomu API i nadal istnieje. Sprawia również, że myślisz o trudnych kwestiach, takich jak sposób postępowania ze znakami specjalnymi lub powtarzane wartości.

Najprostszy kod to

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

Jeśli jesteś zadowolony z domyślnego zachowania podczas analizowania, możesz:

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

ale powinieneś upewnić się, że rozumiesz, jakie jest domyślne zachowanie podczas analizowania, ponieważ może nie być tym, czego chcesz.

Na Androidzie:

import android.net.Uri;

[...]

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

W systemie Android biblioteki Apache zapewniają analizator składni zapytań:

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

Oto odpowiedź BalusC , ale kompiluje i zwraca wyniki:

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

Jeśli masz biblioteki jetty (serwer lub klient) na ścieżce klasy, możesz użyć klas util jetty (patrz javadoc ), np .:

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

Jeśli używasz Wiosna 3.1 lub nowszy (Yikes, miał nadzieję, że wsparcie wrócił dalej), można użyć UriComponentsi UriComponentsBuilder:

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

components.getQueryParams() zwraca a MultiValueMap<String, String>

Oto więcej dokumentacji .

W przypadku serwletu lub strony JSP można uzyskać kwerendowe pary klucz / wartość za pomocą request.getParameter („nazwa parametru”)

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

Są inne sposoby na zrobienie tego, ale tak właśnie robię na wszystkich tworzonych przez mnie serwletach i stronach jsp.

Na Androidzie próbowałem użyć odpowiedzi @diyism, ale napotkałem problem ze spacją podniesiony przez @rpetrich, na przykład: Wypełniam formularz gdzie username = "us+us"i password = "pw pw"powoduję, że ciąg adresu URL wygląda następująco:

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

Jednak kod @diyism zwraca "us+us"i "pw+pw"tzn. Nie wykrywa znaku spacji. Jeśli adres URL został przepisany przy %20użyciu znaku spacji, zostanie on zidentyfikowany:

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

Prowadzi to do następującej poprawki:

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

Analiza łańcucha zapytania jest nieco bardziej skomplikowana niż się wydaje, w zależności od tego, jak wybaczający chcesz być.

Po pierwsze, ciąg zapytania to bajty ascii. Odczytujesz te bajty pojedynczo i konwertujesz je na znaki. Jeśli postać jest? lub & a następnie sygnalizuje początek nazwy parametru. Jeśli znak ma wartość =, oznacza to początek wartości parametru. Jeśli znak ma wartość%, oznacza to początek zakodowanego bajtu. Tutaj jest trudniej.

Kiedy czytasz w% char, musisz przeczytać następne dwa bajty i zinterpretować je jako cyfry szesnastkowe. Oznacza to, że następne dwa bajty to 0-9, af lub AF. Sklej te dwie cyfry szesnastkowe, aby uzyskać wartość bajtu. Pamiętaj jednak, że bajty nie są znakami . Musisz wiedzieć, jakie kodowanie zostało użyte do zakodowania znaków. Znak é nie koduje tego samego w UTF-8, jak w ISO-8859-1. Zasadniczo nie można wiedzieć, jakie kodowanie zastosowano dla danego zestawu znaków. Zawsze używam UTF-8, ponieważ moja witryna jest skonfigurowana tak, aby zawsze obsługiwać wszystko przy użyciu UTF-8, ale w praktyce nie możesz być tego pewien. Niektóre programy klienckie podadzą kodowanie znaków w żądaniu; możesz spróbować to przeczytać, jeśli masz pełne żądanie HTTP. Jeśli masz tylko adres URL w izolacji, powodzenia.

W każdym razie, zakładając, że używasz UTF-8 lub innego wielobajtowego kodowania znaków, teraz po odkodowaniu jednego zakodowanego bajtu musisz go odłożyć na bok, aż do przechwycenia następnego bajtu. Potrzebne są wszystkie zakodowane bajty, które są razem, ponieważ nie można poprawnie dekodować adresu URL jeden bajt na raz. Odłóż wszystkie bajty, które są razem, a następnie odkoduj je wszystkie naraz, aby zrekonstruować swoją postać.

Co więcej, staje się bardziej zabawny, jeśli chcesz być łagodny i brać pod uwagę aplikacje klienckie, które zmieniają adresy URL. Na przykład niektórzy klienci poczty internetowej kodują rzeczy podwójnie. Lub podwoj znaki? & = (Na przykład:) http://yoursite.com/blah??p1==v1&&p2==v2. Jeśli chcesz spróbować z wdziękiem sobie z tym poradzić, musisz dodać więcej logiki do twojego parsera.

Na Androidzie jest to tak proste, jak poniższy kod:

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

Również jeśli nie chcesz rejestrować każdego oczekiwanego klucza zapytania, użyj:

sanitzer.setAllowUnregisteredParamaters(true)

Przed zadzwonieniem:

sanitzer.parseUrl(yourUrl)

Mam metody, aby to osiągnąć:

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) i najłatwiejszy sposób na wykonanie tego za pomocą klasy 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 "";
}

i to jest przykład użycia jednej z dwóch metod:

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

wartość tagValue wynosi 800

Na Androidzie możesz użyć metody statycznej Uri.parse klasy android.net.Uri, aby wykonać ciężkie podnoszenie. Jeśli robisz cokolwiek z identyfikatorami URI i zamiarami, i tak będziesz chciał ich użyć.

Dla porównania, właśnie z tym skończyłem (na podstawie URLEncodedUtils i zwracania mapy).

Cechy:

• akceptuje część ciągu adresu URL adresu URL zapytania (można użyć request.getQueryString())
• pusty ciąg zapytania utworzy pusty Map
• parametr bez wartości (test?) zostanie zamapowany na pusty List<String>

Kod:

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

Pomocnik zgodności (wartości są przechowywane w tablicy String, podobnie jak w 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;
}

To działa dla mnie .. Nie jestem pewien, dlaczego każdy szukał mapy, listy> Potrzebowałem tylko prostej nazwy mapy.

Dla uproszczenia użyłem kompilacji w 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;
}

Do tego lepiej nadaje się Multimapa Guavy. Oto krótka czysta wersja:

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 ma autonomiczną implementację QueryStringParser.java. Jeśli nie używasz Axis2, po prostu pobierz kod źródłowy i przypadek testowy stąd -

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

Oryginalnie odpowiedział tutaj

Na Androida jest klasa Uri w pakiecie android.net . Pamiętaj, że Uri jest częścią android.net, podczas gdy URI jest częścią java.net.

Klasa Uri ma wiele funkcji do wyodrębniania par klucz-wartość zapytania.

Następująca funkcja zwraca pary klucz-wartość w postaci HashMap.

W Javie:

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

W Kotlinie:

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
    }

Nie wydaje mi się, żeby taki był w JRE. Podobne funkcje można znaleźć w innych pakietach, takich jak Apache HttpClient. Jeśli nie używasz żadnych innych pakietów, musisz po prostu napisać własny. To nie jest takie trudne. Oto czego używam

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

Na podstawie odpowiedzi z BalusC napisałem przykładowy kod Java:

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

Użyj Apache HttpComponents i połącz go z kodem kolekcji, aby uzyskać dostęp do parametrów według wartości: http://www.joelgerard.com/2012/09/14/parsing-query-strings-in-java-and-accessing-values-by -klucz/

za pomocą Guawy:

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

Odpowiadając tutaj, ponieważ jest to popularny wątek. To czyste rozwiązanie w Kotlinie, które korzysta z zalecanego UrlQuerySanitizerinterfejsu API. Zobacz oficjalną dokumentację . Dodałem konstruktor ciągów, aby połączyć i wyświetlić parametry.

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

ta metoda pobiera nazwę URI i zwraca mapę wartości nominalnej i wartości nominalnej

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

Mówisz „Java”, ale „nie Java EE”. Czy masz na myśli, że używasz JSP i / lub serwletów, ale nie masz pełnego stosu Java EE? W takim przypadku powinieneś mieć do dyspozycji request.getParameter ().

Jeśli masz na myśli, że piszesz Javę, ale nie piszesz stron JSP ani serwletów, lub po prostu używasz Javy jako punktu odniesienia, ale korzystasz z innej platformy, która nie ma wbudowanej analizy parametrów ... Wow , to brzmi jak mało prawdopodobne pytanie, ale jeśli tak, zasadą byłoby:

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

(Mógłbym napisać kod Java, ale byłoby to bezcelowe, ponieważ jeśli masz dostępną Javę, możesz po prostu użyć request.getParameters.)