Angewandte Netzwerktechnik kompakt

Material zum Buch

Lösungsvorschläge zu Übungsaufgaben

Das ZIP-Archiv beinhaltet Lösungsvorschläge zu den Übungsaufgaben im Buch in Form von Java-Quellcodes und Wireshark-Aufzeichnungen.

Im Folgenden finden Sie zudem eine Vorschau, der enthalteten Quellcodes:

Kapitel 2 Kapitel 3 Kapitel 5 Kapitel 7 Kapitel 8 Kapitel 9




















Vorschau der Java-Klassen in den Lösungsvorschlägen

Loes_Aufg_2_1.java

 // Ermittlung des Mittelwertes ueber alle Noten aller Studenten
	double mittelwert (Student[] studenten) {
			
		double summe=0;
		int count=0;
		
		for(int i=0; i < studenten.length; i++) { // Schleife ueber die Anzahl der eingetragenen Studenten
			if(studenten[i].leistungen != null) { // falls mindestens eine Pruefungsleistung eingetragen, dann...
				for (int j=0; j < studenten[i].leistungen.length; j++) {
                // ...Schleife ueber die Anzahl der eingetragenen Pruefungsleistungen des jeweiligen Studenten
						summe=summe+studenten[i].leistungen[j].note; // Noten aufsummieren
						count++; // count = Anzahl der aufsummierten Noten
						}
				}
			}
			
		if (count > 0)				// Wenn mindestens eine Note, dann...
			return (summe/count);	// ...Rueckgabe des arithm. Mittelwertes
		else return 0;				// ansonsten wird 0 zurueckgegeben
	}

Loes_Aufg_2_2.java

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class Loes_Aufg_2_2 {

	public static void main(String[] args) throws IOException {

		String dateiname = "UTF-8-demo.txt";
		File f = new File( dateiname );
		InputStream in;
		in = new FileInputStream( f );
		int by;

		while( (by=in.read()) != -1 )   // naechstes einzelne Byte lesen
		{
			System.out.println(by + " = " + (char)by);  // als Code und ASCII-Zeichen (der Wert von by ist hier ein 8-Bit-Wert)
		}

		in.close();
	}
}

Loes_Aufg_2_3a.java

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class Loes_Aufg_2_3a {

	public static void main(String[] args) throws IOException {

		FileInputStream fis = null;
		InputStreamReader isr = null;
		try {
			fis = new FileInputStream("UTF8-demo.txt");
			isr = new InputStreamReader(fis, "UTF8");
			int ch;
            while ((ch = isr.read()) != -1) {   // einzelnes Zeichen lesen
				System.out.print((char)ch);
			}
		} finally {
			if (fis != null) {
				fis.close();
			}
			if (isr != null) {
				isr.close();
			}
		}
	}
}

Loes_Aufg_2_3b.java

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class Loes_Aufg_2_3b {

	public static void main(String[] args) throws IOException {
		
		FileInputStream fis = null;
		InputStreamReader isr = null;
		BufferedReader bufRed = null;
		try {
			fis = new FileInputStream("UTF8-demo.txt");
			isr = new InputStreamReader(fis, "UTF8");
			bufRed = new BufferedReader(isr);
			String line;
			while ((line = bufRed.readLine()) != null) {   //naechste Zeile lesen
				System.out.println(line);
			}
		} finally {
			if (fis != null) {
				fis.close();
			}
			if (isr != null) {
				isr.close();
			}
			if (bufRed != null) {
				bufRed.close();
			}
		}	
	}
}

