Làm cách nào để chuẩn hóa URL trong Java?

Question

URL normalization (hoặc URL canonicalization) là quá trình theo đó URL được sửa đổi và chuẩn hóa theo cách nhất quán. Mục tiêu của quá trình chuẩn hóa là chuyển đổi URL thành URL chuẩn hoặc chuẩn để có thể xác định xem hai URL khác nhau về cú pháp có tương đương hay không.

Chiến lược bao gồm thêm dấu gạch chéo, https => http, v.v. Trang Wikipedia liệt kê nhiều.

Có phương pháp yêu thích để thực hiện việc này trong Java? Có lẽ một thư viện (Nutch?), Nhưng tôi đang mở. Phụ thuộc nhỏ hơn và ít hơn là tốt hơn.

Tôi sẽ mã hóa nội dung nào đó ngay bây giờ và theo dõi câu hỏi này.

EDIT: Tôi muốn tích cực chuẩn hóa để đếm các URL giống nhau nếu chúng tham chiếu đến cùng một nội dung. Ví dụ: tôi bỏ qua các thông số utm_source, utm_medium, utm_campaign. Ví dụ: tôi bỏ qua tên miền phụ nếu tiêu đề giống nhau.

Answer 1

Bạn đã xem qua lớp URI chưa?

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

Answer 2

Bạn có thể làm điều này với Restlet khuôn khổ sử dụng Reference.normalize(). Bạn cũng có thể loại bỏ các yếu tố bạn không cần khá thuận tiện với lớp này.

Answer 3

Tôi đã tìm thấy câu hỏi này tối qua, nhưng không có câu trả lời tôi đang tìm kiếm vì vậy tôi đã tự làm. ai đó ở đây nó được trong trường hợp trong tương lai muốn nó:

/** 
* - 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

Bởi vì bạn cũng muốn xác định URL mà tham khảo các nội dung tương tự, tôi thấy bài viết này từ WWW2007 khá thú vị: Do Not Crawl in the DUST: Different URLs with Similar Text. Nó cung cấp cho bạn một cách tiếp cận lý thuyết tốt đẹp.

Answer 5

Không, không có gì trong thư viện chuẩn để thực hiện việc này. Canonicalization bao gồm những thứ như giải mã các ký tự được mã hóa không cần thiết, chuyển đổi tên máy chủ thành chữ thường, v.v.

ví dụ: http://ACME.com/./foo%26bar trở thành:

http://acme.com/foo&bar

URI của normalize() làm không làm điều này.

Answer 6

Thư viện RL: https://github.com/backchatio/rl hoàn toàn nằm ngoài java.net.URL.normalize(). Đó là trong Scala, nhưng tôi tưởng tượng nó có thể sử dụng được từ Java.

Answer 7

Trong Java, bình thường hóa một URL bằng tay lớp URL

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` 

Các java có tất cả các loại phương pháp để phân tích ra bất kỳ một phần của URL.