Java Code Examples for java.net.URL#getProtocol()

/**
 * Compare two urls to see whether they refer to the same file,
 * i.e., having the same protocol, host, port, and path.
 * @return true if u1 and u2 refer to the same file
 */
@Override
protected boolean sameFile(URL u1, URL u2) {
  final String p1 = u1.getProtocol();
  if (PROTOCOL.equals(p1)) {
    if (!p1.equals(u2.getProtocol()))
      return false;

    if (!hostsEqual(u1, u2))
      return false;

    if (!(u1.getFile() == u2.getFile() ||
          (u1.getFile() != null && u1.getFile().equals(u2.getFile()))))
      return false;

    if (u1.getPort() != u2.getPort())
      return false;

    return true;
  } else {
    return u1.equals(u2);
  }
}
 

protected static String getBundleJarPathInternal(String MANIFESTPath,
		URL pluginManifLoc) {
	String protocol = pluginManifLoc.getProtocol();
	String path = pluginManifLoc.getPath();
	if (protocol.equals("file")) {
		// ok, can use like this
	} else if (protocol.equals("jar") && path.startsWith("file:")) {
		path = path.substring("file:".length());
	} else {
		log.warn("Plugin protocol not file but {}", protocol);
		throw new RuntimeException(
				"Cannot determine path - protocol indicates non-local URL.");
	}

	if (path.endsWith(MANIFESTPath)) {
		path = path.substring(0, path.length() - MANIFESTPath.length());
	}
	if (path.endsWith("!")) {
		path = path.substring(0, path.length() - 1);
	}
	return path;
}
 

public static java.net.URI toURI(URL url) {
    String protocol = url.getProtocol();
    String auth = url.getAuthority();
    String path = url.getPath();
    String query = url.getQuery();
    String ref = url.getRef();
    if (path != null && !(path.startsWith("/")))
        path = "/" + path;

    //
    // In java.net.URI class, a port number of -1 implies the default
    // port number. So get it stripped off before creating URI instance.
    //
    if (auth != null && auth.endsWith(":-1"))
        auth = auth.substring(0, auth.length() - 3);

    java.net.URI uri;
    try {
        uri = createURI(protocol, auth, path, query, ref);
    } catch (java.net.URISyntaxException e) {
        uri = null;
    }
    return uri;
}
 

/**
 * 获取包中所有资源，如果字符串为<code>“空”</code>则返回<code>null</code>。
 * 
 * @param packageName 包名
 * @return 包中所有资源文件，如果字符串为<code>“空”</code>则返回<code>null</code>。
 * @throws IOException
 */
public static List<String> getResourceInPackage(String packageName) throws IOException {
    if (StringUtil.isBlank(packageName)) {
        return null;
    }

    boolean recursive = packageName.endsWith(".*");
    String packagePath = getPackagePath(packageName);
    List<String> resources = CollectionUtil.createArrayList();
    String packageDirName = packagePath.replace('.', '/');

    URL[] dirs = ClassLoaderUtil.getResources(packageDirName);
    for (URL url : dirs) {
        String protocol = url.getProtocol();
        if ("file".equals(protocol)) {
            findResourceInDirPackage(packagePath, URLDecoder.decode(url.getFile(), "UTF-8"), resources);
        } else if ("jar".equals(protocol)) {
            findResourceInJarPackage(url, packageName, packageDirName, recursive, resources);
        }

    }
    return resources;
}
 

private String getHostAndPort(URL url) {
    String host = url.getHost();
    final String hostarg = host;
    try {
        // lookup hostname and use IP address if available
        host = AccessController.doPrivileged(
            new PrivilegedExceptionAction<String>() {
                public String run() throws IOException {
                        InetAddress addr = InetAddress.getByName(hostarg);
                        return addr.getHostAddress();
                }
            }
        );
    } catch (PrivilegedActionException e) {}
    int port = url.getPort();
    if (port == -1) {
        String scheme = url.getProtocol();
        if ("http".equals(scheme)) {
            return host + ":80";
        } else { // scheme must be https
            return host + ":443";
        }
    }
    return host + ":" + Integer.toString(port);
}
 

/**
 * Creates a new URL object that retrieves the content specified by the
 * given URL with credentials.. Internally the content is pre-fetched with
 * the given credentials. The returned URL has an custom protocol handler
 * that simply returns the pre-fetched content.
 * 
 * @param url
 * @param username
 * @param password
 * @return
 * @throws IOException
 */