Loes_Aufg_2_4.java

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class Loes_Aufg_2_4 {

	String dateiName;
	
	Loes_Aufg_2_4(String dateiName)
	{
		this.dateiName = dateiName;
	}
	
	public Student[] leseDatei() throws IOException {
		Student[] geleseneStudenten;

		FileInputStream fis = new FileInputStream(dateiName);
		DataInputStream dis = new DataInputStream(fis);

		int studCnt = dis.readInt();	// Lesen der Zahl der Datensaetze (1. Zeile in der Datei)
		// Falls Datensaetze in Datei vorhanden, diese auslesen und in Feld ablegen
		if(studCnt != 0)			
		{
			geleseneStudenten = new Student[studCnt];
			for(int i=0; i < studCnt; i++) {
				geleseneStudenten[i] = new Student();
				geleseneStudenten[i].matrikelNummer = dis.readInt();
				geleseneStudenten[i].name = dis.readUTF();
				int leistCnt = dis.readInt();
				// Falls auch Pruefungsleistungen hinterlegt sind, diese ebenso auslesen und ablegen
				if(leistCnt != 0) {
					geleseneStudenten[i].leistungen = new Leistung[leistCnt];
					for(int j=0; j < leistCnt; j++) {
						geleseneStudenten[i].leistungen[j] = new Leistung();
						geleseneStudenten[i].leistungen[j].modul = dis.readUTF();
						geleseneStudenten[i].leistungen[j].note = dis.readDouble();
					}
				}
				else
					geleseneStudenten[i].leistungen = null;	
			}
		}
		else
			geleseneStudenten = null;

		dis.close();	// Schliessen der Streams
		fis.close();
		return geleseneStudenten;	// Rueckgabe des Feldes mit den Studentendaten
	}
}

Loes_Aufg_2_5.java

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class Loes_Aufg_2_5 {
    
	public void schreibeDemodaten(String dateiName, Student[] studenten) throws IOException {
		FileOutputStream fos = new FileOutputStream(dateiName);
		OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF8");	
		
		String toWrite;
		
		if(studenten != null) {
			// zu schreibenden Text aus einzelnen Elementen zusammensetzen
			toWrite = String.format("%d",studenten.length );
			// Elemente mit ; und Leerzeichen trennen
			toWrite += "; ";
			// Text als Zeile schreiben
			toWrite += "\n";
			osw.write(toWrite);
	
			for(int i=0; i < studenten.length; i++) {
				// neuen Text beginnen
				toWrite = String.format("%d; %s; ",
						studenten[i].matrikelNummer,
						studenten[i].name);
				if(studenten[i].leistungen != null) {
					// Text ergaenzen
					toWrite += String.format("%d; ",studenten[i].leistungen.length);

					for(int j=0; j < studenten[i].leistungen.length; j++) {
						toWrite += String.format("%s; %3.1f; ",
								studenten[i].leistungen[j].modul,
								studenten[i].leistungen[j].note);
					}
				}
				else
					toWrite += "0; ";
				// Text / Datensatz eines Studenten als Zeile ausgeben
				toWrite += "\n";
				osw.write(toWrite);
			}
		}
		else
		{
			toWrite = "0; \n";
			osw.write(toWrite);
		}
		osw.close();
		fos.close();
	}
}

Loes_Aufg_3_1.java

class Person {
	String name;
	int alter;
	Kind [] kinder;				
}

class Kind {
	String name;
	int alter;
}

Loes_Aufg_5_1.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

import org.apache.http.HttpEntity;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

public class Loes_Aufg_5_1 {

	public static void main(String[] args) throws ClientProtocolException, IOException {
				
		CloseableHttpClient httpClient = HttpClients.createDefault();
		
		HttpGet httpGet = new HttpGet ("http://angewnwt.hof-university.de/example-1.php");
		CloseableHttpResponse response = httpClient.execute(httpGet);
		System.out.println(response.getStatusLine());
		HttpEntity entity = response.getEntity();
		InputStream netzwerkStream = entity.getContent();
		InputStreamReader netzwerkStreamReader = new InputStreamReader (netzwerkStream);
		
		BufferedReader bufNeRd = new BufferedReader (netzwerkStreamReader);
		
		String geleseneZeile;
		String such = "/article";	// gesuchter String
		while ((geleseneZeile = bufNeRd.readLine()) != null)
		{
			System.out.println(geleseneZeile); // empfangenen Text zeilenweise ausgeben
			int index = geleseneZeile.indexOf(such,0); // Zufallszahl befindet sich vor dem Tag < /article >
			
			if (index > -1)	// gesuchter String gefunden
				System.out.println("Die extrahierte Zufallszahl lautet: "+ geleseneZeile.substring(0, index-1));
                //index-1 schliesst die oeffnende spitze Klammer vor dem gesuchten Tag aus
		}
		
		EntityUtils.consume(entity);
		response.close();
	}
}

