Java: Eine Weise zu entsprechen Mime (content) geben, um die Datei-Endung von CommonsMultipartFile

Die zuverlässigste Methode ist die Verwendung - Dateien.probeContentType, aber das erfordert eine tatsächliche Datei, teilweise, weil nicht alle Betriebssysteme verlassen sich auf die Erweiterung um die Datei zu bestimmen Art.

In Linux, ist die nächste beste Ansatz ist new MimetypesFileTypeMap("/etc/mime.types"), das wirklich basierend auf dem system die Zuordnungen. Ich weiß nicht, ob OS X hat eine mime.types - Datei (obwohl Sie eine Suche zeigt, dass TASSEN für OS X nutzt eine solche Datei mit einem erweiterten, aber meist abwärtskompatibler syntax).

Soweit ich weiß, gibt es keine integrierte Java-Klasse für die erste MIME-Typ↔extension mappings in Windows.

URLConnection.getFileNameMap() gibt eine FileNameMap, dass hat eine anständige Zahl von Einträgen, aber immer noch nicht, basiert auf dem system die Zuordnungen. Auf meinem Linux-system, zum Beispiel, gibt Sie null zurück .bz2-und .rpm-Dateien.

FileTypeMap.getDefaultFileTypeMap() zu haben scheint, ein paar Einträge, aber es ist auch klar, das nicht basiert auf das system der Zuordnungen. Zumindest auf meinem system, gibt es "application/octet-stream".png-Dateien.

Ich denke, die einfachste Sache zu tun ist Kapseln alle in einer Klasse:

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));
        }
    }
}

Dass Sie ziemlich gute Ergebnisse. Wenn Sie möchten, echte Plattform-basierten MIME-Typ-überprüfung in Windows, ich weiß nur einen Weg, dies zu tun ist, das registry zu Lesen:

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));
        }
    }
}

InformationsquelleAutor VGR