दिए गए url से डोमेन नाम प्राप्त करें

Question

URL को देखते हुए, मैं डोमेन नाम निकालना चाहता हूं (इसमें 'www' भाग शामिल नहीं होना चाहिए)। यूआरएल में http / https शामिल हो सकता है। यहाँ जावा कोड है जो मैंने लिखा है। हालांकि यह ठीक काम करने के लिए लगता है, क्या कोई बेहतर दृष्टिकोण है या कुछ किनारे मामले हैं, जो विफल हो सकते हैं।

public static String getDomainName(String url) throws MalformedURLException{
    if(!url.startsWith("http") && !url.startsWith("https")){
         url = "http://" + url;
    }        
    URL netUrl = new URL(url);
    String host = netUrl.getHost();
    if(host.startsWith("www")){
        host = host.substring("www".length()+1);
    }
    return host;
}

इनपुट: http://google.com/blah

आउटपुट: google.com

Comments

कोशिश करो http://74.125.226.70और मुझे बताएं कि यह कैसे काम करता है :)

— मार्विन पिंटो

यह सिर्फ IP पता देता है। 74.125.226.70

— रैंडमक्वेस्ट

और उससे आपको डोमेन नाम कैसे मिलेगा ? यह मानते हुए कि आप इसके बाद क्या हैं ..

— मार्विन पिंटो

उदाहरण के लिए http://www.de/या http://www.com/वांछित परिणाम नहीं देगा।

— माइकल कोनित्ज़का

Answer 1

यदि आप URL पार्स करना चाहते हैं, तो उपयोग करें java.net.URI। java.net.URLसमस्याओं का एक गुच्छा है - इसकी equalsविधि एक DNS लुकअप का उपयोग करती है जिसका अर्थ है कि कोड का उपयोग करते हुए यह अविश्वसनीय हमलों के साथ उपयोग किए जाने पर सेवा हमलों से इनकार करने के लिए असुरक्षित हो सकता है।

"मिस्टर गोसलिंग - आपने उर समान को चूसना क्यों बनाया?" ऐसी ही एक समस्या बताते हैं। बस java.net.URIइसके बजाय उपयोग करने की आदत डालें।

public static String getDomainName(String url) throws URISyntaxException {
    URI uri = new URI(url);
    String domain = uri.getHost();
    return domain.startsWith("www.") ? domain.substring(4) : domain;
}

आपको जो चाहिए वो करना चाहिए।

---

हालांकि यह ठीक काम करने के लिए लगता है, क्या कोई बेहतर दृष्टिकोण है या कुछ किनारे मामले हैं, जो विफल हो सकते हैं।

मान्य URL के लिए आपका कोड विफल रहता है:

• httpfoo/bar- एक पथ घटक के साथ सापेक्ष URL जो इसके साथ शुरू होता है http।
• HTTP://example.com/ - प्रोटोकॉल केस-असंवेदनशील है।
• //example.com/ - होस्ट के साथ प्रोटोकॉल सापेक्ष URL
• www/foo - एक पथ के घटक के साथ एक रिश्तेदार URL जो इसके साथ शुरू होता है www
• wwwexample.com- डोमेन नाम जो शुरू नहीं होता है, www.लेकिन इसके साथ शुरू होता है www।

पदानुक्रमित URL में एक जटिल व्याकरण होता है। यदि आप RFC 3986 को ध्यान से पढ़े बिना अपने स्वयं के पार्सर को रोल करने का प्रयास करते हैं, तो आप शायद इसे गलत समझेंगे। बस उसी का उपयोग करें जो मुख्य पुस्तकालयों में बनाया गया है।

यदि आपको वास्तव में गन्दे इनपुट से निपटने की आवश्यकता है java.net.URI, जो RFC 3986 परिशिष्ट B को अस्वीकार करता है :

परिशिष्ट बी। एक नियमित अभिव्यक्ति के साथ एक यूआरआई संदर्भ पार्सिंग

जैसा कि "प्रथम-मैच-जीत" एल्गोरिथ्म POSIX नियमित अभिव्यक्ति द्वारा उपयोग किए जाने वाले "लालची" असंतुलन विधि के समान है, एक यूआरआई संदर्भ के संभावित पांच घटकों को पार्स करने के लिए एक नियमित अभिव्यक्ति का उपयोग करना स्वाभाविक और सामान्य है।

निम्नलिखित घटकों को अपने घटकों में एक अच्छी तरह से गठित यूआरआई संदर्भ को तोड़ने के लिए नियमित अभिव्यक्ति है।

  ^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?
   12            3  4          5       6  7        8 9