Loes_Aufg_5_2a.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URISyntaxException;

import org.apache.http.HttpEntity;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

public class Loes_Aufg_5_2a {

	public static void main(String[] args) throws ClientProtocolException, IOException, URISyntaxException {

				String URLstr = "http://angewnwt.hof-university.de/example-4.php";
		
				CloseableHttpClient httpclient = HttpClients.createDefault();
				
				HttpGet httpGet = new HttpGet(URLstr);
				CloseableHttpResponse response = httpclient.execute(httpGet);
				System.out.println(response.getStatusLine()); // --> HTTP/1.1 200 OK
				
				response = httpclient.execute(httpGet);
				HttpEntity entity = response.getEntity();
				InputStream httpStream  = entity.getContent();
				InputStreamReader httpStreamReader = new InputStreamReader(httpStream);
				BufferedReader httpBufferedReader = new BufferedReader(httpStreamReader);
						
				// empfangenen Text zeilenweise ausgeben
				String httpLine;
				while((httpLine = httpBufferedReader.readLine()) != null) {
					System.out.println(httpLine);
				}
				
				// Schliessen der Verbindung
				EntityUtils.consume(entity);
				response.close();
				httpBufferedReader.close();	
	}
}

Loes_Aufg_5_2b.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;

import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
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 org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

public class Loes_Aufg_5_2b {

	public static void main(String[] args) throws ClientProtocolException, IOException, URISyntaxException {

				String URLstr = "http://angewnwt.hof-university.de/example-4.php";
		
				CloseableHttpClient httpclient = HttpClients.createDefault();
				
				// URIBuilder
				URIBuilder uri = new URIBuilder(URLstr);
				List  nvps = new ArrayList ();
			    nvps.add(new BasicNameValuePair("username", "Hans"));
			    nvps.add(new BasicNameValuePair("password", "Wurscht"));
			    uri.addParameters(nvps);
			    
				HttpGet httpGet = new HttpGet(uri.build());
				
				CloseableHttpResponse response = httpclient.execute(httpGet);
				HttpEntity entity = response.getEntity();
				InputStream httpStream  = entity.getContent();
				InputStreamReader httpStreamReader = new InputStreamReader(httpStream);
				BufferedReader httpBufferedReader = new BufferedReader(httpStreamReader);
						
				System.out.println(response.getStatusLine()); // --> HTTP/1.1 200 OK				
				
				// empfangenen Text zeilenweise ausgeben
				String httpLine;
				while((httpLine = httpBufferedReader.readLine()) != null) {
					System.out.println(httpLine);
				}
				
				// Schliessen der Verbindung
				EntityUtils.consume(entity);
				response.close();
				httpBufferedReader.close();	
	}
}

Loes_Aufg_5_3.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

public class Loes_Aufg_5_3 {

	public static void main(String[] args) throws ClientProtocolException, IOException {

				// URL, der die Authentifizierungsdaten uebergeben werden muessen
				String URLstr = "http://angewnwt.hof-university.de/login.php";
				
				// Mit POST nur Authentifizieren OHNE Abrufen der Webseite
		
				CloseableHttpClient httpclient = HttpClients.createDefault();
				CloseableHttpResponse response;
				 
				HttpPost httpPost = new HttpPost(URLstr);
				List  nvps = new ArrayList ();
			    nvps.add(new BasicNameValuePair("username", "Hans"));
			    nvps.add(new BasicNameValuePair("password", "Wurscht"));
			    nvps.add(new BasicNameValuePair("submit", "anmelden"));
			    httpPost.setEntity(new UrlEncodedFormEntity(nvps));
			    response = httpclient.execute(httpPost);
			    System.out.println(response.getStatusLine()); // --> HTTP/1.1 200 OK
			    
			    // Mit GET jetzt Webseite abrufen (nun keine Authentifizierung mehr noetig, da vorher schon geschehen)
						
				HttpGet httpGet = new HttpGet(URLstr);
				response = httpclient.execute(httpGet);
				System.out.println(response.getStatusLine()); // --> HTTP/1.1 200 OK
				HttpEntity entity = response.getEntity();
				InputStream httpStream  = entity.getContent();
				InputStreamReader httpStreamReader = new InputStreamReader(httpStream);
			    BufferedReader httpBufferedReader = new BufferedReader(httpStreamReader);
						
				// empfangenen Text zeilenweise ausgeben
			    String httpLine;
				while((httpLine = httpBufferedReader.readLine()) != null) {
					System.out.println(httpLine);
				}
			    
				// Schliessen der Verbindung
				EntityUtils.consume(entity);
				response.close();
				httpBufferedReader.close();    
	}
}