private static URL withCredentials(final URL url, final String username,
        final String password) throws IOException {

    final byte[] content = getUrlContent(url, username, password);

    final URLStreamHandler handler = new URLStreamHandler() {

        @Override
        protected URLConnection openConnection(URL u) throws IOException {
            return new URLConnection(url) {
                @Override
                public void connect() throws IOException {
                }

                @Override
                public InputStream getInputStream() throws IOException {
                    return new ByteArrayInputStream(content);
                }
            };
        }
    };
    return new URL(url.getProtocol(), url.getHost(), url.getPort(),
            url.getFile(), handler);
}
 

static URL qualifyHost(URL url) {
  try {
    InetAddress a = InetAddress.getByName(url.getHost());
    String qualHost = a.getCanonicalHostName();
    URL q = new URL(url.getProtocol(), qualHost, url.getPort(), url.getFile());
    return q;
  } catch (IOException io) {
    return url;
  }
}
 

/**
 * This method retrieves the the backlinks of a given url.
 * 
 * @param url
 * @return
 * @throws IOException
 */

public BackLinkNeighborhood[] getBacklinks(URL url) throws IOException {
    URL normalizedURL = new URL(url.getProtocol(), url.getHost(), "/");
    String urlId = url2id.get(normalizedURL.toString());
    if (urlId == null) {
        return null;
    }
    String strLinks = authGraph.get(urlId);
    if (strLinks == null) {
        return null;
    } else {
        List<BackLinkNeighborhood> tempBacklinks = new ArrayList<BackLinkNeighborhood>();
        String[] backlinkIds = strLinks.split("###");
        for (int i = 0; i < backlinkIds.length; i++) {
            String url_title = hubID.get(backlinkIds[i]);
            if (url_title != null) {
                BackLinkNeighborhood bln = new BackLinkNeighborhood();
                String[] fields = url_title.split(":::");
                bln.setLink(fields[0]);
                if (fields.length > 1) {
                    bln.setTitle(fields[1]);
                }
                tempBacklinks.add(bln);
            }
        }
        BackLinkNeighborhood[] blns = new BackLinkNeighborhood[tempBacklinks.size()];
        tempBacklinks.toArray(blns);
        return blns;
    }
}
 

/**
 * This method is called to parse the string spec into URL u for a
 * mailto protocol.
 *
 * @param   u the URL to receive the result of parsing the spec
 * @param   spec the URL string to parse
 * @param   start the character position to start parsing at.  This is
 *          just past the ':'.
 * @param   limit the character position to stop parsing at.
 */
public void parseURL(URL u, String spec, int start, int limit) {

    String protocol = u.getProtocol();
    String host = "";
    int port = u.getPort();
    String file = "";

    if (start < limit) {
        file = spec.substring(start, limit);
    }
    /*
     * Let's just make sure we DO have an Email address in the URL.
     */
    boolean nogood = false;
    if (file == null || file.equals(""))
        nogood = true;
    else {
        boolean allwhites = true;
        for (int i = 0; i < file.length(); i++)
            if (!Character.isWhitespace(file.charAt(i)))
                allwhites = false;
        if (allwhites)
            nogood = true;
    }
    if (nogood)
        throw new RuntimeException("No email address");
    setURLHandler(u, protocol, host, port, file, null);
}
 

/**
 * Will encode url, if not disabled, and adds params on the end of it
 *
 * @param url             String with URL, should be valid URL without params
 * @param params          RequestParams to be appended on the end of URL
 * @param shouldEncodeUrl whether url should be encoded (replaces spaces with %20)
 * @return encoded url if requested with params appended if any available
 */
public static String getUrlWithQueryString(boolean shouldEncodeUrl, String url, RequestParams params) {
    if (url == null)
        return null;

    if (shouldEncodeUrl) {
        try {
            String decodedURL = URLDecoder.decode(url, "UTF-8");
            URL _url = new URL(decodedURL);
            URI _uri = new URI(_url.getProtocol(), _url.getUserInfo(), _url.getHost(), _url.getPort(), _url.getPath(), _url.getQuery(), _url.getRef());
            url = _uri.toASCIIString();
        } catch (Exception ex) {
            // Should not really happen, added just for sake of validity
            Log.e(LOG_TAG, "getUrlWithQueryString encoding URL", ex);
        }
    }

    if (params != null) {
        // Construct the query string and trim it, in case it
        // includes any excessive white spaces.
        String paramString = params.getParamString().trim();

        // Only add the query string if it isn't empty and it
        // isn't equal to '?'.
        if (!paramString.equals("") && !paramString.equals("?")) {
            url += url.contains("?") ? "&" : "?";
            url += paramString;
        }
    }

    return url;
}
 

