Java Code Examples for org.apache.http.client.methods.HttpPost#setHeader()

public static String httpPOST(String url, Map<String, String> formParams, Map<String, String> headers) throws Exception {
	HttpPost request = new HttpPost(url);
	if (headers != null) {
		for (Entry<String, String> header : headers.entrySet()) {
			request.setHeader(header.getKey(), header.getValue());
		}
	}
	request.setHeader("User-Agent", "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.4; en-US; rv:1.9.2.2) Gecko/20100316 Firefox/3.6.2");
	List<NameValuePair> params = new ArrayList<NameValuePair>();
	for (Map.Entry<String, String> entry : formParams.entrySet()) {
		params.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
	}
	request.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
	HttpClient client = getClient();
	HttpResponse response = client.execute(request);
	//try {
		return fetchResponse(response);
	/*} finally {
		request.releaseConnection();
		client.getConnectionManager().shutdown();
	}*/
}
 

private void login(String requestURI, CookieStore cookieStore) throws IOException {
    HttpCoreContext httpContext = new HttpCoreContext();
    HttpGet request = new HttpGet(requestURI);

    // send an initial request, we are redirected to login page
    String entityContent;
    try (CloseableHttpResponse response = sendRequest(request, cookieStore, httpContext)) {
        entityContent = IOUtils.toString(response.getEntity().getContent(), "UTF-8");
    }

    // send credentials to login form
    HttpPost post = new HttpPost(ActionURIUtils.getActionURIFromPageSource(entityContent));
    List<NameValuePair> params = new LinkedList<>();
    params.add(new BasicNameValuePair("username", "foo"));
    params.add(new BasicNameValuePair("password", "password"));

    post.setHeader("Content-Type", "application/x-www-form-urlencoded");
    post.setEntity(new UrlEncodedFormEntity(params));

    try (CloseableHttpResponse response = sendRequest(post, cookieStore, httpContext)) {
        Assert.assertThat("Expected successful login.", response.getStatusLine().getStatusCode(), is(equalTo(200)));
    }
}
 

@Test
public void shouldPrintMultilineRequestProperly() throws Exception {

  // given
  HttpPost postRequest = new HttpPost("http://google.pl/");
  List<NameValuePair> postParameters = new ArrayList<>();
  postParameters.add(new BasicNameValuePair("param1", "param1_value"));
  postParameters.add(new BasicNameValuePair("param2", "param2_value"));
  postRequest.setEntity(new UrlEncodedFormEntity(postParameters));
  postRequest.setHeader("Content-Type", "application/x-www-form-urlencoded");

  // when
  Options options = Options.builder().targetPlatform(Platform.UNIX).useShortForm()
      .printMultiliner().build();

  // then
  assertThat(new Http2Curl(options).generateCurl(postRequest),
      equalTo(
          "curl 'http://google.pl/' \\\n  -H 'Content-Type: application/x-www-form-urlencoded' \\\n  --data-binary 'param1=param1_value&param2=param2_value' \\\n  --compressed \\\n  -k \\\n  -v"));
}
 

private static void getPreDownloadLink() throws IOException {

        //http://uploading.com/files/generate/?ajax

        DefaultHttpClient d = new DefaultHttpClient();
        HttpPost h = new HttpPost("http://uploading.com/files/generate/?ajax");
        h.setHeader("Cookie", sidcookie + ";" + ucookie + ";" + timecookie + ";" + cachecookie);
        List<NameValuePair> formparams = new ArrayList<NameValuePair>();
        formparams.add(new BasicNameValuePair("name", file.getName()));
        formparams.add(new BasicNameValuePair("size", String.valueOf(file.length())));
        UrlEncodedFormEntity entity = new UrlEncodedFormEntity(formparams, "UTF-8");
        h.setEntity(entity);
        HttpResponse r = d.execute(h);
        HttpEntity e = r.getEntity();
        downloadlink = EntityUtils.toString(e);
        fileID = parseResponse(downloadlink, "file_id\":\"", "\"");
        downloadlink = parseResponse(downloadlink, "\"link\":\"", "\"");
        System.out.println("File ID : " + fileID);
        System.out.println("Download link : " + downloadlink);
    }
 