Loes_Aufg_7_1Client.java

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

public class Loes_Aufg_7_1Client {

	Socket linkZumServer;
	DataInputStream inFromServer;
	DataOutputStream outToServer;

	public Loes_Aufg_7_1Client(InetAddress address, int port) throws IOException {

		linkZumServer = new Socket(address,port); // mit Server verbinden
		System.out.println("Verbindung hergestellt");

		inFromServer = new DataInputStream(linkZumServer.getInputStream());

		outToServer = new DataOutputStream(linkZumServer.getOutputStream());
	}

	public void tuWas() throws IOException {

		InputStreamReader tastatur = new InputStreamReader(System.in);
		BufferedReader bufferedtastatur = new BufferedReader(tastatur);
		System.out.print("Zeichenkette eingeben: ");

		String eingabe = bufferedtastatur.readLine();

		outToServer.writeUTF(eingabe); // neuer String an Server

		String ausgabe = inFromServer.readUTF(); //String vom Server empfangen

		System.out.println("Zeichenkette empfangen: " + ausgabe);
	}

	public void disconnect() throws IOException {

		inFromServer.close();
		outToServer.close();
		linkZumServer.close();
	}

	public static void main(String[] args) throws UnknownHostException, IOException {

		Loes_Aufg_7_1Client meinClient = new Loes_Aufg_7_1Client(InetAddress.getByName("127.0.0.1"),4711);

		meinClient.tuWas();
		meinClient.disconnect();
	}
}

Loes_Aufg_7_1Server.java

import java.io.IOException;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Loes_Aufg_7_1Server {

	ServerSocket serverSocket;
	Socket linkZumClient;
	DataInputStream inFromClient;
	DataOutputStream outToClient;

	public Loes_Aufg_7_1Server( int port) throws IOException
	{
		serverSocket = new ServerSocket(port); // Socket erzeugen

		System.out.println("Server gestartet.");
		linkZumClient = serverSocket.accept(); // warten bis sich Client verbindet

		System.out.println("Verbindung hergestellt mit "+ serverSocket.getInetAddress());

		inFromClient = new DataInputStream(linkZumClient.getInputStream());

		outToClient = new DataOutputStream(linkZumClient.getOutputStream());
	}

	public void tuWas() throws IOException {

		String zeichenketteklein = null;
		String zeichenkettegross = null;

		zeichenketteklein = inFromClient.readUTF() ; //String vom Client empfangen

		System.out.print("Server Empfangen: "+ zeichenketteklein);

		zeichenkettegross = zeichenketteklein.toUpperCase();

		outToClient.writeUTF(zeichenkettegross);
		System.out.println(" gesendet: "+ zeichenkettegross);
	}

	public void disconnect() throws IOException {
		inFromClient.close();
		outToClient.close();
		linkZumClient.close();
		serverSocket.close();
	}

	public static void main(String[] args) throws IOException {

		Loes_Aufg_7_1Server meinServer = new Loes_Aufg_7_1Server(4711);
		meinServer.tuWas();
		meinServer.disconnect();

	}
}

Loes_Aufg_7_2Client.java

import java.io.IOException;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.net.InetAddress;

import java.net.Socket;
import java.net.UnknownHostException;

public class Loes_Aufg_7_2Client {
   
