logo标签列表

如何在Java中比较两个URL？

javahttpurl
12

这是一个简单的问题 - 给定两个URL，是否有内置方法或Apache库可以确定它们是否（逻辑上）相等？

例如，这两个URL是相等的：

http://stackoverflow.com
http://stackoverflow.com/
4个回答
12

虽然URI.equals()（以及存在问题的URL.equals()）在这些特定示例中不会返回true，但我认为这是可以假定等同性的唯一情况（因为HTTP协议中没有空路径）。

不能假定http://stackoverflow.com/foo和http://stackoverflow.com/foo/是等价的。

也许你可以使用URI.equals()包装在一个实用程序方法中，明确处理这种特定情况。

把URL.sameFile封装在一个实用方法中不是更好吗？例如，这样我就可以免费将http://stackoverflow.com:80/和http://stackoverflow.com/视为相等。 - r0u1i
@r0u1i：我在sameFile()的文档中没有看到任何暗示它处理默认端口的内容（而且快速测试也不支持这种假设）。此外，sameFile()也遭受了与URL.equals()相同的问题，因为它也试图解析主机名。 - Joachim Sauer
端口默认值 - 对我有效。我得检查一下它是否解析了名称（文档上没有说明）。 - r0u1i
@r0u1i：哎呀，我的确在端口号上犯了一个错误。不过主机解析确实发生了（例如尝试访问http://foo.googlecode.com/和http://bar.googlecode.com/）。 - Joachim Sauer
啊，sameFile确实解析了主机名。我希望有一个预先存在的实用方法适用于所有这些情况。 - r0u1i
2

URL::equals 参考资料

URL urlOne = new URL("http://stackoverflow.com");
URL urlTwo = new URL("http://stackoverflow.com/");

if( urlOne.equals(urlTwo) )
{
    // ....
}

文档提示 -

如果两个URL对象具有相同的协议、引用等效主机、在主机上具有相同的端口号以及文件和文件片段相同，则它们是相等的。

如果两个主机名都可以解析为相同的IP地址，则认为这两个主机等效；否则，如果任一主机名无法解析，则主机名必须相等，而不考虑大小写；或者两个主机名都等于null。

由于主机比较需要名称解析，因此此操作是阻塞操作。

注意：equals的定义行为已知与HTTP中的虚拟主机不一致。

因此，如@Joachim所建议的那样，您应该优先选择URI :: equals reference 。

17
警告：URL.equals()将会解析主机名！这不仅会在不期望的地方引入网络 IO，还会产生错误的结果（例如，如果它们托管在相同的 IP 上，则http://vhost1.com/将等于http://vhost2.com/！）。最好使用URI并调用URI.equals()。 - Joachim Sauer
1
更糟糕的是，URL.equals() 可能会产生不同/不一致的结果，这取决于您是否有互联网连接... - Tomasz Nurkiewicz
1
以下内容可能对您有用-它验证了两个URL是否相等，允许以不同的顺序提供参数，并允许配置各种选项，包括：

  • 主机是否区分大小写
  • 路径是否区分大小写
  • 查询字符串参数是否区分大小写
  • 查询字符串值是否区分大小写
  • 方案是否区分大小写

您可以像这样测试它：

class Main {