public static String httpPostMethodWithHeaders(String url,Map<String, Object> headers) throws Exception {
    String json = null;
    
    HttpPost post = new HttpPost(url);
    CloseableHttpClient httpClient = null;
    if (headers != null && !headers.isEmpty()) {
        for (Map.Entry<String, Object> entry : headers.entrySet()) {
            post.setHeader(entry.getKey(), entry.getValue().toString());
        }
    }
    try {
        httpClient = getHttpClient();
        CloseableHttpResponse res = httpClient.execute(post);
        if (res.getStatusLine().getStatusCode() == 200) {
            json = EntityUtils.toString(res.getEntity());
        }
    } finally {
        if (httpClient != null) {
            httpClient.close();
        }
    }
    return json;
}
 

public static String getConcept(JSONObject jjj)
		throws UnsupportedEncodingException, IOException, ClientProtocolException {
	HttpPost httppost = new HttpPost(vocubularyurl);
	// httppost.setHeader("X-GWT-Permutation",
	// "3DE824138FE65400740EC1816A73CACC");
	httppost.setHeader("Content-Type", "application/json");
	StringEntity se = new StringEntity(jjj.toString());
	httppost.setEntity(se);
	startTime = System.currentTimeMillis();
	HttpResponse httpresponse = new DefaultHttpClient().execute(httppost);
	endTime = System.currentTimeMillis();
	System.out.println("statusCode:" + httpresponse.getStatusLine().getStatusCode());
	System.out.println("Call API time (unit:millisecond)：" + (endTime - startTime));

	if (httpresponse.getStatusLine().getStatusCode() == 200) {
		// System.out.println("succeed!");
		String strResult = EntityUtils.toString(httpresponse.getEntity());
		return strResult;
		// httppost.
	} else {
		return null;
	}
}
 

public static String doHttpPost(final String url, final String requestBody) throws Exception {
    try {

        HttpClient client = HttpClientBuilder.create().build();
        HttpPost httppost = new HttpPost(url);
        httppost.setHeader(PacmanRuleConstants.CONTENT_TYPE, ContentType.APPLICATION_JSON.toString());
        StringEntity jsonEntity = new StringEntity(requestBody);
        httppost.setEntity(jsonEntity);
        HttpResponse httpresponse = client.execute(httppost);
        int statusCode = httpresponse.getStatusLine().getStatusCode();
        if (statusCode == HttpStatus.SC_OK || statusCode == HttpStatus.SC_CREATED) {
            return EntityUtils.toString(httpresponse.getEntity());
        } else {
            throw new Exception("unable to execute post request because "
                    + httpresponse.getStatusLine().getReasonPhrase());
        }
    } catch (Exception e) {
        throw new RuleExecutionFailedExeption(e.getMessage());
    }
}
 

/**
 * Post 方式请求 ，并返回HTTP_STATUS_CODE码
 * 
 * @param String address 请求地址
 * @param Map<String, Object> params 请求参数
 * @return int
 * @throws ClientProtocolException
 * @throws IOException
 */
public int postReturnHttpCode(String address, Map<String, Object> params) throws ClientProtocolException,
        IOException {
    HttpPost httpPost = new HttpPost(address);
    HttpResponse httpResponse = null;
    try {
        List<NameValuePair> data = buildPostData(params);
        httpPost.setEntity(new UrlEncodedFormEntity(data, HTTP.UTF_8));
        httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
        httpPost.setHeader("User-Agent", agent);
        httpResponse = httpClient.execute(httpPost);
        return httpResponse.getStatusLine().getStatusCode();
    } finally {
        if (httpResponse != null) {
            try {
                EntityUtils.consume(httpResponse.getEntity()); //会自动释放连接
            } catch (Exception e) {
            }
        }
    }
}
 

