Codifica dell'indirizzo URL HTTP in Java

La mia applicazione autonoma Java ottiene un URL (che punta a un file) dall'utente e devo selezionarlo e scaricarlo. Il problema che sto affrontando è che non sono in grado di codificare correttamente l'indirizzo URL HTTP ...

Esempio:

URL:  http://search.barnesandnoble.com/booksearch/first book.pdf

java.net.URLEncoder.encode(url.toString(), "ISO-8859-1");

mi restituisce:

http%3A%2F%2Fsearch.barnesandnoble.com%2Fbooksearch%2Ffirst+book.pdf

Ma quello che voglio è

http://search.barnesandnoble.com/booksearch/first%20book.pdf

(spazio sostituito da% 20)

Immagino che URLEncodernon sia progettato per codificare URL HTTP ... JavaDoc dice "Classe di utilità per la codifica dei moduli HTML" ... Esiste un altro modo per farlo?

La classe java.net.URI può aiutare; nella documentazione dell'URL che trovi

Nota, la classe URI esegue l'escaping dei suoi campi componenti in determinate circostanze. Il modo consigliato per gestire la codifica e la decodifica degli URL è utilizzare un URI

Usa uno dei costruttori con più di un argomento, come:

URI uri = new URI(
    "http", 
    "search.barnesandnoble.com", 
    "/booksearch/first book.pdf",
    null);
URL url = uri.toURL();
//or String request = uri.toString();