    Socket linkZumServer;
    DataInputStream inFromServer;
    DataOutputStream outToServer;
    
    public Loes_Aufg_7_2Client (InetAddress address, int port) throws IOException {
        
        linkZumServer = new Socket(address,port); // mit Server verbinden
        System.out.println("Verbindung hergestellt");
        
        inFromServer = new DataInputStream(new BufferedInputStream(linkZumServer.getInputStream()));
        outToServer = new DataOutputStream(new BufferedOutputStream(linkZumServer.getOutputStream()));
    }
    
    public void sendeDatei(String dateiName) throws IOException {
        int readByte;
        int numberOfBytes;
        
        // Datei zum Lesen oeffnen
        FileInputStream inFromFile = new FileInputStream(dateiName);
        System.out.println("Datei " + dateiName + "wird uebertragen");
        
        // Dateinamen uebertragen
        outToServer.writeUTF(dateiName);
        
        // Dateilaenge ermitteln und uebertragen
        numberOfBytes = inFromFile.available();
        outToServer.writeInt(numberOfBytes);
        System.out.println("Sende " + numberOfBytes + " Bytes.");
        
        // Datei byteweise einlesen und an Server schicken
        while((readByte = inFromFile.read()) >= 0) {
            outToServer.writeByte(readByte);
        }
        // evtl. noch im Puffer des BufferedOutputStreams befindliche Bytes an Server schicken
        outToServer.flush();
        inFromFile.close();
        
        // Bytezahl vom Server empfangen
        int anzempfbytes = inFromServer.readInt();
        System.out.println("Der Server hat folgende Anzahl empfangener Bytes gemeldet: " + anzempfbytes);
    }
    
    public void disconnect() throws IOException {
        outToServer.close();
        inFromServer.close();
        linkZumServer.close();
    }
   
    public static void main(String[] args) throws UnknownHostException, IOException {
        String dateiName;
        dateiName = "test.jpg";
        
        Loes_Aufg_7_2Client meinClient = new Loes_Aufg_7_2Client (InetAddress.getByName("127.0.0.1"),4711);
        
        meinClient.sendeDatei(dateiName);
        meinClient.disconnect();
    }
}

Loes_Aufg_7_2Server.java

import java.io.IOException;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Loes_Aufg_7_2Server {

	ServerSocket serverSocket;
	Socket linkZumClient;
	DataInputStream inFromClient;
	DataOutputStream outToClient;

	public Loes_Aufg_7_2Server( int port) throws IOException {

		serverSocket = new ServerSocket(port); // Socket erzeugen
		System.out.println("Server gestartet.");

		linkZumClient = serverSocket.accept(); // warten bis sich Client verbindet
		System.out.println("Verbindung hergestellt mit "+ linkZumClient.getInetAddress());

		inFromClient = new DataInputStream(new BufferedInputStream(linkZumClient.getInputStream()));
		outToClient = new DataOutputStream(new BufferedOutputStream(linkZumClient.getOutputStream()));
	}

	public void empfangeDatei() throws IOException {
		
        int readByte;
		String dateiName;
		int bytesToRead;

		// Dateinamen empfangen
		dateiName= inFromClient.readUTF();

		// Datei zum Schreiben oeffnen
		FileOutputStream outToFile = new FileOutputStream("Neu_" + dateiName);
		System.out.println("Empfange Datei "+ "Neu_" + dateiName);

		// Zahl der zu empfangenden Bytes empfangen
		bytesToRead = inFromClient.readInt();
		System.out.println("Lese "+bytesToRead+" Bytes.");

		int anzempfbytes = 0;

		// Byteweise empfangen und in Datei schreiben
		while(bytesToRead-- > 0) {
			readByte = inFromClient.readByte();
			outToFile.write(readByte);
			System.out.print("\rnoch "+bytesToRead);
			anzempfbytes ++;
		}
		outToFile.close();

		// Zahl der empfangenen Bytes an Client schicken
		outToClient.writeInt(anzempfbytes);
	}
    
	public void disconnect() throws IOException {
		outToClient.close();
		inFromClient.close();
		linkZumClient.close();
		serverSocket.close();
	}
    
	public static void main(String[] args) throws IOException {

		Loes_Aufg_7_2Server meinServer = new Loes_Aufg_7_2Server(4711);
		meinServer.empfangeDatei();
		meinServer.disconnect();
	}
}

