Jak normalizować URL w Javie?

Question

URL normalization (lub URL kanonicznej) jest to proces, w którym adresy są zmodyfikowane, a znormalizowane w spójny sposób. Celem procesu normalizacji jest przekształcenie adresu URL w znormalizowany lub kanoniczny adres URL, aby możliwe było sprawdzenie, czy dwa syntaktycznie różne adresy URL są równoważne.

Strategie obejmują dodawanie ukośnych ukośników, https => http, itd. Strona Wikipedia zawiera wiele list.

Masz ulubioną metodę robienia tego w Javie? Być może biblioteka (Nutch?), Ale jestem otwarty. Mniejsza i mniejsza liczba zależności jest lepsza.

Na razie coś podam i sprawdzę to pytanie.

EDYCJA: Chcę agresywnie znormalizować, aby liczyć adresy URL tak samo, jeśli odnoszą się do tej samej treści. Na przykład ignoruję parametry utm_source, utm_medium, utm_campaign. Na przykład ignoruję poddomeny, jeśli tytuł jest taki sam.

Answer 1

Czy zapoznałeś się z klasą URI?

http://docs.oracle.com/javase/7/docs/api/java/net/URI.html#normalize()

Answer 2

Można to zrobić z ramami Restlet wykorzystaniem Reference.normalize(). Powinieneś być w stanie usunąć elementy, których nie potrzebujesz wygodnie z tą klasą.

Answer 3

Znalazłem to pytanie ubiegłej nocy, ale nie było odpowiedzi, której szukałem, więc zrobiłem własną. Tutaj jest okrywać ktoś w przyszłości chce go:

/** 
* - Covert the scheme and host to lowercase (done by java.net.URL) 
* - Normalize the path (done by java.net.URI) 
* - Add the port number. 
* - Remove the fragment (the part after the #). 
* - Remove trailing slash. 
* - Sort the query string params. 
* - Remove some query string params like "utm_*" and "*session*". 
*/ 
public class NormalizeURL 
{ 
    public static String normalize(final String taintedURL) throws MalformedURLException 
    { 
     final URL url; 
     try 
     { 
      url = new URI(taintedURL).normalize().toURL(); 
     } 
     catch (URISyntaxException e) { 
      throw new MalformedURLException(e.getMessage()); 
     } 

     final String path = url.getPath().replace("/$", ""); 
     final SortedMap<String, String> params = createParameterMap(url.getQuery()); 
     final int port = url.getPort(); 
     final String queryString; 

     if (params != null) 
     { 
      // Some params are only relevant for user tracking, so remove the most commons ones. 
      for (Iterator<String> i = params.keySet().iterator(); i.hasNext();) 
      { 
       final String key = i.next(); 
       if (key.startsWith("utm_") || key.contains("session")) 
       { 
        i.remove(); 
       } 
      } 
      queryString = "?" + canonicalize(params); 
     } 
     else 
     { 
      queryString = ""; 
     } 

     return url.getProtocol() + "://" + url.getHost() 
      + (port != -1 && port != 80 ? ":" + port : "") 
      + path + queryString; 
    } 

    /** 
    * Takes a query string, separates the constituent name-value pairs, and 
    * stores them in a SortedMap ordered by lexicographical order. 
    * @return Null if there is no query string. 
    */ 
    private static SortedMap<String, String> createParameterMap(final String queryString) 
    { 
     if (queryString == null || queryString.isEmpty()) 
     { 
      return null; 
     } 

     final String[] pairs = queryString.split("&"); 
     final Map<String, String> params = new HashMap<String, String>(pairs.length); 

     for (final String pair : pairs) 
     { 
      if (pair.length() < 1) 
      { 
       continue; 
      } 

      String[] tokens = pair.split("=", 2); 
      for (int j = 0; j < tokens.length; j++) 
      { 
       try 
       { 
        tokens[j] = URLDecoder.decode(tokens[j], "UTF-8"); 
       } 
       catch (UnsupportedEncodingException ex) 
       { 
        ex.printStackTrace(); 
       } 
      } 
      switch (tokens.length) 
      { 
       case 1: 
       { 
        if (pair.charAt(0) == '=') 
        { 
         params.put("", tokens[0]); 
        } 
        else 
        { 
         params.put(tokens[0], ""); 
        } 
        break; 
       } 
       case 2: 
       { 
        params.put(tokens[0], tokens[1]); 
        break; 
       } 
      } 
     } 

     return new TreeMap<String, String>(params); 
    } 

    /** 
    * Canonicalize the query string. 
    * 
    * @param sortedParamMap Parameter name-value pairs in lexicographical order. 
    * @return Canonical form of query string. 
    */ 
    private static String canonicalize(final SortedMap<String, String> sortedParamMap) 
    { 
     if (sortedParamMap == null || sortedParamMap.isEmpty()) 
     { 
      return ""; 
     } 

     final StringBuffer sb = new StringBuffer(350); 
     final Iterator<Map.Entry<String, String>> iter = sortedParamMap.entrySet().iterator(); 

     while (iter.hasNext()) 
     { 
      final Map.Entry<String, String> pair = iter.next(); 
      sb.append(percentEncodeRfc3986(pair.getKey())); 
      sb.append('='); 
      sb.append(percentEncodeRfc3986(pair.getValue())); 
      if (iter.hasNext()) 
      { 
       sb.append('&'); 
      } 
     } 

     return sb.toString(); 
    } 

    /** 
    * Percent-encode values according the RFC 3986. The built-in Java URLEncoder does not encode 
    * according to the RFC, so we make the extra replacements. 
    * 
    * @param string Decoded string. 
    * @return Encoded string per RFC 3986. 
    */ 
    private static String percentEncodeRfc3986(final String string) 
    { 
     try 
     { 
      return URLEncoder.encode(string, "UTF-8").replace("+", "%20").replace("*", "%2A").replace("%7E", "~"); 
     } 
     catch (UnsupportedEncodingException e) 
     { 
      return string; 
     } 
    } 
} 

Answer 4

Ponieważ chcemy także zidentyfikować adresy URL, które odnoszą się do tej samej zawartości, Znalazłem ten papier z WWW2007 dość ciekawego: Do Not Crawl in the DUST: Different URLs with Similar Text. Zapewnia przyjemne podejście teoretyczne.

Answer 5

Nie, nie ma nic w standardowych bibliotekach, aby to zrobić. Kanonizacja obejmuje takie elementy jak dekodowanie niepotrzebnie zakodowanych znaków, przekształcanie nazw hostów na małe litery itp.

np. http://ACME.com/./foo%26bar staje:

http://acme.com/foo&bar

URI normalize() robi nie to zrobić.

Answer 6

Biblioteka RL: https://github.com/backchatio/rl idzie całkiem daleko poza java.net.URL.normalize(). Jest w Scali, ale wyobrażam sobie, że powinna być użyteczna z Javy.

Answer 7

W Javie normalizować URL ręcznie

String company_website = "http://www.foo.bar.com/whatever&stuff"; 

try { 
    URL url = new URL(company_website); 
    System.out.println(url.getProtocol() + "://" + url.getHost()); 
} catch (MalformedURLException e) { 
    e.printStackTrace(); 
} 

//prints `http://www.foo.bar.com` 

Java klasy URL ma wszelkiego rodzaju metod analizowania wszelkich część adresu URL.