Java : InputStream Multi-partie de conversion de fichier, le fichier est vide

La DiskFileItem utilise un DeferredFileOutputStream qui utilise une mémoire de tableau d'octets qui est rempli uniquement lorsque les octets sont effectivement transférés.
Etant donné que les fichiers sont utilisés directement et sans octets sont réellement copiés,
le tableau d'octets n'est jamais rempli. Voyez par vous-même dans le code source:

Code Source CommonsMultipartFile

Code Source DiskFileItem

Code Source DeferredFileOutputStream

Ainsi, au lieu de simplement appeler fileItem.getOutputStream();, le transfert des octets de remplissage de la mémoire de tableau d'octets:

try (OutputStream out = fileItem.getOutputStream();
        InputStream in = Files.newInputStream(file.toPath())) {
    IOUtils.copy(in, dfos);
}

et puis le tranferTo appel travail.

Ce qui semble être un peu lourd pour le simple fait de déplacer un fichier: CommonsMultipartFile seuls les appels fileItem.write((File)dest) dans le transferTo méthode.
Ci-dessous, deux cas de test, à l'aide de la DiskFileItem et à l'aide de la LocalFileItem. Le code pour LocalFileItem est indiquée ci-dessous.

J'ai utilisé les dépendances org.springframework:spring-web:4.2.2.RELEASE, commons-fileupload:commons-fileupload:1.3.1 et junit:junit:4.12

Classe de Test CommonMp:

import static org.junit.Assert.*;
import java.io.*;
import java.nio.charset.*;
import java.nio.file.*;
import org.apache.commons.fileupload.disk.DiskFileItem;
import org.apache.commons.io.IOUtils;
import org.junit.Test;
import org.springframework.web.multipart.commons.CommonsMultipartFile;
public class CommonMp {
private final Charset CS = StandardCharsets.UTF_8;
@Test
public void testLocalMp() {
Path testInputFile = null, testOutputFile = null;
try {
testInputFile = prepareInputFile();
LocalFileItem lfi = new LocalFileItem(testInputFile);
CommonsMultipartFile cmf = new CommonsMultipartFile(lfi);
System.out.println("Empty: " + cmf.isEmpty());
testOutputFile = testInputFile.getParent().resolve("testMpOutput.txt");
cmf.transferTo(testOutputFile.toFile());
System.out.println("Size: " + cmf.getSize());
printOutput(testOutputFile);
} catch (Exception e) {
e.printStackTrace();
fail();
} finally {
deleteSilent(testInputFile, testOutputFile);
}
}
@Test
public void testMp() {
Path testInputFile = null, testOutputFile = null;
try {
testInputFile = prepareInputFile();
DiskFileItem di = new DiskFileItem("file", "text/plain", false, testInputFile.getFileName().toString(), 
(int) Files.size(testInputFile), testInputFile.getParent().toFile());
try (OutputStream out = di.getOutputStream();
InputStream in = Files.newInputStream(testInputFile)) {
IOUtils.copy(in, out);
}
CommonsMultipartFile cmf = new CommonsMultipartFile(di);
System.out.println("Size: " + cmf.getSize());
testOutputFile = testInputFile.getParent().resolve("testMpOutput.txt");
cmf.transferTo(testOutputFile.toFile());
printOutput(testOutputFile);
} catch (Exception e) {
e.printStackTrace();
fail();
} finally {
deleteSilent(testInputFile, testOutputFile);
}
}
private Path prepareInputFile() throws IOException {
Path tmpDir = Paths.get(System.getProperty("java.io.tmpdir"));
Path testInputFile = tmpDir.resolve("testMpinput.txt");
try (OutputStream out = Files.newOutputStream(testInputFile)){
out.write("Just a test.".getBytes(CS));
}
return testInputFile;
}
private void printOutput(Path p) throws IOException {
byte[] outBytes = Files.readAllBytes(p);
System.out.println("Output: " + new String(outBytes, CS));
}
private void deleteSilent(Path... paths) {
for (Path p : paths) {
try { if (p != null) p.toFile().delete(); } catch (Exception ignored) {}
}
}
}

La coutume LocalFileItem classe, YMMV!

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileItemHeaders;
public class LocalFileItem implements FileItem {
private static final long serialVersionUID = 2467880290855097332L;
private final Path localFile;
public LocalFileItem(Path localFile) {
this.localFile = localFile;
}
@Override
public void write(File file) throws Exception {
Files.move(localFile, file.toPath(), StandardCopyOption.REPLACE_EXISTING);
}
@Override
public long getSize() {
//Spring's CommonsMultipartFile caches the file size and uses it to determine availability.
long size = -1L;
try {
size = Files.size(localFile);
} catch (IOException ignored) {}
return size;
}
@Override
public void delete() {
localFile.toFile().delete();
}
/* *** properties and unsupported methods *** */
private FileItemHeaders headers;
private String contentType;
private String fieldName;
private boolean formField;
@Override
public FileItemHeaders getHeaders() {
return headers;
}
@Override
public void setHeaders(FileItemHeaders headers) {
this.headers = headers;
}
@Override
public InputStream getInputStream() throws IOException {
throw new IOException("Only method write(File) is supported.");
}
public void setContentType(String contentType) {
this.contentType = contentType;
}
@Override
public String getContentType() {
return contentType;
}
@Override
public String getName() {
return localFile.getFileName().toString();
}
@Override
public boolean isInMemory() {
return false;
}
@Override
public byte[] get() {
throw new RuntimeException("Only method write(File) is supported.");
}
@Override
public String getString(String encoding)
throws UnsupportedEncodingException {
throw new RuntimeException("Only method write(File) is supported.");
}
@Override
public String getString() {
throw new RuntimeException("Only method write(File) is supported.");
}
@Override
public String getFieldName() {
return fieldName;
}
@Override
public void setFieldName(String name) {
this.fieldName = name;
}
@Override
public boolean isFormField() {
return formField;
}
@Override
public void setFormField(boolean state) {
this.formField = state;
}
@Override
public OutputStream getOutputStream() throws IOException {
throw new IOException("Only method write(File) is supported.");
}
}

OriginalL'auteur vanOekel