Java URIBuilder.setPath方法代码示例

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包/类
public static String httpGetRequest(String url, Map<String, Object> params) throws URISyntaxException {
    URIBuilder ub = new URIBuilder();
    ub.setPath(url);

    ArrayList<NameValuePair> pairs = covertParams2NVPS(params);
    ub.setParameters(pairs);

    HttpGet httpGet = new HttpGet(ub.build());
    return getResult(httpGet);
}
 

import org.apache.http.client.utils.URIBuilder; //导入方法依赖的package包/类
@Override
protected URIBuilder getClientPathBuilder(String action) {
    URIBuilder builder = super.getClientPathBuilder(action);
    builder.setPath(builder.getPath().replace("{roomId}", roomId));

    return builder;
}
 

import org.apache.http.client.utils.URIBuilder; //导入方法依赖的package包/类
protected URIBuilder getPathBuilder(String module, String version, String action) {
    URIBuilder builder = context.getHs().getClientEndpoint();
    builder.setPath(builder.getPath() + "/_matrix/" + module + "/" + version + action);
    if (context.isVirtualUser()) {
        context.getUser().ifPresent(user -> builder.setParameter("user_id", user.getId()));
    }

    return builder;
}
 

import org.apache.http.client.utils.URIBuilder; //导入方法依赖的package包/类
protected String buildUriFromRepositoryName(String gitUriParam, String gitServiceUrl) throws SLException {
    try {
        URIBuilder gitUriBuilder = new URIBuilder(gitServiceUrl);
        gitUriBuilder.setPath(PATH_SEPARATOR + gitUriParam);
        return gitUriBuilder.toString();
    } catch (URISyntaxException e) {
        throw new SLException(e, Messages.ERROR_PROCESSING_GIT_URI);
    }
}
 

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

import org.apache.http.client.utils.URIBuilder; //导入方法依赖的package包/类
private URI makeLink(boolean remove_last_segment) throws ODataException
{
   try
   {
      URIBuilder ub = new URIBuilder(ServiceFactory.EXTERNAL_URL);
      StringBuilder sb = new StringBuilder();

      String prefix = ub.getPath();
      String path = getContext().getPathInfo().getRequestUri().getPath();
      if (path == null || path.isEmpty() ||
            prefix != null && !prefix.isEmpty() && !path.startsWith(ub.getPath()))
      {
         sb.append(prefix);

         if (path != null)
         {
            if (prefix.endsWith("/") && path.startsWith("/"))
            {
               sb.deleteCharAt(sb.length() - 1);
            }
            if (!prefix.endsWith("/") && !path.startsWith("/"))
            {
               sb.append('/');
            }
         }
      }
      sb.append(path);

      if (remove_last_segment)
      {
         // Removes the last segment.
         int lio = sb.lastIndexOf("/");
         while (lio != -1 && lio == sb.length() - 1)
         {
            sb.deleteCharAt(lio);
            lio = sb.lastIndexOf("/");
         }
         if (lio != -1)
         {
            sb.delete(lio + 1, sb.length());
         }

         // Removes the `$links` segment.
         lio = sb.lastIndexOf("$links/");
         if (lio != -1)
         {
            sb.delete(lio, lio + 7);
         }
      }
      else if (!sb.toString().endsWith("/") && !sb.toString().endsWith("\\"))
      {
         sb.append("/");
      }
      ub.setPath(sb.toString());
      return ub.build();
   }
   catch (NullPointerException | URISyntaxException e)
   {
      throw new ODataException(e);
   }
}