  public static void main(String[] args) 
  {
      UrlComparer urlComparer = new UrlComparer();

      expectResult(false, "key a case different", urlComparer.urlsMatch("//test.com?A=a&B=b", "//test.com?a=a&b=b"));
      expectResult(false, "key a case different", urlComparer.urlsMatch("https://WWW.TEST.COM?A=1&b=2", "https://www.test.com?b=2&a=1"));
      expectResult(false, "key a value different", urlComparer.urlsMatch("/test?a=2&A=A", "/test?a=A&a=2"));
      expectResult(false, "key a value different", urlComparer.urlsMatch("https://WWW.TEST.COM?A=a&b=2", "https://www.test.com?b=2&A=1"));
      expectResult(false, "null", urlComparer.urlsMatch("/test", null));
      expectResult(false, "null", urlComparer.urlsMatch(null, "/test"));
      expectResult(false, "port different", urlComparer.urlsMatch("//test.com:22?A=a&B=b", "//test.com:443?A=a&B=b"));
      expectResult(false, "port different", urlComparer.urlsMatch("https://WWW.TEST.COM:8443", "https://www.test.com"));
      expectResult(false, "protocol different", urlComparer.urlsMatch("http://WWW.TEST.COM:2121", "https://www.test.com:2121"));
      expectResult(false, "protocol different", urlComparer.urlsMatch("http://WWW.TEST.COM?A=a&b=2", "https://www.test.com?b=2&A=a"));
      expectResult(true, "both null", urlComparer.urlsMatch(null, null));
      expectResult(true, "host and scheme different case", urlComparer.urlsMatch("HTTPS://WWW.TEST.COM", "https://www.test.com"));
      expectResult(true, "host different case", urlComparer.urlsMatch("https://WWW.TEST.COM:443", "https://www.test.com"));
      expectResult(true, "identical urls", urlComparer.urlsMatch("//test.com:443?A=a&B=b", "//test.com:443?A=a&B=b"));
      expectResult(true, "identical urls", urlComparer.urlsMatch("/test?a=A&a=2", "/test?a=A&a=2"));
      expectResult(true, "identical urls", urlComparer.urlsMatch("https://www.test.com", "https://www.test.com"));
      expectResult(true, "parameter order changed", urlComparer.urlsMatch("https://www.test.com?a=1&b=2&c=522%2fMe", "https://www.test.com?c=522%2fMe&b=2&a=1"));
      expectResult(true, "parmeter order changed", urlComparer.urlsMatch("https://WWW.TEST.COM?a=1&b=2", "https://www.test.com?b=2&a=1"));
    }

    public static void expectResult(boolean expectedResult, String msg, boolean result)
    {
      if (expectedResult != result)
        throw new RuntimeException(msg);
    }
}

UrlComparer.java

import java.net.URI;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.TreeMap;
import org.apache.http.NameValuePair;
import org.apache.http.client.utils.URLEncodedUtils;

public class UrlComparer
{
    private boolean hostIsCaseSensitive = false;
    private boolean pathIsCaseSensitive = true;
    private boolean queryStringKeysAreCaseSensitive = true;
    private boolean queryStringValuesAreCaseSensitive = false;
    private boolean schemeIsCaseSensitive = false;

    public boolean urlsMatch(String url1, String url2)
    {
        try
        {
            if (Objects.equals(url1, url2))
                return true;

            URI uri1 = new URI(url1);
            URI uri2 = new URI(url2);

            // Compare Query String Parameters
            Map<String, String> mapParams1 = getQueryStringParams(uri1);
            Map<String, String> mapParams2 = getQueryStringParams(uri2);
            if (!mapsAreEqual(mapParams1, mapParams2, getQueryStringValuesAreCaseSensitive()))
                return false;

            // Compare scheme (http or https)
            if (!stringsAreEqual(uri1.getScheme(), uri2.getScheme(), getSchemeIsCaseSensitive()))
                return false;

            // Compare host
            if (!stringsAreEqual(uri1.getHost(), uri2.getHost(), getHostIsCaseSensitive()))
                return false;

            // Compare path
            if (!stringsAreEqual(uri1.getPath(), uri2.getPath(), getPathIsCaseSensitive()))
                return false;

            // Compare ports
            if (!portsAreEqual(uri1, uri2))
                return false;

            return true;
        }
        catch (Exception e)
        {
            return false;
        }
    }

    protected Map<String, String> getQueryStringParams(URI uri)
    {
        Map<String, String> result = getListAsMap(URLEncodedUtils.parse(uri, "UTF-8"), getQueryStringKeysAreCaseSensitive());

        return result;
    }

    protected boolean stringsAreEqual(String s1, String s2, boolean caseSensitive)
    {
        // Eliminate null cases
        if (s1 == null || s2 == null)
        {
            if (s1 == s2)
                return true;

            return false;
        }

        if (caseSensitive)
        {
            return s1.equals(s2);
        }

        return s1.equalsIgnoreCase(s2);
    }

