Socket-Programmierung in Java - yasd.de · Java Kompaktkurs Socket Programmierung 5 TCP/IP versus UDP/IP • TCP (Transfer Control Protocol) – Ein Verbindungsorientiertes Protokoll

Socket-Programmierung in Java

Abdelmajid Khelil

Java Kompaktkurs Socket Programmierung 2

Inhalt

• Das Referenzmodell für offene Systeme• Kommunikationsprotokolle• Socket-Definition• TCP-Sockets• UDP-Sockets• Eigener TCP-Server Programmieren• TCP Client-Server Beispiel• UDP Client-Server Beispiel• SMTP Email-Client Programmieren• Arbeiten mit URLs


Das Referenzmodell für offene Systeme


Verbindungsarten

• Man unterscheidet in der Datenkommunikation zwischen zwei Artenvon Protokollen:

• Verbindungsorientiert: (Telefon-System)– Vor dem Austausch von Daten wird eine Verbindung zum

Kommunikationspartner hergestellt.– Hat meist einen höheren Verarbeitungsaufwand im Rechner.– Drei Phasen sind notwendig: Verbindungsaufbau, Datentransfer,

Verbindungsabbau– Anwendungen: Datentransfer

• Verbindungslos (Post-System)– Einzelne Nachrichten werden versendet .– Transport von in sich abgeschlossenen Nachrichten (Datagramme), zustandslos.– Hat meist einen höheren Verarbeitungsaufwand im Netz.– Anwendungen: Datenbanken, transaktionale Systeme.


TCP/IP versus UDP/IP

• TCP (Transfer Control Protocol)– Ein Verbindungsorientiertes Protokoll auf der Transportschicht (4). – TCP ist eine sichere, strom-orientierte, bidirektionale Verbindung

• UDP (User Datagram Protocol) – Verbindungsloses Protokoll auf der Transportschicht (4).– UDP ist eine unsichere Verbindung für Paketverkehr.– Unzuverlässig: Weder die Auslieferung noch deren Reihenfolge ist

garantiert– Schnell.

• IP (Internet Protocol) – Verbindungsloses Protokoll auf der Vermittlungsschicht (3).


Ports

• Def. TCP und UDP Protokolle verwenden Ports, um eintreffende Daten zum betroffenen laufenden Prozess weiterzuleiten.

• Bekannte Services:ftp (tcp) 21telnet (tcp) 23smtp (tcp) 25login (tcp) 513


Verbindungsaufbau

• 1. Schritt

• 2. Schritt


Prinzip

• Der Server ruft bind und listen auf:

• Der Client ruft connect auf:

• Der Server ruft accept auf:

• Verbindungsarten:– UDP (Datagram)

– TCP (Stream)


Definition

• Ein Socket (Steckdose, Buchse) ist eine Datenstruktur zur Administration von (Netzwerk-) Verbindungen. Ein Socket ist ein Endpunkt einer bidirektionalen Kommunikationsbeziehung zwischen zwei im Netz laufenden Programmen (Prozessen).

• Ein Socket ist mit einer Portnummer verbunden so, dass TCP-Schicht die Anwendung identifizieren kann, für die die Daten gesendet wurden.

• Richtung:– Client Socket: Verbindung mit existierendem Dienst – Server Socket: Stellt Dienst zur Verfügung


Warum Java Sockets?

• Zwei wichtige Vorteile gegenüber RMI:– Kommunizieren mit nicht-java Objekten und Programmen.– Kommunizieren mit Effizienz: Die Objektserialisierung erfordert einen

erhöhten Rechenaufwand und führt zur Übertragung größerer Datenvolumen.

• Vorteile von RMI:– RMI liefert mehr Flexibilität: Neue Klassen können von einem anderen

Rechner dynamisch zur Applikation hinzugeladen werden.


TCP-Sockets

• TCP ist eine sichere, strom-orientierte, bidirektionale Verbindung. Als Endpunkte dienen ein Socket beim Klienten und ein ServerSocket beim Server.

• Die Ströme erhält man mitgetInputStream() und getOutputStream() ,

• Die Kommunikation erfolgt mit read() und write()

• Typische Anwendungsbeispiele sind die meisten Internet-Protokolle:FTP, HTTP, SMTP, TELNET


TCP-Sockets: die wichtigsten Klassen

• java.net.Socket.ServerSocket.DataInputStream.PrintStream .DataOutputStream.URL .URLConnection


UDP-Sockets

