从远程EJB调用返回大文件

Question

I have an EJB client that needs to retrieve a large file from an EJB server (JBoss).

The evident way to implement this is the server to offer a EJB facade with a method like this one:

public byte[] getFile(String fileName);

That means, loading the whole file in memory , in a byte array, and then sending this byte array on the wire.

The problem is that this approach loads the whole file in memory, and since the file is huge, it would overflow it.

Is there any option to overcome this problem?

Answer 1

HTTP would be a better choice, but that said, try this serialization trick:

import java.io.*;

public class FileContent implements Serializable {

    private transient File file;

    public FileContent() {
    }

    public FileContent(File file) {
        this.file = file;
    }

    private void writeObject(ObjectOutputStream out) throws IOException {
        // 1. write the file name
        out.writeUTF(file.getAbsolutePath());

        // 2. write the length
        out.writeLong(file.length());

        // 3. write the content
        final InputStream in = new BufferedInputStream(new FileInputStream(file));
        final byte[] buffer = new byte[1024];

        int length;
        while ((length = in.read(buffer)) != -1) {
            out.write(buffer, 0, length);
        }
        out.flush();
        in.close();
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        // 1. read the file name
        final String path = in.readUTF();

        // 2. read the length
        long remaining = in.readLong();

        // 3. read the content
        file = new File(path);
        final OutputStream out = new BufferedOutputStream(new FileOutputStream(file));

        final byte[] buffer = new byte[1024];

        while (true) {
            int length = in.read(buffer, 0, (int) Math.min(remaining, buffer.length));
            if (length == -1) break;

            out.write(buffer, 0, length);

            remaining -= length;
            if (remaining <= 0) break;
        }
        out.flush();
        out.close();
    }
}

Answer 2

The RMIIO library was built for exactly this situation. It even includes an implementation of @DavidBlevins solution, the DirectRemoteInputStream .

Answer 3

You may use ZipOutputStream, which wrapped in BytearrayOutputStream. This action will allow you to return compressed byte array, using you method declaration in the first place, in order to decrease overhead of RMI transmition.

Answer 4

RMI protocol is a totally bad solution for sending large files. A possible but quiet inefficient solution is splitting your file in small chunks, send them from EJB and reassemble file on the client-side. Something like this:

public class FileMetadata {
    ....
    private long chunkCount;
    private long chunkSize;
    ....
}

...
public FileMetadata getFileMetadata(String fileName) {...}
public byte[] getFileChunk(String fileName, long chunkNumber) {...}
...

Answer 5

我会重新考虑你的架构，恕我直言你应该快速保持你的ejb调用，如何从ejb调用返回文件的位置然后在另一个程序中处理downlod，看看这里有关如何下载大文件的更多信息使用Java从Internet下载并保存文件？

Answer 6

The approach I took (mind you only works for @LocalBean s) is to write to a File.createTempFile from the EJB and return a File to retrieve the data and delete it from the client. Path may be used as well, but note that it is not Serializable .

However, you can also make it write to a file hosted by an HTTP server and retrieve it from there later. Then send an HTTP DELETE request to delete the file afterwards. Your EJB would instead return a java.net.URI .