Получение Mime-типа файла в Java

К несчастью,

mimeType = file.toURL().openConnection().getContentType();

не работает, поскольку такое использование URL-адреса оставляет файл заблокированным, так что, например, его невозможно удалить.

Однако у вас есть это:

mimeType= URLConnection.guessContentTypeFromName(file.getName());

а также следующее, преимущество которого заключается в том, что оно выходит за рамки простого использования расширения файла, и позволяет взглянуть на контент

InputStream is = new BufferedInputStream(new FileInputStream(file));
mimeType = URLConnection.guessContentTypeFromStream(is);
 //...close stream

Однако, как следует из комментария выше, встроенная таблица mime-типов весьма ограничена, не включая, например, MSWord и PDF. Итак, если вы хотите обобщить, вам нужно выйти за рамки встроенных библиотек, используя, например, Mime-Util (отличная библиотека, использующая как расширение файла, так и содержимое).

JAF API является частью JDK 6. Посмотрите на пакет javax.activation.

Наиболее интересными классами являются javax.activation.MimeType - фактический держатель типа MIME - и javax.activation.MimetypesFileTypeMap - класс, экземпляр которого может разрешать тип MIME как String для файла:

String fileName = "/path/to/file";
MimetypesFileTypeMap mimeTypesMap = new MimetypesFileTypeMap();

// only by file name
String mimeType = mimeTypesMap.getContentType(fileName);

// or by actual File instance
File file = new File(fileName);
mimeType = mimeTypesMap.getContentType(file);

От розаиндия:

FileNameMap fileNameMap = URLConnection.getFileNameMap();
String mimeType = fileNameMap.getContentTypeFor("alert.gif");

В Java 7 теперь можно просто использовать Files.probeContentType(path).

Я пробовал несколько способов сделать это, в том числе первый, который сказал @Joshua Fox. Но некоторые не распознают частые mimetypes, например, для файлов PDF, а другим нельзя доверять с поддельными файлами (я пробовал с файлом RAR с расширением, измененным на TIF). Решение, которое я нашел, как также поверхностно сказал @Joshua Fox, заключается в использовании MimeUtil2, например:

MimeUtil2 mimeUtil = new MimeUtil2();
mimeUtil.registerMimeDetector("eu.medsea.mimeutil.detector.MagicMimeMimeDetector");
String mimeType = MimeUtil2.getMostSpecificMimeType(mimeUtil.getMimeTypes(file)).toString();

Если вы разработчик Android, вы можете использовать служебный класс android.webkit.MimeTypeMap, который сопоставляет типы MIME с расширениями файлов и наоборот.

Следующий фрагмент кода может вам помочь.

private static String getMimeType(String fileUrl) {
    String extension = MimeTypeMap.getFileExtensionFromUrl(fileUrl);
    return MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
}

Апач Тика предлагает в тика-ядро определение типа mime на основе магических маркеров в префиксе потока. tika-core не извлекает другие зависимости, что делает его таким же легким, как неподдерживаемый в настоящее время Утилита обнаружения типа Mime.

Пример простого кода (Java 7) с использованием переменных theInputStream и theFileName

try (InputStream is = theInputStream;
        BufferedInputStream bis = new BufferedInputStream(is);) {
    AutoDetectParser parser = new AutoDetectParser();
    Detector detector = parser.getDetector();
    Metadata md = new Metadata();
    md.add(Metadata.RESOURCE_NAME_KEY, theFileName);
    MediaType mediaType = detector.detect(bis, md);
    return mediaType.toString();
}

Обратите внимание, что MediaType.detect(...) нельзя использовать напрямую (ТИКА-1120). Дополнительные подсказки представлены в https://tika.apache.org/1.24/detection.html.

I was just wondering how most people fetch a mime type from a file in Java?

Я опубликовал свой пакет Java SimpleMagic, который позволяет определять тип содержимого (тип mime) из файлов и массивов байтов. Он предназначен для чтения и запуска командных магических файлов файла Unix (1), которые являются частью большинства конфигураций ОС Unix.

Я пробовал Apache Tika, но это огромный с множеством зависимостей, URLConnection не использует байты файлов, а MimetypesFileTypeMap также просто смотрит на имена файлов.

С SimpleMagic вы можете делать что-то вроде:

// create a magic utility using the internal magic file
ContentInfoUtil util = new ContentInfoUtil();
// if you want to use a different config file(s), you can load them by hand:
// ContentInfoUtil util = new ContentInfoUtil("/etc/magic");
...
ContentInfo info = util.findMatch("/tmp/upload.tmp");
// or
ContentInfo info = util.findMatch(inputStream);
// or
ContentInfo info = util.findMatch(contentByteArray);

// null if no match
if (info != null) {
   String mimeType = info.getMimeType();
}

Если вы застряли с java 5-6, затем этот служебный класс из сервой продукт с открытым исходным кодом.

Вам нужна только эта функция

