Obtendo o tipo MIME de um arquivo em Java

Eu só estava me perguntando como a maioria das pessoas busca um tipo MIME de um arquivo em Java? Até agora eu tentei dois utilitários: JMimeMagic& Mime-Util.

O primeiro me deu exceções de memória, o segundo não fecha seus fluxos corretamente. Eu só estava me perguntando se alguém mais tinha um método / biblioteca que eles usaram e funcionaram corretamente?

No Java 7, agora você pode apenas usar Files.probeContentType(path).

Infelizmente,

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

não funciona, pois esse uso de URL deixa um arquivo bloqueado, de modo que, por exemplo, não pode ser excluído.

No entanto, você tem o seguinte:

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

e também o seguinte, que tem a vantagem de ir além do mero uso da extensão de arquivo e dar uma olhada no conteúdo

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

No entanto, conforme sugerido pelo comentário acima, a tabela interna de tipos MIME é bastante limitada, não incluindo, por exemplo, MSWord e PDF. Portanto, se você deseja generalizar, precisará ir além das bibliotecas internas, usando, por exemplo, o Mime-Util (que é uma ótima biblioteca, usando extensão de arquivo e conteúdo).

A API do JAF faz parte do JDK 6. Veja o javax.activationpacote.

As classes mais interessantes são javax.activation.MimeType- um detentor do tipo MIME real - e javax.activation.MimetypesFileTypeMap- cuja instância pode resolver o tipo MIME como String para um arquivo:

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

Com o Apache Tika, você precisa de apenas três linhas de código :

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

Se você tem um console legal, basta colar e executar este código para brincar com ele:

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

Lembre-se de que suas APIs são ricas; ele pode analisar "qualquer coisa". No tika-core 1.14, você tem:

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)

Veja os apidocs para mais informações.

O Apache Tika oferece no tika-core uma detecção do tipo MIME com base em marcadores mágicos no prefixo do fluxo. tika-corenão busca outras dependências, o que a torna tão leve quanto o Mime Type Detection Utility atualmente não mantido .

Exemplo de código simples (Java 7), usando as variáveis theInputStreametheFileName

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

Observe que o MediaType.detect (...) não pode ser usado diretamente ( TIKA-1120 ). Mais dicas são fornecidas em https://tika.apache.org/0.10/detection.html .

Se você é um desenvolvedor Android, pode usar uma classe de utilitário android.webkit.MimeTypeMapque mapeia os tipos MIME para extensões de arquivo e vice-versa.

O seguinte snippet de código pode ajudá-lo.

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

De roseindia :

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

Se você estiver com o java 5-6, então esta classe de utilitário do produto de código-fonte aberto servoy .

Você só precisa desta função

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

Ele investiga os primeiros bytes do conteúdo e retorna os tipos de conteúdo com base nesse conteúdo e não por extensão de arquivo.

Eu só estava me perguntando como a maioria das pessoas busca um tipo MIME de um arquivo em Java?

Publiquei meu pacote Java SimpleMagic , que permite a determinação do tipo de conteúdo (mime-type) a partir de arquivos e matrizes de bytes. Ele foi projetado para ler e executar os arquivos mágicos de comando do arquivo Unix (1) que fazem parte da maioria das configurações do ~ Unix OS.

Eu tentei o Apache Tika, mas é enorme, com toneladas de dependências, URLConnectionnão usa os bytes dos arquivos e MimetypesFileTypeMaptambém apenas olha os nomes dos arquivos.

Com o SimpleMagic, você pode fazer algo como:

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

Para checar meus 5 centavos:

TL, DR

Uso MimetypesFileTypeMap e adiciono qualquer mímica que não esteja lá e preciso especificamente dela, no arquivo mime.types.

E agora, a longa leitura:

Primeiro, a lista de tipos MIME é enorme , veja aqui: https://www.iana.org/assignments/media-types/media-types.xhtml

Gosto de usar as instalações padrão fornecidas pelo JDK primeiro e, se isso não funcionar, irei procurar outra coisa.