ऊपर की दूसरी पंक्ति में संख्या केवल पठनीयता की सहायता के लिए है; वे प्रत्येक उपसंचाई (यानी, प्रत्येक युग्मित कोष्ठक) के लिए संदर्भ बिंदुओं को इंगित करते हैं।

Comments

@ जितेंद्र, मेरी सलाह है कि आप उन्हें ठीक करने पर काम न करें। जावा लाइब्रेरी के लोग आपके लिए काम कर चुके हैं।

— माइक सैमुअल

URI netUrl = नया URI ("www.google.com") के लिए भी; netUrl.getHost () NULL देता है। मुझे लगता है कि मुझे अभी भी http: // या https: // के लिए जाँच करने की आवश्यकता है:

— रैंडमक्वेस्ट

@ जितेंद्र, www.google.comएक पथ घटक वाला एक सापेक्ष URL है www.google.com। उदाहरण के लिए, यदि http://example.com/आप के खिलाफ हल हो, तो आपको मिलेगा http://example.com/www.google.com।

— माइक सैमुअल

धन्यवाद माइक,। अगर मैं सही समझा, पुस्तकालय के साथ, आप मतलब है, या तो ऊपर URI या regex का उपयोग करें?

— रैंडमक्वेशन

"Öob.se": यूआरआई मेजबान अशक्त हो सकता है अगर यह, विशेष वर्ण हैं, उदाहरण के लिए

— इंक

Answer 2

import java.net.*;
import java.io.*;

public class ParseURL {
  public static void main(String[] args) throws Exception {

    URL aURL = new URL("http://example.com:80/docs/books/tutorial"
                       + "/index.html?name=networking#DOWNLOADING");

    System.out.println("protocol = " + aURL.getProtocol()); //http
    System.out.println("authority = " + aURL.getAuthority()); //example.com:80
    System.out.println("host = " + aURL.getHost()); //example.com
    System.out.println("port = " + aURL.getPort()); //80
    System.out.println("path = " + aURL.getPath()); //  /docs/books/tutorial/index.html
    System.out.println("query = " + aURL.getQuery()); //name=networking
    System.out.println("filename = " + aURL.getFile()); ///docs/books/tutorial/index.html?name=networking
    System.out.println("ref = " + aURL.getRef()); //DOWNLOADING
  }
}

अधिक पढ़ें

Answer 3

यहाँ InternetDomainName.topPrivateDomain()अमरूद में एक छोटी और सरल रेखा का उपयोग किया गया है:InternetDomainName.from(new URL(url).getHost()).topPrivateDomain().toString()

दिया http://www.google.com/blah, जो आपको देगा google.com। या, दिया http://www.google.co.mx, यह आपको देगा google.co.mx।

जैसा कि सा क़ादा ने इस पोस्ट पर एक अन्य जवाब में टिप्पणी की , यह सवाल पहले पूछा गया है: किसी दिए गए यूआरएल से मुख्य डोमेन नाम निकालें । सर्वश्रेष्ठ उत्तर उस प्रश्न का से है सत्य , जो अमरूद का पता चलता है (InternetDomainName.topPrivateDomain)

सार्वजनिक बूलियन है TopPStreetDomain ()

इंगित करता है कि क्या यह डोमेन नाम ठीक एक उप-डोमेन घटक से बना है जिसके बाद एक सार्वजनिक प्रत्यय है। उदाहरण के लिए, google.com और foo.co.uk के लिए सही है, लेकिन www.google.com या co.uk के लिए नहीं।

चेतावनी: इस पद्धति से एक सच्चा परिणाम यह नहीं निकलता है कि डोमेन उच्चतम स्तर पर है जो एक मेजबान के रूप में संबोधित करने योग्य है, क्योंकि कई सार्वजनिक प्रत्यय भी पते योग्य होस्ट हैं। उदाहरण के लिए, डोमेन bar.uk.com में uk.com का एक सार्वजनिक प्रत्यय है, इसलिए यह इस पद्धति से सही होगा। लेकिन uk.com अपने आप में एक पते योग्य होस्ट है।

इस विधि का उपयोग यह निर्धारित करने के लिए किया जा सकता है कि क्या डोमेन संभवतः उच्चतम स्तर है जिसके लिए कुकीज़ सेट की जा सकती हैं, हालांकि यह भी कि कुकी के नियंत्रण के व्यक्तिगत ब्राउज़रों के कार्यान्वयन पर निर्भर करता है। जानकारी के लिए RFC 2109 देखें।

साथ कि एक साथ लाना URL.getHost()है, जो मूल पोस्ट पहले से ही है, तो आपको देता है:

