Example usage for org.apache.http.client.config RequestConfig custom

List of usage examples for org.apache.http.client.config RequestConfig custom

  1. HOME
  2. Java
  3. org.apache.http
  4. org.apache.http.client.config.*
  5. RequestConfig
  6. custom

Introduction

In this page you can find the example usage for org.apache.http.client.config RequestConfig custom.

Prototype

public static RequestConfig.Builder custom()

Source Link

Usage

From source file:org.yamj.api.common.http.SimpleHttpClientBuilder.java

/**
 * Create the CloseableHttpClient//from w  w w  . jav a  2s  .c  o  m
 *
 * @return
 */
public CloseableHttpClient build() {
    // create proxy
    HttpHost proxy = null;
    CredentialsProvider credentialsProvider = null;

    if (isNotBlank(proxyHost) && proxyPort > 0) {
        proxy = new HttpHost(proxyHost, proxyPort);

        if (isNotBlank(proxyUsername) && isNotBlank(proxyPassword)) {
            if (systemProperties) {
                credentialsProvider = new SystemDefaultCredentialsProvider();
            } else {
                credentialsProvider = new BasicCredentialsProvider();
            }
            credentialsProvider.setCredentials(new AuthScope(proxyHost, proxyPort),
                    new UsernamePasswordCredentials(proxyUsername, proxyPassword));
        }
    }

    HttpClientBuilder builder = HttpClientBuilder.create().setMaxConnTotal(maxConnTotal)
            .setMaxConnPerRoute(maxConnPerRoute).setProxy(proxy)
            .setDefaultCredentialsProvider(credentialsProvider)
            .setDefaultRequestConfig(RequestConfig.custom()
                    .setConnectionRequestTimeout(connectionRequestTimeout).setConnectTimeout(connectTimeout)
                    .setSocketTimeout(socketTimeout).setProxy(proxy).build());

    // use system properties
    if (systemProperties) {
        builder.useSystemProperties();
    }

    // build the http client
    return builder.build();
}

From source file:edu.mit.scratch.ScratchSession.java

public ScratchCloudSession getCloudSession(final int projectID) throws ScratchProjectException {
    final RequestConfig globalConfig = RequestConfig.custom().setCookieSpec(CookieSpecs.DEFAULT).build();

    final CookieStore cookieStore = new BasicCookieStore();
    final BasicClientCookie lang = new BasicClientCookie("scratchlanguage", "en");
    final BasicClientCookie sessid = new BasicClientCookie("scratchsessionsid", this.getSessionID());
    final BasicClientCookie token = new BasicClientCookie("scratchcsrftoken", this.getCSRFToken());
    final BasicClientCookie debug = new BasicClientCookie("DEBUG", "true");
    lang.setDomain(".scratch.mit.edu");
    lang.setPath("/");
    sessid.setDomain(".scratch.mit.edu");
    sessid.setPath("/");
    token.setDomain(".scratch.mit.edu");
    token.setPath("/");
    debug.setDomain(".scratch.mit.edu");
    debug.setPath("/");
    cookieStore.addCookie(lang);//from  w w  w  .j  ava2  s.  c  o m
    cookieStore.addCookie(sessid);
    cookieStore.addCookie(token);
    cookieStore.addCookie(debug);

    final CloseableHttpClient httpClient = HttpClients.custom().setDefaultRequestConfig(globalConfig)
            .setUserAgent(Scratch.USER_AGENT).setDefaultCookieStore(cookieStore).build();
    CloseableHttpResponse resp = null;

    final HttpUriRequest project = RequestBuilder.get()
            .setUri("https://scratch.mit.edu/projects/" + projectID + "/").addHeader("Accept", "text/html")
            .addHeader("Referer", "https://scratch.mit.edu").build();
    try {
        resp = httpClient.execute(project);
    } catch (final IOException e) {
        e.printStackTrace();
        throw new ScratchProjectException();
    }
    String projectStr = null;
    try {
        projectStr = Scratch.consume(resp);
    } catch (IllegalStateException | IOException e) {
        e.printStackTrace();
        throw new ScratchProjectException();
    }
    final Pattern p = Pattern.compile("cloudToken: '([a-zA-Z0-9\\-]+)'");
    final Matcher m = p.matcher(projectStr);
    m.find();
    final String cloudToken = m.group(1);

    return new ScratchCloudSession(this, cloudToken, projectID);
}

From source file:com.seleritycorp.common.base.http.client.HttpRequest.java