    protected boolean mapsAreEqual(Map<String, String> map1, Map<String, String> map2, boolean caseSensitiveValues)
    {
        for (Map.Entry<String, String> entry : map1.entrySet())
        {
            String key = entry.getKey();
            String map1value = entry.getValue();
            String map2value = map2.get(key);

            if (!stringsAreEqual(map1value, map2value, caseSensitiveValues))
                return false;
        }
        for (Map.Entry<String, String> entry : map2.entrySet())
        {
            String key = entry.getKey();
            String map2value = entry.getValue();
            String map1value = map2.get(key);

            if (!stringsAreEqual(map1value, map2value, caseSensitiveValues))
                return false;
        }

        return true;
    }

    protected boolean portsAreEqual(URI uri1, URI uri2)
    {
        int port1 = uri1.getPort();
        int port2 = uri2.getPort();

        if (port1 == port2)
            return true;

        if (port1 == -1)
        {
            String scheme1 = (uri1.getScheme() == null ? "http" : uri1.getScheme()).toLowerCase();
            port1 = scheme1.equals("http") ? 80 : 443;
        }
        if (port2 == -1)
        {
            String scheme2 = (uri2.getScheme() == null ? "http" : uri2.getScheme()).toLowerCase();
            port2 = scheme2.equals("http") ? 80 : 443;
        }

        boolean result = (port1 == port2);

        return result;
    }

    protected Map<String, String> getListAsMap(List<NameValuePair> list, boolean caseSensitiveKeys)
    {
        Map<String, String> result;

        if (caseSensitiveKeys)
        {
            result = new HashMap<String, String>();
        }
        else
        {
            result = new TreeMap<String, String>(String.CASE_INSENSITIVE_ORDER);
        }

        for (NameValuePair param : list)
        {
            if (caseSensitiveKeys)
            {
                if (!result.containsKey(param.getName()))
                    result.put(param.getName(), param.getValue());
            }
            else
            {
                result.put(param.getName(), param.getValue());
            }
        }

        return result;
    }

    public boolean getSchemeIsCaseSensitive()
    {
        return schemeIsCaseSensitive;
    }

    public void setSchemeIsCaseSensitive(boolean schemeIsCaseSensitive)
    {
        this.schemeIsCaseSensitive = schemeIsCaseSensitive;
    }

    public boolean getHostIsCaseSensitive()
    {
        return hostIsCaseSensitive;
    }

    public void setHostIsCaseSensitive(boolean hostIsCaseSensitive)
    {
        this.hostIsCaseSensitive = hostIsCaseSensitive;
    }

    public boolean getPathIsCaseSensitive()
    {
        return pathIsCaseSensitive;
    }

    public void setPathIsCaseSensitive(boolean pathIsCaseSensitive)
    {
        this.pathIsCaseSensitive = pathIsCaseSensitive;
    }

    public boolean getQueryStringKeysAreCaseSensitive()
    {
        return queryStringKeysAreCaseSensitive;
    }

    public void setQueryStringKeysAreCaseSensitive(boolean queryStringKeysAreCaseSensitive)
    {
        this.queryStringKeysAreCaseSensitive = queryStringKeysAreCaseSensitive;
    }

    public boolean getQueryStringValuesAreCaseSensitive()
    {
        return queryStringValuesAreCaseSensitive;
    }

    public void setQueryStringValuesAreCaseSensitive(boolean queryStringValuesAreCaseSensitive)
    {
        this.queryStringValuesAreCaseSensitive = queryStringValuesAreCaseSensitive;
    }

}
-1

sameFile

public boolean sameFile(URL other)比较两个URL，

不包括片段组件。 如果此URL和其他参数相等而不考虑片段组件，则返回true。

参数： other - 要比较的URL。 返回值： 如果它们引用相同的远程对象，则为true；否则为false。

还请查看此链接

http://download.oracle.com/javase/6/docs/api/java/net/URL.html#sameFile(java.net.URL)

由于我无法添加评论，浏览器抛出了Javascript错误。所以我在这里添加了我的评论。对不便表示歉意。

//这是我建议的内容

>URL url1 = new URL("http://stackoverflow.com/foo");

>URL url2 = new URL("http://stackoverflow.com/foo/");

>System.out.println(url1.sameFile(url2));

// this is suggested by Joachim Sauer 
>URI uri = new URI("http://stackoverflow.com/foo/");
>System.out.println(uri.equals("http://stackoverflow.com/foo"));

// Both are giving same result

所以 Joachim Sauer 再检查一次。

尝试使用该输入：它返回“false”。 - Joachim Sauer
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接