import com.google.common.net.InternetDomainName;

import java.net.URL;

public class DomainNameMain {

  public static void main(final String... args) throws Exception {
    final String urlString = "http://www.google.com/blah";
    final URL url = new URL(urlString);
    final String host = url.getHost();
    final InternetDomainName name = InternetDomainName.from(host).topPrivateDomain();
    System.out.println(urlString);
    System.out.println(host);
    System.out.println(name);
  }
}

Answer 4

मैंने एक विधि लिखी (नीचे देखें) जो एक यूआरएल के डोमेन नाम को निकालती है और जो साधारण स्ट्रिंग मिलान का उपयोग करती है। यह वास्तव में क्या करता है पहले "://"(या सूचकांक के बीच बिट निकालें 0अगर कोई "://"निहित नहीं है ) और पहले बाद में "/"(या String.length()यदि कोई बाद में नहीं है तो सूचकांक "/")। शेष, पूर्ववर्ती "www(_)*."बिट कटा हुआ है। मुझे यकीन है कि ऐसे मामले होंगे जहां यह काफी अच्छा नहीं होगा लेकिन ज्यादातर मामलों में यह काफी अच्छा होना चाहिए!

ऊपर माइक सैमुअल का कहना है कि java.net.URIवर्ग ऐसा कर सकता था (और java.net.URLकक्षा के लिए पसंद किया गया था ) लेकिन मुझे URIकक्षा के साथ समस्याओं का सामना करना पड़ा । विशेष रूप से, URI.getHost()एक शून्य मान देता है यदि url में स्कीम यानी "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;
}

Comments

मुझे लगता है कि यह ठीक नहीं हो सकता हैhttp://bob.com:8080/service/read?name=robert

— ली मीडोर

ली को इंगित करने के लिए धन्यवाद। ध्यान दें कि मैंने अपना जवाब "मुझे यकीन है कि ऐसे मामले होंगे जहां यह काफी अच्छा नहीं होगा ..." के साथ अर्हता प्राप्त की थी। मेरे उत्तर को आपके विशेष मामले के लिए कुछ मामूली संशोधन की आवश्यकता होगी।

— आदिल हुसैन

Answer 5

मैंने यूआरआई ऑब्जेक्ट के निर्माण के बाद एक छोटा सा इलाज किया

 if (url.startsWith("http:/")) {
        if (!url.contains("http://")) {
            url = url.replaceAll("http:/", "http://");
        }
    } else {
        url = "http://" + url;
    }
    URI uri = new URI(url);
    String domain = uri.getHost();
    return domain.startsWith("www.") ? domain.substring(4) : domain;

Answer 6

मेरे मामले में मुझे केवल मुख्य डोमेन की आवश्यकता थी न कि उपडोमेन (कोई "www" या उपडोमेन जो भी हो):

public static String getUrlDomain(String url) throws URISyntaxException {
    URI uri = new URI(url);
    String domain = uri.getHost();
    String[] domainArray = domain.split("\\.");
    if (domainArray.length == 1) {
        return domainArray[0];
    }
    return domainArray[domainArray.length - 2] + "." + domainArray[domainArray.length - 1];
}

इस विधि के साथ url " https://rest.webtoapp.io/llSlider?lg=en&t=8 " डोमेन "webtoapp.io" के लिए होगा।

Answer 7

