studio - using httpclient in android




HttpClient não importará no Android Studio (15)

Eu tenho uma classe simples escrita no Android Studio:

package com.mysite.myapp;

import org.apache.http.client.HttpClient;

public class Whatever {
    public void headBangingAgainstTheWallExample () {
        HttpClient client = new DefaultHttpClient();
    }
}

e deste eu recebo o seguinte erro de tempo de compilação:

Cannot resolve symbol HttpClient

O HttpClient não está incluído no SDK do Android Studio? Mesmo que não seja, eu adicionei à minha build de Gradle assim:

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:23.0.0'
    compile 'org.apache.httpcomponents:httpclient:4.5'
}

Com ou sem a última linha de compilação, o erro é o mesmo. o que estou perdendo?


Outra maneira é se você tiver o arquivo httpclient.jar, então você pode fazer isso:

Cole seu arquivo .jar na pasta "libs" em seu projeto. Então no gradle adicione essa linha no seu build.gradle (Module: app)

dependencies {
compile fileTree(include: ['*.jar'], dir: 'libs')
compile 'com.android.support:appcompat-v7:23.0.0'
compile files('libs/httpcore-4.3.3.jar')
}

1- baixar arquivos jar Apache (como desta resposta) 4.5.zip de:
https://hc.apache.org/downloads.cgi?Preferred=http%3A%2F%2Fapache.arvixe.com%2F

2- abra o zip copie os arquivos jar em sua pasta libs. Você pode encontrá-lo se você vai para o topo do seu projeto, onde diz "Android", você encontrará uma lista quando você clica nele. Assim,

Android -> Projeto -> aplicativo -> libs

Então coloque frascos lá.

3- No build.gradle (Module: app) adicionar

compile fileTree(dir: 'libs', include: ['*.jar'])

em

 dependency { 
   }

4- Na classe java, adicione estas importações:

import org.apache.http.HttpResponse;

import org.apache.http.client.HttpClient;

import org.apache.http.client.methods.HttpGet;

import org.apache.http.impl.client.DefaultHttpClient;

import org.apache.http.params.CoreProtocolPNames;

A versão 6.0 do Android (API 23) remove o suporte para o cliente HTTP Apache. Portanto, você não pode usar essa biblioteca diretamente na API 23. Mas existe uma maneira de usá-la. Adicione useLibrary 'org.apache.http.legacy' no seu arquivo build.gradle como abaixo-

android {
    useLibrary 'org.apache.http.legacy'
}

Se isso não funcionar, você pode aplicar o seguinte hack-

- Copie o org.apache.http.legacy.jar, que está no caminho / platforms / android-23 / opcional do diretório do Android SDK para a pasta app / libs do seu projeto.

- Agora Adicione arquivos de compilação ('libs / org.apache.http.legacy.jar') dentro das dependências {} seção do arquivo build.gradle.


Adicione estas duas linhas em dependências

compile 'org.apache.httpcomponents:httpcore:4.4.1'
compile 'org.apache.httpcomponents:httpclient:4.5'

então

useLibrary 'org.apache.http.legacy'

sob o andróide


Como mencionado anteriormente, o org.apache.http.client.HttpClient não é mais suportado em:

SDK (nível de API) # 23.

Você tem que usar java.net.HttpURLConnection .

Se você quiser tornar seu código (e vida) mais fácil ao usar HttpURLConnection , aqui está um Wrapper dessa classe que permitirá que você faça operações simples com GET , POST e PUT usando JSON , como por exemplo, fazendo um HTTP PUT .

HttpRequest request = new HttpRequest(API_URL + PATH).addHeader("Content-Type", "application/json");
int httpCode = request.put(new JSONObject().toString());
if (HttpURLConnection.HTTP_OK == httpCode) {
    response = request.getJSONObjectResponse();
} else {
  // log error
}
httpRequest.close()

Sinta-se livre para usá-lo.

package com.calculistik.repository;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

/**
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * <p>
 * Copyright © 2017, Calculistik . All rights reserved.
 * <p>
 * Oracle and Java are registered trademarks of Oracle and/or its
 * affiliates. Other names may be trademarks of their respective owners.
 * <p>
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * https://netbeans.org/cddl-gplv2.html or
 * nbbuild/licenses/CDDL-GPL-2-CP. See the License for the specific
 * language governing permissions and limitations under the License.
 * When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this particular file
 * as subject to the "Classpath" exception as provided by Oracle in the
 * GPL Version 2 section of the License file that accompanied this code. If
 * applicable, add the following below the License Header, with the fields
 * enclosed by brackets [] replaced by your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 * <p>
 * Contributor(s):
 * Created by alejandro tkachuk @aletkachuk
 * www.calculistik.com
 */
