# Einfaches Client-Server Programm (verbindungslos)



## Guest (25. Mai 2007)

In folgendem Programm soll ein Client über einen Socket ein Datagramm, sprich eine anfrage an den Server schicken und als Antort ein Zitat, also einen String bekommen.

Da ich mich grade erst in Netzwerkprogrammierung mit Java einarbeite hatte ich versucht dem Tutorial "QuoteServerThread" unter java.sun...probiert aber komme irgendwie nicht mehr weiter.

Ist auch das erste mal dass ich 2 Klassen, sprich erst den Server, dann natürlich erst den anfragenden Client "anschalte"....wäre ja nicht das Problem, nur dass er mir mit Eclipse(die Programmierumgebung die ich nutze) nun komischerweise, nur eine der beiden main()-Methoden, die vom Server zum starten angeboten wird... 

Hier die 3 Klassen...und der Text-File mit den "Zitaten"(Strings) die ausgegeben werden sollen:


```
import java.io.*;

public class QuoteServer 
{
    public static void main(String[] args) throws IOException 
    {
        new QuoteServerThread().start();
    }
}

#############################################

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Date;

public class QuoteServerThread extends Thread
{
	private DatagramSocket socket;
	private BufferedReader in;

	public QuoteServerThread() throws IOException
	{
		this.setName("QuoteServer");
	    //this("QuoteServer");
	}
	
	public QuoteServerThread(String name) throws IOException 
	{
	    super(name);
	    socket=new DatagramSocket(4445);

	    try 
	    {
	        in=new BufferedReader(new FileReader("one-liners.txt"));
	    } 
	    
	    catch (FileNotFoundException e)
	    {
	        System.err.println("Datei konnte nicht geöffnet werden"+"Zeit:");
	    }
	}  
	
	public void run()
	{
		while (true)
		//while (moreQuotes==true)
		{
			byte[] buf=new byte[256];
			DatagramPacket packet=new DatagramPacket(buf, buf.length);
		
			try 
			{
				socket.receive(packet);
			} 
		
			catch (IOException e) 
			{
				e.printStackTrace();
			}
			/**
			 * Jetzt wird die Antwort konstruiert:
			 */
			String dString=null;
			if (in==null)
			{
				dString=new Date().toString();
			}
		
			else
			{
				//dString=getNextQuote();
				buf=dString.getBytes();
			}
			/**
			 * Jetzt wird die konstruierte Antwort über 
			 * den DatagramSocket an den Client geschickt:
			 */
			InetAddress address=packet.getAddress();
			int port=packet.getPort();
			packet=new DatagramPacket(buf, buf.length, address, port);
			try 
			{
				socket.send(packet);
			} 
			catch (IOException e) 
			{
				e.printStackTrace();
				System.out.println("socket.send ist fehlgeschlagen!");
			}
			socket.close();
		}
	}
}
###########################################################

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

public class QuoteClient
{
	public static void main (String[] args,int port,InetAddress address,DatagramSocket socket,
							 DatagramPacket packet,byte[] sendBuf)
	{
		if (args.length!=1) 
		{
		     System.out.println("Für: Client<hostname>");
		     return;
		}
		/**
		 * Hier sendet die QuoteClient-Anwendung 
		 * eine Anfrage an den Server:
		 */
		byte[] buf=new byte[256];
		
		try 
		{
			DatagramSocket ds=new DatagramSocket();
			InetAddress ia=InetAddress.getByName(args[0]);
			DatagramPacket dp=new DatagramPacket(buf,buf.length,ia,4445);
			ds.send(dp);
		} 
		catch (SocketException e) 
		{
			e.printStackTrace();
			System.out.println("socket.send hat versagt!");
		}
		catch (UnknownHostException e) 
		{
			e.printStackTrace();
			System.out.println("Internet-Addresse???");
		}
		catch (IOException e) 
		{
			e.printStackTrace();
		}
		/**
		 * Nachdem der Client eine Nachricht vom 
		 * Server erhalten hat zeigt er diese an:
		 */
		packet=new DatagramPacket(buf,buf.length);
		try 
		{
			socket.receive(packet);
		} 
		catch (IOException e) 
		{
			e.printStackTrace();
		}
		String received=new String(packet.getData(),0,packet.getLength());
		System.out.println("Zitat des Moments:"+received);
	}
}

##################---one-liners.txt---#####################################

Life is wonderful. Without it we'd all be dead.
Daddy, why doesn't this magnet pick up this floppy disk?
Give me ambiguity or give me something else.
I.R.S.: We've got what it takes to take what you've got!
We are born naked, wet and hungry. Then things get worse.
Make it idiot proof and someone will make a better idiot.
He who laughs last thinks slowest!
```


----------



## Ullenboom (27. Mai 2007)

Guten Morgen Gast,

die JVM -- und somit auch Eclipse -- sucht ausschließlich nach einer Funktion mit der Signatur

public static void main( String[] args )

(oder etwas moderner: String... args))

Und bei dir sieht das etwas komplizierter aus.

Grüße

 Christian