(il costruttore a argomento singolo dell'URI NON sfugge ai caratteri illegali)

Solo i caratteri illegali vengono salvati dal codice sopra - NON sfugge ai caratteri non ASCII (vedi il commento di Fatih).
Il toASCIIStringmetodo può essere utilizzato per ottenere una stringa solo con caratteri US-ASCII:

URI uri = new URI(
    "http", 
    "search.barnesandnoble.com", 
    "/booksearch/é",
    null);
String request = uri.toASCIIString();

Per un URL con una query simile http://www.google.com/ig/api?weather=São Paulo, utilizzare la versione a 5 parametri del costruttore:

URI uri = new URI(
        "http", 
        "www.google.com", 
        "/ig/api",
        "weather=São Paulo",
        null);
String request = uri.toASCIIString();

Si prega di essere avvisati che la maggior parte delle risposte di cui sopra sono ERRATE.

La URLEncoderclasse, nonostante il nome, NON è ciò che deve essere qui. È un peccato che Sun abbia nominato questa classe in modo così fastidioso. URLEncoderè pensato per passare i dati come parametri, non per codificare l'URL stesso.

In altre parole, "http://search.barnesandnoble.com/booksearch/first book.pdf"è l'URL. I parametri sarebbero, ad esempio "http://search.barnesandnoble.com/booksearch/first book.pdf?parameter1=this&param2=that",. I parametri sono ciò per cui useresti URLEncoder.

I seguenti due esempi evidenziano le differenze tra i due.

Quanto segue produce parametri errati, secondo lo standard HTTP. Nota la e commerciale (&) e più (+) sono codificati in modo errato.

uri = new URI("http", null, "www.google.com", 80, 
"/help/me/book name+me/", "MY CRZY QUERY! +&+ :)", null);

// URI: http://www.google.com:80/help/me/book%20name+me/?MY%20CRZY%20QUERY!%20+&+%20:)

Quanto segue produrrà i parametri corretti, con la query codificata correttamente. Nota gli spazi, le e commerciali e i segni più.

uri = new URI("http", null, "www.google.com", 80, "/help/me/book name+me/", URLEncoder.encode("MY CRZY QUERY! +&+ :)", "UTF-8"), null);

// URI: http://www.google.com:80/help/me/book%20name+me/?MY+CRZY+QUERY%2521+%252B%2526%252B+%253A%2529

Ho intenzione di aggiungere un suggerimento qui rivolto agli utenti Android. Puoi farlo, evitando così di avere librerie esterne. Inoltre, tutte le soluzioni di ricerca / sostituzione di caratteri suggerite in alcune delle risposte precedenti sono pericolose e dovrebbero essere evitate.

Prova questo:

String urlStr = "http://abc.dev.domain.com/0007AC/ads/800x480 15sec h.264.mp4";
URL url = new URL(urlStr);
URI uri = new URI(url.getProtocol(), url.getUserInfo(), url.getHost(), url.getPort(), url.getPath(), url.getQuery(), url.getRef());
url = uri.toURL();

Puoi vedere che in questo particolare URL, devo avere quegli spazi codificati in modo da poterlo usare per una richiesta.

Questo sfrutta un paio di funzionalità disponibili per te nelle lezioni Android. Innanzitutto, la classe URL può suddividere un URL nei relativi componenti, quindi non è necessario eseguire alcuna ricerca / sostituzione di stringhe. In secondo luogo, questo approccio sfrutta la funzionalità della classe URI di componenti con escape corretto quando si costruisce un URI tramite componenti anziché da una singola stringa.

La bellezza di questo approccio è che puoi prendere qualsiasi stringa di URL valida e farla funzionare senza bisogno di alcuna conoscenza speciale di te stesso.

una soluzione che ho sviluppato e molto più stabile di qualsiasi altra:

public class URLParamEncoder {

    public static String encode(String input) {
        StringBuilder resultStr = new StringBuilder();
        for (char ch : input.toCharArray()) {
            if (isUnsafe(ch)) {
                resultStr.append('%');
                resultStr.append(toHex(ch / 16));
                resultStr.append(toHex(ch % 16));
            } else {
                resultStr.append(ch);
            }
        }
        return resultStr.toString();
    }

    private static char toHex(int ch) {
        return (char) (ch < 10 ? '0' + ch : 'A' + ch - 10);
    }

    private static boolean isUnsafe(char ch) {
        if (ch > 128 || ch < 0)
            return true;
        return " %$&+,/:;=?@<>#%".indexOf(ch) >= 0;
    }

}

Se hai un URL, puoi passare url.toString () in questo metodo. Prima decodifica, per evitare la doppia codifica (ad esempio, la codifica di uno spazio comporta% 20 e la codifica di un segno di percentuale comporta% 25, ​​quindi la doppia codifica trasformerà uno spazio in% 2520). Quindi, utilizza l'URI come spiegato sopra, aggiungendo tutte le parti dell'URL (in modo da non eliminare i parametri della query).

public URL convertToURLEscapingIllegalCharacters(String string){
    try {
        String decodedURL = URLDecoder.decode(string, "UTF-8");
        URL url = new URL(decodedURL);
        URI uri = new URI(url.getProtocol(), url.getUserInfo(), url.getHost(), url.getPort(), url.getPath(), url.getQuery(), url.getRef()); 
        return uri.toURL(); 
    } catch (Exception ex) {
        ex.printStackTrace();
        return null;
    }
}

Sì, la codifica URL sta per codificare quella stringa in modo che venga passata correttamente in un URL a una destinazione finale. Ad esempio, non è possibile avere http://stackoverflow.com?url=http://yyy.com . La codifica Url del parametro avrebbe corretto quel valore di parametro.

Quindi ho due scelte per te:

1. Hai accesso al percorso separato dal dominio? In tal caso, potresti semplicemente essere in grado di UrlEncode il percorso. Tuttavia, in caso contrario, l'opzione 2 potrebbe essere adatta a te.

2. Ottieni commons-httpclient-3.1. Questo ha una classe URIUtil:

   System.out.println (URIUtil.encodePath (" http://example.com/x y", "ISO-8859-1"));

Questo produrrà esattamente ciò che stai cercando, poiché codificherà solo la parte del percorso dell'URI.

Cordiali saluti, avrai bisogno di codec commons e registrazione comune per questo metodo per funzionare in fase di esecuzione.

Nitpicking: una stringa contenente un carattere di spazio bianco per definizione non è un URI. Quindi quello che stai cercando è il codice che implementa l'escaping dell'URI definito nella Sezione 2.1 della RFC 3986 .

Sfortunatamente, org.apache.commons.httpclient.util.URIUtilè deprecato e la replacement org.apache.commons.codec.net.URLCodeccodifica adatta per i post dei moduli, non negli URL effettivi. Quindi ho dovuto scrivere la mia funzione, che fa un singolo componente (non adatto a intere stringhe di query che hanno? 'S & & s)

public static String encodeURLComponent(final String s)
{
  if (s == null)
  {
    return "";
  }

  final StringBuilder sb = new StringBuilder();

  try
  {
    for (int i = 0; i < s.length(); i++)
    {
      final char c = s.charAt(i);

      if (((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z')) ||
          ((c >= '0') && (c <= '9')) ||
          (c == '-') ||  (c == '.')  || (c == '_') || (c == '~'))
      {
        sb.append(c);
      }
      else
      {
        final byte[] bytes = ("" + c).getBytes("UTF-8");

        for (byte b : bytes)
        {
          sb.append('%');

          int upper = (((int) b) >> 4) & 0xf;
          sb.append(Integer.toHexString(upper).toUpperCase(Locale.US));

          int lower = ((int) b) & 0xf;
          sb.append(Integer.toHexString(lower).toUpperCase(Locale.US));
        }
      }
    }

    return sb.toString();
  }
  catch (UnsupportedEncodingException uee)
  {
    throw new RuntimeException("UTF-8 unsupported!?", uee);
  }
}

URLEncoding può codificare bene gli URL HTTP, come sfortunatamente hai scoperto. La stringa che hai passato, " http://search.barnesandnoble.com/booksearch/first book.pdf", è stata correttamente e completamente codificata in un modulo con codifica URL. Potresti passare l'intera lunga stringa di gobbledigook che hai restituito come parametro in un URL e potrebbe essere decodificato nuovamente nella stringa che hai passato.

Sembra che tu voglia fare qualcosa di leggermente diverso dal passare l'intero URL come parametro. Da quello che raccolgo, stai cercando di creare un URL di ricerca che assomigli a " http://search.barnesandnoble.com/booksearch/whateverTheUserPassesIn ". L'unica cosa che devi codificare è il bit "whateverTheUserPassesIn", quindi forse tutto ciò che devi fare è qualcosa del genere:

String url = "http://search.barnesandnoble.com/booksearch/" + 
       URLEncoder.encode(userInput,"UTF-8");

Ciò dovrebbe produrre qualcosa di più valido per te.

Se qualcuno non vuole aggiungere una dipendenza al proprio progetto, queste funzioni potrebbero essere utili.

Passiamo la parte "percorso" del nostro URL qui. Probabilmente non vuoi passare l'URL completo come parametro (le stringhe di query richiedono escape diversi, ecc.).

/**
 * Percent-encodes a string so it's suitable for use in a URL Path (not a query string / form encode, which uses + for spaces, etc)
 */
public static String percentEncode(String encodeMe) {
    if (encodeMe == null) {
        return "";
    }
    String encoded = encodeMe.replace("%", "%25");
    encoded = encoded.replace(" ", "%20");
    encoded = encoded.replace("!", "%21");
    encoded = encoded.replace("#", "%23");
    encoded = encoded.replace("$", "%24");
    encoded = encoded.replace("&", "%26");
    encoded = encoded.replace("'", "%27");
    encoded = encoded.replace("(", "%28");
    encoded = encoded.replace(")", "%29");
    encoded = encoded.replace("*", "%2A");
    encoded = encoded.replace("+", "%2B");
    encoded = encoded.replace(",", "%2C");
    encoded = encoded.replace("/", "%2F");
    encoded = encoded.replace(":", "%3A");
    encoded = encoded.replace(";", "%3B");
    encoded = encoded.replace("=", "%3D");
    encoded = encoded.replace("?", "%3F");
    encoded = encoded.replace("@", "%40");
    encoded = encoded.replace("[", "%5B");
    encoded = encoded.replace("]", "%5D");
    return encoded;
}

/**
 * Percent-decodes a string, such as used in a URL Path (not a query string / form encode, which uses + for spaces, etc)
 */
public static String percentDecode(String encodeMe) {
    if (encodeMe == null) {
        return "";
    }
    String decoded = encodeMe.replace("%21", "!");
    decoded = decoded.replace("%20", " ");
    decoded = decoded.replace("%23", "#");
    decoded = decoded.replace("%24", "$");
    decoded = decoded.replace("%26", "&");
    decoded = decoded.replace("%27", "'");
    decoded = decoded.replace("%28", "(");
    decoded = decoded.replace("%29", ")");
    decoded = decoded.replace("%2A", "*");
    decoded = decoded.replace("%2B", "+");
    decoded = decoded.replace("%2C", ",");
    decoded = decoded.replace("%2F", "/");
    decoded = decoded.replace("%3A", ":");
    decoded = decoded.replace("%3B", ";");
    decoded = decoded.replace("%3D", "=");
    decoded = decoded.replace("%3F", "?");
    decoded = decoded.replace("%40", "@");
    decoded = decoded.replace("%5B", "[");
    decoded = decoded.replace("%5D", "]");
    decoded = decoded.replace("%25", "%");
    return decoded;
}

E test:

@Test
public void testPercentEncode_Decode() {
    assertEquals("", percentDecode(percentEncode(null)));
    assertEquals("", percentDecode(percentEncode("")));

    assertEquals("!", percentDecode(percentEncode("!")));
    assertEquals("#", percentDecode(percentEncode("#")));
    assertEquals("$", percentDecode(percentEncode("$")));
    assertEquals("@", percentDecode(percentEncode("@")));
    assertEquals("&", percentDecode(percentEncode("&")));
    assertEquals("'", percentDecode(percentEncode("'")));
    assertEquals("(", percentDecode(percentEncode("(")));
    assertEquals(")", percentDecode(percentEncode(")")));
    assertEquals("*", percentDecode(percentEncode("*")));
    assertEquals("+", percentDecode(percentEncode("+")));
    assertEquals(",", percentDecode(percentEncode(",")));
    assertEquals("/", percentDecode(percentEncode("/")));
    assertEquals(":", percentDecode(percentEncode(":")));
    assertEquals(";", percentDecode(percentEncode(";")));

    assertEquals("=", percentDecode(percentEncode("=")));
    assertEquals("?", percentDecode(percentEncode("?")));
    assertEquals("@", percentDecode(percentEncode("@")));
    assertEquals("[", percentDecode(percentEncode("[")));
    assertEquals("]", percentDecode(percentEncode("]")));
    assertEquals(" ", percentDecode(percentEncode(" ")));

    // Get a little complex
    assertEquals("[]]", percentDecode(percentEncode("[]]")));
    assertEquals("a=d%*", percentDecode(percentEncode("a=d%*")));
    assertEquals(")  (", percentDecode(percentEncode(")  (")));
    assertEquals("%21%20%2A%20%27%20%28%20%25%20%29%20%3B%20%3A%20%40%20%26%20%3D%20%2B%20%24%20%2C%20%2F%20%3F%20%23%20%5B%20%5D%20%25",
                    percentEncode("! * ' ( % ) ; : @ & = + $ , / ? # [ ] %"));
    assertEquals("! * ' ( % ) ; : @ & = + $ , / ? # [ ] %", percentDecode(
                    "%21%20%2A%20%27%20%28%20%25%20%29%20%3B%20%3A%20%40%20%26%20%3D%20%2B%20%24%20%2C%20%2F%20%3F%20%23%20%5B%20%5D%20%25"));

    assertEquals("%23456", percentDecode(percentEncode("%23456")));

}

C'è ancora un problema se hai un "/" codificato (% 2F) nel tuo URL.

RFC 3986 - La Sezione 2.2 dice: "Se i dati per un componente URI sarebbero in conflitto con lo scopo di un carattere riservato come delimitatore, i dati in conflitto devono essere codificati in percentuale prima che si formi l'URI." (RFC 3986 - Sezione 2.2)

Ma c'è un problema con Tomcat:

http://tomcat.apache.org/security-6.html - Risolto in Apache Tomcat 6.0.10

importante: Directory traversal CVE-2007-0450

Tomcat consente '\', '% 2F' e '% 5C' [...].

Le seguenti proprietà del sistema Java sono state aggiunte a Tomcat per fornire un ulteriore controllo sulla gestione dei delimitatori di percorso negli URL (entrambe le opzioni sono impostate su false):

• org.apache.tomcat.util.buf.UDecoder.ALLOW_ENCODED_SLASH: true | false
• org.apache.catalina.connector.CoyoteAdapter.ALLOW_BACKSLASH: true | false

A causa dell'impossibilità di garantire che tutti gli URL siano gestiti da Tomcat come nei server proxy, Tomcat dovrebbe essere sempre protetto come se non fosse utilizzato alcun proxy che limitasse l'accesso al contesto.

Colpisce: 6.0.0-6.0.9

Quindi, se hai un URL con il carattere% 2F, Tomcat restituisce: "400 URI non valido: noSlash"

È possibile cambiare la correzione bug nello script di avvio Tomcat:

set JAVA_OPTS=%JAVA_OPTS% %LOGGING_CONFIG%   -Dorg.apache.tomcat.util.buf.UDecoder.ALLOW_ENCODED_SLASH=true 

Ho letto le risposte precedenti per scrivere il mio metodo perché non potevo avere qualcosa che funzionasse correttamente usando la soluzione delle risposte precedenti, mi sembra buono ma se riesci a trovare un URL che non funziona con questo, per favore fatemelo sapere.

public static URL convertToURLEscapingIllegalCharacters(String toEscape) throws MalformedURLException, URISyntaxException {
            URL url = new URL(toEscape);
            URI uri = new URI(url.getProtocol(), url.getUserInfo(), url.getHost(), url.getPort(), url.getPath(), url.getQuery(), url.getRef());
            //if a % is included in the toEscape string, it will be re-encoded to %25 and we don't want re-encoding, just encoding
            return new URL(uri.toString().replace("%25", "%"));
}

Sono d'accordo con Matt. In effetti, non l'ho mai visto ben spiegato nei tutorial, ma una questione è come codificare il percorso dell'URL, e uno molto diverso è come codificare i parametri che sono aggiunti all'URL (la parte della query, dietro il "? "simbolo). Usano una codifica simile, ma non la stessa.

Specialmente per la codifica del carattere dello spazio bianco. Il percorso URL deve essere codificato come% 20, mentre la parte della query consente% 20 e anche il segno "+". L'idea migliore è testarla da soli sul nostro server Web, utilizzando un browser Web.

In entrambi i casi, I SEMPRE codificherei SEMPRE COMPONENTE PER COMPONENTE , mai l'intera stringa. Infatti URLEncoder lo consente per la parte di query. Per la parte percorso è possibile utilizzare l'URI di classe, sebbene in questo caso richieda l'intera stringa, non un singolo componente.

Ad ogni modo, credo che il modo migliore per evitare questi problemi sia usare un design personale non conflittuale. Come? Ad esempio, non nominerei mai directory o parametri usando caratteri diversi da aZ, AZ, 0-9 e _. In questo modo, l'unica necessità è codificare il valore di ogni parametro, poiché potrebbe provenire da un input dell'utente e i caratteri utilizzati sono sconosciuti.

Forse puoi provare UriUtils in org.springframework.web.util

UriUtils.encodeUri(input, "UTF-8")

Puoi anche usare GUAVAe tracciare escaper: UrlEscapers.urlFragmentEscaper().escape(relativePath)

Oltre alla risposta di Carlos Heuberger: se è necessario un valore diverso da quello predefinito (80), è necessario utilizzare il costruttore a 7 parametri:

URI uri = new URI(
        "http",
        null, // this is for userInfo
        "www.google.com",
        8080, // port number as int
        "/ig/api",
        "weather=São Paulo",
        null);
String request = uri.toASCIIString();

Ho preso il contenuto sopra e l'ho cambiato un po '. Mi piace prima la logica positiva e ho pensato che un HashSet potesse fornire prestazioni migliori rispetto ad alcune altre opzioni, come la ricerca attraverso una stringa. Tuttavia, non sono sicuro se la pena di boxe automatica valga la pena, ma se il compilatore ottimizza per i caratteri ASCII, il costo della boxe sarà basso.

/***
 * Replaces any character not specifically unreserved to an equivalent 
 * percent sequence.
 * @param s
 * @return
 */
public static String encodeURIcomponent(String s)
{
    StringBuilder o = new StringBuilder();
    for (char ch : s.toCharArray()) {
        if (isSafe(ch)) {
            o.append(ch);
        }
        else {
            o.append('%');
            o.append(toHex(ch / 16));
            o.append(toHex(ch % 16));
        }
    }
    return o.toString();
}

private static char toHex(int ch)
{
    return (char)(ch < 10 ? '0' + ch : 'A' + ch - 10);
}

// https://tools.ietf.org/html/rfc3986#section-2.3
public static final HashSet<Character> UnreservedChars = new HashSet<Character>(Arrays.asList(
        'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
        'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',
        '0','1','2','3','4','5','6','7','8','9',
        '-','_','.','~'));
public static boolean isSafe(char ch)
{
    return UnreservedChars.contains(ch);
}

Utilizzare la seguente soluzione Java standard (supera circa 100 casi di test forniti da Web Plattform Test ):

0. Verifica se l'URL è già codificato .

1. Suddividere l'URL in parti strutturali. Usalo java.net.URL per questo.

2. Codificare correttamente ogni parte strutturale!

3. Utilizzare IDN.toASCII(putDomainNameHere)per Punycode codificare il nome host!

4. Usare java.net.URI.toASCIIString()per codificare in percentuale, Unicode con codifica NFC - (meglio sarebbe NFKC!).

Scopri di più qui: https://stackoverflow.com/a/49796882/1485527

Ho creato un nuovo progetto per aiutare a costruire URL HTTP. La libreria codificherà automaticamente l'URL per segmenti di percorso e parametri di query.

Puoi visualizzare la fonte e scaricare un file binario su https://github.com/Widen/urlbuilder

L'URL di esempio in questa domanda:

new UrlBuilder("search.barnesandnoble.com", "booksearch/first book.pdf").toString()

produce

http://search.barnesandnoble.com/booksearch/first%20book.pdf

Ho avuto lo stesso problema. Risolto questo da unsing:

android.net.Uri.encode(urlString, ":/");

Codifica la stringa ma salta ":" e "/".

lo uso

org.apache.commons.text.StringEscapeUtils.escapeHtml4("my text % & < >");

aggiungi questa dipendenza

 <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-text</artifactId>
        <version>1.8</version>
    </dependency>

Sviluppo una biblioteca che serve a questo scopo: le galimatie . Analizza l'URL nello stesso modo dei browser web. Cioè, se un URL funziona in un browser, verrà analizzato correttamente dalle galimatie .

In questo caso:

// Parse
io.mola.galimatias.URL.parse(
    "http://search.barnesandnoble.com/booksearch/first book.pdf"
).toString()

Vi darà: http://search.barnesandnoble.com/booksearch/first%20book.pdf. Naturalmente questo è il caso più semplice, ma funzionerà con qualsiasi cosa, molto oltre java.net.URI.

Puoi verificarlo su: https://github.com/smola/galimatias

Puoi usare una funzione come questa. Completalo e modificalo secondo le tue necessità:

/**
     * Encode URL (except :, /, ?, &, =, ... characters)
     * @param url to encode
     * @param encodingCharset url encoding charset
     * @return encoded URL
     * @throws UnsupportedEncodingException
     */
    public static String encodeUrl (String url, String encodingCharset) throws UnsupportedEncodingException{
            return new URLCodec().encode(url, encodingCharset).replace("%3A", ":").replace("%2F", "/").replace("%3F", "?").replace("%3D", "=").replace("%26", "&");
    }

Esempio di utilizzo:

String urlToEncode = ""http://www.growup.com/folder/intérieur-à_vendre?o=4";
Utils.encodeUrl (urlToEncode , "UTF-8")

Il risultato è: http://www.growup.com/folder/int%C3%A9rieur-%C3%A0_vendre?o=4

String url = "" http://search.barnesandnoble.com/booksearch/ ;

Questo sarà costante immagino e solo il nome del file cambia in modo dinamico, quindi ottieni il nome del file

Nome file stringa; // ottieni il nome del file

String urlEnc = url + fileName.replace ("", "% 20");

Che ne dite di:

public String UrlEncode (String in_) {

String retVal = "";

try {
    retVal = URLEncoder.encode(in_, "UTF8");
} catch (UnsupportedEncodingException ex) {
    Log.get().exception(Log.Level.Error, "urlEncode ", ex);
}

return retVal;

}