• UDP: Universal ("unreliable") Datagram Protocol• UDP ist eine unsichere Verbindung für Paketverkehr. Als

Endpunkte dienen je ein DatagramSocket bei Klient und Server, über die DatagramPacket-Objekte mit send() verschickt und mit receive() empfangen werden.

• Die Paket-Größe ist limitiert.

• Typische Anwendungsbeispiele sind – informative Internet-Protokolle wie DNS, NIS, TFTP sowie – eine Variante der Remote Procedure Calls und darauf aufbauend NFS.


UDP-Sockets: die wichtigsten Klassen (1)

• java.net.DatagramPacket– Nur Aufbau von Datenstruktur, keine Verbindung! – Wichtige Konstruktoren

! DatagramPacket(byte[] buf, int length): Zum Empfang von length Bytes in buf! DatagramPacket(byte[] buf, int length, InetAddress address, int port): Zum

Versenden von length Bytes aus buf an address und port– Wichtige Methoden

! byte[] getData()! void setData(byte[] buf)! int getLength()! void setLength(int length)! void setAddress(InetAddress iaddr)! void setPort(int iport)


UDP-Sockets: die wichtigsten Klassen (2)

• java.net.DatagramSocket– Repräsentiert die eigentliche Verbindung – Wichtige Konstruktoren

! DatagramSocket()! DatagramSocket(int port)

– Wichtige Methoden! void send(DatagramPacket p) throws IOException! void receive(DatagramPacket p) throws IOException! void close()

• java.net.MulticastSocket– Ist vollständig von der oben beschriebenen Klasse DatagramSocket

abgeleitet– Für einen netzwerkweiten Datagram-“Broadcast“


Der Client (TCP)

1. Schritt: Ein Socket Objekt erzeugen (Öffnen eines Sockets):Socket Client = new Socket(“hostname”,portNumber);

2. Schritt: Ein “output stream” erzeugen, um Daten zu senden:PrintStream out = new PrintStream(Client.getOutputStream()); bzw.DataOutputStream out2 = new DataOutputStream(Client.getOutputStream());

3. Schritt: Ein “input stream” erzeugen, um die Antwort des Servers zu empfangen:DataInputStream in = new DataInputStream(Client.getInputStream()); bzw.BufferedReader in = new BufferedReader(

new InputStreamReader(Client.getInputStream()));4. Schritt: Nutzdaten senden und empfangen.

in.readLine(); out.println(); aber out2.writeBytes();5. Schritt: Ströme schließen: out.close(); in.close();6. Schritt: Socket schliessen: client.close();


Der Server (TCP)

1. Schritt: Ein ServerSocket Objekt erzeugen:ServerSocket listenSocket = new ServerSocket(portNumber);

2. Schritt: Ein Socket Objekt aus dem ServerSocket erzeugen:While (someCondition) { Socket server = listenSocket.accept();

doSomethingWith(server); } 3. Schritt: Ein “input stream” erzeugen:

DataInputStream in = new DataInputStream(server.getInputStream());4. Schritt: Ein “output stream” erzeugen:

PrintStream out = new PrintStream(server.getOutputStream()); 5. Schritt: Nutzdaten senden und empfangen.

in.readLine(); out.println();6. Schritt: Ströme schließen: out.close(); in.close();7. Schritt: Socket schliessen: server.close();


Kompilieren und ausführen

• Kompilieren der java-Quelldateien:javac Client.javajavac Server.java

• Ausführen der Testszenarien– TCP:

Starten des Servers mit:java Server

Starten des Clients (in einer zweiten Shell) mit:java Client

Ggf. starten eines weiteren Clients.

Beenden des Servers (mit Crtl-C).

– [UDP analog]


Eigener TCP-Server Programmieren

Der Server– Ist mit jedem Telnet-Client-Programm aufrufbar, – Echot die Eingaben und – Wird durch Eingabe der Zeichenfolge ’ciao’ beendet

Damit dies Internet-weit erfolgen kann, muss der eigene Rechner über eine IP-Verbindung angeschlossen sein: Zu Testzwecken kann der Server zunächst mit dem Telnet-Client-Programm vom eigenen Rechner genutzt werden (TCP/IP-Protokoll muss allerdings installiert sein):telnet 127.0.0.1 7788

Der Ablauf – Server-Programm mit Java erstellen – Server auf dem eigenen Rechner starten und laufen lassen – während der Server läuft, ist er im Internet über die Internet-Adresse und dem

