Java HTTP Tutorial

  • Ein kleines Tutorial für die Apache HttpComponents mit KapiBados als Anwendungsbeispiel
    Da es hier nicht wirklich viele Tutorials für Java gibt, schreibe ich mal eines über die Kommunikation mit einem Webserver über HTTP. Zur Umsetzung verwende ich die Apache HttpComponents.

    I. Voraussetzungen:II. Vorbereitung:
    1. Startet Eclipse. Wenn ihr Eclipse zuvor noch nie gestartet habt, erscheint ein Fenster, das euch auffordert, einen workspace auszuwählen. Dort werden eure Projekte gespeichert.

    2. Erstellt ein neues Projekt über File -> New -> Java Project

    3. Gebt in dem neu erschienenem Dialog unter "Project name:" den Namen eures Projekts ein (z.B. HttpTutorial), ignoriert die anderen Sachen und klickt auf Finish.

    4. Falls ihr es noch nicht gemacht habt, ladet euch jetzt die Apache HttpComponents runter und entpackt die Datei. Macht einen Rechtsklick auf euer Projekt und wählt unter "Build Path" "Add External Archives..." aus.

      Navigiert zu dem Ordner, in den ihr die HttpComponents entpackt habt und wählt alle jar Dateien im Unterordner lib aus und drückt "Öffnen"
    Damit sind die Vorbereitungen abgeschlossen ;)


    III. Grundgerüst

    Um ein Get Request zu schicken, benötigt man folgenden Code:
    Code:
    Spoiler anzeigen

    Java-Quellcode

    1. // Erstellt einen neuen HttpClient mit dem UserAgent vom Firefox 31
    2. HttpClient client = HttpClientBuilder.create()
    3. .setUserAgent("Mozilla/5.0 (Windows NT 6.1; WOW64; rv:31.0) Gecko/20100101 Firefox/31.0")
    4. .build();
    5. // Erstellt ein GetRequest an www.website.com
    6. HttpGet request = new HttpGet("http://www.website.com");
    7. // Führt das Request aus
    8. HttpResponse response = client.execute(request);
    9. // Ließt die Antwort ein und speichert sie in Content
    10. BufferedReader rd = new BufferedReader(
    11. new InputStreamReader( response.getEntity().getContent()));
    12. String line = "";
    13. final StringBuilder sb = new StringBuilder();
    14. while((line = rd.readLine()) != null) {
    15. sb.append(line);
    16. }
    17. String Content = sb.toString();
    18. // Gibt die Verbindung für die nächste Anfrage frei
    19. request.reset();

    für ein Post Request:
    Spoiler anzeigen

    Java-Quellcode

    1. // Erstellt einen neuen HttpClient mit dem UserAgent vom Firefox 31
    2. HttpClient client = HttpClientBuilder.create()
    3. .setUserAgent("Mozilla/5.0 (Windows NT 6.1; WOW64; rv:31.0) Gecko/20100101 Firefox/31.0")
    4. .build();
    5. // Erstellt ein PostRequest an www.website.com
    6. HttpPost request = new HttpPost("http://www.website.com");
    7. // Setzt die Parameter
    8. List<NameValuePair> postParameters = new ArrayList<NameValuePair>();
    9. postParameters.add( new BasicNameValuePair("parameterName1", "parameterWert1"));
    10. postParameters.add( new BasicNameValuePair("parameterName2", "parameterWert2"));
    11. request.setEntity( new UrlEncodedFormEntity(postParameters);
    12. // Führt das Request aus
    13. HttpResponse response = client.execute(request);
    14. // Ließt die Antwort ein und speichert sie in Content
    15. BufferedReader rd = new BufferedReader(
    16. new InputStreamReader( response.getEntity().getContent()));
    17. String line = "";
    18. final StringBuilder sb = new StringBuilder();
    19. while((line = rd.readLine()) != null) {
    20. sb.append(line);
    21. }
    22. String Content = sb.toString();
    23. // Gibt die Verbindung für die nächste Anfrage frei
    24. request.reset();​


    Da es ziemlich aufwendig ist, sowas für jedes einziges Request zu machen, ist es besser, sich eine Klassse zu schreiben, die das mit 2 Methoden ( für Get und Post ) übernimmt. Also Rechtsklick auf das Projekt -> New -> Class unter "Name:" irgendwas hinschreiben ( z.B. Base), den Rest frei lassen und auf Finish klicken.


    Darein kommt in etwas folgendes (damit es übersichtlich bleibt, lasse ich in den Methoden die Kommentare weg, denke, es sollte auch so klar sein) :
    Spoiler anzeigen

    Java-Quellcode

    1. // .* wird normalerweise nicht verwendet, aber sonst wird der Code so lang ;)
    2. import java.io.*;
    3. import java.util.*;
    4. import org.apache.http.*;
    5. import org.apache.http.client.*;
    6. import org.apache.http.impl.client.*;
    7. import org.apache.http.message.*;
    8. public class Base {
    9. private HttpClient client;
    10. /*
    11. * Erstellt einen neuen HttpClient
    12. * @param UserAgent der UserAgent, der verwendet werden soll
    13. */
    14. public Base(Sring UserAgent){
    15. client = HttpClientBuilder.create().setUserAgent(UserAgent).build();
    16. }
    17. /*
    18. * Sendet ein GetRequest
    19. * @param Url die Seite, an die das Request gesendet werden soll
    20. */
    21. public String GET(String Url) throws Exception {
    22. final HttpGet request = new HttpGet(Url);
    23. final HttpResponse response = this.client.execute(request);
    24. final BufferedReader rd = new BufferedReader(new InputStreamReader(
    25. response.getEntity().getContent()));
    26. String aline = "";
    27. final StringBuilder sb = new StringBuilder();
    28. while ((aline = rd.readLine()) != null) {
    29. sb.append(aline);
    30. }
    31. request.reset();
    32. return sb.toString();
    33. }
    34. /* Sendet ein PostRequest
    35. * @param Url die Seite, an die das Request gesendet werden soll
    36. * @param Post der Text, der an die Seite gesendet werden soll
    37. */
    38. // Nimmt als 2. Parameter ein Stringarray bei dem jedes Element diesen Aufbau habe // sollte:
    39. // "Name=Wert"
    40. // Dadurch wird der Methodenaufruf erleichtert
    41. public String POST(String url, String[] post) throws Exception {
    42. final HttpPost Post = new HttpPost(url);
    43. // Erstellt aus dem Stringarray die Liste urlParameters
    44. final List<NameValuePair> urlParameters = new ArrayList<NameValuePair>();
    45. for (final String element : post) {
    46. final String[] array = element.split("=", 2);
    47. urlParameters.add(new BasicNameValuePair(array[0], array[1]));
    48. }
    49. Post.setEntity(new UrlEncodedFormEntity(urlParameters));
    50. final HttpResponse response = this.client.execute(Post);
    51. final BufferedReader rd = new BufferedReader(new InputStreamReader(
    52. response.getEntity().getContent()));
    53. final StringBuilder sb = new StringBuilder();
    54. String line = "";
    55. while ((line = rd.readLine()) != null) {
    56. sb.append(line);
    57. }
    58. Post.reset();
    59. return sb.toString();
    60. }
    61. }



    IV. Anwendungsbeispiel

    Als Beispiel verwende ich KapiBados

    a) Pakete mitschneiden:
    Ich werde das Packet Sniffen nicht ausgiebig erklären, sondern nur kurz anschneiden
    1. Fiddler herunterladen, installieren und starten
    2. Klickt auf Filters, setzt Haken bei "Use Filters" und unter Request Headers "Show only if URL contains", gebt rechts "kapibados.de" ein und wählt unter Actions "Run Filterset now". Jetzt werden nur noch Pakete von kapibados angezeigt
    3. Öffnet euren Browser und geht auf die Website von KapiBados, Fiddler sollte euch 2 Pakete von kapibados und evtl. noch Pakete von Google anzeigen.
    4. Die Pakete von Google, weil es für uns nicht von Bedeutung ist, und das 2. Paket von KapiBados, weil es für uns unwichtige CSS-Informationen beinhaltet, löschen.
    5. Geht rechts auf Inspectors und ihr seht einige verwirrende Informationen :D , ich bevorzuge deswegen die Ansicht "Raw". Ihr seht hier alles, was zum Botschreiben wichtig ist.
    b) Umsetzung:
    Sollte nicht allzu schwierig sein, einfach ne neue Klasse erstellen, ein neues Objekt von der ersten Klasse initialisieren und dann in der richtige Reihenfolge Get und Post aufrufen :D
    Hier noch ein Beispiel für den Login auf KapiBados:
    Spoiler anzeigen

    Java-Quellcode

    1. import Base;
    2. public class Main {
    3. public static void main( String[] args) {
    4. Base HttpClient = new Base("Mozilla/5.0 (Windows NT 6.1; WOW64; rv:31.0) Gecko/20100101 Firefox/31.0");
    5. try{
    6. HttpClient.GET("http://www.kapibados.de/");
    7. String[] post = { "server=2", "login=HttpTutorial",
    8. "password=tutorial", "servernumber=" };
    9. String response = HttpClient.POST("http://s2.kapibados.de/logw.php", post);
    10. String pattern = "Login fehlgeschlagen";
    11. Pattern p = Pattern.compile(pattern);
    12. Matcher m = p.matcher(response);
    13. if(!m.find()){
    14. // Login erfolgreich
    15. }
    16. } catch (Excetion e){
    17. e.printStackTrace();
    18. }
    19. }
    20. }


    Dies ist mein erstes Tutorial, ich bin für Frage, Kritik und Anregungen offen ;)

    11.538 mal gelesen

Kommentare 6

  • Benutzer-Avatarbild

    zeustates -

    cool danke :))

  • Benutzer-Avatarbild

    zeustates -

    bei meinem appache html components fehlt irgendwie die org.apache.http.message. ...hast du nochmal en download link weil auf demder bisher drin ist finde ich nur die neuste 4.3.6.....

  • Benutzer-Avatarbild

    SilverHazard -

    in deinem mitschnitt sollte der useragent, den das Spiel verwendet, drin stehen

  • Benutzer-Avatarbild

    Acanis -

    Hey, schön, dass es dazu jetzt ein Beispiel gibt ;)... Hätte ich früher gut gebrauchen können. Ich selber nutze auch HttpComponents von Apache, allerdings habe ich ein neues Buch zu Java-Bots und da werden auch URLConnections genutzt, was bisher einfacher aussieht... Hat da jemand den direkten Vergleich und mehr Ahnung? :D (Vorteile/Nachteile)

  • Benutzer-Avatarbild

    SilverHazard -

    cookies werden automatisch gespeichert :)