----------



## Guest (27. Mai 2007)

Habe mich darüber auch schon etwas gewundert, da ich noch nie so viele Argumente  als Parameter in der main()-Methode hatte...aber bin halt einfach nur dem Tutorial gefolgt...scheine da wohl was falsch verstanden zu haben...aber das war ja auch auf Englisch... :cry: 

Habe das ganze jetzt nochmal umgeändert...der Server scheint nun zu funktionieren...alllerdings gibt mir der Client nur seine IP (stimmt mit der unter "ipconfig" im DOS-Modus überein) und meinen Hostnamen an... 

Starte hierbei einfach aus Eclipse raus zuerst den Server und dann den Client...

Warum der Client mir kein Zitat anzeigt, was er vom Server holen soll weiß ich leider immer noch nicht... 


```
import java.io.*;
import java.net.*;

public class QuoteClient
{
	public static void main(String[] args) throws IOException
	{
		//IP Addresse holen:
		InetAddress addr=InetAddress.getLocalHost();
        String hostAddress=addr.getHostAddress();
        System.out.println("Host-Addresse: "+hostAddress);
        
        //Hostname holen:
        String hostname=addr.getHostName();
        
		if(args.length!=1)
		{
			System.out.println("Für Client: "+hostname);
			return;
		}

		//Ein Datagramsocket erstellen:
		DatagramSocket socket=new DatagramSocket();

		//Senden der Anfrage:
		byte[] buf=new byte[256];
		InetAddress address=InetAddress.getByName(hostAddress);
		
		DatagramPacket packet=new DatagramPacket(buf,buf.length,address,4445);
		socket.send(packet);

		//Erhalten der Antwort:
		packet=new DatagramPacket(buf, buf.length);
		socket.receive(packet);

		//Anzeigen der Antwort:
		String antwortZitat=new String(packet.getData(), 0, packet.getLength());
		System.out.println("Zitat: "+antwortZitat);

		socket.close();
	}
}
#######################################################
import java.io.*;
import java.net.*;
import java.util.*;
/**
 * Der QuoteSever soll einem Client auf Anfrage ein Zitat aus 
 * einer Liste senden und bei einer Exception nur das Date:
 */
public class QuoteServerThread extends Thread
{
	DatagramSocket socket=null;
	BufferedReader zitate=null;
	boolean mehrZitate=true;

	/**
	 * Wird ein leerer Konstruktor aufgerufen, wird 
	 * dem Thread automatisch ein Name zugewiesen:
	 */
	public QuoteServerThread() throws IOException
	{
		this("QuoteServerThread");
	}

	public QuoteServerThread(String name) throws IOException
	{
		super(name);//Der Superklasse(dem Thread) wird ein Name gegeben.
		
		//Der QuoteServerThread stellt einen Sockel auf Port 4445 bereit:
		socket=new DatagramSocket(4445); 

		
		//Öffnen der Zitatedatei:
		try
		{
			zitate=new BufferedReader(new FileReader("one-liners.txt"));
		} 
		catch(FileNotFoundException e)
		{
			System.err.println("Fehler beim öffnen der Zitatdatei! Zeit:");
		}
	}

	public void run()
	{
		while(mehrZitate)
		{
			try
			{
				byte[] buf=new byte[256];//Leeres Array für die zu empfangenden Daten.

				/**
				 * Empfangen der Anfrage:
				 * (Erstellen eines leeren Packets das dann mit den 
				 *  empfangenen Daten gefüllt werden kann:)
				 */
				DatagramPacket packet=new DatagramPacket(buf, buf.length);
				socket.receive(packet);

				//Erstellen der Antwort:
				String anwortZitat=null;
				if(zitate==null)
				{
					//Läuft was schief, wird nur das Date als Antwort gesendet:
					anwortZitat=new Date().toString();
				}
					//Andernfalls ein Zitat geholt:
					else
					{
						anwortZitat=getZitat();
						buf=anwortZitat.getBytes();
					}
				/**
				 * Senden der Antwort zum Client mit der 
				 * IP-Addresse "address" und dem Port "port":
				 */
				InetAddress zielIP=packet.getAddress();
				int zielPort=packet.getPort();
				packet=new DatagramPacket(buf, buf.length, zielIP, zielPort);
				socket.send(packet);
				} 
			catch(IOException e)
			{
				e.printStackTrace();
				mehrZitate=false;
			}
		}
		socket.close();
	}
	
	public String getZitat()
	{
		String zitat=null;
		try
		{
			if((zitat=zitate.readLine())==null)
			{
				zitate.close();
				mehrZitate=false;
				zitat="Keine Zitate mehr! Auf Wiedersehen!";
			}
		} 
		catch(IOException e)
		{
			zitat="IOException beim Server aufgetreten!";
		}
		return zitat;
	}
}
#############################################################
import java.io.*;

public class QuoteServer
{
	public static void main(String[] args) throws IOException
	{
		new QuoteServerThread().start();
	}
}
```

Der .txt-File mit den Zitaten bleibt der selbe...


----------

