Wie Parameter zu allen HttpClient Request-Methoden hinzufügen?

Question

Ich schreibe Java-Code, der Apache HttpClient Version 4.2.2 verwendet, um eine RESTful 3rd Party API zu treffen. Diese API verfügt über Methoden, die HTTP GET, POST, PUT und DELETE verwenden. Es ist wichtig zu beachten, dass ich eine 4.x.x-Version und nicht 3.x.x verwende, da sich die API sehr von 3 auf 4 geändert hat. Alle relevanten Beispiele, die ich gefunden habe, waren für eine 3.x.x-Version.

Für alle API-Aufrufe müssen Sie den api_key als Parameter angeben (unabhängig davon, welche Methode Sie verwenden). Dies bedeutet, dass unabhängig davon, ob ich einen GET, POST oder anderweitig mache, ich diese api_key angeben muss, damit der Aufruf serverseitig authentifiziert wird.

// Have to figure out a way to get this into my HttpClient call, 
// regardless of whether I'm using: HttpGet, HttpPost, HttpPut 
// or HttpDelete... 
String api_key = "blah-whatever-my-unique-api-key"; 

So versuche ich herauszufinden, wie HttpClient mit dem api_key unabhängig von meiner Anfrage Verfahren zu schaffen (die wiederum hängt von der RESTful API Methode, die ich getroffen bin versucht). Es sieht aus wie HttpGet nicht einmal Unterstützung der Begriff der Parameter, und HttpPost verwendet etwas namens HttpParams; aber auch diese HttpParams scheinen nur in der 3.x.x-Version von HttpClient zu existieren.

Also frage ich:

• HttpGet
• HttpPost
• HttpPut
• HttpDelete
: Was die richtige ist, v4.2.2 Art und Weise mein api_key String an alle vier zu befestigen/hinzufügen

Vielen Dank im Voraus.

Answer 1

Sie können UriBuilder-Klasse die Anforderungs-URI für alle HTTP-Methoden zu bauen. URI-Builder bietet setParameter Methode zum Festlegen des Parameters.

URIBuilder builder = new URIBuilder(); 
builder.setScheme("http").setHost("www.google.com").setPath("/search") 
    .setParameter("q", "httpclient") 
    .setParameter("btnG", "Google Search") 
    .setParameter("aq", "f") 
    .setParameter("oq", ""); 
URI uri = builder.build(); 
HttpGet httpget = new HttpGet(uri); 
System.out.println(httpget.getURI()); 

sollte die Ausgabe

sein hier

http://www.google.com/search?q=httpclient&btnG=Google+Search&aq=f&oq= 

Answer 2

Eine wichtige Sache explictly der Apache-Pakete zu sagen ist, dass Sie verwenden müssen, weil es verschiedene Möglichkeiten gibt, eine GET-Anforderung zu implementieren.

Zum Beispiel könnten Sie Apache Commons oder HttpComponents verwenden. In diesem Beispiel werde ich HttpComponents (org.apache.http.*)

Anfrage-Klasse verwenden:

package request; 

import java.io.IOException; 
import java.net.URI; 
import java.net.URISyntaxException; 

import org.apache.http.client.methods.CloseableHttpResponse; 
import org.apache.http.client.methods.HttpGet; 
import org.apache.http.client.utils.URIBuilder; 
import org.apache.http.impl.client.CloseableHttpClient; 
import org.apache.http.impl.client.HttpClients; 

import Task; 

public void sendRequest(Task task) throws URISyntaxException { 

    URIBuilder uriBuilder = new URIBuilder(); 
    uriBuilder.setScheme("http") 
      .setHost("localhost") 
      .setPort(8080) 
      .setPath("/TesteHttpRequest/TesteDoLucas") 
      .addParameter("className", task.getClassName()) 
      .addParameter("dateExecutionBegin", task.getDateExecutionBegin()) 
      .addParameter("dateExecutionEnd", task.getDateExecutionEnd()) 
      .addParameter("lastDateExecution", task.getDateLastExecution()) 
      .addParameter("numberExecutions", Integer.toString(task.getNumberExecutions())) 
      .addParameter("idTask", Integer.toString(task.getIdTask())) 
      .addParameter("numberExecutions" , Integer.toString(task.getNumberExecutions())); 
    URI uri = uriBuilder.build(); 

    HttpGet getMethod = new HttpGet(uri); 

    CloseableHttpClient httpclient = HttpClients.createDefault(); 

    CloseableHttpResponse response = null; 

    try { 
     response = httpclient.execute(getMethod); 
    } catch (IOException e) { 
     //handle this IOException properly in the future 
    } catch (Exception e) { 
     //handle this IOException properly in the future 
    } 
} 

Ich bin mit Tomcat v7.0 Server, dann über die Klasse erhält eine neue Aufgabe und sendet sie an einen bestimmten Servlet in die Verbindung http://localhost:8080/TesteHttpRequest/TesteDoLucas.

Mein Dynamic Web-Projekt namens TesteHttpRequest und mein Servlet nimmt an von der URL /TesteDoLucas

Task-Klasse:

package bean; 

public class Task { 

    private int idTask; 
    private String taskDescription; 
    private String dateExecutionBegin; 
    private String dateExecutionEnd; 
    private String dateLastExecution; 
    private int numberExecutions; 
    private String className; 

    public int getIdTask() { 
     return idTask; 
    } 

    public void setIdTask(int idTask) { 
     this.idTask = idTask; 
    } 