public static String getContentType(byte[] data, String name)

Он проверяет первые байты содержимого и возвращает типы содержимого на основе этого содержимого, а не по расширению файла.

Для загрузки файлов лучше использовать двухуровневую проверку.

Сначала вы можете проверить mimeType и подтвердить его.

Во-вторых, вы должны преобразовать первые 4 байта вашего файла в шестнадцатеричное, а затем сравнить их с магическими числами. Тогда это будет действительно безопасный способ проверки файлов.

если вы работаете в ОС linux, есть командная строка file --mimetype:

String mimetype(file){

   //1. run cmd
   Object cmd=Runtime.getRuntime().exec("file --mime-type "+file);

   //2 get output of cmd , then 
    //3. parse mimetype
    if (output){return output.split(":")[1].trim(); }
    return "";
}

потом

mimetype("/home/nyapp.war") //  'application/zip'

mimetype("/var/www/ggg/au.mp3") //  'audio/mp3'

весной файл MultipartFile;

org.springframework.web.multipart.MultipartFile

file.getContentType();

Попробовав различные другие библиотеки, я остановился на mime-util.

<groupId>eu.medsea.mimeutil</groupId>
      <artifactId>mime-util</artifactId>
      <version>2.1.3</version>
</dependency>

File file = new File("D:/test.tif");
MimeUtil.registerMimeDetector("eu.medsea.mimeutil.detector.MagicMimeMimeDetector");
Collection<?> mimeTypes = MimeUtil.getMimeTypes(file);
System.out.println(mimeTypes);

public String getFileContentType(String fileName) {
    String fileType = "Undetermined";
    final File file = new File(fileName);
    try
    {
        fileType = Files.probeContentType(file.toPath());
    }
    catch (IOException ioException)
    {
        System.out.println(
                "ERROR: Unable to determine file type for " + fileName
                        + " due to exception " + ioException);
    }
    return fileType;
}

С Апач Тика вам понадобится только три строки кода:

File file = new File("/path/to/file");
Tika tika = new Tika();
System.out.println(tika.detect(file));

Если у вас отличная консоль, просто вставьте и запустите этот код, чтобы поиграть с ней:

@Grab('org.apache.tika:tika-core:1.14')
import org.apache.tika.Tika;

def tika = new Tika()
def file = new File("/path/to/file")
println tika.detect(file)

Имейте в виду, что его API-интерфейсы богаты, он может разбирать «все». Начиная с tika-core 1.14, у вас есть:

String  detect(byte[] prefix)
String  detect(byte[] prefix, String name)
String  detect(File file)
String  detect(InputStream stream)
String  detect(InputStream stream, Metadata metadata)
String  detect(InputStream stream, String name)
String  detect(Path path)
String  detect(String name)
String  detect(URL url)

См. апидоки для получения дополнительной информации.

Это самый простой способ, который я нашел для этого:

byte[] byteArray = ...
InputStream is = new BufferedInputStream(new ByteArrayInputStream(byteArray));
String mimeType = URLConnection.guessContentTypeFromStream(is);

Чтобы скинуть свои 5 центов:

TL, DR

Я использую MimetypesFileTypeMap и добавляю любой mime, которого нет, и он мне особенно нужен, в файл mime.types.

А теперь длинное прочтение:

Прежде всего, список типов MIME - огромный, см. Здесь: https://www.iana.org/assignments/media-types/media-types.xhtml

Мне нравится сначала использовать стандартные средства, предоставляемые JDK, и если это не сработает, я пойду и поищу что-нибудь еще.

Определить тип файла по расширению файла

Начиная с версии 1.6, Java имеет MimetypesFileTypeMap, как указано в одном из ответов выше, и это самый простой способ определить тип mime:

new MimetypesFileTypeMap().getContentType( fileName );

В своей ванильной реализации это не так много (то есть работает для .html, но не для .png). Однако добавить любой тип контента, который вам может понадобиться, очень просто:

1. Создайте файл с именем mime.types в папке META-INF вашего проекта.
2. Добавьте строку для каждого типа MIME, который вам нужен, и реализация по умолчанию не обеспечивает (существуют сотни типов MIME, и список со временем растет).

Примеры записей для файлов png и js:

image/png png PNG
application/javascript js

Подробнее о формате файла mime.types см. Здесь: https://docs.oracle.com/javase/7/docs/api/javax/activation/MimetypesFileTypeMap.html

Определить тип файла по содержимому файла

Начиная с версии 1.7 в Java есть java.nio.file.spi.FileTypeDetector, который определяет стандартный API для определения типа файла в конкретный способ реализации.

Чтобы получить тип MIME для файла, вы должны просто использовать Файлы и сделать это в своем коде:

Files.probeContentType(Paths.get("either file name or full path goes here"));

Определение API предоставляет средства, которые поддерживают определение типа MIME файла по имени файла или по содержимому файла (магические байты). Вот почему метод probeContentType () выдает исключение IOException, если реализация этого API использует предоставленный ему путь, чтобы фактически попытаться открыть связанный с ним файл.

