Basic Java IO Decorator pattern Advanced Java IO. Java IO - part 2 BIU OOP. BIU OOP Java IO - part 2

Transcription

1 Java IO - part 2 BIU OOP

2 Table of contents 1 Basic Java IO What do we know so far? What s next? 2 Example Overview General structure 3 Stream Decorators Serialization

3 What do we know so far? What s next? What do we know so far? Everything is based on the concept of streams. The basic Java streams work with chunks of type byte. We have separate classes for input and output stream.

4 What do we know so far? What s next? What do we know so far? (2) Java doesn t force us to work in binary, we can use wrappers for extended functionality: We can wrap the streams to get more useful chunks. InputStreamReader & OutputStreamWriter to work with characters instead of bytes.

5 What do we know so far? What s next? What do we know so far? (2) Java doesn t force us to work in binary, we can use wrappers for extended functionality: We can wrap the streams to get more useful chunks. InputStreamReader & OutputStreamWriter to work with characters instead of bytes. We can wrap the streams to get more useful methods. BufferedReader & PrintWriter to get readline() & printf(...)

6 What do we know so far? What s next? What do we know so far? (3) What basic Java streams have we seen? Input streams: FileInputStream - a stream that reads data from a file. System.in - holds a stream object (of unknown class) connected to the Standard Input.

7 What do we know so far? What s next? What do we know so far? (3) What basic Java streams have we seen? Input streams: FileInputStream - a stream that reads data from a file. System.in - holds a stream object (of unknown class) connected to the Standard Input. Output streams: FileOutputStream - a stream that writes data to a file. System.out/System.err - holds a PrintStream object connected to the Standard Output/Error.

8 What do we know so far? What s next? What do we know so far? (3) What basic Java streams have we seen? Input streams: FileInputStream - a stream that reads data from a file. System.in - holds a stream object (of unknown class) connected to the Standard Input. Output streams: FileOutputStream - a stream that writes data to a file. System.out/System.err - holds a PrintStream object connected to the Standard Output/Error. Note Although System.out/System.err hold streams that are already wrapped, they still have the original write() methods to write bytes if we desire.

9 What do we know so far? What s next? What s next? We re still missing some details. To understand these details we need to learn a new design pattern first!

10 Example Overview General structure Decorator Design pattern

11 Example Overview General structure Example - Requirements What do we want to implement? We want the ability to draw/interact with circles. Every circle can have any subset of following behaviours: Have a filling of some color. Have the center point drawn. Have the coordinates drawn near the center. Easily moved in four directions (up, down, left, right). Return from the other direction if it exits the screen. Let s see the final outcome: decorators/main.java

12 Example Overview General structure Example - Possible solutions How can we implement the requirements?

13 Example Overview General structure Example - Possible solutions How can we implement the requirements? Single class?