इसे आज़माएँ: java.net.URL;
JOptionPane.showMessageDialog (null, getDomainName (नया URL (" https://en.wikipedia.org/wiki/List_of_Internet_top-level_domains "));

public String getDomainName(URL url){
String strDomain;
String[] strhost = url.getHost().split(Pattern.quote("."));
String[] strTLD = {"com","org","net","int","edu","gov","mil","arpa"};

if(Arrays.asList(strTLD).indexOf(strhost[strhost.length-1])>=0)
    strDomain = strhost[strhost.length-2]+"."+strhost[strhost.length-1];
else if(strhost.length>2)
    strDomain = strhost[strhost.length-3]+"."+strhost[strhost.length-2]+"."+strhost[strhost.length-1];
else
    strDomain = strhost[strhost.length-2]+"."+strhost[strhost.length-1];
return strDomain;}

Answer 8

एक दिए गए url से मुख्य डोमेन नाम निकालने के समान प्रश्न है । यदि आप इस उत्तर पर एक नज़र डालें , तो आप देखेंगे कि यह बहुत आसान है। आपको बस उपयोग java.net.URLऔर Stringउपयोगिता की आवश्यकता है -Split

Answer 9

private static final String hostExtractorRegexString = "(?:https?://)?(?:www\\.)?(.+\\.)(com|au\\.uk|co\\.in|be|in|uk|org\\.in|org|net|edu|gov|mil)";
private static final Pattern hostExtractorRegexPattern = Pattern.compile(hostExtractorRegexString);

public static String getDomainName(String url){
    if (url == null) return null;
    url = url.trim();
    Matcher m = hostExtractorRegexPattern.matcher(url);
    if(m.find() && m.groupCount() == 2) {
        return m.group(1) + m.group(2);
    }
    return null;
}

स्पष्टीकरण: रेगेक्स में 4 समूह हैं। पहले दो गैर-मिलान समूह हैं और अगले दो मिलान समूह हैं।

पहला गैर-मिलान समूह "http" या "https" या "" है

दूसरा गैर-मिलान समूह "www।" या ""

दूसरा मिलान समूह शीर्ष स्तर का डोमेन है

पहला मिलान समूह गैर-मिलान समूहों के बाद और शीर्ष स्तर डोमेन से पहले कुछ भी है

दो मिलान समूहों का संघ हमें डोमेन / होस्ट नाम देगा।

पुनश्च: ध्यान दें कि आप regex में किसी भी समर्थित डोमेन को जोड़ सकते हैं।

Answer 10

यदि इनपुट url उपयोगकर्ता इनपुट है। यह विधि सबसे उपयुक्त होस्ट नाम देती है। अगर नहीं मिला तो वापस इनपुट url देता है।

private String getHostName(String urlInput) {
        urlInput = urlInput.toLowerCase();
        String hostName=urlInput;
        if(!urlInput.equals("")){
            if(urlInput.startsWith("http") || urlInput.startsWith("https")){
                try{
                    URL netUrl = new URL(urlInput);
                    String host= netUrl.getHost();
                    if(host.startsWith("www")){
                        hostName = host.substring("www".length()+1);
                    }else{
                        hostName=host;
                    }
                }catch (MalformedURLException e){
                    hostName=urlInput;
                }
            }else if(urlInput.startsWith("www")){
                hostName=urlInput.substring("www".length()+1);
            }
            return  hostName;
        }else{
            return  "";
        }
    }

Answer 11

उपरोक्त सभी अच्छे हैं। यह मेरे लिए वास्तव में सरल और समझने में आसान लगता है। भावों का बहाना करो। मैंने इसे Groovy के लिए DataCenter नामक एक वर्ग के अंदर लिखा था।

static String extractDomainName(String url) {
    int start = url.indexOf('://')
    if (start < 0) {
        start = 0
    } else {
        start += 3
    }
    int end = url.indexOf('/', start)
    if (end < 0) {
        end = url.length()
    }
    String domainName = url.substring(start, end)

    int port = domainName.indexOf(':')
    if (port >= 0) {
        domainName = domainName.substring(0, port)
    }
    domainName
}

और यहाँ कुछ जून 4 परीक्षण हैं:

@Test
void shouldFindDomainName() {
    assert DataCenter.extractDomainName('http://example.com/path/') == 'example.com'
    assert DataCenter.extractDomainName('http://subpart.example.com/path/') == 'subpart.example.com'
    assert DataCenter.extractDomainName('http://example.com') == 'example.com'
    assert DataCenter.extractDomainName('http://example.com:18445/path/') == 'example.com'
    assert DataCenter.extractDomainName('example.com/path/') == 'example.com'
    assert DataCenter.extractDomainName('example.com') == 'example.com'
}

Answer 12

जिस तरह से मैंने किया और सभी मामलों के लिए काम किया, वह संयोजन में अमरूद लाइब्रेरी और रेगेक्स का उपयोग कर रहा है।

public static String getDomainNameWithGuava(String url) throws MalformedURLException, 
  URISyntaxException {
    String host =new URL(url).getHost();
    String domainName="";
    try{
        domainName = InternetDomainName.from(host).topPrivateDomain().toString();
    }catch (IllegalStateException | IllegalArgumentException e){
        domainName= getDomain(url,true);
    }
    return domainName;
}

getDomain () regex के साथ कोई भी सामान्य विधि हो सकती है।

Answer 13

उप डोमेन के बिना वास्तविक डोमेन नाम प्राप्त करने के लिए, मैं उपयोग करता हूं:

private String getDomainName(String url) throws URISyntaxException {
    String hostName = new URI(url).getHost();
    if (!hostName.contains(".")) {
        return hostName;
    }
    String[] host = hostName.split("\\.");
    return host[host.length - 2];
}

ध्यान दें कि यह दूसरे स्तर के डोमेन (जैसे .co.uk) के साथ काम नहीं करेगा।