java - puerto - ¿Cuál es la forma más rápida de obtener el nombre de dominio/host de una URL?
enmascarar puerto 8080 tomcat (8)
¿Podrías escribir una expresión regular? http: // siempre es el mismo, y luego hace coincidir todo hasta que obtenga el primer ''/''.
Necesito ir a través de una gran lista de cadenas de URL y extraer el nombre de dominio de ellos.
Por ejemplo:
http://www.stackoverflow.com/questions extraería www.stackoverflow.com
Originalmente estaba usando la new URL(theUrlString).getHost() pero la inicialización del objeto de la URL agrega mucho tiempo al proceso y parece innecesaria.
¿Existe un método más rápido para extraer el nombre de host que sería tan confiable?
Gracias
Edit: mi error, sí el www. sería incluido en el ejemplo de nombre de dominio anterior. Además, estas direcciones URL pueden ser http o https
Desea ser bastante cuidadoso con la implementación de URL de manera "rápida". Existe una gran cantidad de variabilidad potencial en las URL que podría hacer que falle un método "rápido". Por ejemplo:
La parte del esquema (protocolo) se puede escribir en cualquier combinación de mayúsculas y minúsculas; por ejemplo, "http", "Http" y "HTTP" son equivalentes.
La parte de autoridad puede incluir opcionalmente un nombre de usuario y / o un número de puerto como en " http://[email protected]:8080/index.html ".
Dado que el DNS no distingue entre mayúsculas y minúsculas, la parte del nombre de host de una URL también es (efectivamente) insensible a mayúsculas y minúsculas.
Es legal (aunque altamente irregular) codificar% los caracteres no reservados en los componentes de esquema o autoridad de una URL. Debe tener esto en cuenta al hacer coincidir (o eliminar) el esquema, o al interpretar el nombre de host. Un nombre de host con caracteres codificados en% se define como equivalente a uno con las secuencias codificadas en% decodificadas.
Ahora, si tienes el control total del proceso que genera las URL que estás eliminando, probablemente puedas ignorar estas sutilezas. Pero si se recopilan a partir de documentos o páginas web, o si ingresan personas, se recomienda que considere lo que podría suceder si su código encuentra una URL "inusual".
Si su preocupación es el tiempo necesario para construir objetos de URL, considere usar objetos URI en su lugar. Entre otras cosas buenas, los objetos URI no intentan una búsqueda de DNS de la parte del nombre de host.
Escribí un método (ver más abajo) que extrae el nombre de dominio de una url y que usa una simple concordancia de cadenas. Lo que realmente hace es extraer el bit entre el primer "://" (o el índice 0 si no hay "://" contenido) y el primer "/" subsiguiente (o el índice String.length() si no hay ningún "/" ). Lo restante, precediendo a "www(_)*." se corta el bit. Estoy seguro de que habrá casos en los que esto no será lo suficientemente bueno, ¡pero debería ser lo suficientemente bueno en la mayoría de los casos!
Leí here que la clase java.net.URI podía hacer esto (y era preferible a la clase java.net.URL ) pero encontré problemas con la clase URI . Notablemente, URI.getHost() da un valor nulo si la url no incluye el esquema, es decir, el bit "http(s)" .
/**
* Extracts the domain name from {@code url}
* by means of String manipulation
* rather than using the {@link URI} or {@link URL} class.
*
* @param url is non-null.
* @return the domain name within {@code url}.
*/
public String getUrlDomainName(String url) {
String domainName = new String(url);
int index = domainName.indexOf("://");
if (index != -1) {
// keep everything after the "://"
domainName = domainName.substring(index + 3);
}
index = domainName.indexOf(''/'');
if (index != -1) {
// keep everything before the ''/''
domainName = domainName.substring(0, index);
}
// check for and remove a preceding ''www''
// followed by any sequence of characters (non-greedy)
// followed by a ''.''
// from the beginning of the string
domainName = domainName.replaceFirst("^www.*?//.", "");
return domainName;
}
Podrías intentar usar expresiones regulares.
http://download.oracle.com/javase/6/docs/api/java/util/regex/Pattern.html
Aquí hay una pregunta sobre cómo extraer el nombre de dominio con expresiones regulares en Java:
Pruebe el método: getDomainFromUrl () en esa clase
package com.visc.mobilesecurity.childrencare.utils;
import android.content.Context;
import com.visc.mobilesecurity.antitheft.backwardcompatibility.FroyoSupport;
import com.visc.mobilesecurity.antitheft.util.AntiTheftUtils;
import com.visc.mobilesecurity.constant.Key;
import com.visc.mobilesecurity.util.Prefs;
import org.json.JSONObject;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
/**
* Created by thongnv12 on 3/9/2018.
*/
public class ChildcareUtils {
public static final String[] NATION_DOMAIN = {"af", "ax", "al", "dz", "as", "ad", "ao", "ai", "aq", "ag", "ar", "am", "aw", "ac", "au", "at", "az", "bs", "bh", "bd", "bb", "eus",
"by", "be", "bz", "bj", "bm", "bt", "bo", "bq", "ba", "bw", "bv", "br", "io", "vg", "bn", "bg", "bf", "mm", "bi", "kh", "cm", "ca", "cv", "cat", "ky", "cf", "td", "cl",
"cn", "cx", "cc", "co", "km", "cd", "cg", "ck", "cr", "ci", "hr", "cu", "cw", "cy", "cz", "dk", "dj", "dm", "do", "tl", "ec", "eg", "sv", "gq", "er", "ee", "et", "eu",
"fk", "fo", "fm", "fj", "fi", "fr", "gf", "pf", "tf", "ga", "gal", "gm", "ps", "ge", "de", "gh", "gi", "gr", "gl", "gd", "gp", "gu", "gt", "gg", "gn", "gw", "gy", "ht",
"hm", "hn", "hk", "hu", "is", "in", "id", "ir", "iq", "ie", "im", "il", "it", "jm", "jp", "je", "jo", "kz", "ke", "ki", "kw", "kg", "la", "lv", "lb", "ls", "lr", "ly",
"li", "lt", "lu", "mo", "mk", "mg", "mw", "my", "mv", "ml", "mt", "mh", "mq", "mr", "mu", "yt", "mx", "md", "mc", "mn", "me", "ms", "ma", "mz", "mm", "na", "nr", "np",
"nl", "nc", "nz", "ni", "ne", "ng", "nu", "nf", "kp", "mp", "no", "om", "pk", "pw", "ps", "pa", "pg", "py", "pe", "ph", "pn", "pl", "pt", "pr", "qa", "ro", "ru", "rw",
"re", "bq", "bl", "sh", "kn", "lc", "mf", "fr", "pm", "vc", "ws", "sm", "st", "sa", "sn", "rs", "sc", "sl", "sg", "bq", "sx", "sk", "si", "sb", "so", "so", "za", "gs",
"kr", "ss", "es", "lk", "sd", "sr", "sj", "sz", "se", "ch", "sy", "tw", "tj", "tz", "th", "tg", "tk", "to", "tt", "tn", "tr", "tm", "tc", "tv", "ug", "ua", "ae", "uk",
"us", "vi", "uy", "uz", "vu", "va", "ve", "vn", "wf", "eh", "zm", "zw"};
public static boolean isInNationString(String str) {
for (int index = 0; index < NATION_DOMAIN.length; index++) {
if (NATION_DOMAIN[index].equals(str)) {
return true;
}
}
return false;
}
public static String getDomainFromUrl(String urlStr) {
try {
String result = null;
// URL url = new URL(urlStr);
// result = url.getHost();
// return result;
//
// for test
// check dau cach
if (urlStr.contains(" ")) {
return null;
}
// replace
urlStr = urlStr.replace("https://", "");
urlStr = urlStr.replace("http://", "");
urlStr = urlStr.replace("www.", "");
//
String[] splitStr = urlStr.split("/");
String domainFull = splitStr[0];
String[] splitDot = domainFull.split("//.");
if (splitDot.length < 2) {
return null;
}
String nationStr = splitDot[splitDot.length - 1];
if (isInNationString(nationStr)) {
if (splitDot.length < 4) {
result = domainFull;
} else {
StringBuilder strResult = new StringBuilder();
int lengthDot = splitDot.length;
strResult.append(splitDot[lengthDot - 3]).append(".");
strResult.append(splitDot[lengthDot - 2]).append(".");
strResult.append(splitDot[lengthDot - 1]);
result = strResult.toString();
}
} else {
if (splitDot.length < 3) {
result = domainFull;
} else {
StringBuilder strResult = new StringBuilder();
int lengthDot = splitDot.length;
strResult.append(splitDot[lengthDot - 2]).append(".");
strResult.append(splitDot[lengthDot - 1]);
result = strResult.toString();
}
}
return result;
} catch (Exception ex) {
ex.printStackTrace();
return null;
}
}
}
Si quieres manejar https , etc., te sugiero que hagas algo como esto:
int slashslash = url.indexOf("//") + 2;
domain = url.substring(slashslash, url.indexOf(''/'', slashslash));
Tenga en cuenta que esto incluye la parte www (tal como lo URL.getHost() ) que en realidad es parte del nombre de dominio.
Edición solicitada a través de comentarios
Aquí hay dos métodos que podrían ser útiles:
/**
* Will take a url such as http://www..com and return www..com
*
* @param url
* @return
*/
public static String getHost(String url){
if(url == null || url.length() == 0)
return "";
int doubleslash = url.indexOf("//");
if(doubleslash == -1)
doubleslash = 0;
else
doubleslash += 2;
int end = url.indexOf(''/'', doubleslash);
end = end >= 0 ? end : url.length();
int port = url.indexOf('':'', doubleslash);
end = (port > 0 && port < end) ? port : end;
return url.substring(doubleslash, end);
}
/** Based on : http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/2.3.3_r1/android/webkit/CookieManager.java#CookieManager.getBaseDomain%28java.lang.String%29
* Get the base domain for a given host or url. E.g. mail.google.com will return google.com
* @param host
* @return
*/
public static String getBaseDomain(String url) {
String host = getHost(url);
int startIndex = 0;
int nextIndex = host.indexOf(''.'');
int lastIndex = host.lastIndexOf(''.'');
while (nextIndex < lastIndex) {
startIndex = nextIndex + 1;
nextIndex = host.indexOf(''.'', startIndex);
}
if (startIndex > 0) {
return host.substring(startIndex);
} else {
return host;
}
}
Solo hay otra forma de conseguir el host.
private String getHostName(String hostname) {
// to provide faultproof result, check if not null then return only hostname, without www.
if (hostname != null) {
return hostname.startsWith("www.") ? hostname.substring(4) : getHostNameDFExt(hostname);
}
return hostname;
}
private String getHostNameDFExt(String hostname) {
int substringIndex = 0;
for (char character : hostname.toCharArray()) {
substringIndex++;
if (character == ''.'') {
break;
}
}
return hostname.substring(substringIndex);
}
Ahora hemos pasado el nombre de host en función después de extraerlo de la URL
URL url = new URL("https://www.facebook.com/");
String hostname = getHostName(ur.getHost());
Toast.makeText(this, hostname, Toast.LENGTH_SHORT).show();
La salida sería: " facebook.com ".
Suponiendo que todas ellas sean URL bien formadas, pero no sabe si serán http: //, https: //, etc.
int start = theUrlString.indexOf(''/'');
int start = theUrlString.indexOf(''/'', start+1);
int end = theUrlString.indexOf(''/'', start+1);
String domain = theUrlString.subString(start, end);