@Test
public void testContentIDReferencingfail() throws Exception {
  final HttpPost post = new HttpPost(URI.create(getEndpoint().toString() + "$batch"));
  post.setHeader("Content-Type", "multipart/mixed;boundary=" + BOUNDARY);

  String body = StringHelper.inputStreamToStringCRLFLineBreaks(
      this.getClass().getResourceAsStream("/basicBatchWithContentIdReferencingFail.batch"));
  HttpEntity entity = new StringEntity(body);
  post.setEntity(entity);
  HttpResponse batchResponse = getHttpClient().execute(post);

  assertNotNull(batchResponse);
  assertEquals(202, batchResponse.getStatusLine().getStatusCode());
  
  InputStream responseBody = batchResponse.getEntity().getContent();
  String contentType = batchResponse.getFirstHeader(HttpHeaders.CONTENT_TYPE).getValue();
  List<BatchSingleResponse> responses = EntityProvider.parseBatchResponse(responseBody, contentType);
  assertEquals("400", responses.get(0).getStatusCode());
  assertEquals("Bad Request", responses.get(0).getStatusInfo());
  assertEquals("201", responses.get(1).getStatusCode());
  assertEquals("Created", responses.get(1).getStatusInfo());
  assertEquals("404", responses.get(2).getStatusCode());
  assertEquals("Not Found", responses.get(2).getStatusInfo());
  assertEquals("200", responses.get(3).getStatusCode());
  assertEquals("OK", responses.get(3).getStatusInfo());
}
 

@Test
public void testBatchUriEncoded() throws Exception {
  final HttpPost post = new HttpPost(URI.create(getEndpoint().toString() + "%24batch"));
  post.setHeader("Content-Type", "multipart/mixed;boundary=batch_98c1-8b13-36bb");
  HttpEntity entity = new StringEntity(REQUEST_PAYLOAD);
  post.setEntity(entity);
  HttpResponse response = getHttpClient().execute(post);

  assertNotNull(response);
  assertEquals(202, response.getStatusLine().getStatusCode());
  assertEquals("HTTP/1.1", response.getProtocolVersion().toString());
  assertTrue(response.containsHeader("Content-Length"));
  assertTrue(response.containsHeader("Content-Type"));
  assertTrue(response.containsHeader("DataServiceVersion"));
  assertTrue(response.getEntity().getContentType().getValue().matches(REG_EX));
  assertNotNull(response.getEntity().getContent());

  String body = StringHelper.inputStreamToString(response.getEntity().getContent(), true);
  assertTrue(body.contains("Content-Id: mimeHeaderContentId1"));
  assertTrue(body.contains("Content-Id: requestHeaderContentId1"));
  assertTrue(body.contains("Content-Id: mimeHeaderContentId2"));
  assertTrue(body.contains("Content-Id: requestHeaderContentId2"));
}
 

@Test
public void basicOTAForSingleUserAndExistingProject() throws Exception {
    HttpPost post = new HttpPost(httpsAdminServerUrl + "/ota/start?user=" + getUserName() + "&project=My%20Dashboard");
    post.setHeader(HttpHeaderNames.AUTHORIZATION.toString(), "Basic " + Base64.getEncoder().encodeToString(auth));

    String fileName = "test.bin";

    InputStream binFile = OTATest.class.getResourceAsStream("/static/ota/" + fileName);
    ContentBody fileBody = new InputStreamBody(binFile, ContentType.APPLICATION_OCTET_STREAM, fileName);

    MultipartEntityBuilder builder = MultipartEntityBuilder.create();
    builder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
    builder.addPart("upfile", fileBody);
    HttpEntity entity = builder.build();

    post.setEntity(entity);

    String path;
    try (CloseableHttpResponse response = httpclient.execute(post)) {
        assertEquals(200, response.getStatusLine().getStatusCode());
        path = TestUtil.consumeText(response);

        assertNotNull(path);
        assertTrue(path.startsWith("/static"));
        assertTrue(path.endsWith("bin"));
    }

    String responseUrl = "http://127.0.0.1:18080" + path;
    verify(clientPair.hardwareClient.responseMock, after(500).never()).channelRead(any(), eq(internal(7777, "ota " + responseUrl)));

    TestHardClient newHardwareClient = new TestHardClient("localhost", properties.getHttpPort());
    newHardwareClient.start();
    newHardwareClient.login(clientPair.token);
    verify(newHardwareClient.responseMock, timeout(1000)).channelRead(any(), eq(ok(1)));
    newHardwareClient.reset();

    newHardwareClient.send("internal " + b("ver 0.3.1 h-beat 10 buff-in 256 dev Arduino cpu ATmega328P con W5100 build 111"));
    verify(newHardwareClient.responseMock, timeout(500)).channelRead(any(), eq(ok(1)));
    verify(newHardwareClient.responseMock, timeout(500)).channelRead(any(), eq(internal(7777, "ota " + responseUrl)));
}
 

