Admin: 1 версия

2010-06-01T06:04:31Z

1 версия

в 18:01, 31 мая 2010

2010-05-31T18:01:43Z

Новая страница

== 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>

← Предыдущая	Версия 06:04, 1 июня 2010
(нет различий)

Java/File Input Output/PipedInputStream - История изменений

Admin: 1 версия

в 18:01, 31 мая 2010