private org.apache.http.HttpResponse getHttpResponse() throws HttpException {
    final HttpRequestBase request;

    switch (method) {
    case HttpGet.METHOD_NAME:
        request = new HttpGet();
        break;/* www .j  a va2  s. c  o m*/
    case HttpPost.METHOD_NAME:
        request = new HttpPost();
        break;
    default:
        throw new HttpException("Unknown HTTP method '" + method + "'");
    }

    try {
        request.setURI(URI.create(uri));
    } catch (IllegalArgumentException e) {
        throw new HttpException("Failed to create URI '" + uri + "'", e);
    }

    if (userAgent != null) {
        request.setHeader(HTTP.USER_AGENT, userAgent);
    }

    if (readTimeoutMillis >= 0) {
        request.setConfig(RequestConfig.custom().setSocketTimeout(readTimeoutMillis)
                .setConnectTimeout(readTimeoutMillis).setConnectionRequestTimeout(readTimeoutMillis).build());
    }

    if (!data.isEmpty()) {
        if (request instanceof HttpEntityEnclosingRequestBase) {
            final HttpEntity entity;
            ContentType localContentType = contentType;
            if (localContentType == null) {
                localContentType = ContentType.create("text/plain", StandardCharsets.UTF_8);
            }
            entity = new StringEntity(data, localContentType);
            HttpEntityEnclosingRequestBase entityRequest = (HttpEntityEnclosingRequestBase) request;
            entityRequest.setEntity(entity);
        } else {
            throw new HttpException(
                    "Request " + request.getMethod() + " does not allow to send data " + "with the request");
        }
    }

    final HttpClient httpClient;
    if (uri.startsWith("file://")) {
        httpClient = this.fileHttpClient;
    } else {
        httpClient = this.netHttpClient;
    }
    final org.apache.http.HttpResponse response;
    try {
        response = httpClient.execute(request);
    } catch (IOException e) {
        throw new HttpException("Failed to execute request to '" + uri + "'", e);
    }
    return response;
}

From source file:com.ibm.twitter.TwitterInsights.java

public Sentiment getSentimentCount(String bookTitle, String bookAuthor, String sentimentType) {
    SentimentSearch returnedSentiment = new SentimentSearch();

    try {/*from ww w  .  j a  va  2  s. co  m*/
        CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(new AuthScope(AuthScope.ANY_HOST, AuthScope.ANY_PORT),
                new UsernamePasswordCredentials(usernameTwitter, passwordTwitter));

        CookieStore cookieStore = new BasicCookieStore();
        CookieSpecProvider csf = new CookieSpecProvider() {
            @Override
            public CookieSpec create(HttpContext context) {
                return new DefaultCookieSpec() {
                    @Override
                    public void validate(Cookie cookie, CookieOrigin origin) throws MalformedCookieException {
                        // Allow all cookies
                    }
                };
            }
        };

        RequestConfig requestConfig = RequestConfig.custom().setCookieSpec("easy").setSocketTimeout(15 * 1000)
                .setConnectTimeout(15 * 1000).build();

        CloseableHttpClient httpClient = HttpClientBuilder.create()
                .setDefaultCredentialsProvider(credentialsProvider).setDefaultCookieStore(cookieStore)
                .setDefaultCookieSpecRegistry(RegistryBuilder.<CookieSpecProvider>create()
                        .register(CookieSpecs.DEFAULT, csf).register("easy", csf).build())
                .setDefaultRequestConfig(requestConfig).build();

        URIBuilder builder = new URIBuilder();
        builder.setScheme("https").setHost(baseURLTwitter).setPath("/api/v1/messages/count").setParameter("q",
                "\"" + bookTitle + "\"" + " AND " + "\"" + bookAuthor + "\"" + " AND " + "sentiment:"
                        + sentimentType);
        URI uri = builder.build();
        HttpGet httpGet = new HttpGet(uri);

        httpGet.setHeader("Content-Type", "text/plain");
        HttpResponse httpResponse = httpClient.execute(httpGet);

        if (httpResponse.getStatusLine().getStatusCode() == 200) {
            BufferedReader rd = new BufferedReader(
                    new InputStreamReader(httpResponse.getEntity().getContent(), "UTF-8"));

            // Read all the books from the best seller list
            ObjectMapper mapper = new ObjectMapper();
            returnedSentiment = mapper.readValue(rd, SentimentSearch.class);
        } else {
            logger.error("could not get tweets from IBM insights http code {}",
                    httpResponse.getStatusLine().getStatusCode());
        }

    } catch (Exception e) {
        logger.error("Twitter error: {}", e.getMessage());
    }

    return new Sentiment(sentimentType, returnedSentiment.getCount());
}

