Java: Un moyen de faire correspondre Mime (contenu) type d'extension de fichier de CommonsMultipartFile

La méthode la plus fiable est d'utiliser Les fichiers.probeContentType, mais qui nécessite un fichier réel, en partie parce que tous les systèmes d'exploitation dépendent de l'extension de déterminer le type de fichier.

Dans Linux, la meilleure approche est new MimetypesFileTypeMap("/etc/mime.types"), qui va être vraiment basé sur le système de correspondances. Je ne sais pas si mac OS X est un mime.types fichier (même si la recherche montre que TASSES pour OS X utilise un fichier de ce type, avec un renforcement, mais surtout la syntaxe de compatibilité descendante).

Autant que je sache, il n'est pas intégré dans la classe Java pour arriver MIME-type↔mappages d'extension de Windows.

URLConnection.getFileNameMap() renvoie une FileNameMap qui a un bon nombre d'entrées, mais tout n'est pas basé sur le système de correspondances. Sur mon système Linux, par exemple, il renvoie la valeur null .bz2 et .les fichiers rpm.

FileTypeMap.getDefaultFileTypeMap() semble avoir quelques entrées, mais il est clairement pas basée sur le système de correspondances. Au moins sur mon système, elle renvoie la valeur "application/octet-stream" pour .les fichiers png.

Je pense que la meilleure chose à faire est d'encapsuler tous d'entre eux dans une classe:

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.net.FileNameMap;
import java.net.URLConnection;
import java.util.logging.Logger;
import java.util.logging.Level;
import javax.activation.FileTypeMap;
import javax.activation.MimetypesFileTypeMap;
public class MimeTypes {
private static final Logger logger =
Logger.getLogger(MimeTypes.class.getName());
private static final String DEFAULT_TYPE = "application/octet-stream";
private static final Path mimeTypesFile = Paths.get("/etc/mime.types");
private final FileNameMap fileNameMap = URLConnection.getFileNameMap();
private final FileTypeMap fileTypeMap = FileTypeMap.getDefaultFileTypeMap();
private final FileTypeMap mimeTypesMap;
public MimeTypes() {
FileTypeMap map = null;
if (Files.isRegularFile(mimeTypesFile)) {
try {
map = new MimetypesFileTypeMap(mimeTypesFile.toString());
} catch (IOException e) {
logger.log(Level.WARNING, "Couldn't read " + mimeTypesFile, e);
}
}
mimeTypesMap = map;
}
public String getContentType(String filename) {
String type = null;
if (mimeTypesMap != null) {
type = mimeTypesMap.getContentType(filename);
}
if (type == null || type.equals(DEFAULT_TYPE)) {
type = fileNameMap.getContentTypeFor(filename);
}
if (type == null || type.equals(DEFAULT_TYPE)) {
type = fileTypeMap.getContentType(filename);
}
return type;
}
public static void main(String[] args) {
MimeTypes mimeTypes = new MimeTypes();
for (String arg : args) {
System.out.printf("Type of file \"%s\" is \"%s\"%n",
arg, mimeTypes.getContentType(arg));
}
}
}

