determinar si una cadena es URL absoluta o URL relativa en java

Question

Dada una cadena, ¿cómo puedo determinar si es una URL absoluta o una URL relativa en Java? Probé el siguiente código:

private boolean isAbsoluteURL(String urlString) 
    { 
     boolean result = false; 
     try 
     { 
      URL url = new URL(urlString); 
      String protocol = url.getProtocol(); 
      if (protocol != null && protocol.trim().length() > 0) 
       result = true; 
     } 
     catch (MalformedURLException e) 
     { 
      return false; 
     } 
     return result; 
    } 

El problema es que todas las URLs relativas están tirando la MalformedURLException ya que no hay protocolo definido (ejemplo: www.google.com y/preguntas/ask).

Answer 1

Como dije en mi comentario, debe normalizar la URL, antes de verificarla, y esa normalización depende de su aplicación, ya que www.google.com no es una URL absoluta. Aquí es un código de ejemplo, que se puede utilizar para comprobar las direcciones URL a ser absoluta:

import java.net.URL; 

public class Test { 
    public static void main(String [] args) throws Exception { 
    String [] urls = {"www.google.com", 
         "http://www.google.com", 
         "/search", 
         "file:/dir/file", 
         "file://localhost/dir/file", 
         "file:///dir/file"}; 

    for(String url:urls) { 
     System.out.println("`" + url + "' is " + 
          (isAbsoluteURL(url)?"absolute":"relative")); 
    } 
    } 

    public static boolean isAbsoluteURL(String url) 
          throws java.net.MalformedURLException { 
    final URL baseHTTP = new URL("http://example.com"); 
    final URL baseFILE = new URL("file:///"); 
    URL frelative = new URL(baseFILE, url); 
    URL hrelative = new URL(baseHTTP, url); 
    System.err.println("DEBUG: file URL: " + frelative.toString()); 
    System.err.println("DEBUG: http URL: " + hrelative.toString()); 
    return frelative.equals(hrelative); 
    } 
} 

de reproducción:

~$ java Test 2>/dev/null 
`www.google.com' is relative 
`http://www.google.com' is absolute 
`/search' is relative 
`file:/dir/file' is absolute 
`file://localhost/dir/file' is absolute 
`file:///dir/file' is absolute 

Answer 2

Este es un fragmento de código que utilizo para asegurar enlaces son absolutos:

private String ensureAbsoluteURL(String base, String maybeRelative) { 
    if (maybeRelative.startsWith("http")) { 
     return maybeRelative; 
    } else { 
     try { 
      return new URL(new URL(base), maybeRelative).toExternalForm(); 
     } catch (MalformedURLException e) { 
      // do something 
     } 
    } 
} 

Answer 3

¿Qué tal:

final URI u = new URI("http://www.anigota.com/start"); 
// URI u = new URI("/works/with/me/too"); 
// URI u = new URI("/can/../do/./more/../sophis?ticated=stuff+too"); 

if(u.isAbsolute()) 
{ 
    System.out.println("Yes, i am absolute!"); 
} 
else 
{ 
    System.out.println("Ohh noes, it's a relative URI!"); 
} 

para ver Detalles: http://docs.oracle.com/javase/7/docs/api/java/net/URI.html

HTH

Answer 4

Hice esta

public static String processUrl(String urlToProcess, String grantedNormalUrl){ 
    if (urlToProcess.startsWith("//")){ 
     urlToProcess = checkUrlStartsWithProtocol(urlToProcess); 
     return urlToProcess; 
    } 

    if (!isAbsolute(urlToProcess)){ 
     String rootPage = extractRootPage(grantedNormalUrl); 
     boolean domainEndsWithSlash = rootPage.endsWith("/"); 
     boolean urlStartsWithSlash = urlToProcess.startsWith("/"); 
     if (domainEndsWithSlash && urlStartsWithSlash){ 
      rootPage = rootPage.substring(0, rootPage.length() - 1); // exclude/
     } 
     urlToProcess = rootPage + (!(domainEndsWithSlash || urlStartsWithSlash) ? "/" : "") + urlToProcess; 
    } 

    return urlToProcess; 
} 

public static boolean isAbsolute(String url){ 
    if (url.startsWith("//")) { // //www.domen.com/start 
     return true; 
    } 

    if (url.startsWith("/")){ // /somePage.html 
     return false; 
    } 

    boolean result = false; 

    try { 
     URI uri = new URI(url); 
     result = uri.isAbsolute(); 
    } catch (URISyntaxException e) { 
     e.printStackTrace(); 
    } 

    return result; 
} 

public static String checkUrlStartsWithProtocol(String url) { 
    if (!url.startsWith("http://") && !url.startsWith("https://")) { 
     StringBuilder prefixBuilder = new StringBuilder(); 
     prefixBuilder.append("http:"); 
     if (!url.startsWith("//")) { 
      prefixBuilder.append("//"); 
     } 
     url = prefixBuilder.toString() + url; 
    } 
    return url; 
} 

public static String extractRootPage(String urlString) { 
    int ignoreSlashes = 0; 
    if (urlString.startsWith("http://") || urlString.startsWith("https://")) { 
     ignoreSlashes = 2; 
    } 
    int endPosition = urlString.length(); 
    for (int i = 0; i < urlString.length(); i++) { 
     if (urlString.charAt(i) == '/') { 
      if (ignoreSlashes == 0) { 
       endPosition = i; //substring exclude/
       break; 
      } else { 
       ignoreSlashes--; 
      } 
     } 
    } 
    return checkUrlStartsWithProtocol(urlString.substring(0, endPosition)); 
}