Http-Client

B

Bgag

Hallo!
Ich habe mal wieder ein kleines Problem. Ich habe vor längerer Zeit mal einen HttpClient in PHP geschrieben und wollte nun einen solchen Client auch in Java programmieren. Das klappte auch ganz gut, aber ich habe immernoch einige Compilier-Fehler, die ich nicht beheben kann. Kann mir dabei jemand helfen?

Des weiteren würde mich interessieren, ob es die Möglichkeit in Java gibt Parameter einer Methode vorzudeklarieren. Dies könnte dann so aussehen:

Java:
public void sayHello(String name="World") ...

Des weiteren würde mich interessieren, wie man überprüft ob ein Eintrag im Array existiert.

Java:
if( isset(array[23]) )
    System.out.println("Jibbets net.");

Des weiteren würde mich interessieren, wie ich den Inhalt einer Variablen überprüfen kann bzw. wie ich prüfen kann, ob sie überhaupt existiert.

Java:
if( isset(pfeife) && !empty(pfeife) )
    rauche(pfeife);

Wäre sehr nett, wenn mir einer bei meinen Problemen helfen könnte. Google hat mich leider an dieser Stelle nicht wirklich weiter gebracht. Und man sehe mir meine Unwissenheit nach, da ich noch ein Neuling auf dem Gebiet Java bin. Den Code der Klasse findet ihr unten.
MfG, Andy

Java:
import java.net.*;
import java.io.*;

/**
 * HttpClient Class
 *
 * This class enables the usage of
 * the Hypertext Transfere Protocol
 * via java. So you are now able to
 * load files from the world wide web
 * via java.
 *
 * @package HttpClient
 * @version 0.1
 * @author Andreas Wilhelm <andreas.wilhelm@avedo.net>
 * @website <a href='http://www.stud.informatik.uni-goettingen.de/~awilhelm' target='_blank'><u>www.stud.informatik.uni-goettingen.de/~awilhelm</u></a>
 * @copyright Andreas Wilhelm
 **/
public class HttpClient
{
	// set private class variables
	private Socket server;
	private InputStream input;
	private OutputStream output;
	private String host = "localhost";
	private int port = 80;
	private String referrer = "Java-Client";
	private String log = "Logged data...\n\n";

	/**
	 * Constructor - Is called when the class is instanced.
	 *
	 * @access public
	 * @param Str host
	 * @param int port
	 * @return NONE
	 **/
	public HttpClient(String host, int port) throws IOException
	{
		// save private class variables
		this.host = host;
		this.port = Integer.parseInt(port);

	 	// connect to the server
	 	this.server = new Socket(host, port);

		// initiate input-stream
		this.input = this.server.getInputStream();

		// initiate outout stream
		this.output = this.server.getOutputStream();
	}
	
	/**
	 * main - Is called when the programm starts.
	 *
	 * @access public
	 * @param Str host
	 * @param int port
	 * @return NONE
	 **/
	public static void main(String[] args)
	{
		try
		{
			// parse hostname
			String host = args[0];

			// parse port
			int port = Integer.parseInt(args[1]);
			
			// connect to server
			HttpClient client = new HttpClient(host, port);

			// send HTTP-Request
			client.head("/index.html", "");

			// print out log
			System.out.println( client );

			// close connection
			client.close();
		}

		catch(IOException e)
		{
			System.out.println( e.getMessage() );
		}
	}

	/**
	 * close() - Closes the connection.
	 *
	 * @access public
	 * @return NONE
	 **/
	public void close()
	{
		// close server connection
		this.server.close();

		// close streams
		this.input.close();
		this.output.close();
	}

	/**
	 * head() - Sends a HTTP-HEAD-Request to the server.
	 *
	 * @access public
	 * @param Str uri
	 * @param Str params
	 * @return NONE
	 **/
	public String head(String uri, String params)
	{
		// prepapre parameters
		if( (params != "") && (params != null) )
			params = "?" + params;
		else
			params = "";

		if( this.port != 80 )
			this.host = this.host + ":" + this.port;

		// send request to server
		write("HEAD "+uri+params+" HTTP/1.1\r\n" );
		write("Host: "+host+"\r\n");
		write("User-Agent: "+this.referrer+"\r\n");
		write("Connection: close\r\n\r\n");

		// get server response
		return read();
	}

	/**
	 * __toString() - Returns the the logging-variable.
	 *
	 * @access public
	 * @return String
	 **/
	public String __toString()
	{
		return this.log;
	}

	/**
	 * log() - Logs inputs and outputs.
	 *
	 * @access private
	 * @param str
	 * @return NONE
	 **/
	private void log(String str)
	{
		this.log += str + "\n";
	}

	/**
	 * read() - Reads input from Stream.
	 *
	 * @access private
	 * @return String
	 **/
	private String read()
	{
		// free output
		this.output.flush();

		// save input to string
		String in = this.input.read();

		// log input
		log("<<" + in + "\n");

		// print out input
		return in;
	}