gewählten Port (im Beispiel 7788) erreichbar.


Eigener TCP-Server: SimpleServer.java

• Das Serverprogramm SimpleServer.java besteht aus zwei Klassen:

• SimpleServer– Die zentrale Applikations-Klasse SimpleServer erstellt die Socket-

Verbindungen zu "anrufenden" Verbindungen. Jede Telnet-Verbindung zu SimpleServer ist eine eigene SocketVerbindung.

• ServerThread– Die Datenkommunikation über Eingabe- und Ausgabe-Streams erfolgt in

der Klasse ServerThread.

• Würde die Datenkommunikation nicht als Thread ausgeführt, würde bereits die erste Kommunikationsverbindung den eigenen Server-Rechner vollständig belegen.


SimpleServer.java (1)

• In der Klasse SimpleServer wird eine Instanz ss von ServerSocket auf dem Port 7788 erstellt.

• Die Methode accept() von ServerSocket erwartet Client-Anfragen auf dem Server-Socket

• Liegt eine Anfrage vor, wird ein neuer Thread ServerThread gestartet, der die Client-Anforderung bedient (jede Socket-ServerSocket-Verbindung ist somit ein eigener Thread)



import java.io.*; // import der Klassen für Streamsimport java.net.*; // import der Klassen für Netzwerkkommunikation

public class SimpleServer {

public static void main(String args[]) {

int anz = 1;

try { ServerSocket ss = new ServerSocket(7788);

while(true) { Socket sverb = ss.accept();

System.out.println(" Verbindung " + anz);

new ServerThread(sverb,anz).start();

anz++;

}

} catch (Exception e) { System.out.println(e); }

}

}



• In der Klasse ServerThread wird eine Instanz sverb der Klasse Socket erstellt.

• Die Streams DataInputStream und PrintStream werden genutzt, zur Abwicklung der über die Socket-Verbindung eingehenden und ausgehenden Datenströme



class ServerThread extends Thread {

Socket sverb; int nverb;

/* Konstruktor von ServerThread wird bei jeder neuen Verbindung aus SimpleServeraufgerufen */

ServerThread (Socket s , int n) { this.sverb = s; this.nverb = n; }

public void run () {

try {

/** Verwaltet den Eingabestream der Socketverbindung */

DataInputStream in = new DataInputStream(sverb.getInputStream());

/** Verwaltet den Ausgabestream der Socketverbindung */

PrintStream out = new PrintStream(sverb.getOutputStream());

out.println( "Hallo - Willkommen beim Simple-Echo-Server!\r\n");



boolean weiter = true;

while (weiter) {

String str = in.readLine();

if (str == null) weiter = false;

else {

out.println("Enter ciao "+nverb+" : "+str);

if (str.trim().equals("ciao")) weiter=false;

} // Ende if

} // Ende while

sverb.close();

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

} // Ende run()

} // Ende SimpleServer


TCPClient.java (1)

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

/** Testprogramm für einen TCP Client* Dem Client wird per Kommandozeile ein Satz eingegeben, der an den* Server gesendet wird. Nach erhalt der Antwort beendet sich der* Client. */

class TCPClient {/**Exceptions, die auftreten können, werden durchgereichtpublic static void main(String args[]) throws

java.net.SocketException, java.io.IOException {/** Nachricht, die an den Server geschickt wird */String sentence;/** Nachricht, die vom Server empfangen wird */String modifiedSentence;/** Objekt, dass Benutzerdaten einliest */BufferedReader inFromUser = new BufferedReader(

new InputStreamReader(System.in));


TCPClient.java (2)

/** Stellt die Verbindung zum Server auf Port 6789 her. In diesem

Fall läuft der Server auf dem gleichen Rechner wie der Client. */

Socket clientSocket = new Socket("localhost", 6789);

DataOutputStream outToServer = new DataOutputStream(clientSocket.getOutputStream());

/** Verwaltet den Eingabestream der Socketverbindung , 2. Möglichkeit*/

BufferedReader inFromServer = new BufferedReader(

new InputStreamReader(clientSocket.getInputStream()));

/** Der Benutzer gibt einen Satz ein */

sentence = inFromUser.readLine();


TCPClient.java (3)

/* Der Satz wird über den Ausgabestream der Socketverbindung an den Servergesendet. */

outToServer.writeBytes(sentence +'\n');

/* Es wird auf die Nachricht vom Server gewartet und diese Empfangen */

modifiedSentence = inFromServer.readLine();

/* Die Antwort wird auf der Konsole ausgegeben */

System.out.println("FROM SERVER: "+ modifiedSentence);

/* Der Client schliesst die Socketverbindung */

clientSocket.close();

}

} // Programmende