public class HttpRequest {

    public static enum Method {
        POST, PUT, DELETE, GET;
    }

    private URL url;
    private HttpURLConnection connection;
    private OutputStream outputStream;
    private HashMap<String, String> params = new HashMap<String, String>();

    public HttpRequest(String url) throws IOException {
        this.url = new URL(url);
        connection = (HttpURLConnection) this.url.openConnection();
    }

    public int get() throws IOException {
        return this.send();
    }

    public int post(String data) throws IOException {
        connection.setDoInput(true);
        connection.setRequestMethod(Method.POST.toString());
        connection.setDoOutput(true);
        outputStream = connection.getOutputStream();
        this.sendData(data);
        return this.send();
    }

    public int post() throws IOException {
        connection.setDoInput(true);
        connection.setRequestMethod(Method.POST.toString());
        connection.setDoOutput(true);
        outputStream = connection.getOutputStream();
        return this.send();
    }

    public int put(String data) throws IOException {
        connection.setDoInput(true);
        connection.setRequestMethod(Method.PUT.toString());
        connection.setDoOutput(true);
        outputStream = connection.getOutputStream();
        this.sendData(data);
        return this.send();
    }

    public int put() throws IOException {
        connection.setDoInput(true);
        connection.setRequestMethod(Method.PUT.toString());
        connection.setDoOutput(true);
        outputStream = connection.getOutputStream();
        return this.send();
    }

    public HttpRequest addHeader(String key, String value) {
        connection.setRequestProperty(key, value);
        return this;
    }

    public HttpRequest addParameter(String key, String value) {
        this.params.put(key, value);
        return this;
    }

    public JSONObject getJSONObjectResponse() throws JSONException, IOException {
        return new JSONObject(getStringResponse());
    }

    public JSONArray getJSONArrayResponse() throws JSONException, IOException {
        return new JSONArray(getStringResponse());
    }

    public String getStringResponse() throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream()));
        StringBuilder response = new StringBuilder();
        for (String line; (line = br.readLine()) != null; ) response.append(line + "\n");
        return response.toString();
    }

    public byte[] getBytesResponse() throws IOException {
        byte[] buffer = new byte[8192];
        InputStream is = connection.getInputStream();
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        for (int bytesRead; (bytesRead = is.read(buffer)) >= 0; )
            output.write(buffer, 0, bytesRead);
        return output.toByteArray();
    }

    public void close() {
        if (null != connection)
            connection.disconnect();
    }

    private int send() throws IOException {
        int httpStatusCode = HttpURLConnection.HTTP_BAD_REQUEST;

        if (!this.params.isEmpty()) {
            this.sendData();
        }
        httpStatusCode = connection.getResponseCode();

        return httpStatusCode;
    }

    private void sendData() throws IOException {
        StringBuilder result = new StringBuilder();
        for (Map.Entry<String, String> entry : params.entrySet()) {
            result.append((result.length() > 0 ? "&" : "") + entry.getKey() + "=" + entry.getValue());//appends: key=value (for first param) OR &key=value(second and more)
        }
        sendData(result.toString());
    }

    private HttpRequest sendData(String query) throws IOException {
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(outputStream, "UTF-8"));
        writer.write(query);
        writer.close();
        return this;
    }

}

