Java/File Input Output/PipedInputStream
Defines utility routines that use Java serialization
<source lang="java">
/*
* Copyright (c) 2004 David Flanagan. All rights reserved. * This code is from the book Java Examples in a Nutshell, 3nd Edition. * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied. * You may study, use, and modify it for any non-commercial purpose, * including teaching and use in open-source projects. * You may distribute it non-commercially as long as you retain this notice. * For a commercial use license, or to purchase the book, * please visit http://www.davidflanagan.ru/javaexamples3. */
import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.PipedInputStream; import java.io.PipedOutputStream; import java.io.Serializable; /**
* This class defines utility routines that use Java serialization. */
public class Serializer {
/** * Serialize the object o (and any Serializable objects it refers to) and * store its serialized state in File f. */ static void store(Serializable o, File f) throws IOException { ObjectOutputStream out = // The class for serialization new ObjectOutputStream(new FileOutputStream(f)); out.writeObject(o); // This method serializes an object graph out.close(); } /** * Deserialize the contents of File f and return the resulting object */ static Object load(File f) throws IOException, ClassNotFoundException { ObjectInputStream in = // The class for de-serialization new ObjectInputStream(new FileInputStream(f)); return in.readObject(); // This method deserializes an object graph } /** * Use object serialization to make a "deep clone" of the object o. This * method serializes o and all objects it refers to, and then deserializes * that graph of objects, which means that everything is copied. This differs * from the clone() method of an object which is usually implemented to * produce a "shallow" clone that copies references to other objects, instead * of copying all referenced objects. */ static Object deepclone(final Serializable o) throws IOException, ClassNotFoundException { // Create a connected pair of "piped" streams. // We"ll write bytes to one, and them from the other one. final PipedOutputStream pipeout = new PipedOutputStream(); PipedInputStream pipein = new PipedInputStream(pipeout); // Now define an independent thread to serialize the object and write // its bytes to the PipedOutputStream Thread writer = new Thread() { public void run() { ObjectOutputStream out = null; try { out = new ObjectOutputStream(pipeout); out.writeObject(o); } catch (IOException e) { } finally { try { out.close(); } catch (Exception e) { } } } }; writer.start(); // Make the thread start serializing and writing // Meanwhile, in this thread, read and deserialize from the piped // input stream. The resulting object is a deep clone of the original. ObjectInputStream in = new ObjectInputStream(pipein); return in.readObject(); } /** * This is a simple serializable data structure that we use below for testing * the methods above */ public static class DataStructure implements Serializable { String message; int[] data; DataStructure other; public String toString() { String s = message; for (int i = 0; i < data.length; i++) s += " " + data[i]; if (other != null) s += "\n\t" + other.toString(); return s; } } /** This class defines a main() method for testing */ public static class Test { public static void main(String[] args) throws IOException, ClassNotFoundException { // Create a simple object graph DataStructure ds = new DataStructure(); ds.message = "hello world"; ds.data = new int[] { 1, 2, 3, 4 }; ds.other = new DataStructure(); ds.other.message = "nested structure"; ds.other.data = new int[] { 9, 8, 7 }; // Display the original object graph System.out.println("Original data structure: " + ds); // Output it to a file File f = new File("datastructure.ser"); System.out.println("Storing to a file..."); Serializer.store(ds, f); // Read it back from the file, and display it again ds = (DataStructure) Serializer.load(f); System.out.println("Read from the file: " + ds); // Create a deep clone and display that. After making the copy // modify the original to prove that the clone is "deep". DataStructure ds2 = (DataStructure) Serializer.deepclone(ds); ds.other.message = null; ds.other.data = null; // Change original System.out.println("Deep clone: " + ds2); } }
}
</source>
Test PipedInputStream and PipedOutputStream with Thread
<source lang="java">
import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.io.PipedInputStream; import java.io.PipedOutputStream; public class TestPipes {
public static void writeData(OutputStream os) { try { DataOutputStream out = new DataOutputStream(new BufferedOutputStream(os)); int[] numArray = { 1, 2, 3, 4, 5 }; for (int i = 0; i < numArray.length; i++) { out.writeInt(numArray[i]); } out.flush(); out.close(); } catch (IOException e) { e.printStackTrace(); } } public static void readData(InputStream is) { DataInputStream in = new DataInputStream(new BufferedInputStream(is)); boolean eof = false; try { while (!eof) { int iValue = in.readInt(); System.out.println("read value = " + iValue); } } catch (IOException e) { e.printStackTrace(); } System.out.println("End of Data"); } public static void main(String[] args) throws Exception { final PipedOutputStream pos = new PipedOutputStream(); final PipedInputStream pis = new PipedInputStream(pos); Runnable runOutput = new Runnable() { public void run() { writeData(pos); } }; Thread outThread = new Thread(runOutput, "outThread"); outThread.start(); Runnable runInput = new Runnable() { public void run() { readData(pis); } }; Thread inThread = new Thread(runInput, "inThread"); inThread.start(); }
}
</source>