TCPServer.java (1)

import java.io.*; import java.net.*;/** Testprogramm für einen TCP Server Der Server empfängt Nachrichten, wandelt sie in

Grossbuchstaben und sendet sie zurück. */class TCPServer {

public static void main(String args[]) throwsjava.net.SocketException, java.io.IOException {

/** Die vom Client gesendete Nachricht */String clientSentence;/** Die Antwort fuer den Client */String capitalizedSentence;/** Der Serverdienst wird auf Port 6789 aufgesetzt */ServerSocket welcomeSocket = new ServerSocket(6789);while(true) {

/** Eingehende TCP Verbindungen werden an einen eigenen (virtuellen) Socketweitergereicht, über den die eigentliche Kommunikation stattfindet (Damit mehrereAnfragen gleichzeitig bearbeitet werden können, müsste dieser Teil durch Threadsparallelisiert werden.) */

Socket connectionSocket = welcomeSocket.accept();


TCPServer.java (2)

BufferedReader inFromClient = new BufferedReader(new InputStreamReader(connectionSocket.getInputStream()));

DataOutputStream outToClient = new DataOutputStream(connectionSocket.getOutputStream());

clientSentence = inFromClient.readLine();/* Wandele die Nachricht in Grossbuchstaben */capitalizedSentence = clientSentence.toUpperCase() + '\n';/* Sende die Antwort an den Client */outToClient.writeBytes(capitalizedSentence);

/* Der Server schliesst die Socketverbindung nicht. Weitere* Anfragen über diesen Socket werden jedoch nicht beachtet. */

} // Ende der Schleife} // Ende von main (wird nie erreicht)

}


UDPClient.java (1)

import java.io.*; /* import der Klassen fuer Streams */import java.net.*; /* import der Klassen fuer Netzwerkkommunikation */

/** Testprogramm fuer einen UDP Client. Dem Client wird per Kommandozeile ein Satzeingegeben, der an den Server gesendet wird. Nach erhalt der Antwort beendet sich der Client.*/

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

java.net.SocketException, java.io.IOException {BufferedReader inFromUser = new BufferedReader(

new InputStreamReader(System.in));

/** Erstellt einen UDP Socket */DatagramSocket clientSocket = new DatagramSocket();

/** Enthält die IP Adresse des Servers. In diesem Fall laeuft der* Server auf dem gleichen Rechner wie der Client. */InetAddress IPAddress = InetAddress.getByName("localhost");


UDPClient.java (2)

byte[] sendData = new byte[1024]; /* Datenpuffer fuer ausgehende Pakete */byte[] receiveData = new byte[1024]; /* Datenpuffer fuer eingehende Pakete */

String sentence = inFromUser.readLine(); /* Der Benutzer gibt einen Satz ein */sendData = sentence.getBytes(); /* Der Satz wird in den Sendepuffer kopiert */

/* Aus dem Sendepuffer wird ein UDP Paket "geschnuert"; Zieladresseist der UDPServer auf dem Port 9876 */

DatagramPacket sendPacket = new DatagramPacket(sendData,sendData.length, IPAddress, 9876);

clientSocket.send(sendPacket); /* das UDP Paket wird ueber Socket verschickt */

DatagramPacket receivePacket = new DatagramPacket(receiveData,receiveData.length); /* Variable fuer eingehende UDP Pakete */

/* Warten auf eingehende UDP Pakete; weiter, wenn Paket eingetroffen */clientSocket.receive(receivePacket);


UDPClient.java (3)

/** Lese die Antwort des Servers aus dem emfangenem UDP Paket aus */String modifiedSentence = new String(receivePacket.getData());/* Die Antwort wird auf der Konsole ausgegeben */System.out.println("FROM SERVER: " +modifiedSentence);

/* Schliessen des Sockets */clientSocket.close();

}}


UDPServer.java (1)

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

/** Testprogramm fuer einen UDP Server* Der Server empfaengt Nachrichten, wandelt sie in Grossbuchstaben und* sendet sie zurueck. */

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

