Как определить тип MIME на основе содержимого после переименования файла. Используя JAVA [duplicate]

, если вы работаете с операционной системой 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'

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

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

org.springframework.web.multipart.MultipartFile

file.getContentType();

Из roseindia :

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

Вы можете сделать это только с одной строкой: 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")));
    }
}

Этот код выводит следующий вывод: text / plain

Я попробовал несколько способов сделать это, в том числе первые, которые сказал @Joshua Fox. Но некоторые из них не распознают частые миметики, например, для файлов 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();

Мне просто интересно, как большинство людей выбирает тип mime из файла на Java?

Я опубликовал свой пакет Java SimpleMagic Java, который позволяет определять тип содержимого (mime-type) из файлов и массивов байтов. Он предназначен для чтения и запуска файлов команд с файлами 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();
}

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

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

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

К сожалению,

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 (это отличная библиотека, использующая как расширение файла, так и контент).

После тестирования различных других библиотек я установил 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);

Apache Tika предлагает в tika-core обнаружение типа mime, основанное на магических маркерах в префиксе потока. tika-core не извлекает другие зависимости, что делает его столь же легким, как и текущая потерянная утилита Mime Type Detection Utility .

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 (...) нельзя использовать напрямую ( TIKA-1120 ). Дополнительные советы указаны в https://tika.apache.org/0.10/detection.html .

С помощью Apache Tika вам понадобятся только три строки кода:

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)

Для получения дополнительной информации см. apidocs .

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

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

Чтобы чип с моими 5 центами:

TL, DR

Я использую MimetypesFileTypeMap и добавляю любой мим, которого нет, и я специально нуждаюсь это файл 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-файлов будут be:

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 и сделать это в вашем коде:

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

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

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

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

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

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

https://github.com/Servoy/servoy-client/blob/e7f5bce3c3dc0f0eb1cd240fce48c75143a25432/servoy_shared /src/com/servoy/j2db/util/MimeTypes.java#L34

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

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

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

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

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

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