/**
 * Create Post Request with json body
 */
public HttpPost createPost(String uri, String data) {
    HttpPost httpPost = new HttpPost(uri);
    httpPost.setHeader("Content-Type", "application/json");
    HttpEntity entity = new StringEntity(data, ContentType.APPLICATION_JSON);
    httpPost.setEntity(entity);
    return httpPost;
}
 

static void assertGreet(Path wildFlyHome, String uri, String user, String password, int responseCode,
        String responseBody) throws KeyManagementException, UnrecoverableKeyException, NoSuchAlgorithmException,
        KeyStoreException, CertificateException, IOException {
    try (CloseableHttpClient httpclient = HttpClients.custom()
            .setSSLSocketFactory(SecurityUtils.createBasicSocketFactory(wildFlyHome)).build()) {
        HttpPost request = new HttpPost(uri);
        request.setHeader("Content-Type", "text/xml");
        request.setHeader("soapaction", "\"urn:greet\"");

        if (user != null) {
            String auth = user + ":" + password;
            String authHeader = "Basic "
                    + Base64.getEncoder().encodeToString(auth.getBytes(StandardCharsets.ISO_8859_1));
            request.setHeader(HttpHeaders.AUTHORIZATION, authHeader);
        }

        request.setEntity(
                new StringEntity(String.format(WS_MESSAGE_TEMPLATE, "Hi", "Joe"), StandardCharsets.UTF_8));
        try (CloseableHttpResponse response = httpclient.execute(request)) {
            final int actualCode = response.getStatusLine().getStatusCode();
            Assert.assertEquals(responseCode, actualCode);
            if (actualCode == 200) {
                HttpEntity entity = response.getEntity();
                String body = EntityUtils.toString(entity, StandardCharsets.UTF_8);
                Assert.assertTrue(body.contains(responseBody));
            }
        }
    }
}
 

/**
 * 功能：请求一个url,得到返回的信息。
 * @author 朱志杰 QQ：695520848
 * Jul 2, 2013 6:04:59 PM
 * @param url 需要请求的url。
 * @param method 使用的方法，POST或者GET。
 * @param argsMap ,当method为POST时，在这里传入post的参数信息。
 * @param ContentType 文本类型，例如"text/html;charset=UTF-8".注意POST时会自动修改为"application/x-www-form-urlencoded"。
 * @return String
 * @throws IOException 请求IO异常
 * @throws ClientProtocolException 请求客户端协议异常
 */
public String requestUrl(String url,String method,Map<String,String> argsMap,String ContentType) throws ClientProtocolException, IOException{
	((DefaultHttpClient)httpclient).setCookieStore(cookieStore);
       ResponseHandler<String> responseHandler = new BasicResponseHandler();
       //页面的返回信息。
       String confirmResponse ="";
       
	//POST请求
	if("POST".equals(method.toUpperCase())){
		HttpPost httpPost = new HttpPost(url);
		//表单内容。
		if(!CollectionUtil.isEmpty(argsMap)){
	        List <NameValuePair> nvps = new ArrayList <NameValuePair>();
	        for(String key : argsMap.keySet()){
	        	nvps.add(new BasicNameValuePair(key, argsMap.get(key)));
	        }
	        httpPost.setEntity(new UrlEncodedFormEntity(nvps, HTTP.UTF_8));
	        httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded");
		}
		confirmResponse=httpclient.execute(httpPost,responseHandler);
	}else{
		//get请求
		HttpGet httpGet = new HttpGet(url);
		httpGet.setHeader("Content-Type", ContentType);
		confirmResponse=httpclient.execute(httpGet,responseHandler);
	}
       cookieStore=((DefaultHttpClient)httpclient).getCookieStore();
       return confirmResponse;
}
 