	/**
	 * write() - Writes a command to the socket.
	 *
	 * @access private
	 * @param cmd
	 * @return NONE
	 **/
	private void write(String cmd)
	{
		// write into stream
		this.output.write(cmd);
	
		// log input
		log(">>" + cmd + "\n");
	}
}
 
Zuletzt bearbeitet von einem Moderator:
...ob es die Möglichkeit in Java gibt Parameter einer Methode vorzudeklarieren
Nein, die gibt es nicht. Methoden können in Java jedoch überladen werden, womit sich Default-Parameter realisieren lassen.

...wie man überprüft ob ein Eintrag im Array existiert.
Schau Dir die API-Dokumentation der Klasse Arrays an, die beinhaltet eine (bzw. mehrere) Methode(n) namens find.

...wie ich den Inhalt einer Variablen überprüfen kann bzw. wie ich prüfen kann, ob sie überhaupt existiert.
In Java musst Du Variablen vor deren Verwendung deklarieren, ansonsten meckert Dein Compiler. Wie Du den Inhalt überprüfst, hängt vom jeweiligen Objekt ab. Am besten Du postest ein konkretes Beispiel.
 
Danke für deine Hilfe. Habe die API-Dokumentation gefunden. ist schon recht hilfreich. Optionale Parameter einer Methode durch das Überladen von Methoden ist in meinem Fall mehr als daneben, da die Klasse teilweise Methoden mit bis zu 5 optionalen Parametern enthalten wird. Habe mir überlegt, dass man dies mit einem Eingabe Array lösen könnte. Die Parameter bekommen einfach eine bestimmte Reihenfolge zugeordnet. Man überprüft ob der Eintrag im Array an der Position des Parameters gesezt ist oder nicht. Je nach dem ob dies der Fall ist oder nicht, wird einfach der Wert aus dem Array oder der Standard Eintrag gesetzt. Ich habe aber leider nicht gefunden, wie ich die Länge eines Eingabearray, wie bei der main Methode, deklarieren kann. Ich weiß auch noch nicht, wie und ob ich abfragen kann, ob ein Eintrag im Array an Position 5 existiert oder nicht. Oder ist das ähnlich wie bei normalen Variabeln, dass dieser Eintrag existieren muss und ich nur seinen Inhalt vergleichen kann? Wäre nett, wenn mir da auch noch jemand helfen könnte.
MfG, Andy
 
Hallo!
Danke für deine Antwort. Diese Parameter sind unbedingt notwendig. Die Methode soll einen HTTP-HEAD-Request an einen Server senden. Dafür muss man eine URI, Parameter (optional), Cookies (optional) und Username und Passwort für den Fall, dass man eine SSL-Verbindung (optional) nutzen möchte. Die Klasse steht ja bereits oben die einzelnen Parameter sind jedoch noch nicht eingefügt.
MfG, Andy
 
Zuletzt bearbeitet von einem Moderator:
Nein, die gibt es nicht. Methoden können in Java jedoch überladen werden, womit sich Default-Parameter realisieren lassen.
Richtig, so eine syntaktisch komfortablen Vorbelegung gibt es für Parameter nicht, aber alternativ kannst Du Deinen String auf null abfragen und dann mit Deinem Default belegen.
Java:
  void lala (String x)
 {
    if (x ==null)
    {
       x = " mein Defaultwert";
    }
 }


Schau Dir die API-Dokumentation der Klasse Arrays an, die beinhaltet eine (bzw. mehrere) Methode(n) namens find.

Wenn Du den Index weißt, würde ich den Index verwenden und bei Strings kombiniert auf null bzw Länge == 0 oder equals("") abfragen

Java:
   void lala (String ixe[])
   {
       // genaugenommen sollte man hier auch das ixe fragen ob es ungleich null ist bzw wie groß es ist

        if (ixe[0]==null || ixe[0].equals(""))
        {
           //mach was
        }
       //alternativ dazu ...
       if (ixe[0]==null || ixe[0].length()==0)
       {
         // mach was
       }
   }
 
Wie gesagt, baust Du so PHP-Syntax in Java nach. Klar, es funktioniert - aber hübsch ist es nicht. In Java würde es wohl schöner gelöst werden, indem nicht alle Parameter in eine Methode reingepackt werden, sondern weiter in Klassen zerlegt wird - z.B. in eine Head-Klasse. Notwendige Parameter kommen in den Konstruktor, optionale Parameter wie Username und Passwort könnten bei Bedarf über set-Methoden angegeben werden.

Zum Beispiel:
Code:
Head head = new Head("http://www.tutorials.de/");
// head.setAuthentication(...)
head.execute();

(Womit wir dann fast schon bei der HttpClient-Library aus den Jakarta Commons wären ;))
 
Zurück