webentwicklung-frage-antwort-db.com.de

Was ist der schnellste Weg, um den Domain-/Hostnamen von einer URL zu erhalten?

Ich muss eine große Liste von String-URLs durchgehen und den Domain-Namen daraus extrahieren.

Zum Beispiel:

http://www.stackoverflow.com/questions würde extrahieren www.stackoverflow.com

Ich habe ursprünglich new URL(theUrlString).getHost() verwendet, aber die URL-Objektinitialisierung verlängert den Prozess erheblich und scheint nicht erforderlich zu sein.

Gibt es eine schnellere Methode zum Extrahieren des Hostnamens, die genauso zuverlässig wäre?

Vielen Dank

Edit: Mein Fehler, ja das www. würde im obigen Domainnamen-Beispiel enthalten sein. Diese URLs können auch http oder https sein

17
cottonBallPaws

Wenn Sie mit https usw. umgehen möchten, sollten Sie Folgendes tun:

int slashslash = url.indexOf("//") + 2;
domain = url.substring(slashslash, url.indexOf('/', slashslash));

Beachten Sie, dass dies den www-Teil enthält (genau wie URL.getHost()), der eigentlich zum Domänennamen gehört.

Über Kommentare angeforderte bearbeiten

Hier sind zwei Methoden, die hilfreich sein könnten:

/**
 * Will take a url such as http://www.stackoverflow.com and return www.stackoverflow.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;
    }
}
35
aioobe

Sie möchten mit der Implementierung einer "schnellen" Methode zum Abholen von URLs ziemlich vorsichtig sein. Es gibt viele mögliche Abweichungen in URLs, die dazu führen können, dass eine "schnelle" Methode fehlschlägt. Zum Beispiel:

  • Der Schema- (Protokoll-) Teil kann in einer beliebigen Kombination aus Groß- und Kleinbuchstaben geschrieben werden. z.B. "http", "Http" und "HTTP" sind gleichwertig.

  • Der Berechtigungsteil kann optional einen Benutzernamen und/oder eine Portnummer enthalten, wie in " http: //[email protected]: 8080/index.html ".

  • Da bei DNS die Groß- und Kleinschreibung nicht beachtet wird, ist der Hostname-Teil einer URL (effektiv) nicht für Groß- und Kleinschreibung relevant.

  • Es ist legal (wenn auch sehr unregelmäßig), nicht-reservierte Zeichen in dem Schema oder den Berechtigungskomponenten einer URL zu kodieren. Sie müssen dies berücksichtigen, wenn Sie das Schema abgleichen (oder entfernen) oder den Hostnamen interpretieren. Ein Hostname mit% -kodierten Zeichen entspricht einem Namen, bei dem die% -kodierten Sequenzen dekodiert werden.

Wenn Sie nun die vollständige Kontrolle über den Prozess haben, der die URLs generiert, die Sie entfernen, können Sie diese Feinheiten wahrscheinlich ignorieren. Wenn sie jedoch aus Dokumenten oder Webseiten entnommen oder von Menschen eingegeben werden, sollten Sie überlegen, was passieren könnte, wenn Ihr Code auf eine "ungewöhnliche" URL stößt.


Wenn Sie die Zeit zum Erstellen von URL-Objekten angehen, sollten Sie stattdessen URI-Objekte verwenden. URI-Objekte versuchen unter anderem nicht, eine DNS-Suche nach dem Hostnamen-Teil durchzuführen.

8
Stephen C

Ich habe eine Methode geschrieben (siehe unten), die den Domainnamen einer URL extrahiert und die einfache Zeichenfolge verwendet. Was er tatsächlich tut, ist das Bit zwischen dem ersten "://" (oder dem Index 0, wenn kein "://" enthalten ist) und dem ersten nachfolgenden "/" (oder dem Index String.length(), wenn es keinen nachfolgenden "/" gibt) zu extrahieren. Das verbleibende "www(_)*."-Bit wird abgehackt. Ich bin mir sicher, dass es Fälle geben wird, in denen das nicht gut genug ist, aber in den meisten Fällen sollte es gut genug sein!

Ich habe hier gelesen, dass die Java.net.URI-Klasse dies tun könnte (und der Java.net.URL-Klasse vorgezogen wurde), aber ich hatte Probleme mit der URI-Klasse. Insbesondere gibt URI.getHost() einen Nullwert an, wenn die URL das Schema nicht enthält, d. H. Das "http(s)"-Bit.

/**
 * 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;
}
2
Adil Hussain

Es gibt nur einen anderen Weg, um den Host zu bekommen

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);

}

Jetzt müssen wir den Hostnamen nach dem Extrahieren aus der URL in Funktion übergeben

URL url = new URL("https://www.facebook.com/");
String hostname = getHostName(ur.getHost());

Toast.makeText(this, hostname, Toast.LENGTH_SHORT).show();

Die Ausgabe wäre: "facebook.com"

1
Ali Azaz Alam

Sie könnten einen Regex schreiben? http: // ist immer das gleiche und passt dann alles zusammen, bis Sie das erste '/' erhalten.

0
Nanne

Angenommen, es handelt sich dabei um wohlgeformte URLs, aber Sie wissen nicht, ob es sich um http: //, https: // usw. handelt.


int start = theUrlString.indexOf('/');
int start = theUrlString.indexOf('/', start+1);
int end = theUrlString.indexOf('/', start+1);
String domain = theUrlString.subString(start, end);
0
Jason LeBrun

Sie können versuchen, reguläre Ausdrücke zu verwenden. 

http://download.Oracle.com/javase/6/docs/api/Java/util/regex/Pattern.html

Hier ist eine Frage zum Extrahieren von Domänennamen mit regulären Ausdrücken in Java:

Regulärer Ausdruck zum Abrufen von domain.tld

0
Martin M

Versuchen Sie die Methode: getDomainFromUrl () in dieser Klasse

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;
        }

    }
}
0
Mr.Thong