Loes_Aufg_8_1.java

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

public class Loes_Aufg_8_1 {
    InetAddress adresse;
    int port;
    DatagramSocket socket;
    byte[] bytePuffer;
    DatagramPacket udpPaket;
    
    public Loes_Aufg_8_1(InetAddress empfaengerAdresse, int empfaengerPort) throws IOException {
        
        socket = new DatagramSocket();
        System.out.println("UDPSender Socket erzeugt");
        bytePuffer = new byte[10];
        udpPaket = new DatagramPacket(bytePuffer,bytePuffer.length);
        System.out.println("UDPSender Datenpaket erzeugt");
        this.adresse = empfaengerAdresse;
        this.port = empfaengerPort;
    }
    
    public void tuWas(int startwert) throws IOException, InterruptedException {
        
        do {
            String zahl = String.valueOf(startwert);
            byte[] ziffern = zahl.getBytes();
            udpPaket.setData(ziffern);
            udpPaket.setLength(ziffern.length);
            udpPaket.setPort(port);
            udpPaket.setAddress(adresse);
            socket.send(udpPaket);
            System.out.println("UDPSender gesendet: "+zahl);
            Thread.sleep(1000);
            startwert++;
        }
        while(true);
    }
    
    public void disconnect() throws IOException {
        
        socket.close();
    }
    
    public static void main(String[] args) throws UnknownHostException, IOException, InterruptedException {
        
        Loes_Aufg_8_1 sender = new Loes_Aufg_8_1(InetAddress.getByName("127.0.0.1"),4711);
        sender.tuWas(1);
        sender.disconnect();
    }
}

Loes_Aufg_8_2.java

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

public class Loes_Aufg_8_2 {
    InetAddress adresse;
    int port;
    DatagramSocket socket;
    byte[] bytePuffer;
    DatagramPacket udpPaket;
    
    public Loes_Aufg_8_2 (int empfaengerPort) throws IOException {
        
        socket = new DatagramSocket(empfaengerPort);
        System.out.println("UDPEmpfaenger Socket erzeugt");
        bytePuffer = new byte[10];
        udpPaket = new DatagramPacket(bytePuffer,bytePuffer.length);
        System.out.println("UDPEmpfaenger Datenpaket erzeugt");
    }
    
    public void tuWas() throws IOException {
        
        String zahl;
        do {
            socket.receive(udpPaket);
            zahl = new String(udpPaket.getData());
            System.out.println("Empfangen: "+zahl);
        }
        while(true);
    }
    
    public void disconnect() throws IOException {
        
        socket.close();
    }
    
    public static void main(String[] args) throws UnknownHostException, IOException {
        
        Loes_Aufg_8_2 empfaenger = new Loes_Aufg_8_2(4711);
        empfaenger.tuWas();
        empfaenger.disconnect();
    }
}

Leistung.java

package Loes_Aufg_9_1;

public class Leistung {
	String modul;
	double note;

	public Leistung() {
		modul = "nicht initialisiert";
		note = 6.0;
	}

	public String getModul() {
		return modul;
	}

	public void setModul(String modul) {
		this.modul = modul;
	}

	public double getNote() {
		return note;
	}

	public void setNote(double note) {
		this.note = note;
	}

}

Loes_Aufg_9_1.java

package Loes_Aufg_9_1;

import java.net.MalformedURLException;
import java.net.URL;
import javax.xml.namespace.QName;
import javax.xml.ws.Service;

