@Override
public List<Role> getUserRoles(String userId) throws Exception {
// Add AuthCache to the execution context
BasicHttpContext ctx = new BasicHttpContext();
ctx.setAttribute(ClientContext.AUTH_CACHE, authCache);
HttpPost post = new HttpPost("/api/secure/jsonws/role/get-user-roles");
MultipartEntity entity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);
entity.addPart("userId", new StringBody(userId, Charset.forName("UTF-8")));
post.setEntity(entity);
HttpResponse resp = httpclient.execute(targetHost, post, ctx);
System.out.println("getOrganizationsByUserId Status:[" + resp.getStatusLine() + "]");
String response = null;
if (resp.getEntity() != null) {
response = EntityUtils.toString(resp.getEntity());
}
System.out.println("getUserRoles Res:[" + response + "]");
ArrayList<Role> roles =
new JSONDeserializer<ArrayList<Role>>().use("values", Role.class).deserialize(response);
EntityUtils.consume(resp.getEntity());
return roles;
}
public void login() throws IOException {
String checkUrl = "http://web.im.baidu.com/check?callback=_nbc_.f1&v=30&time=" + guid;
HttpGet getCheck = new HttpGet(checkUrl);
HttpResponse res1 = httpClient.execute(getCheck);
System.out.println("Check result: " + EntityUtils.toString(res1.getEntity()));
EntityUtils.consume(res1.getEntity());
}
@RequestMapping(value = "/kkn1234/create", method = RequestMethod.POST)
public String formSubmit(@ModelAttribute User user, Model model)
throws MalformedURLException, IOException {
model.addAttribute("user", user);
HttpPost post =
new HttpPost(
"http://ec2-52-4-138-196.compute-1.amazonaws.com/magento/index.php/customer/account/createpost/");
BasicCookieStore cookieStore = new BasicCookieStore();
CloseableHttpClient httpclient =
HttpClients.custom().setDefaultCookieStore(cookieStore).build();
List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
nameValuePairs.add(new BasicNameValuePair("firstname", user.getFirstName()));
nameValuePairs.add(new BasicNameValuePair("lastname", user.getLastName()));
nameValuePairs.add(new BasicNameValuePair("email", user.getEmail()));
nameValuePairs.add(new BasicNameValuePair("password", user.getPassword()));
nameValuePairs.add(new BasicNameValuePair("confirmation", user.getConfirmation()));
post.setEntity(new UrlEncodedFormEntity(nameValuePairs));
HttpResponse response = httpclient.execute(post);
response = httpclient.execute(post);
System.out.println("Status code is " + response.getStatusLine().getStatusCode());
System.out.println(response.toString());
System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++++");
System.out.println(response.getFirstHeader("Location"));
HttpEntity entity = response.getEntity();
EntityUtils.consume(entity);
EntityUtils.consume(response.getEntity());
/*File newTextFile = new File("C:\\Users\\Kris\\Desktop\\temp.html");
FileWriter fileWriter = new FileWriter(newTextFile);
fileWriter.write(response.toString());
fileWriter.close();*/
return "result";
}
/**
* Get请求
*
* @param url
* @param params
* @return
*/
public static String get(String url, List<NameValuePair> params) {
String body = null;
try {
// Get请求
HttpGet httpget = new HttpGet(url);
// 设置参数
String str = EntityUtils.toString(new UrlEncodedFormEntity(params));
httpget.setURI(new URI(httpget.getURI().toString() + "?" + str));
// 发送请求
HttpResponse httpresponse = httpClient.execute(httpget);
// 获取返回数据
HttpEntity entity = httpresponse.getEntity();
body = EntityUtils.toString(entity);
if (entity != null) {
entity.consumeContent();
}
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (URISyntaxException e) {
e.printStackTrace();
}
return body;
}
/**
* @param httppost A well-formed {@link HttpUriRequest}
* @param owlsim An initialized {@link OWLSim} instance. It is expected that the {@link
* OWLGraphWrapper} is already loaded with an ontology.
* @throws Exception
*/
protected void runServerCommunication(HttpUriRequest httppost, OwlSim owlsim) throws Exception {
// create server
Server server = new Server(9031);
server.setHandler(new OWLServer(g, owlsim));
try {
server.start();
// create a client
HttpClient httpclient = new DefaultHttpClient();
// run request
LOG.info("Executing=" + httppost);
HttpResponse response = httpclient.execute(httppost);
LOG.info("Executed=" + httpclient);
// check response
HttpEntity entity = response.getEntity();
StatusLine statusLine = response.getStatusLine();
LOG.info("Status=" + statusLine.getStatusCode());
if (statusLine.getStatusCode() == 200) {
String responseContent = EntityUtils.toString(entity);
handleResponse(responseContent);
} else {
EntityUtils.consumeQuietly(entity);
}
} finally {
// clean up
server.stop();
}
}
protected String convertResponseToString(HttpResponse response, boolean pIgnoreStatus)
throws IOException {
int statuscode = response.getStatusLine().getStatusCode();
if (statuscode != 200 && statuscode != 201 && !pIgnoreStatus) {
throw new ParseException(
"server respond with "
+ response.getStatusLine().getStatusCode()
+ ": "
+ EntityUtils.toString(response.getEntity())
+ response.getStatusLine().getStatusCode()
+ ": <unparsable body>");
}
HttpEntity entity = response.getEntity();
if (entity == null) {
throw new ParseException("http body was empty");
}
long len = entity.getContentLength();
if (len > 2048) {
throw new ParseException(
"http body is to big and must be streamed (max is 2048, but was " + len + " byte)");
}
String body = EntityUtils.toString(entity, HTTP.UTF_8);
return body;
}
public void send(GCMMessage messageBase) throws Exception {
if (gcmURI == null) {
throw new Exception("Error sending push. Google cloud messaging properties not provided.");
}
HttpPost httpPost = new HttpPost(gcmURI);
httpPost.setHeader("Authorization", API_KEY);
httpPost.setEntity(new StringEntity(messageBase.toJson(), ContentType.APPLICATION_JSON));
try (CloseableHttpResponse response = httpclient.execute(httpPost)) {
HttpEntity entity = response.getEntity();
String responseMsg = EntityUtils.toString(entity);
if (response.getStatusLine().getStatusCode() == 200) {
GCMResponseMessage gcmResponseMessage = gcmResponseReader.readValue(responseMsg);
if (gcmResponseMessage.failure == 1) {
if (gcmResponseMessage.results != null && gcmResponseMessage.results.length > 0) {
throw new Exception(
"Error sending push. Problem : " + gcmResponseMessage.results[0].error);
} else {
throw new Exception("Error sending push. Token : " + messageBase.getToken());
}
}
} else {
EntityUtils.consume(entity);
throw new Exception(responseMsg);
}
} finally {
httpPost.releaseConnection();
}
}
public String unTag(NewTagModel untag) {
CloseableHttpClient httpclient = HttpClients.createDefault();
try {
HttpGet oldTagGet = new HttpGet(cloudantURI + "/tag/" + untag.get_id());
oldTagGet.addHeader(authHeaderKey, authHeaderValue);
oldTagGet.addHeader(acceptHeaderKey, acceptHeaderValue);
oldTagGet.addHeader(contentHeaderKey, contentHeaderValue);
HttpResponse oldTagResp = httpclient.execute(oldTagGet);
Gson gson = new Gson();
TagModel updatedtag =
gson.fromJson(EntityUtils.toString(oldTagResp.getEntity()), TagModel.class);
httpclient.close();
updatedtag.getTagged().remove(untag.getUsername());
LOGGER.info(untag.get_id() + " is untagging " + untag.getUsername());
HttpPut updatedTagPut = new HttpPut(cloudantURI + "/tag/" + untag.get_id());
updatedTagPut.addHeader(authHeaderKey, authHeaderValue);
updatedTagPut.addHeader(acceptHeaderKey, acceptHeaderValue);
updatedTagPut.addHeader(contentHeaderKey, contentHeaderValue);
updatedTagPut.setEntity(new StringEntity(gson.toJson(updatedtag)));
httpclient = HttpClients.createDefault();
HttpResponse updatedTagResp = httpclient.execute(updatedTagPut);
if (!(updatedTagResp.getStatusLine().getStatusCode() == HttpStatus.SC_CREATED)) {
String updatedTagEntity = EntityUtils.toString(updatedTagResp.getEntity());
httpclient.close();
return updatedTagEntity;
}
httpclient.close();
return successJson;
} catch (Exception e) {
e.printStackTrace();
return failJson;
}
}
public static ResponseResult getSSL(String url, String paramsCharset, String resultCharset)
throws Exception {
if (url == null || "".equals(url)) {
return null;
}
ResponseResult responseObject = null;
String responseStr = null;
HttpClient httpClient = null;
HttpGet hg = null;
try {
httpClient = getNewHttpClient();
hg = new HttpGet(url);
HttpResponse response = httpClient.execute(hg);
if (response != null) {
responseObject = new ResponseResult();
responseObject.setUri(hg.getURI().toString());
responseObject.setStatusCode(response.getStatusLine().getStatusCode());
if (response.getStatusLine().getStatusCode() == 200) {
if (resultCharset == null || "".equals(resultCharset)) {
responseStr = EntityUtils.toString(response.getEntity(), LSystem.encoding);
} else {
responseStr = EntityUtils.toString(response.getEntity(), resultCharset);
}
} else {
responseStr = null;
}
responseObject.setResult(responseStr);
}
} catch (Exception e) {
throw new Exception(e.getMessage());
} finally {
abortConnection(hg, httpClient);
}
return responseObject;
}
public static void test1() throws ClientProtocolException, IOException {
// httpClient.getParams().setParameter(ClientPNames.COOKIE_POLICY, CookiePolicy.BEST_MATCH);
List<NameValuePair> formparams = new ArrayList<NameValuePair>();
formparams.add(new BasicNameValuePair("username", ""));
formparams.add(new BasicNameValuePair("areacode", "86"));
formparams.add(new BasicNameValuePair("telephone", "18782071219"));
formparams.add(new BasicNameValuePair("remember_me", "1"));
formparams.add(new BasicNameValuePair("password", Encoding.MD5("199337").toUpperCase()));
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(formparams, "UTF-8");
HttpPost httppost = new HttpPost("http://xueqiu.com/user/login");
httppost.setEntity(entity);
httppost.setHeader("X-Requested-With", "XMLHttpRequest");
CloseableHttpResponse httpResponse = httpClient.execute(httppost);
HttpEntity entity1 = httpResponse.getEntity();
if (entity1 != null) {
System.out.println("--------------------------------------");
System.out.println("Response content: " + EntityUtils.toString(entity1, "UTF-8"));
System.out.println("--------------------------------------");
}
setCookieStore(httpResponse);
HttpGet httpGet =
new HttpGet(
"http://xueqiu.com/financial_product/query.json?page=1&size=3&order=desc&orderby=SALEBEGINDATE&status=1&_=1439607538138");
httpResponse = httpClient.execute(httpGet);
entity1 = httpResponse.getEntity();
if (entity1 != null) {
System.out.println("--------------------------------------");
System.out.println("Response content: " + EntityUtils.toString(entity1, "UTF-8"));
System.out.println("--------------------------------------");
}
}
private void retract()
throws Exception, UnsupportedEncodingException, IOException, InterruptedException {
HttpPost postStart = new HttpPost(BASE_URL + "/youtube/retract");
ArrayList<NameValuePair> formParams = new ArrayList<NameValuePair>();
formParams.add(new BasicNameValuePair("mediapackage", getSampleMediaPackage()));
formParams.add(new BasicNameValuePair("elementId", "track-1"));
postStart.setEntity(new UrlEncodedFormEntity(formParams, "UTF-8"));
// Ensure we get a 200 OK
HttpResponse response = client.execute(postStart);
Assert.assertEquals("Error during retract", 200, response.getStatusLine().getStatusCode());
String jobXML = EntityUtils.toString(response.getEntity());
long jobId = getJobId(jobXML);
// Check if job is finished
// Ensure that the job finishes successfully
int attempts = 0;
while (true) {
if (++attempts == 20) Assert.fail("ServiceRegistry rest endpoint test has hung");
HttpGet getJobMethod = new HttpGet(BASE_URL + "/services/job/" + jobId + ".xml");
String getResponse = EntityUtils.toString(client.execute(getJobMethod).getEntity());
String state = getJobStatus(getResponse);
if ("FINISHED".equals(state)) break;
if ("FAILED".equals(state))
Assert.fail("Retract from youtube failed! (Job " + jobId + "). Do it manually for video!");
System.out.println("Job " + jobId + " is " + state);
Thread.sleep(5000);
}
}
public Organization getOrganizationById(String portalOrgId) throws Exception {
// Add AuthCache to the execution context
BasicHttpContext ctx = new BasicHttpContext();
ctx.setAttribute(ClientContext.AUTH_CACHE, authCache);
HttpPost post = new HttpPost("/api/secure/jsonws/organization/get-organization");
List<NameValuePair> params = new ArrayList<NameValuePair>();
params.add(new BasicNameValuePair("organizationId", portalOrgId));
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(params, "UTF-8");
post.setEntity(entity);
HttpResponse resp = httpclient.execute(targetHost, post, ctx);
System.out.println("getOrganizationById Status:[" + resp.getStatusLine() + "]");
String response = null;
if (resp.getEntity() != null) {
response = EntityUtils.toString(resp.getEntity());
}
System.out.println("getOrganizationById Res:[" + response + "]");
Organization org =
new JSONDeserializer<Organization>().deserialize(response, Organization.class);
EntityUtils.consume(resp.getEntity());
return org;
}
@Override
public void setUserRole(String userId, String roleId) throws Exception {
// Add AuthCache to the execution context
BasicHttpContext ctx = new BasicHttpContext();
ctx.setAttribute(ClientContext.AUTH_CACHE, authCache);
HttpPost post = new HttpPost("/api/secure/jsonws//user/set-role-users");
List<NameValuePair> params = new ArrayList<NameValuePair>();
params.add(new BasicNameValuePair("roleId", roleId));
params.add(new BasicNameValuePair("userIds", userId));
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(params, "UTF-8");
post.setEntity(entity);
HttpResponse resp = httpclient.execute(targetHost, post, ctx);
System.out.println("getOrganizationsByUserId Status:[" + resp.getStatusLine() + "]");
String response = null;
if (resp.getEntity() != null) {
response = EntityUtils.toString(resp.getEntity());
}
System.out.println("setUserRole Res:[" + response + "]");
EntityUtils.consume(resp.getEntity());
}
@Override
public boolean userHasRole(String userId, String roleName) throws Exception {
// Add AuthCache to the execution context
BasicHttpContext ctx = new BasicHttpContext();
ctx.setAttribute(ClientContext.AUTH_CACHE, authCache);
HttpPost post = new HttpPost("/api/secure/jsonws/role/has-user-role");
MultipartEntity entity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);
entity.addPart("userId", new StringBody(userId, Charset.forName("UTF-8")));
entity.addPart("companyId", new StringBody(companyId, Charset.forName("UTF-8")));
entity.addPart("name", new StringBody(roleName, Charset.forName("UTF-8")));
entity.addPart("inherited", new StringBody("false", Charset.forName("UTF-8")));
post.setEntity(entity);
HttpResponse resp = httpclient.execute(targetHost, post, ctx);
System.out.println("userHasRole Status:[" + resp.getStatusLine() + "]");
String response = null;
if (resp.getEntity() != null) {
response = EntityUtils.toString(resp.getEntity());
}
System.out.println("userHasRole Res:[" + response + "]");
JSONDeserializer<Boolean> deserializer = new JSONDeserializer<Boolean>();
Boolean hasRole = deserializer.deserialize(response, Boolean.class);
EntityUtils.consume(resp.getEntity());
return hasRole;
}
public void run() {
for (Object MSISDN : mListMSISDN) {
String TextResponse = "";
String XMLReqeust = String.format(Template, MSISDN);
HttpPost mPost = new HttpPost(URL);
StringEntity mEntity = new StringEntity(XMLReqeust, ContentType.create("text/xml", "UTF-8"));
mPost.setEntity(mEntity);
HttpClient mClient = new DefaultHttpClient();
try {
HttpResponse response = mClient.execute(mPost);
HttpEntity entity = response.getEntity();
TextResponse = EntityUtils.toString(entity);
System.out.println(TextResponse);
EntityUtils.consume(entity);
} catch (Exception ex) {
mLog.log.error(ex);
} finally {
mLog.log.debug("REQUEST --> " + XMLReqeust);
mLog.log.debug("RESPONSE --> " + TextResponse);
}
}
mLog.log.debug("KET THUC THEAD " + ThreadIndex);
}
@Override
public String getChannels(String serverUrl, boolean premium)
throws ClientProtocolException, UnsupportedEncodingException, IOException {
String playLIst = null;
CloseableHttpClient httpClient = HttpClientBuilder.create().build();
// CloseableHttpClient httpClient = HttpClients.custom().setRoutePlanner(routePlanner).build();
HttpResponse login = httpClient.execute(getVideoStarLogin());
EntityUtils.consume(login.getEntity());
if (login.getStatusLine().getStatusCode() == 302) {
HttpResponse getChannel = httpClient.execute(getChannelsRequest(login));
if (getChannel.getStatusLine().getStatusCode() == 200) {
VideoStarChannelRequest channels =
jsonService.parseVideoStarChannels(EntityUtils.toString(getChannel.getEntity()));
if (channels != null && channels.getStatus().equals("ok")) {
return prepareChannelList(channels, serverUrl, premium);
// return channelsString;
} else if (channels != null && channels.getStatus().equals("error")) {
// TODO
} else {
// TODO
}
}
}
return playLIst;
}
@Override
public void execute() throws Exception {
int statusCode = 0, triesCount = 0;
HttpResponse response = null;
logger.info("Sending bulk request to elasticsearch cluster");
String entity;
synchronized (bulkBuilder) {
entity = bulkBuilder.toString();
bulkBuilder = new StringBuilder();
}
while (statusCode != HttpStatus.SC_OK && triesCount < serversList.size()) {
triesCount++;
String host = serversList.get();
String url = host + "/" + BULK_ENDPOINT;
HttpPost httpRequest = new HttpPost(url);
httpRequest.setEntity(new StringEntity(entity));
response = httpClient.execute(httpRequest);
statusCode = response.getStatusLine().getStatusCode();
logger.info("Status code from elasticsearch: " + statusCode);
if (response.getEntity() != null)
logger.debug(
"Status message from elasticsearch: "
+ EntityUtils.toString(response.getEntity(), "UTF-8"));
}
if (statusCode != HttpStatus.SC_OK) {
if (response.getEntity() != null) {
throw new EventDeliveryException(EntityUtils.toString(response.getEntity(), "UTF-8"));
} else {
throw new EventDeliveryException("Elasticsearch status code was: " + statusCode);
}
}
}
public void testConsumeContent() throws Exception {
String s = "Message content";
StringEntity httpentity = new StringEntity(s);
HttpEntityWrapper wrapped = new HttpEntityWrapper(httpentity);
EntityUtils.consume(wrapped);
EntityUtils.consume(wrapped);
}
@Override
public final HttpResponse invoke(Q query, String endpoint) throws InvocationException {
Preconditions.checkNotNull(query);
Preconditions.checkNotNull(endpoint);
HttpRequestBase method = null;
HttpEntity response = null;
try {
method = getHttpMethod(query, endpoint);
method.setParams(getHttpClientParams(query));
org.apache.http.HttpResponse httpResponse = httpClient.execute(method);
response = httpResponse.getEntity();
return HttpResponse.create(
httpResponse.getStatusLine().getStatusCode(), EntityUtils.toString(response));
} catch (Exception e) {
if (method != null) {
log.debug(
"Error during invocation with URL: "
+ method.getURI()
+ ", endpoint: "
+ endpoint
+ ", query: "
+ query,
e);
} else {
log.debug("Error during invocation with: endpoint: " + endpoint + ", query: " + query, e);
}
throw new InvocationException("InvocationException : ", e);
} finally {
EntityUtils.consumeQuietly(response);
}
}
/**
* proxy query log for the specified task.
*
* @param task the specified task
*/
private void listLogs() {
// PROXY_URL = "http://%s:%s/logview?%s=%s";
String url =
String.format(
PROXY_URL,
host,
port,
HttpserverUtils.HTTPSERVER_LOGVIEW_PARAM_CMD,
HttpserverUtils.HTTPSERVER_LOGVIEW_PARAM_CMD_LIST);
try {
// 1. proxy call the task host log view service
HttpClient client = HttpClientBuilder.create().build();
HttpPost post = new HttpPost(url);
HttpResponse response = client.execute(post);
// 2. check the request is success, then read the log
if (response.getStatusLine().getStatusCode() == 200) {
String data = EntityUtils.toString(response.getEntity());
parseString(data);
} else {
String data = EntityUtils.toString(response.getEntity());
summary = ("Failed to get files\n" + data);
}
} catch (Exception e) {
summary = ("Failed to get files\n" + e.getMessage());
LOG.error(e.getCause(), e);
}
}
public static String postJSON(final String url, JSONObject params, final String headValue)
throws Exception {
HttpPost httpRequest = new HttpPost(url);
if (headValue != null) {
httpRequest.setHeader(CUSTOM_HEAD_NAME, headValue);
}
httpRequest.setHeader("Content-Type", CONTENT_TYPE);
httpRequest.setEntity(new StringEntity(params.toString(), HTTP.UTF_8));
HttpResponse httpResponse;
try {
httpResponse = HttpManager.execute(httpRequest);
} catch (SocketException e) {
httpResponse = HttpManager.execute(httpRequest);
}
int statusCode = httpResponse.getStatusLine().getStatusCode();
if (statusCode == 200) {
return EntityUtils.toString(httpResponse.getEntity(), HTTP.UTF_8);
} else if (statusCode == 302) {
throw new IOException("302");
} else {
String result = EntityUtils.toString(httpResponse.getEntity(), HTTP.UTF_8);
throw new ApiRequestErrorException(result);
}
}
public PingInfo ping(String host, int restPort, boolean noProxy) throws Exception {
PingInfo myPingInfo = pingInfoProvider.createPingInfo();
RequestConfig.Builder requestConfigBuilder =
httpClientProvider.createRequestConfigBuilder(host, noProxy);
String url = String.format(URL_PATTERN, host, restPort) + PingHandler.URL;
HttpUriRequest request =
RequestBuilder.post(url)
.setConfig(requestConfigBuilder.build())
.addParameter(PingHandler.PING_INFO_INPUT_NAME, gson.toJson(myPingInfo))
.build();
CloseableHttpResponse response = httpClientProvider.executeRequest(request);
try {
StatusLine statusLine = response.getStatusLine();
if (statusLine.getStatusCode() != HttpStatus.SC_OK) {
EntityUtils.consumeQuietly(response.getEntity());
throw new Exception(statusLine.getStatusCode() + " " + statusLine.getReasonPhrase());
}
HttpEntity entity = response.getEntity();
String content = EntityUtils.toString(entity);
EntityUtils.consumeQuietly(entity);
PingInfo receivedPingInfo = gson.fromJson(content, PingInfo.class);
receivedPingInfo.getAgentId().setHost(request.getURI().getHost());
return receivedPingInfo;
} finally {
response.close();
}
}
public static boolean uploadFile(
String url, String uploadKey, File file, Map<String, String> params) {
// TODO httpClient连接关闭问题需要考虑
try {
HttpPost httppost = new HttpPost("http://www.new_magic.com/service.php");
MultipartEntity reqEntity = new MultipartEntity();
reqEntity.addPart(uploadKey, new FileBody(file));
for (Map.Entry<String, String> entry : params.entrySet()) {
StringBody value = new StringBody(entry.getValue());
reqEntity.addPart(entry.getKey(), value);
}
httppost.setEntity(reqEntity);
HttpResponse response = httpClient.execute(httppost);
int statusCode = response.getStatusLine().getStatusCode();
if (statusCode == HttpStatus.SC_OK) {
HttpEntity resEntity = response.getEntity();
String body = EntityUtils.toString(resEntity);
EntityUtils.consume(resEntity);
Map<String, Object> responseMap = JsonUtil.parseJson(body, Map.class);
if (responseMap.containsKey("code") && responseMap.get("code").equals(10000)) {
return true;
}
}
} catch (Exception e) {
log.error("", e);
}
return false;
}
@Test
public void testBasicAuthenticationCredentialsCaching() throws Exception {
this.localServer.register("*", new AuthHandler());
this.localServer.start();
BasicCredentialsProvider credsProvider = new BasicCredentialsProvider();
credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials("test", "test"));
TestTargetAuthenticationStrategy authStrategy = new TestTargetAuthenticationStrategy();
this.httpclient.setCredentialsProvider(credsProvider);
this.httpclient.setTargetAuthenticationStrategy(authStrategy);
HttpContext context = new BasicHttpContext();
HttpHost targethost = getServerHttp();
HttpGet httpget = new HttpGet("/");
HttpResponse response1 = this.httpclient.execute(targethost, httpget, context);
HttpEntity entity1 = response1.getEntity();
Assert.assertEquals(HttpStatus.SC_OK, response1.getStatusLine().getStatusCode());
Assert.assertNotNull(entity1);
EntityUtils.consume(entity1);
HttpResponse response2 = this.httpclient.execute(targethost, httpget, context);
HttpEntity entity2 = response1.getEntity();
Assert.assertEquals(HttpStatus.SC_OK, response2.getStatusLine().getStatusCode());
Assert.assertNotNull(entity2);
EntityUtils.consume(entity2);
Assert.assertEquals(1, authStrategy.getCount());
}
public void pick() throws IOException {
while (true) {
pickUrl =
String.format(
"http://web.im.baidu.com/pick?v=30&session=&source=22&type=23&flag=1&seq=%d&ack=%s&guid=%s",
sequence, ack, guid);
HttpGet getRequest = new HttpGet(pickUrl);
HttpResponse pickRes = httpClient.execute(getRequest);
String entityStr = EntityUtils.toString(pickRes.getEntity());
System.out.println("Pick result:" + entityStr);
EntityUtils.consume(pickRes.getEntity());
JSONObject jsonObject = JSONObject.fromObject(entityStr);
JSONObject content = jsonObject.getJSONObject("content");
if (content != null && content.get("ack") != null) {
ack = (String) content.get("ack");
JSONArray fields = content.getJSONArray("fields");
JSONObject o = fields.getJSONObject(0);
String fromUser = (String) o.get("from");
System.out.println("++++Message from: " + fromUser);
}
updateSequence();
if (sequence > 4) {
break;
}
}
}
public static String get(String url, List<NameValuePair> params) {
String body = null;
try {
HttpClient hc = new DefaultHttpClient();
// Get请求
HttpGet httpget = new HttpGet(url);
// 设置参数
String str = EntityUtils.toString(new UrlEncodedFormEntity(params));
httpget.setURI(new URI(httpget.getURI().toString() + "?" + str));
// 设置请求和传输超时时间
RequestConfig requestConfig =
RequestConfig.custom().setSocketTimeout(4000).setConnectTimeout(4000).build();
httpget.setConfig(requestConfig);
// 发送请求
HttpResponse httpresponse = hc.execute(httpget);
// 获取返回数据
HttpEntity entity = httpresponse.getEntity();
body = EntityUtils.toString(entity);
if (entity != null) {
entity.consumeContent();
}
} catch (Exception e) {
logger.error("http的get方法" + e.toString());
throw new RuntimeException(e);
}
return body;
}
// 底层请求打印页面
private byte[] sendRequest(HttpRequestBase request) throws Exception {
CloseableHttpResponse response = httpclient.execute(request);
// 设置超时
setTimeOut(request, 5000);
// 获取返回的状态列表
StatusLine statusLine = response.getStatusLine();
System.out.println("StatusLine : " + statusLine);
if (statusLine.getStatusCode() == HttpStatus.SC_OK) {
try {
// 获取response entity
HttpEntity entity = response.getEntity();
System.out.println("getContentType ： " + entity.getContentType().getValue());
System.out.println("getContentEncoding ： " + entity.getContentEncoding().getValue());
// 读取响应内容
byte[] responseBody = EntityUtils.toByteArray(entity);
// 关闭响应流
EntityUtils.consume(entity);
return responseBody;
} finally {
response.close();
}
}
return null;
}
public LocalDocument getDocument(LocalQuery query, boolean recurring) throws IOException {
HttpResponse response;
if (recurring) {
response = core.post(getRecurringUrl, query.toJson());
} else {
response = core.post(getUrl, query.toJson());
}
if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
LocalDocument ld;
try {
ld = new LocalDocument(EntityUtils.toString(response.getEntity()));
} catch (JsonException e) {
throw new IOException(e);
}
InternalLogger.debug("Received document with ID " + ld.getID());
currentDocument = ld;
return ld;
} else if (response.getStatusLine().getStatusCode() == HttpStatus.SC_NOT_FOUND) {
InternalLogger.debug("No document found matching query");
EntityUtils.consume(response.getEntity());
return null;
} else {
logUnexpected(response);
return null;
}
}
public byte[] handleResponse(HttpResponse hr) throws ClientProtocolException, IOException {
if (hr.getStatusLine().getStatusCode() == 200) {
if (hr.getEntity().getContentEncoding() == null) {
return EntityUtils.toByteArray(hr.getEntity());
}
if (hr.getEntity().getContentEncoding().getValue().contains("gzip")) {
GZIPInputStream gis = null;
try {
gis = new GZIPInputStream(hr.getEntity().getContent());
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] b = new byte[1024];
int n;
while ((n = gis.read(b)) != -1) baos.write(b, 0, n);
System.out.println("Gzipped");
return baos.toByteArray();
} catch (IOException e) {
throw e;
} finally {
try {
if (gis != null) gis.close();
} catch (IOException ex) {
throw ex;
}
}
}
return EntityUtils.toByteArray(hr.getEntity());
}
if (hr.getStatusLine().getStatusCode() == 302) {
throw new IOException("302");
}
return null;
}
private Role getRoleByName(String name) throws ParseException, IOException {
// Add AuthCache to the execution context
BasicHttpContext ctx = new BasicHttpContext();
ctx.setAttribute(ClientContext.AUTH_CACHE, authCache);
HttpPost post = new HttpPost("/api/secure/jsonws//role/get-role");
List<NameValuePair> params = new ArrayList<NameValuePair>();
params.add(new BasicNameValuePair("companyId", companyId));
params.add(new BasicNameValuePair("name", name));
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(params, "UTF-8");
post.setEntity(entity);
HttpResponse resp = httpclient.execute(targetHost, post, ctx);
System.out.println("getRoleById Status:[" + resp.getStatusLine() + "]");
String response = null;
if (resp.getEntity() != null) {
response = EntityUtils.toString(resp.getEntity());
}
Role role = null;
if (!StringUtil.contains(response, "NoSuch", "")
&& !StringUtil.contains(response, "exception", "")) {
JSONDeserializer<Role> deserializer = new JSONDeserializer<Role>();
role = deserializer.deserialize(response, Role.class);
}
EntityUtils.consume(resp.getEntity());
return role;
}