From source file:org.eclipse.vorto.repository.RestClient.java

private RequestConfig createProxyConfiguration() {
    IProxyService proxyService = getProxyService();
    IProxyData[] proxyDataForHost = proxyService.select(java.net.URI.create(connectionInfo.getUrl()));
    RequestConfig.Builder configBuilder = RequestConfig.custom();
    for (IProxyData data : proxyDataForHost) {
        HttpHost proxyConfig = new HttpHost(data.getHost(), data.getPort(), data.getType());
        configBuilder.setProxy(proxyConfig);
    }/*from   w w w. j  av  a 2 s .co m*/
    return configBuilder.build();
}

From source file:com.ppcxy.cyfm.showcase.demos.web.RemoteContentServlet.java

private void initApacheHttpClient() {
    RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(TIMEOUT_SECONDS * 1000)
            .setConnectTimeout(TIMEOUT_SECONDS * 1000).build();

    httpClient = HttpClientBuilder.create().setMaxConnTotal(POOL_SIZE).setMaxConnPerRoute(POOL_SIZE)
            .setDefaultRequestConfig(requestConfig).build();
}

From source file:io.ucoin.ucoinj.core.client.service.HttpServiceImpl.java

protected RequestConfig getRequestConfig() {
    // build request config for timeout
    return RequestConfig.custom().setSocketTimeout(baseTimeOut).setConnectTimeout(baseTimeOut).build();
}

From source file:com.maxmind.ws.HTTPBase.java

boolean querySingleServer(String hostname) {
    String scheme, url2;/*from w ww .java  2  s  .  c om*/

    // check if we using the Secure HTTPS protocol
    scheme = isSecure ? "https://" : "http://";

    final ArrayList<NameValuePair> parameters = new ArrayList<NameValuePair>();
    for (final Map.Entry<String, String> entry : queries.entrySet()) {
        parameters.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
    }
    parameters.add(new BasicNameValuePair("clientAPI", clientApi));

    // scheme already has the name of the protocol
    // append the domain name of the server, url of the web service
    // and the query string to the string named url2
    url2 = scheme + hostname + "/" + url;
    if (debug) {
        System.out.println("url2 = " + url2);
    }
    CloseableHttpClient client = null;
    try {
        RequestConfig timeoutConfig = RequestConfig.custom().setConnectionRequestTimeout((int) timeout * 1000)
                .setSocketTimeout((int) timeout * 1000).build();

        HttpRoutePlanner proxyPlaner = null;
        if (useSystemProxies) {
            proxyPlaner = new SystemDefaultRoutePlanner(ProxySelector.getDefault());
        }
        if (proxyHost != null && proxyPort > -1) {
            proxyPlaner = new DefaultProxyRoutePlanner(new HttpHost(proxyHost, proxyPort));
        }
        client = HttpClients.custom().setDefaultRequestConfig(timeoutConfig).setRoutePlanner(proxyPlaner)
                .build();

        // connect the server
        final HttpPost method = new HttpPost(url2);
        method.setEntity(new UrlEncodedFormEntity(parameters));

        final HttpResponse response = client.execute(method);

        final String content = EntityUtils.toString(response.getEntity());
        if (response.getStatusLine().getStatusCode() == 200) {

            if (debug) {
                System.out.println("content = " + content);
            }

            // get the keys and values from
            // the string content and store them
            // the hash named outputstr

            // split content into pairs containing both
            // the key and the value
            final StringTokenizer st = new StringTokenizer(content, ";");

            // for each pair store key and value into the
            // hash named outputstr
            while (st.hasMoreTokens()) {
                final String keyvaluepair = st.nextToken();

                // split the pair into a key and a value
                final StringTokenizer st2 = new StringTokenizer(keyvaluepair, "=");
                String key;
                String value;
                key = st2.nextToken();
                value = st2.hasMoreTokens() ? st2.nextToken() : "";
                // store the key and the value into the
                // hash named outputstr
                outputstr.put(key, value);
                if (debug) {
                    System.out.println("key = " + key + ", value = " + value);
                }
            }
            if (!outputstr.containsKey(check_field)) {
                // if the output does not have the field it is checking for
                // then return false
                return false;
            }
            method.releaseConnection();
            return true;
        }
        method.releaseConnection();
        return false;
    } catch (final java.io.IOException e) {
        if (e instanceof InterruptedIOException) {
            System.out.println("web service timeout");
        }
        System.out.println("error = " + e.getMessage());
        e.printStackTrace();
    } finally {
        try {
            if (client != null) {
                client.close();
            }
        } catch (IOException e) {
            //ignore
        }
    }
    return false;
}