private Map<String, Object> tokenRequest(App app, String authCodeOrRefreshToken, String redirectURI, String alias)
		throws IOException {
	String[] keys = SecurityUtils.getOAuthKeysForApp(app, oauthPrefix(alias));

	String entity;
	String scope = SecurityUtils.getSettingForApp(app, configKey("scope", alias), "");
	if (redirectURI == null) {
		entity = Utils.formatMessage(REFRESH_PAYLOAD, authCodeOrRefreshToken,
				URLEncoder.encode(scope, "UTF-8"), keys[0], keys[1]);
	} else {
		entity = Utils.formatMessage(PAYLOAD, authCodeOrRefreshToken, Utils.urlEncode(redirectURI),
				URLEncoder.encode(scope, "UTF-8"), keys[0], keys[1]);
	}

	String acceptHeader = SecurityUtils.getSettingForApp(app, configKey("accept_header", alias), "");
	HttpPost tokenPost = new HttpPost(SecurityUtils.getSettingForApp(app, configKey("token_url", alias), ""));
	tokenPost.setHeader(HttpHeaders.CONTENT_TYPE, "application/x-www-form-urlencoded");
	tokenPost.setEntity(new StringEntity(entity, "UTF-8"));
	if (!StringUtils.isBlank(acceptHeader)) {
		tokenPost.setHeader(HttpHeaders.ACCEPT, acceptHeader);
	}

	Map<String, Object> tokens = null;
	try (CloseableHttpResponse resp1 = httpclient.execute(tokenPost)) {
		if (resp1 != null && resp1.getEntity() != null) {
			tokens = jreader.readValue(resp1.getEntity().getContent());
			EntityUtils.consumeQuietly(resp1.getEntity());
		}
	}
	return tokens;
}
 

public YouTrackResponse post(String path, String body) throws IOException {
    HttpPost request = new HttpPost(host + path);
    request.setHeader("Content-Type", CONTENT_TYPE);
    if (body != null) {
        request.setEntity(new StringEntity(body));
    }

    return call(request);
}
 

@Repeat(iterations=2) // 2 times to make sure cleanup is complete and we can create the same collection
public void testCreateDelete() throws Exception {
  switch (random().nextInt(3)) {
    case 0:
      CollectionAdminRequest.createCollection(collectionName, "conf", 2, 0, 4, 0)
      .setMaxShardsPerNode(100)
      .process(cluster.getSolrClient());
      cluster.waitForActiveCollection(collectionName, 2, 8);
      break;
    case 1:
      // Sometimes don't use SolrJ
      String url = String.format(Locale.ROOT, "%s/admin/collections?action=CREATE&name=%s&collection.configName=%s&numShards=%s&tlogReplicas=%s&maxShardsPerNode=%s",
          cluster.getRandomJetty(random()).getBaseUrl(),
          collectionName, "conf",
          2,    // numShards
          4,    // tlogReplicas
          100); // maxShardsPerNode
      HttpGet createCollectionGet = new HttpGet(url);
      HttpResponse httpResponse = cluster.getSolrClient().getHttpClient().execute(createCollectionGet);
      assertEquals(200, httpResponse.getStatusLine().getStatusCode());
      cluster.waitForActiveCollection(collectionName, 2, 8);
      break;
    case 2:
      // Sometimes use V2 API
      url = cluster.getRandomJetty(random()).getBaseUrl().toString() + "/____v2/c";
      String requestBody = String.format(Locale.ROOT, "{create:{name:%s, config:%s, numShards:%s, tlogReplicas:%s, maxShardsPerNode:%s}}",
          collectionName, "conf",
          2,    // numShards
          4,    // tlogReplicas
          100); // maxShardsPerNode
      HttpPost createCollectionPost = new HttpPost(url);
      createCollectionPost.setHeader("Content-type", "application/json");
      createCollectionPost.setEntity(new StringEntity(requestBody));
      httpResponse = cluster.getSolrClient().getHttpClient().execute(createCollectionPost);
      assertEquals(200, httpResponse.getStatusLine().getStatusCode());
      cluster.waitForActiveCollection(collectionName, 2, 8);
      break;
  }

  boolean reloaded = false;
  while (true) {
    DocCollection docCollection = getCollectionState(collectionName);
    assertNotNull(docCollection);
    assertEquals("Expecting 2 shards",
        2, docCollection.getSlices().size());
    assertEquals("Expecting 4 relpicas per shard",
        8, docCollection.getReplicas().size());
    assertEquals("Expecting 8 tlog replicas, 4 per shard",
        8, docCollection.getReplicas(EnumSet.of(Replica.Type.TLOG)).size());
    assertEquals("Expecting no nrt replicas",
        0, docCollection.getReplicas(EnumSet.of(Replica.Type.NRT)).size());
    assertEquals("Expecting no pull replicas",
        0, docCollection.getReplicas(EnumSet.of(Replica.Type.PULL)).size());
    for (Slice s:docCollection.getSlices()) {
      assertTrue(s.getLeader().getType() == Replica.Type.TLOG);
      List<String> shardElectionNodes = cluster.getZkClient().getChildren(ZkStateReader.getShardLeadersElectPath(collectionName, s.getName()), null, true);
      assertEquals("Unexpected election nodes for Shard: " + s.getName() + ": " + Arrays.toString(shardElectionNodes.toArray()),
          4, shardElectionNodes.size());
    }
    assertUlogPresence(docCollection);
    if (reloaded) {
      break;
    } else {
      // reload
      CollectionAdminResponse response = CollectionAdminRequest.reloadCollection(collectionName)
      .process(cluster.getSolrClient());
      assertEquals(0, response.getStatus());
      waitForState("failed waiting for active colletion", collectionName, clusterShape(2, 8));
      reloaded = true;
    }
  }
}
 

