Android에서 쿼리 문자열 구문 분석

Java EE에는 ServletRequest.getParameterValues ​​()가 있습니다.

비 EE 플랫폼에서 URL.getQuery ()는 단순히 문자열을 반환합니다.

Java EE에 있지 않을 때 URL에서 쿼리 문자열을 올바르게 구문 분석하는 일반적인 방법은 무엇입니까 ?

< 랜트 >

자신의 파서를 시도하고 만드는 대답에서 인기가 있습니다. 이것은 매우 재미 있고 흥미 진진한 마이크로 코딩 프로젝트이지만, 나는 그것이 좋은 생각이라고 말할 수 없습니다 :(

아래 코드 스 니펫은 일반적으로 결함이 있거나 끊어집니다 (btw). 그것들을 깨는 것은 독자에게 흥미로운 연습입니다. 그리고 해커들은이를 사용하는 웹 사이트를 공격합니다 .

쿼리 문자열 구문 분석은 잘 정의 된 문제이지만 사양을 읽고 뉘앙스를 이해하는 것은 쉽지 않습니다. 일부 플랫폼 라이브러리 코더가 열심히 작업하고 수정 작업을 수행하는 것이 훨씬 좋습니다!

< / rant >

Android M 이후 더 복잡해졌습니다. android.net.URI .getQueryParameter () 의 대답은 JellyBean 앞의 공백을 깨는 버그가 있습니다. Apache URLEncodedUtils.parse () 는 작동했지만 L 에서는 더 이상 사용되지 않으며 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

기본 구문 분석 동작에 만족하면 다음을 수행 할 수 있습니다.

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

그러나 기본 구문 분석 동작이 무엇인지 이해해야합니다. 원하는 동작이 아닐 수도 있습니다.

안드로이드 :

import android.net.Uri;

[...]

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

Android에서 Apache 라이브러리는 쿼리 파서를 제공합니다.

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

다음은 BalusC의 답변 이지만 컴파일하고 결과를 반환합니다.

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

클래스 경로에 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");

Spring 3.1 이상을 사용하는 경우 (좋아요, 지원이 더 나아지기를 바랐습니다) UriComponentsand UriComponentsBuilder:

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

components.getQueryParams() 를 반환 MultiValueMap<String, String>

더 많은 문서가 있습니다.

서블릿 또는 JSP 페이지의 경우 request.getParameter ( "paramname")을 사용하여 쿼리 문자열 키 / 값 쌍을 얻을 수 있습니다.

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

다른 방법이 있지만 내가 만든 모든 서블릿 및 jsp 페이지에서 수행하는 방식입니다.

안드로이드에, 나는 @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");

쿼리 문자열을 구문 분석하는 것은 원하는 용서에 따라 보이는 것보다 조금 더 복잡합니다.

먼저 쿼리 문자열은 ASCII 바이트입니다. 이 바이트를 한 번에 하나씩 읽고 문자로 변환하십시오. 문자가? 또는 & 다음 매개 변수 이름의 시작을 알립니다. 문자가 =이면 매개 변수 값의 시작을 나타냅니다. 문자가 %이면 인코딩 된 바이트의 시작을 알립니다. 여기 까다로운 곳이 있습니다.

% 문자를 읽을 때는 다음 두 바이트를 읽고 16 진수로 해석해야합니다. 즉, 다음 두 바이트는 0-9, af 또는 AF가됩니다. 이 두 16 진수를 함께 붙이면 바이트 값을 얻을 수 있습니다. 그러나 바이트는 문자가 아닙니다. . 문자를 인코딩하는 데 사용 된 인코딩을 알아야합니다. 문자 é는 ISO-8859-1에서와 동일하게 UTF-8로 인코딩하지 않습니다. 일반적으로 주어진 문자 집합에 어떤 인코딩이 사용되었는지 알 수 없습니다. 내 웹 사이트는 항상 UTF-8을 사용하여 모든 것을 제공하도록 구성되어 있기 때문에 항상 UTF-8을 사용하지만 실제로는 확실하지 않습니다. 일부 사용자 에이전트는 요청에서 문자 인코딩을 알려줍니다. 전체 HTTP 요청이있는 경우이를 읽으려고 시도 할 수 있습니다. URL이 격리되어 있다면 행운을 빕니다.

어쨌든 UTF-8 또는 다른 멀티 바이트 문자 인코딩을 사용한다고 가정하면 인코딩 된 바이트 하나를 디코딩 했으므로 다음 바이트를 캡처 할 때까지 따로 설정해야합니다. 한 번에 한 바이트 씩 올바르게 URL 디코딩 할 수 없으므로 함께 인코딩 된 모든 바이트가 필요합니다. 함께있는 모든 바이트를 따로두고 한 번에 모두 디코딩하여 캐릭터를 재구성하십시오.

또한 관대하고 URL을 조작하는 사용자 에이전트를 설명하려는 경우 더 재미있어집니다. 예를 들어, 일부 웹 메일 클라이언트는 이중 인코딩을합니다. 또는? & = 문자를 두 배로 늘리십시오 (예 :) http://yoursite.com/blah??p1==v1&&p2==v2. 이것을 올바르게 처리하려면 파서에 더 많은 논리를 추가해야합니다.

안드로이드에서는 아래 코드와 같이 간단합니다.

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

또한 각 예상 쿼리 키를 등록하지 않으려면 다음을 사용하십시오.

sanitzer.setAllowUnregisteredParamaters(true)

전화하기 전에 :

sanitzer.parseUrl(yourUrl)

이것을 달성하는 방법이 있습니다.

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) 그리고 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 "";
}