String getKey(HttpClientReq req) {
    URL url = req.getUrlObj();
    String schema = url.getProtocol();
    String host = url.getHost();
    int port = url.getPort();
    if (port == -1) port = url.getDefaultPort();
    return schema + "//" + host + ":" + port;
}
 

public static String createApacheHttpClientLimiterKey(Config config) {
  try {
    String urlTemplate = config.getString(HttpConstants.URL_TEMPLATE);
    URL url = new URL(urlTemplate);
    String key = url.getProtocol() + "/" + url.getHost();
    if (url.getPort() > 0) {
      key = key + "/" + url.getPort();
    }
    log.info("Get limiter key [" + key + "]");
    return key;
  } catch (MalformedURLException e) {
    throw new IllegalStateException("Cannot get limiter key.", e);
  }
}
 

/**
 * This method is called to parse the string spec into URL u for a
 * mailto protocol.
 *
 * @param   u the URL to receive the result of parsing the spec
 * @param   spec the URL string to parse
 * @param   start the character position to start parsing at.  This is
 *          just past the ':'.
 * @param   limit the character position to stop parsing at.
 */
public void parseURL(URL u, String spec, int start, int limit) {

    String protocol = u.getProtocol();
    String host = "";
    int port = u.getPort();
    String file = "";

    if (start < limit) {
        file = spec.substring(start, limit);
    }
    /*
     * Let's just make sure we DO have an Email address in the URL.
     */
    boolean nogood = false;
    if (file == null || file.equals(""))
        nogood = true;
    else {
        boolean allwhites = true;
        for (int i = 0; i < file.length(); i++)
            if (!Character.isWhitespace(file.charAt(i)))
                allwhites = false;
        if (allwhites)
            nogood = true;
    }
    if (nogood)
        throw new RuntimeException("No email address");
    setURLHandler(u, protocol, host, port, file, null);
}
 

protected static URLHandler getDefault(URL url) {
    URLHandler handler = null;

    String protocol = url.getProtocol();
    try {
        if (protocol.equals("file")) {
            handler = new FileURLHandler(url);
        } else if (protocol.equals("jar") || protocol.equals("wsjar")) {
            handler = new JarURLHandler(url);
        }
    } catch (Exception e) {
        // ignore - just return null
    }
    return handler;
}
 

/**
 * Constructor an un-schemed object for proxy access.
 */
public HttpCallerInfo(URL url, String host, int port) {
    this.url= url;
    this.host = host;
    this.port = port;
    prompt = "";
    addr = null;
    protocol = url.getProtocol();
    authType = RequestorType.PROXY;
    scheme = "";
}
 

@Override
public URL adjustJarFileEntryUrl(URL url, URL rootUrl) {
	final String protocol = url.getProtocol();
	final boolean check = StringHelper.isEmpty( protocol )
			|| "file".equals( protocol )
			|| "vfszip".equals( protocol )
			|| "vfsfile".equals( protocol );
	if ( !check ) {
		return url;
	}

	final String filePart = extractLocalFilePath( url );
	if ( filePart.startsWith( "/" ) || new File(url.getFile()).isAbsolute() ) {
		// the URL is already an absolute form
		return url;
	}
	else {
		// prefer to resolve the relative URL relative to the root PU URL per
		// JPA 2.0 clarification.
		final File rootUrlFile = new File( extractLocalFilePath( rootUrl ) );
		try {
			if ( rootUrlFile.isDirectory() ) {
				// The PU root is a directory (exploded).  Here we can just build
				// the relative File reference and use the Filesystem API to convert
				// to URI and then a URL
				final File combined = new File( rootUrlFile, filePart );
				// make sure it exists..
				if ( combined.exists() ) {
					return combined.toURI().toURL();
				}
			}
			else {
				// The PU root is an archive.  Here we have to build a JAR URL to properly
				// handle the nested entry reference (the !/ part).
				return new URL(
						"jar:" + protocol + "://" + rootUrlFile.getAbsolutePath() + "!/" + filePart
				);
			}
		}
		catch (MalformedURLException e) {
			// allow to pass through to return the original URL
			log.debugf(
					e,
					"Unable to adjust relative <jar-file/> URL [%s] relative to root URL [%s]",
					filePart,
					rootUrlFile.getAbsolutePath()
			);
		}

		return url;
	}
}
 

