Exemple #1
0
  public String executeHttpGet(String URL) throws Exception {
    BufferedReader in = null;
    try {
      HttpClient client = new DefaultHttpClient();
      client.getParams().setParameter(CoreProtocolPNames.USER_AGENT, "android");
      HttpGet request = new HttpGet();
      request.setHeader("Content-Type", "text/plain; charset=utf-8");
      request.setURI(new URI(URL));
      HttpResponse response = client.execute(request);
      in = new BufferedReader(new InputStreamReader(response.getEntity().getContent()));

      StringBuffer sb = new StringBuffer("");
      String line = "";

      String NL = System.getProperty("line.separator");
      while ((line = in.readLine()) != null) {
        sb.append(line + NL);
      }
      in.close();
      String page = sb.toString();
      // System.out.println(page);
      return page;
    } finally {
      if (in != null) {
        try {
          in.close();
        } catch (IOException e) {
          Log.d("BBB", e.toString());
        }
      }
    }
  }
Exemple #2
0
    @Override
    protected String doInBackground(String... url) {

      if (allPhoneContacts != null) {
        allPhoneContacts.clear();
      }

      if (syncedContacts != null) {
        syncedContacts.clear();
      }

      String resp = "";
      Header[] responseHeaders = null;
      HttpParams httpParams = new BasicHttpParams();
      HttpConnectionParams.setConnectionTimeout(httpParams, TIMEOUT_MILLSEC);
      HttpGet request = new HttpGet(url[0]);
      MyHttpClient Client = LogonClass.Client;
      Client.putContext(context);
      try {
        request.setHeader("syncstatus", "True");
        HttpResponse response = Client.execute(request);
        resp = EntityUtils.toString(response.getEntity());
        responseHeaders = response.getAllHeaders();
      } catch (Exception e) {

        resp = "none is righteous";
      }

      Log.v(TAG, "response is " + resp);
      return resp;
    }
  private String doGet(String url) {
    String responseStr = "";
    try {
      HttpGet httpRequest = new HttpGet(url);
      HttpParams params = new BasicHttpParams();
      ConnManagerParams.setTimeout(params, 1000);
      HttpConnectionParams.setConnectionTimeout(params, 3000);
      HttpConnectionParams.setSoTimeout(params, 5000);
      httpRequest.setParams(params);

      HttpResponse httpResponse = new DefaultHttpClient().execute(httpRequest);
      final int ret = httpResponse.getStatusLine().getStatusCode();
      if (ret == HttpStatus.SC_OK) {
        responseStr = EntityUtils.toString(httpResponse.getEntity(), HTTP.UTF_8);
      } else {
        responseStr = "-1";
      }
    } catch (ClientProtocolException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

    return responseStr;
  }
Exemple #4
0
  public static List<RoleRepresentation> getRealmRoles(HttpServletRequest req) throws Failure {
    KeycloakSecurityContext session =
        (KeycloakSecurityContext) req.getAttribute(KeycloakSecurityContext.class.getName());

    HttpClient client = new HttpClientBuilder().disableTrustManager().build();
    try {
      HttpGet get =
          new HttpGet(
              AdapterUtils.getOriginForRestCalls(req.getRequestURL().toString(), session)
                  + "/auth/admin/realms/demo/roles");
      get.addHeader("Authorization", "Bearer " + session.getTokenString());
      try {
        HttpResponse response = client.execute(get);
        if (response.getStatusLine().getStatusCode() != 200) {
          throw new Failure(response.getStatusLine().getStatusCode());
        }
        HttpEntity entity = response.getEntity();
        InputStream is = entity.getContent();
        try {
          return JsonSerialization.readValue(is, TypedList.class);
        } finally {
          is.close();
        }
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    } finally {
      client.getConnectionManager().shutdown();
    }
  }
  /**
   * Fetches user's e-mail - only public for testing.
   *
   * @param allToks OAuth tokens.
   * @param httpClient The HTTP client.
   */
  public int fetchEmail(final Map<String, String> allToks, final HttpClient httpClient) {
    final String endpoint = "https://www.googleapis.com/oauth2/v1/userinfo";
    final String accessToken = allToks.get("access_token");
    final HttpGet get = new HttpGet(endpoint);
    get.setHeader(HttpHeaders.Names.AUTHORIZATION, "Bearer " + accessToken);

    try {
      log.debug("About to execute get!");
      final HttpResponse response = httpClient.execute(get);
      final StatusLine line = response.getStatusLine();
      log.debug("Got response status: {}", line);
      final HttpEntity entity = response.getEntity();
      final String body = IOUtils.toString(entity.getContent(), "UTF-8");
      EntityUtils.consume(entity);
      log.debug("GOT RESPONSE BODY FOR EMAIL:\n" + body);

      final int code = line.getStatusCode();
      if (code < 200 || code > 299) {
        log.error("OAuth error?\n" + line);
        return code;
      }

      final Profile profile = JsonUtils.OBJECT_MAPPER.readValue(body, Profile.class);
      this.model.setProfile(profile);
      Events.sync(SyncPath.PROFILE, profile);
      // final String email = profile.getEmail();
      // this.model.getSettings().setEmail(email);
      return code;
    } catch (final IOException e) {
      log.warn("Could not connect to Google?", e);
    } finally {
      get.reset();
    }
    return -1;
  }
  private static Bitmap getCaptchaImage(HttpClient client, String captchaId)
      throws ClientProtocolException, IOException {
    final HttpGet request = new HttpGet(String.format(CAPTCHA_IMAGE, captchaId));
    request.addHeader("User-Agent", USER_AGENT);
    request.addHeader("Referer", REFERER);
    request.getParams().setBooleanParameter(CoreProtocolPNames.USE_EXPECT_CONTINUE, true);

    final HttpResponse response = client.execute(request);

    final HttpEntity entity = response.getEntity();
    final InputStream in = entity.getContent();

    int next;
    final ByteArrayOutputStream bos = new ByteArrayOutputStream();
    while ((next = in.read()) != -1) {
      bos.write(next);
    }
    bos.flush();
    byte[] result = bos.toByteArray();

    bos.close();

    entity.consumeContent();
    return BitmapFactory.decodeByteArray(result, 0, result.length);
  }
  @Override
  public List<Entity> annotateEntity(Entity entity) {
    HttpGet httpGet = new HttpGet(getServiceUri(entity));
    Entity resultEntity = new MapEntity();

    if (!annotatedInput.contains(entity.get(UNIPROT_ID))) {
      annotatedInput.add(entity.get(UNIPROT_ID));
      try {
        HttpResponse response = httpClient.execute(httpGet);
        BufferedReader br =
            new BufferedReader(
                new InputStreamReader(
                    (response.getEntity().getContent()), Charset.forName("UTF-8")));

        String output;
        StringBuilder result = new StringBuilder();

        while ((output = br.readLine()) != null) {
          result.append(output);
        }
        resultEntity = parseResult(entity, result.toString());
      } catch (Exception e) {
        httpGet.abort();
        // TODO: how to handle exceptions at this point
        throw new RuntimeException(e);
      }
    }
    return Collections.singletonList(resultEntity);
  }
  public String call(String url, Map<String, String> fields) {

    // create an HTTP request to a protected resource
    HttpGet request = new HttpGet(endpoint);

    HttpParams p = new BasicHttpParams();

    for (Entry<String, String> en : fields.entrySet()) {
      p.setParameter(en.getKey(), en.getValue());
    }

    request.setParams(p);

    // sign the request
    try {
      consumer2.sign(request);
    } catch (OAuthMessageSignerException e) {
      e.printStackTrace();
    } catch (OAuthExpectationFailedException e) {
      e.printStackTrace();
    }

    // send the request
    HttpClient httpClient = new DefaultHttpClient();
    try {
      HttpResponse response = httpClient.execute(request);
      return convertStreamToString(response.getEntity().getContent());
    } catch (ClientProtocolException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }

    return null;
  }
Exemple #9
0
  /**
   * This method retrieves data using HTTP or HTTPS protocol and 'get' method.
   *
   * @param url
   * @return
   */
  protected byte[] httpGet(String url) {

    HttpGet httpRequest = null;
    HttpResponse httpResponse = null;
    try {

      final URI uri = URI.create(url.trim());
      httpRequest = new HttpGet(uri);
      if (contentType != null) {
        httpRequest.setHeader(CONTENT_TYPE, contentType);
      }

      httpResponse = getHttpResponse(httpRequest, url);

      final byte[] returnedBytes = readHttpResponse(url, httpResponse);
      return returnedBytes;
    } finally {
      if (httpRequest != null) {
        httpRequest.releaseConnection();
      }
      if (httpResponse != null) {
        EntityUtils.consumeQuietly(httpResponse.getEntity());
      }
    }
  }
Exemple #10
0
  public static Bitmap downloadBitmap(String url) {
    DefaultHttpClient client = getDefaultHttpClient(null);
    final HttpGet getRequest = new HttpGet(url);

    try {
      HttpResponse response = client.execute(getRequest);
      final int statusCode = response.getStatusLine().getStatusCode();
      if (statusCode != HttpStatus.SC_OK) {
        return null;
      }

      final HttpEntity entity = response.getEntity();
      if (entity != null) {
        InputStream inputStream = null;
        try {
          inputStream = entity.getContent();
          final Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
          return bitmap;
        } finally {
          if (inputStream != null) {
            inputStream.close();
          }
          entity.consumeContent();
        }
      }
    } catch (Exception e) {
      getRequest.abort();
    } finally {
      if (client != null) {
        client.getConnectionManager().shutdown();
      }
    }
    return null;
  }
    @Override
    protected Drawable doInBackground(String... param) {
      Drawable thumbnail = null;

      try {

        HttpClient httpClient = new DefaultHttpClient();
        HttpGet httpGet = new HttpGet();
        httpGet.setURI(new URI(param[0]));
        httpGet.setHeader("Accept", "image/jpeg");

        HttpResponse response = httpClient.execute(httpGet);
        InputStream inputStream = response.getEntity().getContent();

        thumbnail = Drawable.createFromStream(inputStream, "src name");

      } catch (MalformedURLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } catch (URISyntaxException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }

      return thumbnail;
    }
Exemple #12
0
  private void requestReadingList() throws HttpException, IOException {
    if (!this.isRight()) return;

    int originalSize = 0;
    if (feed != null) {
      items = feed.getItems();
      originalSize = items.size();
    }
    String url =
        "https://www.google.com/reader/atom/user/-/state/com.google/reading-list?n="
            + String.valueOf(pagenumber * everypage);

    HttpClient httpclient = new DefaultHttpClient();
    getreadinglistmethod = new HttpGet(url);
    getreadinglistmethod.setHeader("Authorization", "GoogleLogin auth=" + auth);
    getreadinglistmethod.setHeader("Cookie", "SID=" + sid);
    getreadinglistmethod.setHeader("accept-encoding", "gzip, deflate");
    HttpResponse response = null;
    response = httpclient.execute(getreadinglistmethod);
    int result = response.getStatusLine().getStatusCode();
    // Log.d("GOOGLE_READER", "load result"+result);
    if (result >= 200 && result <= 299) {

      RssParser rp = new RssParser(response.getEntity().getContent());
      //            //System.out.println("++++++++++");

      //            //System.out.println((rp != null ? 1 : 0));
      rp.parse();
      feed = rp.getFeed();
      try {
        items = feed.getItems();
        if (items.size() == originalSize) {
          throw new NoMoreStatusException();
        }
      } catch (Exception e) {
        e.printStackTrace();
        throw new NoNetworkException(e);
      }

      greaderlistItems = new ArrayList<GreaderListItem>();

      for (RssParser.Item item : items) {
        {
          GreaderListItem greaderlistItem = new GreaderListItem();
          greaderlistItem.setId(item.id);
          greaderlistItem.setTitle(item.title);
          greaderlistItem.setLink(item.link);
          greaderlistItem.setAuthor(item.author);
          greaderlistItems.add(greaderlistItem);
        }
      }
      fromindex = (pagenumber - 1) * everypage;
      pagenumber += 1;
      lastModified = new Date();
      // this.getreadingliststring=getreadinglistmethod.getResponseBodyAsString();
    } else {
      throw new NoNetworkException();
    }
    releaseReadingList(getreadinglistmethod);
  }
Exemple #13
0
  // taglist
  private StringBuilder requestList(String url) throws HttpException, IOException {
    HttpClient httpclient = new DefaultHttpClient();
    HttpGet get = new HttpGet(url);
    get.setHeader("Authorization", "GoogleLogin auth=" + auth);
    get.setHeader("Cookie", "SID=" + sid);
    get.setHeader("accept-encoding", "gzip, deflate");
    HttpResponse response = null;
    response = httpclient.execute(get);
    int result = response.getStatusLine().getStatusCode();
    StringBuilder requestListSB;
    if (result == 200) {
      // //System.out.println(get.getResponseBodyAsString());

      requestListSB = new StringBuilder(EntityUtils.toString(response.getEntity()));

    } else {
      //// System.out.println("xxx:" + String.valueOf(result));

      requestListSB = null;
    }
    get.abort();
    httpclient.getConnectionManager().shutdown();
    httpclient = null;
    return requestListSB;
  }
Exemple #14
0
  public void requestToken() throws ParseException, HttpException, IOException {
    if (!this.isGetSidAndAuth) return;
    String url = "https://www.google.com/reader/api/0/token?client=scroll&ck=";

    // HttpClient httpclient = new DefaultHttpClient();
    DefaultHttpClient httpclient = new DefaultHttpClient();
    String timestap = String.valueOf(getTimestamp());
    HttpGet get = new HttpGet(url + timestap);
    get.setHeader("Authorization", "GoogleLogin auth=" + auth);
    get.setHeader("Cookie", "SID=" + sid);
    HttpResponse response = null;
    response = httpclient.execute(get);
    int result = response.getStatusLine().getStatusCode();
    ////// System.out.println(result);
    if (result == 200) {
      // this.token = get.getResponseBodyAsString().substring(2);
      //// System.out.println("2222222222222");
      this.token = EntityUtils.toString(response.getEntity()).substring(2);
      //// System.out.println(this.token);
    }
    // ////System.out.println(this.token);
    get.abort();
    httpclient.getConnectionManager().shutdown();
    httpclient = null;
  }
    @Override
    protected Object doInBackground(Object... params) {
      // TODO Auto-generated method stub

      try {
        HttpClient httpClient = new DefaultHttpClient();
        HttpContext localContext = new BasicHttpContext();
        String website =
            "http://myflickpicks.net/php/db/deleteusermovie.php?UserID="
                + currentUser.getId()
                + "&MovieTitle="
                + params[0].toString().replace(" ", "%20");
        HttpGet httpGet = new HttpGet(website);
        httpGet.setHeader("accept", "application/json");
        HttpResponse response = httpClient.execute(httpGet, localContext);
        // Toast.makeText(getActivity().getApplicationContext(), "Adding",
        // Toast.LENGTH_LONG).show(); // For example
        Log.v("MyDebug", "Door 1");
        Log.v("MyDebug", currentUser.getId());
      } catch (ClientProtocolException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
        Log.v("MyDebug", "Door 2");
      } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
        Log.v("MyDebug", "Door 3");
      }
      return null;
    }
Exemple #16
0
 public static HttpHeaderInfo getHttpHeader(String url, Map<Object, Object> headers)
     throws ClientProtocolException, IOException {
   HttpGet httpGet = new HttpGet(url);
   if (headers != null) {
     for (Map.Entry<Object, Object> entry : headers.entrySet()) {
       httpGet.addHeader(entry.getKey() + "", entry.getValue() + "");
     }
   }
   CloseableHttpResponse response = minHttpclient.execute(httpGet);
   try {
     response.close();
     HttpHeaderInfo headerInfo = new HttpHeaderInfo();
     headerInfo.setStatus(response.getStatusLine().getStatusCode());
     headerInfo.setReasonPhrase(response.getStatusLine().getReasonPhrase());
     Header[] allHeaders = response.getAllHeaders();
     if (allHeaders != null) {
       Map<String, Object> headerMap = new HashMap<String, Object>();
       for (Header header : allHeaders) {
         headerMap.put(header.getName(), header.getValue());
       }
       headerInfo.setHeaders(headerMap);
     }
     return headerInfo;
   } finally {
     response.close();
   }
 }
  static void testBasicAuth() throws ClientProtocolException, IOException {
    HttpHost targetHost = new HttpHost("localhost", 8080, "http");

    DefaultHttpClient httpclient = new DefaultHttpClient();

    httpclient
        .getCredentialsProvider()
        .setCredentials(
            new AuthScope(targetHost.getHostName(), targetHost.getPort()),
            new UsernamePasswordCredentials("newuser", "tomcat"));

    // 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
    BasicHttpContext localcontext = new BasicHttpContext();
    localcontext.setAttribute(ClientContext.AUTH_CACHE, authCache);

    HttpGet httpget = new HttpGet("/simpleweb/protected");
    System.out.println(httpget.getURI());

    HttpResponse response = httpclient.execute(targetHost, httpget, localcontext);

    HttpEntity entity = response.getEntity();

    System.out.println(response.getStatusLine().getStatusCode());
    String charset = HttpclientTutorial.getResponseCharset(response);
    HttpclientTutorial.output(entity, charset);

    EntityUtils.consume(entity);
  }
  /**
   * Performs an HTTP GET request to the specified url.
   *
   * @param url The web address to post the request to
   * @return The result of the request
   * @throws Exception
   */
  public static String executeHttpGet(String url) throws Exception {
    BufferedReader in = null;
    try {

      //	        	HttpClient httpclient = new DefaultHttpClient();
      //	            HttpPost httppost = new HttpPost("http://example.com/your_file.php");
      //	             ResponseHandler<String> responseHandler = new BasicResponseHandler();
      //	             String responseBody = httpclient.execute(httppost, responseHandler);

      HttpClient client = getHttpClient();
      HttpGet request = new HttpGet();
      request.setURI(new URI(url));
      HttpResponse response = client.execute(request);
      in = new BufferedReader(new InputStreamReader(response.getEntity().getContent()));

      StringBuffer sb = new StringBuffer("");
      String line = "";
      String NL = System.getProperty("line.separator");
      while ((line = in.readLine()) != null) {
        sb.append(line + NL);
      }
      in.close();

      String result = sb.toString();
      return result;
    } finally {
      if (in != null) {
        try {
          in.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }
  }
  public void testMojoExecution() throws Exception {
    assertNotNull(mojo);
    mojo.execute();

    HttpClient client = HttpClientBuilder.create().build();

    HttpGet get = new HttpGet("http://localhost:" + elasticsearchNode.getHttpPort());

    final int connectionTimeout = 500; // millis
    RequestConfig requestConfig =
        RequestConfig.custom()
            .setConnectionRequestTimeout(connectionTimeout)
            .setConnectTimeout(connectionTimeout)
            .setSocketTimeout(connectionTimeout)
            .build();
    get.setConfig(requestConfig);

    try {
      client.execute(get);

      fail("The ES cluster should have been down by now");
    } catch (HttpHostConnectException | ConnectTimeoutException expected) {
    }

    assertTrue(elasticsearchNode.isClosed());
  }
Exemple #20
0
  /**
   * Wrapper around a HTTP GET to a REST service
   *
   * @param url
   * @return JSONObject
   */
  static JSONObject performHTTPGet(String url) throws IOException, JSONException {

    HttpClient httpClient = new DefaultHttpClient();
    String encoding =
        new String(
            org.apache.commons.codec.binary.Base64.encodeBase64(
                org.apache.commons.codec.binary.StringUtils.getBytesUtf8(
                    props.getProperty(StringConstants.COMMANDER_USER)
                        + ":"
                        + props.getProperty(StringConstants.COMMANDER_PASSWORD))));
    try {
      HttpGet httpGetRequest = new HttpGet(url);
      httpGetRequest.setHeader("Authorization", "Basic " + encoding);
      HttpResponse httpResponse = httpClient.execute(httpGetRequest);
      if (httpResponse.getStatusLine().getStatusCode() >= 400) {
        throw new RuntimeException(
            "HTTP GET failed with "
                + httpResponse.getStatusLine().getStatusCode()
                + "-"
                + httpResponse.getStatusLine().getReasonPhrase());
      }
      return new JSONObject(EntityUtils.toString(httpResponse.getEntity()));

    } finally {
      httpClient.getConnectionManager().shutdown();
    }
  }
  @Test
  public void testReqriteHostHeader() throws Exception {
    setProxyHandler(true, false);
    TestHttpClient client = new TestHttpClient();

    try {
      HttpGet get = new HttpGet(DefaultServer.getDefaultServerURL() + "/x-forwarded");
      get.addHeader(Headers.X_FORWARDED_FOR.toString(), "50.168.245.32");
      HttpResponse result = client.execute(get);
      Assert.assertEquals(StatusCodes.OK, result.getStatusLine().getStatusCode());

      Assert.assertEquals(
          port,
          Integer.parseInt(result.getFirstHeader(Headers.X_FORWARDED_PORT.toString()).getValue()));
      Assert.assertEquals(
          "http", result.getFirstHeader(Headers.X_FORWARDED_PROTO.toString()).getValue());
      Assert.assertEquals(
          String.format("localhost:%d", port),
          result.getFirstHeader(Headers.X_FORWARDED_HOST.toString()).getValue());
      Assert.assertEquals(
          DefaultServer.getDefaultServerAddress().getAddress().getHostAddress(),
          result.getFirstHeader(Headers.X_FORWARDED_FOR.toString()).getValue());

    } finally {
      client.getConnectionManager().shutdown();
    }
  }
  @Test
  public void testKeepAlive() throws Exception {
    String url = httpServerUrl + "4ae3851817194e2596cf1b7103603ef8/pin/a14";

    HttpPut request = new HttpPut(url);
    request.setHeader("Connection", "keep-alive");

    HttpGet getRequest = new HttpGet(url);
    getRequest.setHeader("Connection", "keep-alive");

    for (int i = 0; i < 100; i++) {
      request.setEntity(new StringEntity("[\"" + i + "\"]", ContentType.APPLICATION_JSON));

      try (CloseableHttpResponse response = httpclient.execute(request)) {
        assertEquals(200, response.getStatusLine().getStatusCode());
        EntityUtils.consume(response.getEntity());
      }

      try (CloseableHttpResponse response2 = httpclient.execute(getRequest)) {
        assertEquals(200, response2.getStatusLine().getStatusCode());
        List<String> values = consumeJsonPinValues(response2);
        assertEquals(1, values.size());
        assertEquals(String.valueOf(i), values.get(0));
      }
    }
  }
 public HttpGet prepareHttpGet(URI uri) {
   HttpGet httpget = new HttpGet(uri);
   httpget.addHeader("content-type", this.configuration.getContentType());
   if (!Strings.isNullOrEmpty(authHeader))
     httpget.addHeader("Authorization", String.format("Basic %s", authHeader));
   return httpget;
 }
Exemple #24
0
 /**
  * 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;
 }
 @Test
 public final void givenCustomHeaderIsSet_whenSendingRequest_thenNoExceptions()
     throws ClientProtocolException, IOException {
   final HttpGet request = new HttpGet(SAMPLE_URL);
   request.addHeader(HttpHeaders.ACCEPT, "application/xml");
   response = instance.execute(request);
 }
 /**
  * Fill an http get request with the header information.
  *
  * @param get An http get request
  */
 public void fill(HttpGet get) {
   get.addHeader("User-Agent", user_agent);
   get.addHeader("Accept", accept);
   get.addHeader("Accept-Language", accept_language);
   get.addHeader("Accept-Encoding", accept_encoding);
   get.addHeader("Connection", connection);
 }
Exemple #27
0
  public String Coment(String membre, String contenu, int lieu, float rate) throws Exception {
    String link =
        "http:"
            + Utilisateur.ip
            + "/geekAdvisorApi/avisApi.php?membre="
            + URLEncoder.encode(membre)
            + "&contenu="
            + URLEncoder.encode(contenu)
            + "&lieu="
            + lieu
            + "&rate="
            + rate
            + "";
    URL url = new URL(link);
    HttpClient client = new DefaultHttpClient();
    HttpGet request = new HttpGet();
    request.setURI(new URI(link));
    HttpResponse response = client.execute(request);
    BufferedReader in =
        new BufferedReader(new InputStreamReader(response.getEntity().getContent()));

    StringBuffer sb = new StringBuffer("");
    String line = "";
    while ((line = in.readLine()) != null) {
      sb.append(line);
      break;
    }
    // jObject = new JSONObject(sb.toString());

    in.close();
    return sb.toString();
  }
  /*public static double getTescoTotal(String barcode) throws JSONException
  {
  	double parsedvalue= JsonObject.getTescoProductValue(barcode);

  	//int i= Integer.parseInt(parsedvalue);
  	int total = 0;
  	while(parsedvalue!=0)
  	{
  		total+=parsedvalue;
  	}
    return total;
  }*/
  public static String getTescoProductName(String barcode) throws JSONException {
    String key = "empty";
    key = login();
    String URL = startURL + key + "&SEARCHTEXT=" + barcode;

    // InputStream is=null;
    HttpClient httpclient = new DefaultHttpClient();
    HttpGet request = new HttpGet(URL);
    request.addHeader("deviceId", deviceId);
    ResponseHandler<String> handler = new BasicResponseHandler();

    try {
      result = httpclient.execute(request, handler);
    } catch (ClientProtocolException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    jObject = new JSONObject(result);

    JSONArray productinfo = jObject.getJSONArray("Products");

    String name = null;

    for (int i = 0; i < productinfo.length(); i++) {
      name = productinfo.getJSONObject(i).getString("Name").toString();
    }

    return name;
  }
  /**
   * Get the user preferences from the GPII
   *
   * @param user
   * @return
   * @throws Exception
   */
  private String getPreferencesFromServer(EasitAccount user) throws Exception {

    HttpClient client = new DefaultHttpClient();
    HttpGet request =
        new HttpGet(
            environment.getProperty("flowManager.url")
                + environment.getProperty("flowManager.preferences"));

    // add the access token to the request header
    request.addHeader("Authorization", "Bearer " + user.getAccessToken());
    HttpResponse response = client.execute(request);

    // NOT Correct answer
    if (response.getStatusLine().getStatusCode() != 200) {
      throw new Exception("Failed : HTTP error code : " + response.getStatusLine().getStatusCode());
    }

    // Correct answer
    BufferedReader rd =
        new BufferedReader(new InputStreamReader(response.getEntity().getContent()));
    StringBuffer result = new StringBuffer();
    String line = "";
    while ((line = rd.readLine()) != null) {
      result.append(line);
    }

    logger.info("User preferences:" + result);
    return result.toString();
  }
Exemple #30
0
  /**
   * Get方法传送消息
   *
   * @param url 连接的URL
   * @param queryString 请求参数串
   * @return 服务器返回的信息
   * @throws Exception
   */
  public String httpGet(String url, String queryString) throws Exception {

    String responseData = null;
    if (queryString != null && !queryString.equals("")) {
      url += "?" + queryString;
    }
    RequestBuilder requestBuilder = RequestBuilder.get().setUri(url);
    log.info("QHttpClient httpGet [1] url = " + url);
    RequestConfig requestConfig =
        RequestConfig.custom()
            .setSocketTimeout(new Integer(CONNECTION_TIMEOUT))
            .setCookieSpec(CookieSpecs.IGNORE_COOKIES)
            .build();
    requestBuilder.setConfig(requestConfig);
    HttpResponse response;
    HttpGet httpGet = (HttpGet) requestBuilder.build();
    response = httpClient.execute(httpGet);
    try {
      log.info("QHttpClient httpGet [2] StatusLine : " + response.getStatusLine());
      responseData = EntityUtils.toString(response.getEntity());
      log.info("QHttpClient httpGet [3] Response = " + responseData);
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      httpGet.abort();
    }
    return responseData;
  }