public class Loes_Aufg_9_1 
{
	public static void main(String[] args) throws MalformedURLException
	{
		String url = "http://angewnwt.hof-university.de:4437/verwaltung";

		// Verbindung zum Server aufbauen
		Service service = Service.create(
				new URL(url + "?wsdl"), 
				new QName("http://soap/", "VerwaltungImplService"));

		// Stub-Methoden bereitstellen
		VerwaltungInterface verwaltung = service.getPort(VerwaltungInterface.class);

		// Alle Matrikelnummern durchprobieren
		for(int matNr = 10000; matNr < 30000; matNr++ ) {
			Student s = verwaltung.nameZuMatrikelnummer(matNr);
			if(s != null) {
				System.out.println("Gueltige Matrikelnummer: "+ s.matrikelNummer + ": " + s.name);
			}
		}
	}
}

Student.java

package Loes_Aufg_9_1;

public class Student {
	int matrikelNummer;
	String name;
	Leistung[] leistungen;
	
	public Student() {
		name = "nicht initialisiert";
		matrikelNummer = -1;
		leistungen = null;
	}

	public int getMatrikelNummer() {
		return matrikelNummer;
	}
	public void setMatrikelNummer(int matrikelNummer) {
		this.matrikelNummer = matrikelNummer;
	}

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public Leistung[] getLeistungen() {
		return leistungen;
	}
	public void setLeistungen(Leistung[] leistungen) {
		this.leistungen = leistungen;
	}
}

VerwaltungInterface.java

package Loes_Aufg_9_1;

import javax.jws.*;

@WebService
public interface VerwaltungInterface 
{
	public int martikelnummerZuName( @WebParam( name = "name" ) String name );
	
	public Student nameZuMatrikelnummer( @WebParam( name = "matrikelNummer" ) int matrikelNummer );
	
	public Leistung[] studienleistungZuMartikelnummer( @WebParam( name = "matrikelNummer" ) int matrikelNummer );
}

Leistung.java

package Loes_Aufg_9_2;

public class Leistung {
	String modul;
	double note;

	public String getModul() {
		return modul;
	}
	public void setModul(String modul) {
		this.modul = modul;
	}
	public double getNote() {
		return note;
	}
	public void setNote(double note) {
		this.note = note;
	}
}

Loes_Aufg_9_2.java

package Loes_Aufg_9_2;

import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.Invocation;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.MediaType;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class Loes_Aufg_9_2 {
	public static void main(String[] args) 
	{
		// URL des Servers
		String baseUrl   = "http://angewnwt.hof-university.de:4438";

		// Relative Pfade auf dem Server
		String webContextPath = "/student";  
		
		Student s = null;
		
		// GSON Instanz fuer das Interpretieren der Antwort vom Server
		Gson gson = new GsonBuilder().create();
		
		// Jersey Client fuer das Abfragen des Servers erzeugen
		Client client = ClientBuilder.newClient();
		
		// Alle Matrikelnummern durchprobieren
		for(int matNr = 10000; matNr < 30000; matNr++ ) {
			// Server abfragen: Name zur Matrikelnummer
			// WebTarget erzeugen und richtigen Pfad angeben
			WebTarget target = client.target( baseUrl + webContextPath);
			// abzufragende Matrikelnummer an Pfad anhaengen
			target = target.path( String.valueOf(matNr) );
			// GET-Anfrage erzeugen
			Invocation invocation = target.request( MediaType.APPLICATION_JSON ).buildGet();
			// Anfrag an Server senden, JSON-String empfangen und decodieren
			String jsonString = invocation.invoke(String.class );
			// JSON-String decodieren
			s = gson.fromJson(jsonString, Student.class);
			if(s != null) {
				System.out.println("Gueltige Matrikelnummer: "+ s.matrikelNummer + ": " + s.name);
			}
		}
	}
}

Student.java

package Loes_Aufg_9_2;

public class Student {
	int matrikelNummer;
	String name;
	Leistung[] leistungen;

	public int getMatrikelNummer() {
		return matrikelNummer;
	}
	public void setMatrikelNummer(int matrikelNummer) {
		this.matrikelNummer = matrikelNummer;
	}

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public Leistung[] getLeistungen() {
		return leistungen;
	}
	public void setLeistungen(Leistung[] leistungen) {
		this.leistungen = leistungen;
	}
}

Befehl.java

package Loes_Aufg_9_3;

import java.io.UnsupportedEncodingException;