14 Example Overview General structure Example - Possible solution (Single class) 1 public class Circle { 2 3 // drawing 4 public void drawon ( DrawSurface ds) {...} 5 6 // moving 7 public void moveleft () {...} 8 public void moveup () {...} 9 public void movedown () {...} 10 public void moveright () {...} // configuration 13 public void drawfill ( boolean value ) {...} 14 public void drawcenter ( boolean value ) {...} 15 public void drawcoordinates ( boolean value ) {...} 16 public void shouldreturn ( boolean value ) {...} 17 }

15 Example Overview General structure Example - Possible solution (Single class) 1 public class Circle { 2 3 // drawing 4 public void drawon ( DrawSurface ds) {...} 5 6 // moving 7 public void moveleft () {...} 8 public void moveup () {...} 9 public void movedown () {...} 10 public void moveright () {...} // configuration 13 public void drawfill ( boolean value ) {...} 14 public void drawcenter ( boolean value ) {...} 15 public void drawcoordinates ( boolean value ) {...} 16 public void shouldreturn ( boolean value ) {...} 17 } Drawbacks: Many lines of code in a single class - will be hard to maintain/debug. Violates the single responsibility design principle.

16 Example Overview General structure Example - Possible solutions How can we implement the requirements? Single class Inheritance with many classes?

17 Example Overview General structure Example - Possible solution (Inheritance)

18 Example Overview General structure Example - Possible solution (Inheritance) Drawbacks: How do we even decide who inherits from whom? No clear is a kind of relationship exists. We will end up with 2 5 number of classes. How will we name our classes?

19 Example Overview General structure Example - Possible solutions How can we implement the requirements? Single class Inheritance with many classes to the rescue!

20 Example Overview General structure - Overview Features Provide a flexible alternative to subclassing for extending behaviour. Extend class behaviour at run time, as opposed to inheritance that extends behaviour at compile time. Linear number of classes to the number of behaviours. Allows different combinations of behaviours.

21 Example Overview General structure - Class diagram Things to notice Decorator holds a reference to the decorated object Each decorator exposes the same interface as the object it decorates Abstract decorator implements the default behaviour of passing the message to the decorated object

22 Example Overview General structure - Class diagram Things to notice Decorator holds a reference to the decorated object Each decorator exposes the same interface as the object it decorates Abstract decorator implements the default behaviour of passing the message to the decorated object What we gain from this? We can call the implementation of the decorated object from the decorators implemenation We can decorate an already decorated object and add an additional behaviour (multiple times) No need to implement what the decorators does not wish to extend

23 Example Overview General structure Example - Solution (Decorator Pattern Class Diagram)

24 Example Overview General structure Example - Solution (Combination of Behaviours)

25 Example Overview General structure Example - Implementation See full code example under package decorators

26 Example Overview General structure - Summary We had an implementation problem, involving circles that needed many different behaviour combinations. We saw that inheritance was not a good fit to solve our problem. We solved the problem with the, a very flexible and elegant alternative to inheritance. The core mechanism of the pattern is to wrap around an interface, add behaviour, and expose the same interface.

27 Stream Decorators Serialization Java IO Stream Decorators

28 Stream Decorators Serialization Stream Decorators - Overview InputStream and OutputStream are the base classes. FileInputStream and FileOutputStream are just one example of the concrete implementations that exist. We can add behaviour to the streams with the help of Decorators.

29 Stream Decorators Serialization OutputStream - Class diagram

30 Stream Decorators Serialization OutputStream compression example Writing bytes to a file (and compressing at the same time): 1 OutputStream os = null ; 2 try { 3 os = new GZipOutputStream (new FileOutputStream (" somefile.bin.gz")); 4 5 for ( int i = 0; i < 100; i+= 1) { 6 os. write (i); 7 } 8 } catch ( IOException e) { 9 System.out. println (" Something went wrong while writing!"); 10 } finally { 11 if(os!= null ){ // Exception might have happened at constructor 12 try { 13 os. close (); 14 } catch ( IOException e) { 15 System.out. println (" Failed closing the file!"); 16 } 17 } 18 } Note Decorate the stream to write with compression (How easy is that?)

31 Stream Decorators Serialization OutputStream compression example (with text) Writing text to a file (and compressing at the same time): 1 OutputStreamWriter os = null ; 2 try { 3 os = new OutputStreamWriter ( 4 new GZipOutputStream ( 5 new FileOutputStream (" somefile.txt.gz"))); 6 7 os. write (" Hello World "); 8 9 } catch ( IOException e) { 10 System.out. println (" Something went wrong while writing!"); 11 } finally { 12 if(os!= null ){ // Exception might have happened at constructor 13 try { 14 os. close (); 15 } catch ( IOException e) { 16 System.out. println (" Failed closing the file!"); 17 } 18 } 19 } Note GZipOutputStream is also a type of OutputStream

32 Stream Decorators Serialization InputStream - Class diagram

33 Stream Decorators Serialization InputStream compression example Reading bytes from a compressed file: 1 InputStream is = null ; 2 try { 3 is = new GZipInputStream (new FileInputStream (" somefile.bin.gz")); 4 5 int readbyte ; 6 while (( readbyte = is.read ())!= -1){ // -1 -> no more data in the stream 7 System.out. print ( readbyte ); 8 } 9 } catch ( IOException e) { 10 System.out. println (" Something went wrong while reading!"); 11 } finally { 12 if(is!= null ){ // Exception might have happened at constructor 13 try { 14 is. close (); 15 } catch ( IOException e) { 16 System.out. println (" Failed closing the file!"); 17 } 18 } 19 } Note Decorate the stream to read compression (How easy is that?).

34 Stream Decorators Serialization InputStream compression example Reading text from a compressed file: 1 BufferedReader is = null ; 2 try { 3 is = new BufferedReader ( 4 new InputStreamReader ( 5 new GZipInputStream ( 6 new FileInputStream (" somefile.txt.gz")))); 7 8 System.out. print (is. readline ()); 9 10 } catch ( IOException e) { 11 System.out. println (" Something went wrong while reading!"); 12 } finally { 13 if(is!= null ){ // Exception might have happened at constructor 14 try { 15 is. close (); 16 } catch ( IOException e) { 17 System.out. println (" Failed closing the file!"); 18 } 19 } 20 } Note GZipInputStream is a type of InputStream

35 Stream Decorators Serialization Stream Decorators - Summary We ve seen another example of the Decorator Pattern Java IO extracts common concerns such as compression and encryption into appropriate Decorators. Each concern has two symmetric implementations, one for input and one for output. We saw how we can compress any stream with the GZipOutputStream Because GZipOutputStream is still an OutputStream, we were able to wrap it again with OutputStreamWriter, extending the stream with the ability to write characters.

36 Stream Decorators Serialization Java IO Serialization

37 Stream Decorators Serialization Serialization Overview We ve seen how the basic streams work with byte chunks. We ve seen how we can convert the streams to use character chunks with the use of Reader/Writer wrappers. We will now see that we can also convert the streams to use Object chunks with new types of wrappers.

38 Stream Decorators Serialization Preparing classes for serialization We would like to be able to serialize an object of type Person. Serialization refers to encoding all the data in Person (not the code). Part of Person data is inside two inner objects: Address & CreditCardInfo. Can we just serialize it? No.

39 Stream Decorators Serialization Preparing classes for serialization (2) Serialization works on primitive data types. If the type is not primitive, it must implement the Serializable interface. Serializable interface has no methods, it s just a way to mark a class that it s safe to serialize. So can we now serialize Person? Still No.

40 Stream Decorators Serialization Preparing classes for serialization (3) Serialization is a recursive process, while trying to serialize Person it will need to serialize the Address. What about String? Lucky for us most basic classes in Java already implement Serializable. So can we now serialize Person? Yes.

41 Stream Decorators Serialization Controlling what will be serialized Sometimes we want to not serialize specific field members: The data may be too sensitive (credit card number). We may contain a class that is not Serializable (and we can t change it) but we still want to be serialized without it. We can use a new keyword: transient on field members to achieve this.

42 Stream Decorators Serialization Controlling what will be serialized - example 8 public class CreditCardInfo implements Serializable { 9 10 // regular information 11 private String lastfourdigits ; 12 private String cardholdername ; // sensitive information 15 private transient String cardnumber ; 16 private transient String cardsecuritycode ; } We mark the class as Serializable. We omit the sensitive information field members for security. Only lastfourdigits & cardholderinfo will be serialized.

43 Stream Decorators Serialization Serializing objects into/from streams Similar to InputStreamReader & OutputStremWriter wrappers, we will use: ObjectInputStream - adds the method readobject() ObjectOutputStream - adds the method writeobject(...) A binary data format is used to encode the data in the objects. It s common practice to use the file extension of.ser for files that contain Java serialized objects.

44 Stream Decorators Serialization Example - Implementation See full code example under package io.serialization

45 Stream Decorators Serialization Summary 1 Basic Java IO What do we know so far? What s next? 2 Example Overview General structure 3 Stream Decorators Serialization