java.net.SocketException, java.io.IOException {

/** Erstellt einen UDPSocket der auf Port 9876 Verbindungen entgegennimmt */DatagramSocket serverSocket = new DatagramSocket(9876);

byte[] receiveData = new byte[1024]; /** Datenpuffer fuer eingehende Pakete */byte[] sendData = new byte[1024]; /** Datenpuffer fuer ausgehende Pakete */

while(true){/** Variable fuer eingehende UDP Pakete */DatagramPacket receivePacket = new DatagramPacket(receiveData,

receiveData.length);


UDPServer.java (2)

/* Warten auf eingehende UDP Pakete; weiter, wenn Paket eingetroffen */serverSocket.receive(receivePacket);/* Lese die Nachricht des Clients aus dem emfangenem UDP Paket aus */String sentence = new String(receivePacket.getData());/* Die IP Adresse des Clients */InetAddress IPAddress = receivePacket.getAddress();/* Der Port auf dem der Client erreichbar ist */int port = receivePacket.getPort();

String capitalizedSentence = sentence.toUpperCase();/* Kopiere die Antwort in den Sendepuffer */sendData = capitalizedSentence.getBytes();

/** "Schnüre" das Paket für den Client (seine IP Adresse und* Port wurden Zwischengespeichert) */DatagramPacket sendPacket = new DatagramPacket(sendData,

sendData.length, IPAddress, port);serverSocket.send(sendPacket); /* Verschicke das Paket */

}}

}


SMTP

• Lieferung von Mails im Internet: – Die Client-Maschine etabliert eine TCP-Verbindung zu Port 25 der Server-

Maschine.– An diesem Port befindet sich ein Email SMTP-Dämon (simple mail transfer

protocol).– Dämon akzeptiert eintreffende Verbindungen.– Dämon kopiert Email-Nachrichten in Mailbox.– Wenn die Nachricht nicht zulieferbar ist, ein Fehler-Bericht wird zum

Sender zurückgegeben.

• Im folgenden ein SMTP-Client in Java


SMTP client (1)

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

public class smtpClient {

public static void main(String[] args) {

Socket smtpSocket = null;

DataOutputStream os = null;

DataInputStream is = null;

// Port 25 ist reserviert für SMTP

try {

smtpSocket = new Socket("hostname", 25);

os = new DataOutputStream(smtpSocket.getOutputStream());

is = new DataInputStream(smtpSocket.getInputStream());


SMTP client (2)

} catch (UnknownHostException e) {

System.err.println("Don't know about host: hostname");

} catch (IOException e) {

System.err.println("Couldn't get I/O for the connection to: hostname");

}

// If everything has been initialized then we want to write some data

// to the socket we have opened a connection to on port 25

if (smtpSocket != null && os != null && is != null) {

try {

// The capital string before each colon has a special meaning to SMTP

// you may want to read the SMTP specification, RFC1822/3


SMTP client (3)

os.writeBytes("HELO\n");

os.writeBytes("MAIL From: [email protected]\n");

os.writeBytes("RCPT To: [email protected]\n");

os.writeBytes("DATA\n");

os.writeBytes("From: [email protected]\n");

os.writeBytes("Hi there\n"); // message body

os.writeBytes("\n.\n");

os.writeBytes("QUIT");

// keep on reading from/to the socket till we receive the "Ok" from SMTP,

// once we received that then we want to break.

String responseLine;

while ((responseLine = is.readLine()) != null) {


SMTP client (4)

System.out.println("Server: " + responseLine);

if (responseLine.indexOf("Ok") != -1) {break;}

}

os.close(); is.close(); smtpSocket.close();

} catch (UnknownHostException e) {

System.err.println("Trying to connect to unknown host: " + e);

} catch (IOException e) {

System.err.println("IOException: " + e);

}

}

}

}


Arbeiten mit URLs

• URL (Uniform Resource Locator) ist– Ein Verweis (Adresse) für eine Ressource im Internet– Eine Klasse in java.net

1. Schritt: Erzeugen einer URL.

URL meine_url = new URL("http://www.informatik.uni-stuttgart.de");

2. Schritt: Öffnen einer Verbindung zur URL

URLConnection url_connect = meine_url.openConnection();

3. Schritt: Erhalten eines Ausgabestroms aus der Verbindung. (Dieser Ausgabestrom kann z.B. mitdem Standardeingabestrom des cgi-bin-Skripts auf dem Server verbunden werden).

DataInputStream dis = new DataInputStream(meine_url.openStream())

4. Schritt: Schreiben in den Ausgabestrom.

5. Schritt: Schließen des Ausgabestroms.


URL- Beispiel (1)

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