private static String checkAnchorTags(String value) {
	logger.debug("IN");
	Pattern aPattern = Pattern.compile("<a([^>]+)>(.+?)</a>", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
	Pattern hrefPattern = Pattern.compile("\\s*href\\s*=\\s*['\"]([^'\"]+)['\"]", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);

	Matcher aTagMatcher = aPattern.matcher(value);

	while (aTagMatcher.find()) {
		String aTag = aTagMatcher.group();
		String href = aTagMatcher.group(1);

		// In <a> tag find href attribute
		Matcher hrefMatcher = hrefPattern.matcher(href);

		while (hrefMatcher.find()) {
			String link = hrefMatcher.group(1);

			try {
				URL url = new URL(link);
				String baseUrl = url.getProtocol() + "://" + url.getHost();

				if (!whitelist.getExternalServices().contains(baseUrl)) {
					logger.warn("Provided anchor's href is: " + url + ". Anchor base url is not in Whitelist and therefore anchor will be deleted");
					value = value.replace(aTag, "");
				}

			} catch (MalformedURLException e) {
				logger.debug("URL [" + link + "] is malformed. Trying to see if it is a valid relative URL...");
				if (isValidRelativeURL(link) && isTrustedRelativePath(link)) {
					logger.debug("URL " + link + " is recognized to be a valid URL");
				} else {
					logger.error("Malformed URL [" + link + "]", e);
					value = value.replace(aTag, "");
				}
			}
		}

	}

	logger.debug("OUT");
	return value;
}
 

public static void processUrls(final String caller,
                               final List<URL> urls,
                               final ClassLoader classLoader,
                               final Set<RequireDescriptors> requireDescriptors,
                               final List<URL> jarList) {
    for (final URL url : urls) {

        final String urlProtocol = url.getProtocol();
        //Currently, we only support jar and file protocol
        final boolean isValidURL = urlProtocol.equals("jar") || urlProtocol.equals("file");
        if (!isValidURL) {
            logger.warning("Unknown protocol " + urlProtocol);
            continue;
        }

        if (logger.isDebugEnabled()) {
            logger.debug(caller + ".processing: " + url);
        }

        try {

            final DeploymentLoader deploymentLoader = new DeploymentLoader();

            final Class<? extends DeploymentModule> moduleType = deploymentLoader.discoverModuleType(url, classLoader, requireDescriptors);
            if (AppModule.class.isAssignableFrom(moduleType) ||
                    EjbModule.class.isAssignableFrom(moduleType) ||
                    PersistenceModule.class.isAssignableFrom(moduleType) ||
                    ConnectorModule.class.isAssignableFrom(moduleType) ||
                    ClientModule.class.isAssignableFrom(moduleType)) {

                final URL archive = toFileUrl(url);

                if (!jarList.contains(archive)) {
                    jarList.add(archive);
                    final File file = toFile(archive);
                    logger.info("Found " + moduleType.getSimpleName() + " in classpath: " + file.getAbsolutePath());
                }
            }
        } catch (final IOException e) {
            logger.warning("Unable to determine the module type of " + url.toExternalForm() + ": Exception: " + e.getMessage(), e);
        } catch (final UnknownModuleTypeException ignore) {
            // no-op
        }
    }
}
 

private static Permission getURLConnectPermission(URL url) {
    String urlString = url.getProtocol() + "://" + url.getAuthority() + url.getPath();
    return new URLPermission(urlString);
}
 

/**
 * Determine whether the given URL points to a resource in the file system,
 * that is, has protocol "file" or "vfs".
 * @param url the URL to check
 * @return whether the URL has been identified as a file system URL
 */
public static boolean isFileURL(URL url) {
	String protocol = url.getProtocol();
	return (URL_PROTOCOL_FILE.equals(protocol) || protocol.startsWith(URL_PROTOCOL_VFS));
}