Java Schulung. Objektorientierte Programmierung in Java Teil VI: Wichtige Java Pakete. Prof. Dr. Nikolaus Wulff

Transkript

1 Java Schulung Objektorientierte Programmierung in Java Teil VI: Wichtige Java Pakete Prof. Dr. Nikolaus Wulff

2 Java Pakete Für die meisten Aufgaben stellt Java bereits viele nützliche Bibliotheken zur Verfügung: Datei Ein- und Ausgabe java.io Container Klassen java.util Logging API java.util.logging Netzwerk und Socket Programmierung java.net Datenbankzugriffe java.sql Graphische Benutzerschnittstellen java.awt und javax.swing Das Problem ist lediglich das richtige Paket für die gestellte Aufgabe zu finden :-( Prof. Dr. Nikolaus Wulff 2

3 java.io Das java.io Paket enthält die wichtigen Konzepte zur Manipulation von Dateien und das Arbeiten mit Streams: File Input- und OutputStream Reader und Writer Die Streams und Reader/Writer Klassen sind nach dem Unix Pipe Konzept modelliert und lassen sich nahezu beliebig verschachteln. Prof. Dr. Nikolaus Wulff 3

4 Input Klassenhierarchie System (from lang) +$in InputStream -in FilterInputStream ObjectInputStream ByteArrayInputStream StringBufferInputStream PipedInputStream LineNumberInputStream -dis DataInputStream BufferedInputStream PushbackInputStream io (from java) FileInputStream -fd FileDescriptor +$out +$err +$in IOException String (from lang) -path +$separator +$pathseparator File Prof. Dr. Nikolaus Wulff 4

5 Output Klassenhierarchie OutputStream #out -out <<Interface>> ObjectStreamConstants <<Interface>> ObjectOutput PipedOutputStream ByteArrayOutputStream FilterOutputStream ObjectOutputStream io (from java) BufferedOutputStream -dos DataOutputStream PrintStream OutputStreamWriter -charout IOException FileOutputStream FileDescriptor +$out -fd +$out System (from lang) Prof. Dr. Nikolaus Wulff 5

6 Reader InputStream Reader #in -in InputStreamReader StringReader BufferedReader FilterReader PipedReader CharArrayReader FileReader Die Reader Klassen kapseln Texteingaben. Häufig verwenden sie im Konstruktor einen InputStream, von dem sie die Daten einlesen. Beispiel InputStream- und FileReader Die Reader lassen sich verschachteln. Prof. Dr. Nikolaus Wulff 6

7 Writer Writer -out PipedWriter CharArrayWriter StringWrite r OutputStreamWriter PrintWriter BufferedWriter Fil terwri ter Die Writer Hierarchie besteht aus Klassen für Textausgaben. Sie ist ähnlich strukturiert wie die Reader Hierarchie. Prof. Dr. Nikolaus Wulff 7

8 Fehler über Fehler... EOFException io (from java) IOException FileNotFoundException InterruptedIOException SyncFailedException ObjectStreamException CharConversionException UTFDataFormatException NotActiveException UnsupportedEncodingException StreamCorruptedException OptionalDataException InvalidObjectException InvalidClass Exception WriteAbortedException Prof. Dr. Nikolaus Wulff 8

9 Übung Entwickeln Sie das Unix Head Utility Head schreibt die ersten 10 Zeilen einer Datei auf die Console. Die Anzahl der zu lesenden Zeilen kann vorgegeben werden. Testen Sie mit JUnit! Die Ausgabe kann in eine Datei umgeleitet werden. Aufruf: java Head dateiname [-o ausgabedatei] [-l anzahl zeilen] Ziele: Kennenlernen der io-klassen: File & FileInput/OutputStream, LineNumberReader Stream Verkettungen Datei IO sinnvoll mit JUnit testen, temporäre Dateien anlegen. Prof. Dr. Nikolaus Wulff 9

10 Head in Aktion Aufruf Verwendete Klassen Ausgabe Schleife Zeilen zählen! Prof. Dr. Nikolaus Wulff 10

11 Ströme verketten Die Java IO-Ströme lassen sich wie bei der Unix Pipe Architektur verketten. Dadurch ist es möglich Filter dazwischen zu schalten oder Ströme mit neuen Eigenschaften zu dekorieren. Eingabe Datei FileInputStream copy(from, to) Ausgabe Datei FileOutputStream GZIPOutputStream Prof. Dr. Nikolaus Wulff 11

12 Ein ZIP Strom Die Verkettung von Strömen ist recht einfach: OutputStream out; out = new FileOutputStream(destination); out = new BufferedOutputStream(out); out = new GZIPOutputStream(out); und hier die generische Kopiermethode: protected void copy(inputstream in, OutputStream out) throws IOException { byte[] buf = new byte[4096]; int read, EOF = -1; while( (read = in.read(buf))!= EOF) { out.write(buf, 0, read); } } Prof. Dr. Nikolaus Wulff 12

13 Filter als Ströme Durch die Verkettung von Eingabe- oder Ausgabeströmen lassen sich sehr einfach und modular Filter entwickeln. Es muss lediglich ein zusätzlicher Filter in die Einoder Ausgabe geschaltet werden: Eingabe Datei FileInputStream MyFilterInputStream Ausgabe Datei FileOutputStream copy(from, to) Prof. Dr. Nikolaus Wulff 13

14 Ein HTML Filter Ein einfacher HTML zu Text Konverter soll entwickelt werden. Hierzu wird ein Filter verwendet, der alle HTML Markup Tags elemeniert. Da es sich hierbei um reinen Text handelt ist es einfacher mit einem Reader/Writer Paar zu arbeiten: Eingabe Datei FileReader HTMLReader Ausgabe Datei FileWriter copy(from, to) Prof. Dr. Nikolaus Wulff 14

15 BufferedReader überladen Um einen CharakterFilter zu entwickeln bietet es sich an von BufferedReader zu erben und dessen read-methode zu überladen. Die gesamte Funktionalität eines (gepufferten) Readers ist dann bereits vorhanden. Es wird lediglich eine Methode implementiert, die die HTML Auszeichnungen <xxx> herausfiltert. Eine gute Implementierung würde eventuell noch mehr leisten und z. B. an den richtigen Stellen Zeilenumbrüche einbauen etc... public class HTMLReader extends BufferedReader {...} Prof. Dr. Nikolaus Wulff 15

16 Gefiltertes read public int read(char[] buf, int start, int len) throws IOException { int i, j, num = 0; boolean markup = false; while(num == 0) { num = super.read(buf, start, len); if (num == EOF) return EOF; i = j = start; for(; i < start + num; i++) { switch( buf[i]) { case '<': markup = true; break; case '>': markup = false; break; default: if(!markup) buf[j++] = buf[i]; } // end switch } // for loop num = j - start; } // while loop return num; } Prof. Dr. Nikolaus Wulff 16

17 Java Persistenz Im IO Paket befindet sich die Serializable Schnittstelle. Serializable ist ein leeres Marker Interface. Klassen die diese Schnittstelle implementieren können von der JVM automatisch in einem Stream serialisiert und somit per TCP/IP verschickt oder im Dateisystem gespeichert und wieder ausgelesen werden. Java verwendet hierzu die von Object geerbten Methoden read/writeobject. Jedes Objekt lässt sich in einen ObjectOutputStream schreiben oder von einem ObjectInputStream lesen. Prof. Dr. Nikolaus Wulff 17

18 Übung Erweitern Sie das Painter und Shapes Beispiel, so dass der Painter die Shapes in eine Datei schreiben oder wieder auslesen kann. Geben Sie den Shapes mehr Attribute posx, posy, width, height Speichern/Lesen Sie in/aus "Paintable.dat" Geben Sie die Datei mit dem DOS Type Befehl auf der Console aus. Was sehen Sie? Was passiert wenn eine der Shapes Klassen nicht Serializable implementiert? Prof. Dr. Nikolaus Wulff 18

19 Tip: Painter ObjectOutputStream (from java.io) writeall (from painter) drawall() addpaintable() storeall() readall() readall ObjectInputStream (from java.io) <<Interface>> Serializable (from java.io) 0..* <<Interface>> Paintable (from painter) Shape (from shapes) Lesen und Schreiben sind symmetrische Aktionen mit korrepondierenden IO-Streams. Das Serializable Marker-Interface wird am besten von der abstrakten Shapes Klasse implementiert. Prof. Dr. Nikolaus Wulff 19

20 Serialisierung in Aktion public static void main(string[] args) throws Exception { Painter painter = new Painter(); addshapes(painter); painter.drawall(); System.out.println(""); String filename = "Paintable.dat"; // store graph to file system System.out.println("Store to " + filename); painter.storeall(filename); // now create an empty fresh painter Painter emptypainter = new Painter(); System.out.println(""); System.out.println("Read from " + filename); emptypainter.readall(filename); emptypainter.drawall(); } Prof. Dr. Nikolaus Wulff 20

21 Systemeigenschaften Das java.util Paket enthält die Klasse Properties als Erweiterung einer Hashtable (Map). In ihr werden System- oder Applikationseigenschaften hinterlegt. Properties werden häufig als Textdateien gepflegt, um eine Anwendung zu parametrisieren - ohne neu compilieren zu müssen. Properties lassen sich per In-/OutStream einfach (lesbar!) serialisieren. Die java.lang.system Klasse liefert z.b. per getproperties die aktuellen Umgebungsvariablen der JVM. Properties props = System.getProperties(); Prof. Dr. Nikolaus Wulff 21

22 Eine Property Datei # # general server settings # server.url = localhost server.protocol = http server.port = 80 # # available services # service.1.name = HelloWorld service.1.class = services.helloworldservice service.1.param = DummyParameter # service.2.name = Calculator service.2.class = services.calculatorservice Obiges Beispiel zeigt die Struktur einer Property Datei. Sie besteht aus (key,value)-tupeln mit dem Kommentarzeichen #. Aufgrund des einfachen Aufbaus lässt sich diese Struktur ideal in einer Map/Collection Klasse speichern... Prof. Dr. Nikolaus Wulff 22

23 Übung Schreiben Sie ein Programm, das die Systemeinstellungen auf der Console ausgibt und auf Wunsch in einer Datei speichert. Was bedeuten die Eigenschaften? Systemeinstellungen lassen sich beim Start der JVM per Kommandozeile java -Dkey=value übergeben. Probieren sie dies aus. Tip: versuchen Sie einmal java -help Erweitern Sie die Klasse, so dass diese eine beliebige Property Datei wieder einliest und ausgibt. Prof. Dr. Nikolaus Wulff 23

24 Properties einlesen Eigenschaften lassen sich von beliebigen InputStreams einlesen: protected Properties loadinput(string name) { Properties props = new Properties(); try { InputStream fin = new FileInputStream(name); props.load(fin); } catch (Exception error) { println("error reading " + name); error.printstacktrace(); } return props; } Prof. Dr. Nikolaus Wulff 24

25 Properties schreiben Ebenso leicht lassen sich diese in beliebige Ströme schreiben: protected void storeoutput(properties props, String name) { try { OutputStream fout = new FileOutputStream(name); props.store(fout, "Properties example"); } catch (Exception error) { println("error writing " + name); error.printstacktrace(); } } Prof. Dr. Nikolaus Wulff 25

26 Logging Häufig werden während der Entwicklung Debug Ausgaben per System.out.println ausgegeben. Im Release Code sollen diese meistens nicht mehr erscheinen und auch die Laufzeitumgebung nicht mehr unnötig mit String Operationen belasten. Nur noch wichtige Fehlermeldungen müssen protokolliert werden. Diese Funktionalität wird von Bibliotheken wie z.b. Log4J oder seit JDK1.4 von dem java.util.logging Paket erfüllt. Debug Nachrichten lassen sich per Konfiguration aus einer Properties Datei gezielt für einzelne Pakete oder Klassen gestaffelt nach der Wichtigkeit (DEBUG, INFO, WARN, ERROR,...) an oder ausschalten und in Dateien umleiten. Prof. Dr. Nikolaus Wulff 26

27 Logging Example import java.util.logging.logger; public class LoggingExample { public static final boolean DEBUG = true; /** create a logger associated to this class name */ private static Logger logger = Logger.getLogger(LoggingExample.class.getName()); } public void assertion(boolean cond, String reason) { if (!cond) { // assertions logging will stay in production code logger.severe("assertion " + reason); throw new IllegalStateException(reason); } } public void dosomething(object obj) { if (DEBUG) { // no info logging in production code logger.info("doing something with " + obj); } assertion(obj!= null,"object == null"); // do something useful... } public static void main(string[] args) { LoggingExample example = new LoggingExample(); example.dosomething(null); } Prof. Dr. Nikolaus Wulff 27

28 Tips zum Logging Da das DEBUG boolean als final static markiert ist, kann der Compiler dies bereits auswerten und der gesamte Codeblock wird nicht in die Class-Datei generiert, falls das Flag false ist. => Performance im Release! Damit nicht in allen Klassen DEBUG Flags gesetzt werden müssen, das Flag pro Projekt/Bibliothek in eine zentrale Schnittstellendatei auslagern. Diese wird an einer zentralen Stelle verwaltet: import myproject.settings.global; public class LoggingExample { public void dosomething(object obj) { if (Global.DEBUG) { // no info logging in production code logger.info("doing something with " + obj); } assertion(obj!= null,"object == null"); // do something useful... } Prof. Dr. Nikolaus Wulff 28

29 Logging Format Eigene LoggingFormatter können entwickelt und definiert werden. Der Formatter der Log Ausgaben lässt sich in der Logging.properties Datei parametrisieren. Optional kann er auch als Systemeigenschaft definieren werden (funktioniert noch nicht): -Djava.util.logging.ConsoleHandler.formatter=myFormatter Prof. Dr. Nikolaus Wulff 29

30 Logging.properties ## From %JDK_HOME%\jre\lib\Logging.properties handlers= java.util.logging.consolehandler # To also add the FileHandler, use the following line instead. #handlers= java.util.logging.filehandler, java.util.logging.consolehandler # Default global logging level..level= INFO ############################################################ # Handler specific properties. # Describes specific configuration info for Handlers. ############################################################ # default file output is in user's home directory. java.util.logging.filehandler.pattern = %h/java%u.log java.util.logging.filehandler.limit = java.util.logging.filehandler.count = 1 java.util.logging.filehandler.formatter = java.util.logging.xmlformatter # Limit the message that are printed on the console to INFO and above. java.util.logging.consolehandler.level = INFO # java.util.logging.consolehandler.formatter = java.util.logging.simpleformatter java.util.logging.consolehandler.formatter=logging.logformatter Einbinden eines eigenen Formatierers Prof. Dr. Nikolaus Wulff 30

31 Übung Entwickeln Sie einen LogFormatter der die Klasse und Zeilenummer der Lognachricht mit ausgibt. Tip: Die Zeilennummer lässt sich aus dem Stacktrace einer Exception ermitteln... Verwenden Sie anstatt des + Operators die Klasse java.lang.stringbuffer, um Strings zusammenzufügen. Prof. Dr. Nikolaus Wulff 31

32 Stringparsing Häufig müssen zusammengesetzte Strings nach einem bestimmten Schema zerlegt werden, z.b. CSV Dateien (comma-separated-values). Im java.util Paket befindet sich die Klasse StringTokenizer, die es gestattet String sehr komfortabel in Teilausdrücke (Tokens) zu zerlegen. String bigline = "this is a test"; StringTokenizer st = new StringTokenizer(bigline); while (st.hasmoretokens()) { System.out.println(st.nextToken()); } this is a test Prof. Dr. Nikolaus Wulff 32

33 Stringparsing Im Konstruktor kann das Trennungszeichen angeben werden Voreinstellung ist das Leerzeichen (space) ' ' == '\s' Seit dem JDK1.4 gibt es in der String Klasse die Operation split, die gleiches leistet und bevorzugt verwendet werden soll. (Erfordert regular expression Syntax). String[] result = bigline.split("\\s"); for (int x=0; x<result.length; x++) System.out.println(result[x]); Prof. Dr. Nikolaus Wulff 33

34 Übung Entwickeln Sie einen Parser, der den Klassennamen einer beliebigen Klasse in die einzelnen Pakete und die eigentliche Klasse zerlegt. Denken Sie daran auch innere Klassen und Interfaces mit auszugeben. Woran kann man diese erkennen? Tip: Schauen Sie in das bin Verzeichnis... Vergessen Sie den JUnit Test nicht. Prof. Dr. Nikolaus Wulff 34

35 Übung Entwickeln und Testen Sie einen Parser, der einen HTTP GET request in seine Bestandteile zerlegt. Ein solcher Request hat die generische Form Request-Line = Method SP Request-URI SP HTTP-Version CRLF Die URI setzt sich aus dem Pfad und dem Dokument zusammen. Handelt es sich statt dessen um ein Servlet so können durch '?' und '&' getrennt optionale Parameter übergeben werden. Request-URI = /path/dokument Request-URI = /name? arg1=val1 &arg2=val2... GET /Calculator?arg1=5&arg2=3&op=+ HTTP/1.1 Prof. Dr. Nikolaus Wulff 35