Java URIBuilder.setHost方法代码示例

import org.apache.http.client.utils.URIBuilder; //导入方法依赖的package包/类
private JsonObject sendGet(URIBuilder target) {
    try {
        if (!target.getScheme().equals("matrix")) {
            throw new IllegalArgumentException("Scheme can only be matrix");
        }

        String domain = target.getHost();
        target.setScheme("https");
        IRemoteAddress addr = resolver.resolve(target.getHost());
        target.setHost(addr.getHost());
        target.setPort(addr.getPort());

        return sendGet(domain, target.build());
    } catch (URISyntaxException e) {
        throw new RuntimeException(e);
    }
}
 

import org.apache.http.client.utils.URIBuilder; //导入方法依赖的package包/类
private JsonObject sendPut(URIBuilder target, JsonObject payload) {
    try {
        if (!target.getScheme().equals("matrix")) {
            throw new IllegalArgumentException("Scheme can only be matrix");
        }

        String domain = target.getHost();
        target.setScheme("https");
        IRemoteAddress addr = resolver.resolve(target.getHost());
        target.setHost(addr.getHost());
        target.setPort(addr.getPort());

        return sendPut(domain, target.build(), payload);
    } catch (URISyntaxException e) {
        throw new RuntimeException(e);
    }
}
 

import org.apache.http.client.utils.URIBuilder; //导入方法依赖的package包/类
public URIBuilder transform(URI initial) {
    URIBuilder builder = new URIBuilder(initial);
    Entry mapping = mappings.get(initial.getHost());
    if (mapping == null) {
        return builder;
    }

    try {
        URL target = new URL(mapping.getValue());
        builder.setScheme(target.getProtocol());
        builder.setHost(target.getHost());
        if (target.getPort() != -1) {
            builder.setPort(target.getPort());
        }

        return builder;
    } catch (MalformedURLException e) {
        log.warn("Skipping DNS overwrite entry {} due to invalid value [{}]: {}", mapping.getName(), mapping.getValue(), e.getMessage());
        throw new ConfigurationException("Invalid DNS overwrite entry in homeserver client: " + mapping.getName(), e.getMessage());
    }
}
 

import org.apache.http.client.utils.URIBuilder; //导入方法依赖的package包/类
/**
 * Creates a URI for the requested api and method
 * [bittrex-api-url]/[version]/[api]/[method]
 * 
 * @param api
 *            API to use
 * @param method
 *            String literal representing the methodname
 * @param params
 *            URI Parameter
 * @return Bittrex API URI
 */
public static URI build(String api, String method, Map<String, String> params) {
	final URIBuilder builder = new URIBuilder();
	builder.setScheme(SCHEME);
	builder.setHost(HOST);
	builder.setPath(String.format("%s/%s/%s/%s", API_PATH, VERSION, api, method));
	if(params == null) {
		params = new HashMap<>();
	}
	
	for(Entry<String, String> paramEntry : params.entrySet()) {
		builder.addParameter(paramEntry.getKey(), paramEntry.getValue());
	}

	try {
		return builder.build();
	} catch (URISyntaxException e) {
		// Do
		e.printStackTrace();
	}

	return null;
}
 

import org.apache.http.client.utils.URIBuilder; //导入方法依赖的package包/类
@Override
protected URI createLocationURI(String location) throws ProtocolException
{
    try
    {
        final URIBuilder b = new URIBuilder(new URI(encode(location)).normalize());
        final String host = b.getHost();
        if (host != null)
        {
            b.setHost(host.toLowerCase(Locale.ROOT));
        }
        final String path = b.getPath();
        if (TextUtils.isEmpty(path))
        {
            b.setPath("/");
        }
        return b.build();
    }
    catch (final URISyntaxException ex)
    {
        throw new ProtocolException("Invalid redirect URI: " + location, ex);
    }
}
 

import org.apache.http.client.utils.URIBuilder; //导入方法依赖的package包/类
URI buildUri(URI baseUri, Map<String, String> params) {

            String schemaAfterReplacements = replaceParamsInTemplate(schema, params);

            URIBuilder builder = new URIBuilder();
            builder.setScheme(baseUri.getScheme());
            builder.setHost(baseUri.getHost());
            builder.setPort(baseUri.getPort());
            String path = baseUri.normalize().getPath() + schemaAfterReplacements;
            builder.setPath(path.replaceAll("//", "/")); // Replace double slashes

            for (String templateParamKey : templateParams.keySet()) {
                String templateParamKeyAfterReplacements = replaceParamsInTemplate(templateParamKey, params);
                String templateParamValueAfterReplacements = replaceParamsInTemplate(templateParams.get(templateParamKey), params);
                builder.setParameter(templateParamKeyAfterReplacements, templateParamValueAfterReplacements);
            }


            URI result;
            try {
                result = builder.build();
            } catch (URISyntaxException e) {
                throw new WebmateApiClientException("Could not build valid API URL", e);
            }
            return result;
        }
 

import org.apache.http.client.utils.URIBuilder; //导入方法依赖的package包/类
/**
 * 创建URI
 *
 * @return
 */
public URI buildURIByConfig() throws URISyntaxException {
    URIBuilder builder = new URIBuilder();
    builder.setHost(config.getHost());
    builder.setPort(config.getPort());
    builder.setPath(config.getPath());
    builder.setScheme(config.getProtocol());
    builder.setCharset(Charset.forName(config.getCharset()));
    return builder.build();
}
 

import org.apache.http.client.utils.URIBuilder; //导入方法依赖的package包/类
/**
 * 返回完整的请求URL；
 *
 * @param pathParams  路径参数；
 * @param queryParams 查询参数；
 * @return
 */
public URI generateRequestURI(Map<String, String> pathParams, Properties queryParams,
                              Charset encodingCharset){
    // 生成路径；
    String reallyActionPath = createActionPath(pathParams);
    String path = PathUtils.concatPaths(serviceEndpoint.getContextPath(), servicePath, reallyActionPath);
    path = PathUtils.absolute(path);

    // 生成查询字符串；
    URIBuilder uriBuilder = new URIBuilder();
    uriBuilder.setCharset(encodingCharset);
    if (serviceEndpoint.isHttps()) {
        uriBuilder.setScheme("https");
    } else {
        uriBuilder.setScheme("http");
    }

    uriBuilder.setHost(serviceEndpoint.getHost());
    uriBuilder.setPort(serviceEndpoint.getPort());
    uriBuilder.setPath(path.toString());
    List<NameValuePair> queryParameters = RequestUtils.createQueryParameters(queryParams);
    uriBuilder.setParameters(queryParameters);
    try {
        return uriBuilder.build();
    } catch (URISyntaxException e) {
        throw new IllegalArgumentException(e.getMessage(), e);
    }
}