다음은 두 가지 방법 중 하나를 사용하는 방법의 예입니다.

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

tagValue의 값은 800

Android에서는 android.net.Uri 클래스 의 Uri.parse 정적 메소드를 사용 하여 무거운 작업을 수행 할 수 있습니다 . URI와 의도로 무언가를하고 있다면 어쨌든 그것을 사용하고 싶을 것입니다.

참고로 이것은 URLEncodedUtils를 기반으로하고 맵을 반환하는 결과입니다.

풍모:

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

호환성 도우미 (값은 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;
}

이것은 나를 위해 작동합니다. 왜 모든 사람들이 Map, List>를 따랐는지 모르겠습니다.

일을 단순하게 유지하기 위해 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;
}

구아바의 멀티 맵이 더 적합합니다. 다음은 깨끗하고 짧은 버전입니다.

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에는 QueryStringParser.java의 자체 포함 구현이 있습니다. Axis2를 사용하지 않는 경우 여기에서 소스 코드 및 테스트 사례를 다운로드하십시오.

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

Origanally 여기에 대답

안드로이드에는 android.net 패키지에 Uri 클래스가 있습니다 있습니다. URI는 android.net의 일부이고 URI는 java.net의 일부입니다.

Uri 클래스에는 쿼리 키-값 쌍을 추출하는 많은 기능이 있습니다.

다음 함수는 키-값 쌍을 HashMap 형식으로 반환합니다.

자바에서 :

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
    }

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

BalusC의 답변을 바탕으로 몇 가지 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;
}

Apache HttpComponents를 사용하고 일부 콜렉션 코드와 연결하여 값별로 매개 변수에 액세스 하십시오. -키/

구아바 사용하기 :

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

이것은 인기있는 스레드이기 때문에 여기에 대답하십시오. 이것은 권장 UrlQuerySanitizerAPI 를 사용하는 Kotlin의 깨끗한 솔루션입니다 . 공식 문서를 참조하십시오 . 매개 변수를 연결하고 표시하기 위해 문자열 작성기를 추가했습니다.

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

이 메소드는 par 이름과 par 값의 URI 및 리턴 맵을 사용합니다.

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

"Java"라고 말하지만 "Java EE"는 아닙니다. JSP 및 / 또는 서블릿을 사용하고 있지만 전체 Java EE 스택을 사용하고 있지 않습니까? 이 경우 여전히 request.getParameter ()를 사용할 수 있어야합니다.

Java를 작성하고 있지만 JSP 또는 서블릿을 작성하지 않거나 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 만 사용할 수 있기 때문입니다.)