public class URLConnectionTest {

public static void main(String[] args) {

if (args.length == 0) {

System.err.println("Usage: URLConnectionTest <host> [<user> <password>]");

return;

}

try {

URL url = new URL(args[0]);

URLConnection connection = url.openConnection();

// set username, password if specified on command line


URL- Beispiel (2)

// set username, password if specified on command line

if (args.length > 2) {

String username = args[1], password = args[2];

String encoding = base64Encode(username + ":" + password);

connection.setRequestProperty("Authorization", "Basic " + encoding);

}

connection.connect();

// print header fields

String key;

for (int n = 1; (key = connection.getHeaderFieldKey(n)) != null; ++n) {

String value = connection.getHeaderField(n);

System.out.println(key + ": " + value);

}


URL- Beispiel (3)

// print convenience functions

System.out.println("----------");

System.out.println("getContentType: " + connection.getContentType());

System.out.println("getContentLength: " + connection.getContentLength());

System.out.println("getContentEncoding: " + connection.getContentEncoding());

System.out.println("getDate: " + connection.getDate());

System.out.println("getExpiration: " + connection.getExpiration());

System.out.println("getLastModifed: " + connection.getLastModified());

System.out.println("----------");

BufferedReader in =

new BufferedReader(new InputStreamReader(connection.getInputStream()));


URL- Beispiel (4)

String line; // print first ten lines of contents

for (int n = 1; (line = in.readLine()) != null && n <= 10; ++n)

System.out.println(line);

if (line != null) System.out.println(". . .");

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

}

public static String base64Encode(String s) {

ByteArrayOutputStream bOut = new ByteArrayOutputStream();

Base64OutputStream out = new Base64OutputStream(bOut);

try { out.write(s.getBytes()); out.flush();

} catch (IOException e) { }

return bOut.toString();

}

}


URL- Beispiel (5)

/* BASE64 encoding encodes 3 bytes into 4 characters.

|11111122|22223333|33444444|

Each set of 6 bits is encoded according to the toBase64 map. If the number of input bytes is not a multiple of 3,then the last group of 4 characters is padded with one or two = signs. Each output line is at most 76characters. */

class Base64OutputStream extends FilterOutputStream {

public Base64OutputStream(OutputStream out) { super(out); }

public void write(int c) throws IOException {

inbuf[i] = c; i++;

if (i == 3) {

super.write(toBase64[(inbuf[0] & 0xFC) >> 2]);

super.write(toBase64[((inbuf[0] & 0x03) << 4) | ((inbuf[1] & 0xF0) >> 4)]);

super.write(toBase64[((inbuf[1] & 0x0F) << 2) | ((inbuf[2] & 0xC0) >> 6)]);

super.write(toBase64[inbuf[2] & 0x3F]);


URL- Beispiel (6)

col += 4;

i = 0;

if (col >= 76) {

super.write('\n'); col = 0;

}

}

}

public void flush() throws IOException {

if (i == 1) {


super.write(toBase64[(inbuf[0] & 0x03) << 4]);

super.write('=');

super.write('=');

}


URL- Beispiel (7)

else if (i == 2) {


super.write(toBase64[((inbuf[0] & 0x03) << 4) | ((inbuf[1] & 0xF0) >> 4)]);

super.write(toBase64[(inbuf[1] & 0x0F) << 2]);

super.write('=');

}

}

private static char[] toBase64 = {

'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',

'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',

'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',


URL- Beispiel (8)

'o', 'p', 'q', 'r', 's', 't', 'u', 'v',

'w', 'x', 'y', 'z', '0', '1', '2', '3',

'4', '5', '6', '7', '8', '9', '+', '/'

};

private int col = 0; private int i = 0;

private int[] inbuf = new int[3];

}

Ein Aufrufbeispiel ist

java URLConnectionTest http://www.informatik.uni-stuttgart.de/ipvr/vs/lehre/ws0001/KompaktKurs/index.html


Zusammenfassung

• Client-Server Programmierung in Java ist einfach.

• Das Package java.net stellt eine sehr mächtige und flexible Infrastruktur für Netzprogrammierung zur Verfügung.

• Die Packages Sun.* stellen auch sehr gute Klassen zur Verfügung, werden aber stetig aktualisiert und einige sind nichtportable.

Documents

Socket-Programmierung in Java - yasd.de · Java Kompaktkurs Socket Programmierung 5 TCP/IP versus UDP/IP • TCP (Transfer Control Protocol) – Ein Verbindungsorientiertes Protokoll