From source file:microsoft.exchange.webservices.data.HttpClientWebRequest.java

/**
 * Prepare connection//from  www  . ja  v  a2 s . c o m
 *
 * @throws microsoft.exchange.webservices.data.EWSHttpException the eWS http exception
 */
@Override
public void prepareConnection() throws EWSHttpException {
    try {
        HttpClientBuilder builder = HttpClients.custom();
        builder.setConnectionManager(this.httpClientConnMng);

        //create the cookie store
        if (cookieStore == null) {
            cookieStore = new BasicCookieStore();
        }
        builder.setDefaultCookieStore(cookieStore);

        if (getProxy() != null) {
            HttpHost proxy = new HttpHost(getProxy().getHost(), getProxy().getPort());
            builder.setProxy(proxy);

            if (HttpProxyCredentials.isProxySet()) {
                NTCredentials cred = new NTCredentials(HttpProxyCredentials.getUserName(),
                        HttpProxyCredentials.getPassword(), "", HttpProxyCredentials.getDomain());
                CredentialsProvider credsProvider = new BasicCredentialsProvider();
                credsProvider.setCredentials(new AuthScope(proxy), cred);
                builder.setDefaultCredentialsProvider(credsProvider);
            }
        }
        if (getUserName() != null) {
            CredentialsProvider credsProvider = new BasicCredentialsProvider();
            credsProvider.setCredentials(AuthScope.ANY,
                    new NTCredentials(getUserName(), getPassword(), "", getDomain()));
            builder.setDefaultCredentialsProvider(credsProvider);
        }

        //fix socket config
        SocketConfig sc = SocketConfig.custom().setSoTimeout(getTimeout()).build();
        builder.setDefaultSocketConfig(sc);

        RequestConfig.Builder rcBuilder = RequestConfig.custom();
        rcBuilder.setAuthenticationEnabled(true);
        rcBuilder.setConnectionRequestTimeout(getTimeout());
        rcBuilder.setConnectTimeout(getTimeout());
        rcBuilder.setRedirectsEnabled(isAllowAutoRedirect());
        rcBuilder.setSocketTimeout(getTimeout());

        // fix issue #144 + #160: if we used NTCredentials from above: these are NT credentials
        if (getUserName() != null) {
            ArrayList<String> authPrefs = new ArrayList<String>();
            authPrefs.add(AuthSchemes.NTLM);
            rcBuilder.setTargetPreferredAuthSchemes(authPrefs);
        }
        //
        builder.setDefaultRequestConfig(rcBuilder.build());

        httpPostReq = new HttpPost(getUrl().toString());
        httpPostReq.addHeader("Content-type", getContentType());
        //httpPostReq.setDoAuthentication(true);
        httpPostReq.addHeader("User-Agent", getUserAgent());
        httpPostReq.addHeader("Accept", getAccept());
        httpPostReq.addHeader("Keep-Alive", "300");
        httpPostReq.addHeader("Connection", "Keep-Alive");

        if (isAcceptGzipEncoding()) {
            httpPostReq.addHeader("Accept-Encoding", "gzip,deflate");
        }

        if (getHeaders().size() > 0) {
            for (Map.Entry<String, String> httpHeader : getHeaders().entrySet()) {
                httpPostReq.addHeader(httpHeader.getKey(), httpHeader.getValue());
            }
        }

        //create the client
        client = builder.build();
    } catch (Exception er) {
        er.printStackTrace();
    }
}

From source file:org.apache.zeppelin.sap.universe.UniverseClient.java

public UniverseClient(String user, String password, String apiUrl, String authType, int queryTimeout) {
    RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(queryTimeout)
            .setSocketTimeout(queryTimeout).build();
    PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
    cm.setMaxTotal(100);/*from  ww  w .j  a  v a 2s .c o m*/
    cm.setDefaultMaxPerRoute(100);
    cm.closeIdleConnections(10, TimeUnit.MINUTES);
    httpClient = HttpClientBuilder.create().setConnectionManager(cm).setDefaultRequestConfig(requestConfig)
            .build();

    this.user = user;
    this.password = password;
    this.authType = authType;
    if (StringUtils.isNotBlank(apiUrl)) {
        this.apiUrl = apiUrl.replaceAll("/$", "");
    }
}