Storing Byte Array inside an Object, and then converting it to ObjectOutputStream? (Stuck)

Question

I'm kind of stuck with this problem.

I have this FileDetails class which stores details/metadata of the file along with the complete file in a byte array. I want to send the FileDetails object inside ObjectOutputStream across network, where the receiver will simple read the file and cast it back to FileDetails.

Here is the code:

class FileDetails {

    private String fileName;
    private long fileSize;
    private byte[] fileData;

    public FileDetails(String fileName, long fileSize, byte[] fileData) {
        this.fileName = fileName;
        this.fileSize = fileSize;       
        this.fileData = fileData;
    }

    public String getFileName() {
        return fileName;
    }

    public long getFileSize() {
        return fileSize;
    }

    public byte[] getFileData() {
        return fileData;
    }

}


File file = new File("C://test.dat");
RandomAccessFile randFileAccess = new RandomAccessFile(file, "r");
byte[] buff = new byte[(int) file.length()];
randFileAccess.readFully(buff);

FileDetails fd = new FileDetails(file.getname(), file.length(); buff);

FileOutputStream fos = = new FileOutputStream(C://oos.dat);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(fd);
oos.write(buff);

The problem is that the file "test.dat" is quite large and it's not optimal to read it fully into the buffer(very large) in one go. I could have read the file into the buffer in chunks, but that would require me to create file and save data into the disk, which I cannot do as FileDetails object takes byte array.

How can I solve this problem? I want this approach only, i.e. Storing data as byte array in FileDetails object and then converting it to ObjectOutputStream, because I will be appending the appending an mp3 file infornt of the ObjectOutStream file and sending it over the internet.

Any suggetions? Or alternative approach?

Edit: Actually I am developing an android app. Where it stores the metadata of the file in a FileDetails object along with the file data in byte array. This FileDetails object is converted into an ObjectOutputStream file. Now an a specific mp3 file is appended in front of this ObjectOutputStream file, which is used to recognize that the file has been sent by my app. This combined mp3 file (which contains "hidden" ObjectOutputStream file) is send via a "popular" message app to the receiver. The receiver downloads the mp3 file through his "popular" message app. Now my app comes into action. It recognizes the mp3 file. And extracts the ObjectOutputStream file from the mp3 file. And casts it back to FileDetails and retrieves the Original file with it's metadata. Is my approach correct? Is there any other way to recognize my appended/hidden file?

Thanks a lot in advance.

Answer 1

Is it possible to add the class to the receiver? Then you could try something like this:

File file = new File("C://test.dat")
InputStream in = null;
   try {
     in = new BufferedInputStream(new FileInputStream(file));
     -> send over the network
    finally {
     if (in != null) {
       in.close();
     }
   }
 }

the receiver could just write the byte to a temporary file (and not hold them in memory)

InputStream is = socket.getInputStream();
FileOutputStream fos = new FileOutputStream("C://test.dat");
BufferedOutputStream bos = new BufferedOutputStream(fos);
//something like:
byte[] buffer = new byte[1024];
int len = is.read(buffer);
while (len != -1) {
    bos.write(buffer, 0, len);
    len = is.read(buffer);
}

and if the operation is finished, instantiate the object FileDetails fd = new FileDetails(the file you just created,....)

You can also send the class definition over network, if you must.

Answer 2

Here I've added read/writeObject methods:

class FileDetails implements Serializable {
  private static final int CHUNK_LEN = 0x10000; // 64k
  private String fileName;
  private long fileSize;
  private File file;

  // Note: everything can be deduced from a File object
  public FileDetails(File file) {
    this.fileName = file.getName();
    this.fileSize = file.length();       
    this.file = file;
  }

  public String getFileName() {
    return fileName;
  }

  public long getFileSize() {
    return fileSize;
  }

  // explicit coding for reading a FileDetails object
  private void readObject(ObjectInputStream stream)
    throws IOException, ClassNotFoundException {
    fileName = stream.readUTF();  // file name
    fileSize = stream.readLong(); // file size
    // file data as a series of byte[], length CHUNK_LEN
    long toRead = fileSize;
    // write file data to a File object, same path name
    file = new File( fileName );
    OutputStream os = new FileOutputStream( file );
    while( toRead > 0 ){
      // last byte arrays may be shorter than CHUNK_LEN
      int chunkLen = toRead > CHUNK_LEN ? CHUNK_LEN : (int)toRead;
      byte[] bytes = new byte[chunkLen];
      int nread = stream.read( bytes );
      // write data to file
      os.write( bytes, 0, nread );
      toRead -= nread;
    }
    os.close();
  }

  // explicit coding for writing a FileDetails object
  private void writeObject(ObjectOutputStream stream)
    throws IOException {
    stream.writeUTF( fileName );   // file name as an "UTF string"
    stream.writeLong( fileSize );  // file size
    // file data as a series of byte[], length CHUNK_LEN
    long toWrite = fileSize;
    // read file data from the File object passed to the constructor
    InputStream is = new FileInputStream( file );
    while( toWrite > 0 ){
      // last byte[] may be shorter than CHUNK_LEN
      int chunkLen = toWrite > CHUNK_LEN ? CHUNK_LEN : (int)toWrite;
      byte[] bytes = new byte[chunkLen];
      int nread = is.read( bytes );
      stream.write( bytes );
      toWrite -= nread;
    }
    is.close();
  }

  private void readObjectNoData()
    throws ObjectStreamException {
  }
}

I've tested this with a short file:

File file = new File( "test.dat" );
FileDetails fd = new FileDetails( file );
FileOutputStream fos = new FileOutputStream("oos.dat");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject( fd );
oos.close();

// test on a local system: rename test.dat to avoid overwriting
file.renameTo( new File( "test.dat.sav" ) );

FileInputStream fis = new FileInputStream("oos.dat");
ObjectInputStream ois = new ObjectInputStream(fis);
FileDetails fd1 = (FileDetails)ois.readObject();
ois.close();
// now the file test.dat has been rewritten under the same path,
// i.e., test.dat exists again and test.dat.sav == test.dat

I'm not sure whether the receiver will be happy with some file being written according to a path name being sent in the message.