Erro: (30, 0) Método DSL Gradle não encontrado: 'classpath ()' Causas possíveis:

  • O projeto 'cid' pode estar usando uma versão do plug-in Android Gradle que não contém o método (por exemplo, 'testCompile' foi adicionado em 1.1.0). Atualize o plugin para a versão 2.3.3 e sincronize o projeto
  • O projeto 'cid' pode estar usando uma versão do Gradle que não contém o método. Abra o arquivo wrapper Gradle
  • O arquivo de construção pode estar faltando um plugin Gradle. Aplique o plugin Gradle

  • HttpClient não é mais suportado no SDK 23. A versão 6.0 (API Nível 23) do Android remove o suporte para o cliente HTTP Apache. Você tem que usar

    android {
        useLibrary 'org.apache.http.legacy'
        .
        .
        .

    e também adicione abaixo o trecho de código em sua dependência:

    // http final solution for web-service (incluindo upload de arquivos)

    compile('org.apache.httpcomponents:httpmime:4.3.6') {
            exclude module: 'httpclient'
    }
     compile 'org.apache.httpcomponents:httpclient-android:4.3.5'

    Ele também irá ajudá-lo enquanto você usa o recurso MultipartEntity para upload de arquivos .


    O HttpClient foi descontinuado no nível 22 da API e removido no nível 23 da API. Você ainda pode usá-lo no nível 23 da API, se necessário, mas é melhor migrar para métodos suportados para lidar com HTTP. Então, se você está compilando com 23, adicione isto em seu build.gradle:

    android {
        useLibrary 'org.apache.http.legacy'
    }

    Para usar o Apache HTTP para o nível 23 do SDK:

    Nível superior build.gradle - /build.gradle

    buildscript {
        ...
        dependencies {
            classpath 'com.android.tools.build:gradle:1.5.0' 
            // Lowest version for useLibrary is 1.3.0
            // Android Studio will notify you about the latest stable version
            // See all versions: http://jcenter.bintray.com/com/android/tools/build/gradle/
        }
        ...
    }

    Notificação do estúdio Android sobre atualizações gradle:

    Módulo específico build.gradle - /app/build.gradle

    android {
        compileSdkVersion 23
        buildToolsVersion "23.0.2"
        ...
        useLibrary 'org.apache.http.legacy'
        ...
    }

    Qual alvo da API você tem em seu projeto? AndroidHttpClient é apenas para o nível 8 da API <. e por favor dê uma olhada here

    aproveite seu código :)


    Se você quiser importar alguma classe como:

    import org.apache.http.NameValuePair;
    import org.apache.http.client.HttpClient; 
    import org.apache.http.client.entity.UrlEncodedFormEntity;
    import org.apache.http.client.methods.HttpPost;
    import org.apache.http.impl.client.DefaultHttpClient;
    import org.apache.http.message.BasicNameValuePair;
    import org.apache.http.params.BasicHttpParams;
    import org.apache.http.params.HttpConnectionParams;
    import org.apache.http.params.HttpParams;

    Você pode adicionar a seguinte linha no build.gradle (dependências Gradle)

    dependencies {
        implementation fileTree(dir: 'libs', include: ['*.jar'])
        implementation 'com.android.support:appcompat-v7:27.1.0'
        implementation 'com.android.support:support-v4:27.1.0'
    
        .
        .
        .
    
        implementation 'org.jbundle.util.osgi.wrapped:org.jbundle.util.osgi.wrapped.org.apache.http.client:4.1.2'
    
    }

    Simplesmente use isso:

    android {
             .
             .
             .
     useLibrary 'org.apache.http.legacy'
             .
             .
             .
              }

    Você pode simplesmente adicionar isso às dependências do Gradle:

    compile "org.apache.httpcomponents:httpcore:4.3.2"

    Você tem que adicionar apenas uma linha

    useLibrary 'org.apache.http.legacy'

    em build.gradle (Module: app), por exemplo

    apply plugin: 'com.android.application'
    
    android {
        compileSdkVersion 24
        buildToolsVersion "25.0.0"
    
        useLibrary 'org.apache.http.legacy'
    
        defaultConfig {
            applicationId "com.avenues.lib.testotpappnew"
            minSdkVersion 15
            targetSdkVersion 24
            versionCode 1
            versionName "1.0"
            testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
        }
        buildTypes {
            release {
                minifyEnabled false
                proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
            }
        }
    }
    
    dependencies {
        compile fileTree(dir: 'libs', include: ['*.jar'])
        androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
            exclude group: 'com.android.support', module: 'support-annotations'
        })
        compile 'com.android.support:appcompat-v7:24.2.1'
        testCompile 'junit:junit:4.12'
    }

    HttpClient não é mais suportado no sdk 23. Você tem que usar URLConnection ou downgrade para o SDK 22 ( compile 'com.android.support:appcompat-v7:22.2.0' )

    Se você precisa do sdk 23, adicione isto ao seu gradle:

    android {
        useLibrary 'org.apache.http.legacy'
    }

    Você também pode tentar baixar e incluir o HttpClient jar diretamente em seu projeto ou usar o OkHttp





    apache-httpclient-4.x