Determinar o tipo de arquivo da extensão do arquivo

Desde a versão 1.6, o Java possui MimetypesFileTypeMap, conforme apontado em uma das respostas acima, e é a maneira mais simples de determinar o tipo mime:

new MimetypesFileTypeMap().getContentType( fileName );

Na sua implementação de baunilha, isso não faz muito (ou seja, funciona para .html, mas não para .png). No entanto, é super simples adicionar qualquer tipo de conteúdo que você possa precisar:

1. Crie um arquivo chamado 'mime.types' na pasta META-INF no seu projeto
2. Adicione uma linha para cada tipo MIME que você precisa e a implementação padrão não fornece (existem centenas de tipos MIME e a lista aumenta à medida que o tempo passa).

As entradas de exemplo para arquivos png e js seriam:

image/png png PNG
application/javascript js

Para o formato de arquivo mime.types, veja mais detalhes aqui: https://docs.oracle.com/javase/7/docs/api/javax/activation/MimetypesFileTypeMap.html

Determinar o tipo de arquivo a partir do conteúdo do arquivo

Desde 1.7, Java possui java.nio.file.spi.FileTypeDetector , que define uma API padrão para determinar um tipo de arquivo de maneira específica de implementação .

Para buscar o tipo MIME para um arquivo, basta usar Arquivos e fazer isso no seu código:

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

A definição da API fornece recursos que suportam a determinação do tipo de mímica de arquivo a partir do nome do arquivo ou do conteúdo do arquivo (bytes mágicos). É por isso que o método probeContentType () lança IOException, caso uma implementação dessa API use o Path fornecido para tentar realmente abrir o arquivo associado a ela.

Novamente, a implementação baunilha disso (a que acompanha o JDK) deixa muito a desejar.

Em algum mundo ideal em uma galáxia muito distante, todas essas bibliotecas que tentam resolver esse problema de arquivo a mimo simplesmente implementariam java.nio.file.spi.FileTypeDetector , você deixaria o jar da biblioteca de implementação preferida arquivo em seu caminho de classe e seria isso.

No mundo real, aquele em que você precisa da seção TL, DR, você deve encontrar a biblioteca com mais estrelas ao lado do nome e usá-la. Para este caso em particular, não preciso de um (ainda;)).

Eu tentei várias maneiras de fazer isso, incluindo as primeiras ditas por Joshua Fox. Mas alguns não reconhecem tipos de mimet frequentes, como arquivos PDF, e outros não podem ser confiáveis ​​com arquivos falsos (tentei com um arquivo RAR com a extensão alterada para TIF). A solução que encontrei, como também é dito por Joshua Fox de uma maneira superficial, é usar o MimeUtil2 , assim:

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

É melhor usar a validação em duas camadas para o upload de arquivos.

Primeiro você pode verificar o mimeType e validá-lo.

Segundo, você deve converter os 4 primeiros bytes do seu arquivo em hexadecimal e depois compará-lo com os números mágicos. Então será uma maneira realmente segura de verificar as validações de arquivo.

Esta é a maneira mais simples que encontrei para fazer isso:

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

Se você estiver trabalhando com um Servlet e se o contexto do servlet estiver disponível, você poderá usar:

getServletContext().getMimeType( fileName );

no arquivo MultipartFile da primavera ;

org.springframework.web.multipart.MultipartFile

file.getContentType();

Se você trabalha no sistema operacional Linux, há uma linha de comando 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 "";
}

Então

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

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

Depois de tentar várias outras bibliotecas, resolvi usar o 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;
}

Você pode fazer isso com apenas uma linha: MimetypesFileTypeMap (). GetContentType (new File ("filename.ext")) . Veja o código de teste completo (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")));
    }
}

Este código produz a seguinte saída: text / plain

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

Eu fiz isso com o seguinte código.

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

        }
    }
}

Apache Tika.

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

e duas linhas de código.

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

Captura de tela abaixo