    public String getTaskDescription() { 
     return taskDescription; 
    } 

    public void setTaskDescription(String taskDescription) { 
     this.taskDescription = taskDescription; 
    } 

    public String getDateExecutionBegin() { 
     return dateExecutionBegin; 
    } 

    public void setDateExecutionBegin(String dateExecutionBegin) { 
     this.dateExecutionBegin = dateExecutionBegin; 
    } 

    public String getDateExecutionEnd() { 
     return dateExecutionEnd; 
    } 

    public void setDateExecutionEnd(String dateExecutionEnd) { 
     this.dateExecutionEnd = dateExecutionEnd; 
    } 

    public String getDateLastExecution() { 
     return dateLastExecution; 
    } 

    public void setDateLastExecution(String dateLastExecution) { 
     this.dateLastExecution = dateLastExecution; 
    } 

    public int getNumberExecutions() { 
     return numberExecutions; 
    } 

    public void setNumberExecutions(int numberExecutions) { 
     this.numberExecutions = numberExecutions; 
    } 

    public String getClassName() { 
     return className; 
    } 

    public void setClassName(String className) { 
     this.className = className; 
    } 
} 

Servletklasse:

package servlet; 

import java.io.IOException; 
import javax.servlet.ServletException; 
import javax.servlet.annotation.WebServlet; 
import javax.servlet.http.HttpServlet; 
import javax.servlet.http.HttpServletRequest; 
import javax.servlet.http.HttpServletResponse; 

@WebServlet("/TesteDoLucas") 
public class TesteHttpRequestServlet extends HttpServlet { 
    private static final long serialVersionUID = 1L; 

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { 
     String query = request.getQueryString(); 
     System.out.println(query); 
    } 

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { 
     doGet(request, response); 
     } 
    } 

Die gesendeten Abfrageparameter werden an der Konsole angezeigt.

classname = java.util.Objects% 3B & dateExecutionBegin = 2016% 2F04 2F07% + 22% 3A22 3A22% & dateExecutionEnd = 2016% 2F04 2F07% + 06% 3A06 3A06% & lastDateExecution = 2016% 2F04% 2F07 + 11% 3A11% 3A11 & numberExecutions = 10 & idTask = 1 & numberExecutions = 10

die Codierung zu beheben, können Sie sich hier: HttpServletRequest UTF-8 Encoding

Answer 3

Sie können diesen Ansatz auch im Fall verwenden yo u wollen einige http Parameter zu übergeben und eine json Anfrage senden:

(Anmerkung: Ich habe in einigen zusätzlichen Code hinzugefügt nur sofern es keine anderen zukünftigen Leser hilft und Importe sind von org.apache.http Client-Bibliotheken)

public void postJsonWithHttpParams() throws URISyntaxException, UnsupportedEncodingException, IOException { 

    //add the http parameters you wish to pass 
    List<NameValuePair> postParameters = new ArrayList<>(); 
    postParameters.add(new BasicNameValuePair("param1", "param1_value")); 
    postParameters.add(new BasicNameValuePair("param2", "param2_value")); 

    //Build the server URI together with the parameters you wish to pass 
    URIBuilder uriBuilder = new URIBuilder("http://google.ug"); 
    uriBuilder.addParameters(postParameters); 

    HttpPost postRequest = new HttpPost(uriBuilder.build()); 
    postRequest.setHeader("Content-Type", "application/json"); 

    //this is your JSON string you are sending as a request 
    String yourJsonString = "{\"str1\":\"a value\",\"str2\":\"another value\"} "; 

    //pass the json string request in the entity 
    HttpEntity entity = new ByteArrayEntity(yourJsonString.getBytes("UTF-8")); 
    postRequest.setEntity(entity); 

    //create a socketfactory in order to use an http connection manager 
    PlainConnectionSocketFactory plainSocketFactory = PlainConnectionSocketFactory.getSocketFactory(); 
    Registry<ConnectionSocketFactory> connSocketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create() 
      .register("http", plainSocketFactory) 
      .build(); 

    PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(connSocketFactoryRegistry); 

    connManager.setMaxTotal(20); 
    connManager.setDefaultMaxPerRoute(20); 

    RequestConfig defaultRequestConfig = RequestConfig.custom() 
      .setSocketTimeout(HttpClientPool.connTimeout) 
      .setConnectTimeout(HttpClientPool.connTimeout) 
      .setConnectionRequestTimeout(HttpClientPool.readTimeout) 
      .build(); 

    // Build the http client. 
    CloseableHttpClient httpclient = HttpClients.custom() 
      .setConnectionManager(connManager) 
      .setDefaultRequestConfig(defaultRequestConfig) 
      .build(); 

    CloseableHttpResponse response = httpclient.execute(postRequest); 

    //Read the response 
    String responseString = ""; 

    int statusCode = response.getStatusLine().getStatusCode(); 
    String message = response.getStatusLine().getReasonPhrase(); 

    HttpEntity responseHttpEntity = response.getEntity(); 

    InputStream content = responseHttpEntity.getContent(); 

    BufferedReader buffer = new BufferedReader(new InputStreamReader(content)); 
    String line; 

    while ((line = buffer.readLine()) != null) { 
     responseString += line; 
    } 

    //release all resources held by the responseHttpEntity 
    EntityUtils.consume(responseHttpEntity); 

    //close the stream 
    response.close(); 

    // Close the connection manager. 
    connManager.close(); 
}