Java：一种将 Mime（内容）类型与 CommonsMultipartFile 中的文件扩展名匹配的方法

Question

At my company, I need to compare the mime type to the file extension for extra reason. I have a CommonsMultipartFile . I am trying to figure out the best way to do this comparison. I have seen a MimetypesFileTypeMap , but not sure if that will work here. I am trying to avoid (or limit) any hard coding.

I get the values as such:

CommonsMultipartFile file = ...;
String fileName = file.getOriginalFilename();
String contentType = file.getContentType();

String extension = FilenameUtils.getExtension(fileName);

I appreciate any guidance and help on this. Thanks!

Answer 1

Java library for that case is quite limited (number of types). This is how I do it:

static String getMimeType(String fileName) {
    // 1. first use java's built-in utils
    FileNameMap mimeTypes = URLConnection.getFileNameMap();
    String contentType = mimeTypes.getContentTypeFor(fileName);

    // 2. nothing found -> lookup our in extension map to find types like ".doc" or ".docx"
    if (contentType == null) {
        String extension = fileName.substring(fileName.lastIndexOf('.') + 1, fileName.length());;
        contentType = fileExtensionMap.get(extension);
    }
    return contentType;
}

step 2 involves having a static map:

private static final Map<String, String> fileExtensionMap;

static {
    fileExtensionMap = new HashMap<String, String>();
    // MS Office
    fileExtensionMap.put("doc", "application/msword");
    fileExtensionMap.put("dot", "application/msword");
    fileExtensionMap.put("docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document");
    fileExtensionMap.put("dotx", "application/vnd.openxmlformats-officedocument.wordprocessingml.template");
    fileExtensionMap.put("docm", "application/vnd.ms-word.document.macroEnabled.12");
    fileExtensionMap.put("dotm", "application/vnd.ms-word.template.macroEnabled.12");
    fileExtensionMap.put("xls", "application/vnd.ms-excel");
    fileExtensionMap.put("xlt", "application/vnd.ms-excel");
    fileExtensionMap.put("xla", "application/vnd.ms-excel");
    fileExtensionMap.put("xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
    fileExtensionMap.put("xltx", "application/vnd.openxmlformats-officedocument.spreadsheetml.template");
    fileExtensionMap.put("xlsm", "application/vnd.ms-excel.sheet.macroEnabled.12");
    fileExtensionMap.put("xltm", "application/vnd.ms-excel.template.macroEnabled.12");
    fileExtensionMap.put("xlam", "application/vnd.ms-excel.addin.macroEnabled.12");
    fileExtensionMap.put("xlsb", "application/vnd.ms-excel.sheet.binary.macroEnabled.12");
    fileExtensionMap.put("ppt", "application/vnd.ms-powerpoint");
    fileExtensionMap.put("pot", "application/vnd.ms-powerpoint");
    fileExtensionMap.put("pps", "application/vnd.ms-powerpoint");
    fileExtensionMap.put("ppa", "application/vnd.ms-powerpoint");
    fileExtensionMap.put("pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation");
    fileExtensionMap.put("potx", "application/vnd.openxmlformats-officedocument.presentationml.template");
    fileExtensionMap.put("ppsx", "application/vnd.openxmlformats-officedocument.presentationml.slideshow");
    fileExtensionMap.put("ppam", "application/vnd.ms-powerpoint.addin.macroEnabled.12");
    fileExtensionMap.put("pptm", "application/vnd.ms-powerpoint.presentation.macroEnabled.12");
    fileExtensionMap.put("potm", "application/vnd.ms-powerpoint.presentation.macroEnabled.12");
    fileExtensionMap.put("ppsm", "application/vnd.ms-powerpoint.slideshow.macroEnabled.12");
    // Open Office
    fileExtensionMap.put("odt", "application/vnd.oasis.opendocument.text");
    fileExtensionMap.put("ott", "application/vnd.oasis.opendocument.text-template");
    fileExtensionMap.put("oth", "application/vnd.oasis.opendocument.text-web");
    fileExtensionMap.put("odm", "application/vnd.oasis.opendocument.text-master");
    fileExtensionMap.put("odg", "application/vnd.oasis.opendocument.graphics");
    fileExtensionMap.put("otg", "application/vnd.oasis.opendocument.graphics-template");
    fileExtensionMap.put("odp", "application/vnd.oasis.opendocument.presentation");
    fileExtensionMap.put("otp", "application/vnd.oasis.opendocument.presentation-template");
    fileExtensionMap.put("ods", "application/vnd.oasis.opendocument.spreadsheet");
    fileExtensionMap.put("ots", "application/vnd.oasis.opendocument.spreadsheet-template");
    fileExtensionMap.put("odc", "application/vnd.oasis.opendocument.chart");
    fileExtensionMap.put("odf", "application/vnd.oasis.opendocument.formula");
    fileExtensionMap.put("odb", "application/vnd.oasis.opendocument.database");
    fileExtensionMap.put("odi", "application/vnd.oasis.opendocument.image");
    fileExtensionMap.put("oxt", "application/vnd.openofficeorg.extension");
    // Other
    fileExtensionMap.put("txt", "text/plain");
    fileExtensionMap.put("rtf", "application/rtf");
    fileExtensionMap.put("pdf", "application/pdf");
}

works fine for me, hope that helps!

Answer 2

The most reliable method is to use Files.probeContentType , but that requires an actual file, partly because not all operating systems rely on the extension to determine the file type.

In Linux, the next best approach is new MimetypesFileTypeMap("/etc/mime.types") , which will be truly based on the system's mappings. I don't know if OS X has a mime.types file (though a search shows that CUPS for OS X uses such a file, with an enhanced but mostly backward compatible syntax).

As far as I know, there is no built-in Java class for getting MIME-type↔extension mappings in Windows.

URLConnection.getFileNameMap() returns a FileNameMap that has a decent number of entries, but still isn't based on the system's mappings. On my Linux system, for example, it returns null for .bz2 and .rpm files.

FileTypeMap.getDefaultFileTypeMap() seems to have a few entries, but it too is clearly not based on the system's mappings. At least on my system, it returns "application/octet-stream" for .png files.

I think the easiest thing to do is encapsulate all of them in a class:

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

That will get you fairly good results. If you want to have true platform-based MIME type checking in Windows, the only way I know to do that is to read the registry:

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

Answer 3

I have a class https://github.com/nablex/utils-io/blob/master/src/main/java/be/nabu/utils/io/ContentTypeMap.java that does this.

It adds a few things that are missing in the URLConnection stuff:

• it can handle 1-* relationships in both directions (one mime type, multiple extensions and the other way around)
• you can go both directions (mimetype > extension and extension > mimetype)

Additionally it can be plugged into the URLConnection using:

ContentTypeMap.register()

By default it uses a file to load the mappings: https://github.com/nablex/utils-io/blob/master/src/main/resources/mime.properties

Answer 4

boolean getMimeType(String fileName) {
boolean flag=false;
Map<String, String> fileExtnMap= new HashMap<String, String>();
fileExtnMap.put("jpg","image/jpg");
fileExtnMap.put("jpeg","image/jpeg");
fileExtnMap.put("pdf","application/pdf");

FileNameMap fileMap = URLConnection.getFileNameMap();
String contentType=fileMap .getContentTypeFor(fileName);
String[] extn= fileName.split("\\.");
contentType = fileExtnMap.get(extn[1]);
if(extn[1].equals("pdf") && contentType.equals("application/pdf") || extn[1].equals("jpg") && contentType.equals("image/jpg") || extn[1].equals("jpeg") && contentType.equals("image/jpeg")){
    flag=true;
}
    
    return flag;
}