Appending objects to a binary file

Supose you have the following method:

public static void writeToBinary(Object obj, String filename) 
{
 ObjectOutputStream oos = null;
 try {
  oos = new ObjectOutputStream(new FileOutputStream(filename));
  oos.writeObject(obj);
 } catch (Exception e) {
  e.printStackTrace();
 }  finally{
  try{
   if (oos != null) oos.close ();
  }catch (Exception e){
   e.printStackTrace();
  }
 }
}

As you can see, the method writes an object to a binary file.

But now you want to rewrite the same method to allow appending objects to the same file.

Ok, you look at the java documentation and you see th开发者_JAVA百科at you have to add a parameter with value true to the FileOutputStream:

oos = new ObjectOutputStream(new FileOutputStream(filename, true));

You compile but, whoops!, it seems that it continues overriding the file.

Well, the problems begin. After searching in google you read that you have to use the SAME ObjectOutputStream to append objects to the same file. You want to have a function that every time you call it, it appends an object. I.e. :

writeToBinary("a", filename);
writeToBinary("b", filename);

But as I said before, you have to use the same ObjectOutputStream.

Solution 1:

ObjectOutputStream out = getOutputStream (filename);
writeToBinary("a", out);
writeToBinary("b", out);
writeToBinary("c", out);
out.close ();

This is very ugly because I want to hide the usage of streams.

Is there any other solution?

EDIT: The method is static. It is inside an utility class where all methods are static.

EDIT2: SOLVED! Appending to an ObjectOutputStream. See accepted answer to my question. Thanks.

Solved.

import java.io.EOFException;
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.OutputStream;

public class Test{
    private static String filename = "test";

    public static void main(String[] args) {
        writeToBinary (filename, "a", true);
        writeToBinary (filename, "b", true);
        writeToBinary (filename, "c", true);
        readFromBinaryFile (filename);
    }

    public static void writeToBinary (String filename, Object obj, boolean append){
        File file = new File (filename);
        ObjectOutputStream out = null;

        try{
            if (!file.exists () || !append) out = new ObjectOutputStream (new FileOutputStream (filename));
            else out = new AppendableObjectOutputStream (new FileOutputStream (filename, append));
            out.writeObject(obj);
            out.flush ();
        }catch (Exception e){
            e.printStackTrace ();
        }finally{
            try{
                if (out != null) out.close ();
            }catch (Exception e){
                e.printStackTrace ();
            }
        }
    }

    public static void readFromBinaryFile (String filename){
        File file = new File (filename);

        if (file.exists ()){
            ObjectInputStream ois = null;
            try{
                ois = new ObjectInputStream (new FileInputStream (filename));
                while (true){
                    String s = (String)ois.readObject ();
                    System.out.println (s);
                }
            }catch (EOFException e){

            }catch (Exception e){
                e.printStackTrace ();
            }finally{
                try{
                    if (ois != null) ois.close();
                }catch (IOException e){
                    e.printStackTrace ();
                }
            }
        }
    }

    private static class AppendableObjectOutputStream extends ObjectOutputStream {
          public AppendableObjectOutputStream(OutputStream out) throws IOException {
            super(out);
          }

          @Override
          protected void writeStreamHeader() throws IOException {}
    }
}

oos = new ObjectOutputStream(new FileOutputStream(filename, true)); You compile but, whoops!, it seems that it continues overriding the file.

That does not make sense. The FileOutputStream is a streams that appends to the existing file, so it will not overwite the file. Check it.

The problem is that a stream cannot be closed and reopened to serialize several objects. Run the following and compare the resulting files to check it.

public class XX {

 public static void writeToBinary(Object obj, String filename) throws Exception {
   ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filename,true));
   oos.writeObject(obj);
   oos.close();
 }

 public static void writeToBinary2(Object obj1, Object obj2,String filename) throws Exception { 
   ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filename,true));
   oos.writeObject(obj1);
   oos.writeObject(obj2);
   oos.close();
 }

 public static void main(String[] args) throws Exception {
  String s1= "hi, just trying";
  String s2= "bye bye cruel world";
  String filename = "/temp/f.dat";
  String filename2 = filename + ".2" ;
  writeToBinary(s1, filename);
  writeToBinary(s2, filename);
  writeToBinary2(s1, s2,filename2);
  ObjectInputStream fin = new ObjectInputStream(new FileInputStream(filename)); // oops... works with filename2
  Object x1 = fin.readObject();
  Object x2 = fin.readObject();
  System.out.println(x1);
  System.out.println(x2);
 }
}

Write a helper class. In constructor it will instantiate an output stream for a particular file name. Then using some append() or writeToBinary() method it will append the data. on method close() there will be flush() and close() calls on the stream.

BinaryWriteHelper helper = new BinaryWriteHelper("test.dat");

helper.writeToBinary("1");
helper.writeToBinary(2);

helper.close();

in BinaryWriteHelper :

public BinaryWriteHelper(String filename) {
 this.stream = new ObjectOutputStream(new FileOutputStream(filename));
}

public close() {
  // the cleanup here
}

Try this approach:

1. Write the object to a ByteArrayOutputStream.
2. Append the the size and contents of the ByteArrayOutputStream to a RandomAccessFile.
3. To load an object from the file, read the bytes that represent an Object into a ByteArrayInputStream and initialize an ObjectInputStream on this. The size field that was prepends each object byte sequence will come handy here.