Qui vous permettra d'obtenir d'assez bons résultats. Si vous voulez avoir une véritable plate-forme basée sur le type MIME de la vérification dans Windows, la seule façon que je sais faire c'est de lire le registre:

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.net.FileNameMap;
import java.net.URLConnection;
import java.util.logging.Logger;
import java.util.logging.Level;
import javax.activation.FileTypeMap;
import javax.activation.MimetypesFileTypeMap;
import java.io.File;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.Collections;
import java.util.Formatter;
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.ExecutionException;
public class MimeTypes {
private static final Logger logger =
Logger.getLogger(MimeTypes.class.getName());
private static final String DEFAULT_TYPE = "application/octet-stream";
private static final Path mimeTypesFile = Paths.get("/etc/mime.types");
private final FileNameMap fileNameMap = URLConnection.getFileNameMap();
private final FileTypeMap fileTypeMap = FileTypeMap.getDefaultFileTypeMap();
private final FileTypeMap mimeTypesMap;
public MimeTypes() {
FileTypeMap map = null;
if (Files.isRegularFile(mimeTypesFile)) {
try {
map = new MimetypesFileTypeMap(mimeTypesFile.toString());
} catch (IOException e) {
logger.log(Level.WARNING, "Couldn't read " + mimeTypesFile, e);
}
}
if (map == null && System.getProperty("os.name").contains("Windows")) {
try {
map = new WindowsFileTypeMap();
} catch (IOException e) {
logger.log(Level.WARNING, "Couldn't read registered types", e);
} catch (InterruptedException e) {
logger.log(Level.INFO, "Interrupted; read canceled", e);
}
}
mimeTypesMap = map;
}
public String getContentType(String filename) {
String type = null;
if (mimeTypesMap != null) {
type = mimeTypesMap.getContentType(filename);
}
if (type == null || type.equals(DEFAULT_TYPE)) {
type = fileNameMap.getContentTypeFor(filename);
}
if (type == null || type.equals(DEFAULT_TYPE)) {
type = fileTypeMap.getContentType(filename);
}
return type;
}
private static class WindowsFileTypeMap
extends FileTypeMap {
private final Map<String, String> extensionToMimeType;
public WindowsFileTypeMap()
throws IOException,
InterruptedException {
ProcessBuilder builder =
new ProcessBuilder("PowerShell.exe", "-Command", "-");
Process process = builder.start();
List<String> regEntryNames = getOutput(process, String.format(
"Get-ChildItem \"Registry::HKEY_CLASSES_ROOT\\\" |"
+ " Select-String -InputObject { $_.Name }"
+ " -SimpleMatch -Pattern \"HKEY_CLASSES_ROOT\\.\"%n"));
Formatter input = new Formatter();
for (String name : regEntryNames) {
input.format(
"$values = Get-ItemProperty \"Registry::%s\"%n" +
"$values.\"Content Type\" + \" \"%n", name);
}
process = builder.start();
List<String> mimeTypes = getOutput(process, input.toString());
int len = regEntryNames.size();
extensionToMimeType = new HashMap<>(len);
for (int i = 0; i < len; i++) {
String mimeType = mimeTypes.get(i).trim();
if (!mimeType.isEmpty()) {
String extension =
regEntryNames.get(i).replace("HKEY_CLASSES_ROOT\\", "");
extensionToMimeType.put(extension, mimeType);
}
}
}
@Override
public String getContentType(File file) {
return getContentType(file.toString());
}
@Override
public String getContentType(String filename) {
int period = filename.lastIndexOf('.');
if (period < 0) {
return DEFAULT_TYPE;
}
String ext = filename.substring(period);
String type = extensionToMimeType.get(ext);
return (type != null ? type : DEFAULT_TYPE);
}
private static List<String> getOutput(final Process process,
final String input)
throws IOException,
InterruptedException {
Callable<Void> inputSender = new Callable<Void>() {
@Override
public Void call()
throws IOException {
try (BufferedWriter writer =
new BufferedWriter(
new OutputStreamWriter(
process.getOutputStream()))) {
writer.write(input);
}
return null;
}
};
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<?> inputSenderStatus = executor.submit(inputSender);
List<String> lines;
try (BufferedReader reader =
new BufferedReader(
new InputStreamReader(
process.getInputStream()))) {
lines = new ArrayList<>();
String line;
while ((line = reader.readLine()) != null) {
lines.add(line);
}
}
try {
inputSenderStatus.get();
} catch (ExecutionException e) {
throw new IOException(e);
}
executor.shutdown();
executor.awaitTermination(30, TimeUnit.SECONDS);
process.waitFor();
return lines;
}
}
public static void main(String[] args) {
MimeTypes mimeTypes = new MimeTypes();
for (String arg : args) {
System.out.printf("Type of file \"%s\" is \"%s\"%n",
arg, mimeTypes.getContentType(arg));
}
}
}