Опять же, ванильный выполнение этого (тот, что идет с JDK) оставляет желать лучшего.

В каком-то идеальном мире в далекой-далекой галактике все эти библиотеки, которые пытаются решить эту проблему типа file-to-mime, просто реализуют java.nio.file.spi.FileTypeDetector, вы должны добавить jar-файл предпочтительной реализуемой библиотеки в свой путь к классам, и это будет Это.

В реальном мире, где вам нужен раздел TL, DR, вы должны найти библиотеку с наибольшим количеством звезд рядом с ее названием и использовать ее. В данном конкретном случае он мне не нужен (пока;)).

Вы можете сделать это с помощью одной строки: MimetypesFileTypeMap (). GetContentType (новый файл ("filename.ext")). Посмотрите полный тестовый код (Java 7):

import java.io.File;
import javax.activation.MimetypesFileTypeMap;
public class MimeTest {
    public static void main(String a[]){
         System.out.println(new MimetypesFileTypeMap().getContentType(
           new File("/path/filename.txt")));
    }
}

Этот код дает следующий результат: текст / простой

File file = new File(PropertiesReader.FILE_PATH);
MimetypesFileTypeMap fileTypeMap = new MimetypesFileTypeMap();
String mimeType = fileTypeMap.getContentType(file);
URLConnection uconnection = file.toURL().openConnection();
mimeType = uconnection.getContentType();

Я сделал это с помощью следующего кода.

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class MimeFileType {

    public static void main(String args[]){

        try{
            URL url = new URL ("https://www.url.com.pdf");

            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            connection.setDoOutput(true);
            InputStream content = (InputStream)connection.getInputStream();
            connection.getHeaderField("Content-Type");

            System.out.println("Content-Type "+ connection.getHeaderField("Content-Type"));

            BufferedReader in = new BufferedReader (new InputStreamReader(content));

        }catch (Exception e){

        }
    }
}

Если вы работаете с сервлетом и вам доступен контекст сервлета, вы можете использовать:

getServletContext().getMimeType( fileName );

Апач Тика.

<!-- https://mvnrepository.com/artifact/org.apache.tika/tika-parsers -->
<dependency>
    <groupId>org.apache.tika</groupId>
    <artifactId>tika-parsers</artifactId>
    <version>1.24</version>
</dependency>

и две строки кода.

Tika tika=new Tika();
tika.detect(inputStream);

Снимок экрана ниже

Мне не удалось найти ничего для проверки типа MIME video/mp4, поэтому я сделал собственное решение. Я случайно заметил, что Википедия ошибалась и что подпись файла 00 00 00 18 66 74 79 70 69 73 6F 6D неверна. четвертый байт (18) и все 70 (исключенные) после значительных изменений среди других допустимых файлов mp4.

Этот код по сути является копией / вставкой кода URLConnection.guessContentTypeFromStream, но адаптирован для video/mp4.

BufferedInputStream bis = new BufferedInputStream(new ByteArrayInputStream(content));
String mimeType = URLConnection.guessContentTypeFromStream(bis);

// Goes full barbaric and processes the bytes manually
if (mimeType == null){
    // These ints converted in hex ar:
    // 00 00 00 18 66 74 79 70 69 73 6F 6D
    // which are the file signature (magic bytes) for .mp4 files
    // from https://www.wikiwand.com/en/List_of_file_signatures
    // just ctrl+f "mp4"
    int[] mp4_sig = {0, 0, 0, 24, 102, 116, 121, 112};

    bis.reset();
    bis.mark(16);
    int[] firstBytes = new int[8];
    for (int i = 0; i < 8; i++) {
        firstBytes[i] = bis.read();
    }
    // This byte doesn't matter for the file signature and changes
    mp4_sig[3] = content[3];

    bis.reset();
    if (Arrays.equals(firstBytes, mp4_sig)){
        mimeType = "video/mp4";
    }
}

Успешно протестирован с 10 различными файлами .mp4.

Обновлено: Вот полезная ссылка (если она все еще в сети), где вы можете найти образцы многих типов. У меня нет этих видео, и я не знаю, у кого они есть, но они полезны для тестирования приведенного выше кода.

Простой и лучший вариант - получить тип MIME содержимого из местоположения файла.

Используйте этот импорт

import java.nio.file.Files;
import java.nio.file.Path;

Код

String type = Files.probeContentType(Path.of(imagePath));

Потому что так много ответов, связанных с библиотеками или непереносимым кодом; Я подумал, что поделюсь альтернативным способом, просто проверив магические байты потока или файла, тип которого вы хотите узнать, как я показал здесь: https://stackoverflow.com/a/65667558/3225638

Он использует родную java, но требует, чтобы вы заранее определили в перечислении типы, которые вы хотите обрабатывать / обнаруживать, но вам нужно будет сделать это только один раз.