public HttpPost createPost(String uri, ServerConfig serverConfig) {
    HttpPost post = new HttpPost(getServerUrl(serverConfig, uri));
    post.setHeader("Content-Type", "application/json");
    post.setHeader("Accept", "application/json");
    return post;
}
 

private String oozieSubmitJob( String user, String password, String request, int status ) throws IOException, URISyntaxException {
    driver.getMock( "OOZIE" )
        .expect()
        .method( "POST" )
        .pathInfo( "/v1/jobs" )
        .respond()
        .status( HttpStatus.SC_CREATED )
        .content( driver.getResourceBytes( "oozie-jobs-submit-response.json" ) )
        .contentType( "application/json" );
    URL url = new URL( driver.getUrl( "OOZIE" ) + "/v1/jobs?action=start" + ( driver.isUseGateway() ? "" : "&user.name=" + user ) );
    HttpHost targetHost = new HttpHost( url.getHost(), url.getPort(), url.getProtocol() );
    HttpClientBuilder builder = HttpClientBuilder.create();
    CloseableHttpClient client = builder.build();

    HttpClientContext context = HttpClientContext.create();
    CredentialsProvider credsProvider = new BasicCredentialsProvider();
    credsProvider.setCredentials(
        new AuthScope( targetHost ),
        new UsernamePasswordCredentials( user, password ) );
    context.setCredentialsProvider( credsProvider );

    // Create AuthCache instance
    AuthCache authCache = new BasicAuthCache();
    // Generate BASIC scheme object and add it to the local auth cache
    BasicScheme basicAuth = new BasicScheme();
    authCache.put( targetHost, basicAuth );
    // Add AuthCache to the execution context
    context.setAuthCache( authCache );

    HttpPost post = new HttpPost( url.toURI() );
//      post.getParams().setParameter( "action", "start" );
    StringEntity entity = new StringEntity( request, org.apache.http.entity.ContentType.create( "application/xml", StandardCharsets.UTF_8.name() ) );
    post.setEntity( entity );
    post.setHeader( "X-XSRF-Header", "ksdjfhdsjkfhds" );
    HttpResponse response = client.execute( targetHost, post, context );
    assertThat( response.getStatusLine().getStatusCode(), Matchers.is(status) );
    String json = EntityUtils.toString( response.getEntity() );

//      String json = given()
//          .log().all()
//          .auth().preemptive().basic( user, password )
//          .queryParam( "action", "start" )
//          .contentType( "application/xml;charset=UTF-8" )
//          .content( request )
//          .then()
//          .log().all()
//          .statusCode( status )
//          .when().post( getUrl( "OOZIE" ) + "/v1/jobs" + ( isUseGateway() ? "" : "?user.name=" + user ) ).asString();
    return JsonPath.from(json).getString( "id" );
  }
 

private static void processAuthentication(HttpPost method, String username, String password) {
    if (username != null && username.trim().length() > 0) {
        method.setHeader("Authorization",
                         "Basic " + Base64.encode((username + ":" + password).getBytes()));
    }
}