public class Befehl 
{
	String anfrage = "";
	String anhang  = "";
	
	public byte[] baueBefehlString() throws UnsupportedEncodingException
	{
		// Speicher fuer die Teile des Befehls
		// 3 Bytes fuer die Anfrage im 7Bit Ascii-Code
		byte[] anfrageBytes = anfrage.getBytes("ASCII");
		// Bytes fuer den Parameter im 8/16/32Bit UTF-8 Code
		byte[] anhangBytes = anhang.getBytes("UTF-8");
		// 3 Bytes fuer die Zeichenkette der Laenge im 7Bit Ascii-Code
		byte[] lengthBytes =  String.format("%03d", anhangBytes.length).getBytes("ASCII");
		
		// Zielarray in entsprechender Groesse anlegen
		byte[] befehlBytes = new byte[3 + 3 + anhangBytes.length];
		
		// umkopieren in Zielarray
		int index = 0;
		for(int i=0; i < anfrageBytes.length; i++)
			befehlBytes[index++] = anfrageBytes[i];
		for(int i=0; i < lengthBytes.length; i++)
			befehlBytes[index++] = lengthBytes[i];
		for(int i=0; i < anhangBytes.length; i++)
			befehlBytes[index++] = anhangBytes[i];
		
		return befehlBytes;
	}
}

Loes_Aufg_9_3.java

package Loes_Aufg_9_3;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.nio.charset.Charset;

public class Loes_Aufg_9_3 
{
	String ip;
	int port;
	Socket server;
	OutputStream outToServer;
	InputStream inFromServer;

	public Loes_Aufg_9_3(String ip, int port)
	{
		this.ip = ip;
		this.port = port;
	}

	public void baueVerbindungAuf() throws UnknownHostException, IOException
	{
		this.server = new Socket(ip, port);

		System.out.println("Client verbunden mit: " + this.server.getInetAddress() + ":" + this.server.getPort());

		this.outToServer = this.server.getOutputStream();
		this.inFromServer = this.server.getInputStream();
	}

	public Befehl sendeBefehl(Befehl befehl) throws IOException
	{
		byte[] bytes = new byte[6];
		Befehl antwort = new Befehl();

		outToServer.write(befehl.baueBefehlString());

		int read = inFromServer.read(bytes, 0, 6);
		if(read == -1)
		{
			schliesseVerbindung();
			return antwort;
		}
		antwort.anfrage = new String(bytes, 0, 3, Charset.forName("ASCII"));
		String antwortAnhangLaenge = new String(bytes, 3, 3, Charset.forName("ASCII"));

		int anhangLaenge = Integer.parseInt(antwortAnhangLaenge);
		if(anhangLaenge > 0)
		{
			bytes = new byte[anhangLaenge];
			inFromServer.read(bytes, 0, anhangLaenge);
			antwort.anhang = new String(bytes, 0, anhangLaenge, Charset.forName("UTF-8"));
		}
		return antwort;
	}

	public void schliesseVerbindung() throws IOException
	{
		outToServer.close();
		inFromServer.close();
		server.close();
	}

	public static void main(String[] args) throws UnknownHostException, IOException, InterruptedException
	{
		String ip =  "angewnwt.hof-university.de";
		int port  =  4439;
		
		Loes_Aufg_9_3 client = new Loes_Aufg_9_3(ip, port);

		client.baueVerbindungAuf();

		// Alle Matrikelnummern durchprobieren
		for(int matNr = 10000; matNr < 30000; matNr++ ) {
			
			// Finde Name zu Matrikelnummer 
			Befehl befehl = new Befehl(); 
			befehl.anfrage = "STU";
			befehl.anhang = Integer.toString(matNr);
			Befehl antwort = client.sendeBefehl(befehl);
			if(antwort.anhang.length() > 0) {
				String teile[] = antwort.anhang.split(";");

				int matrikelNummer = Integer.parseInt(teile[0]);
				String name = teile[1];
				
				System.out.println("Gueltige Matrikelnummer: "+ matrikelNummer + ": " + name);
			}
		}
		client.schliesseVerbindung();
	}
}