Ottenere il tipo Mime di un file in Java

Mi stavo solo chiedendo come la maggior parte delle persone recuperi un tipo MIME da un file in Java? Finora ho provato due programmi di utilità: JMimeMagic& Mime-Util.

Il primo mi ha dato eccezioni di memoria, il secondo non chiude correttamente i suoi flussi. Mi stavo solo chiedendo se qualcun altro avesse un metodo / libreria che hanno usato e funzionato correttamente?

In Java 7 ora puoi semplicemente usare Files.probeContentType(path).

Sfortunatamente,

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

non funziona, poiché questo utilizzo dell'URL lascia un file bloccato, in modo che, ad esempio, non sia cancellabile.

Tuttavia, hai questo:

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

e anche quanto segue, che ha il vantaggio di andare oltre il semplice uso dell'estensione del file e dà una sbirciatina al contenuto

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

Tuttavia, come suggerito dal commento sopra, la tabella integrata dei tipi mime è piuttosto limitata, ad esempio MSWord e PDF. Quindi, se vuoi generalizzare, dovrai andare oltre le librerie integrate, usando, ad esempio, Mime-Util (che è una grande libreria, che utilizza sia l'estensione che il contenuto).

L'API JAF fa parte di JDK 6. Guarda il javax.activationpacchetto.

Le classi più interessanti sono javax.activation.MimeType- un vero detentore del tipo MIME - e javax.activation.MimetypesFileTypeMap- la cui istanza può risolvere il tipo MIME come String per un file:

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

Con Apache Tika sono necessarie solo tre righe di codice :

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

Se hai una console groovy, incolla ed esegui questo codice per giocarci:

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

Tieni presente che le sue API sono ricche, può analizzare "qualsiasi cosa". A partire da tika-core 1.14, hai:

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)

Vedi gli apidocs per maggiori informazioni.

Apache Tika offre in tika-core un rilevamento del tipo mime basato su marcatori magici nel prefisso dello stream. tika-corenon recupera altre dipendenze, il che la rende leggera come l' utilità di rilevamento del tipo Mime attualmente non mantenuta .

Esempio di codice semplice (Java 7), usando le variabili 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();
}

Si noti che MediaType.detect (...) non può essere utilizzato direttamente ( TIKA-1120 ). Ulteriori suggerimenti sono disponibili su https://tika.apache.org/0.10/detection.html .

Se sei uno sviluppatore Android, puoi utilizzare una classe di utilità android.webkit.MimeTypeMapche associa i tipi MIME alle estensioni dei file e viceversa.

Il seguente frammento di codice può aiutarti.

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

Da roseindia :

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

Se sei bloccato con java 5-6, questa classe di utilità dal prodotto open source servoy .

Hai solo bisogno di questa funzione

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

Rileva i primi byte del contenuto e restituisce i tipi di contenuto in base a quel contenuto e non in base all'estensione del file.

Mi stavo solo chiedendo come la maggior parte delle persone recuperi un tipo MIME da un file in Java?

Ho pubblicato il mio pacchetto Java SimpleMagic che consente la determinazione del tipo di contenuto (tipo mime) da file e array di byte. È progettato per leggere ed eseguire i file magici di comando file Unix (1) che fanno parte della maggior parte delle configurazioni del sistema operativo ~ Unix.

Ho provato Apache Tika ma è enorme con tonnellate di dipendenze, URLConnectionnon usa i byte dei file e MimetypesFileTypeMapguarda solo i nomi dei file.

Con SimpleMagic puoi fare qualcosa del tipo:

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

Per entrare con i miei 5 centesimi:

TL, DR

Uso MimetypesFileTypeMap e aggiungo qualsiasi mime che non c'è e ne ho specificamente bisogno, nel file mime.types.

E ora, la lunga lettura:

Prima di tutto, l'elenco dei tipi MIME è enorme , vedi qui: https://www.iana.org/assignments/media-types/media-types.xhtml

Mi piace usare prima i servizi standard forniti da JDK e, se non funziona, andrò a cercare qualcos'altro.

Determina il tipo di file dall'estensione del file

Dalla 1.6, Java ha MimetypesFileTypeMap, come indicato in una delle risposte sopra, ed è il modo più semplice per determinare il tipo mime:

new MimetypesFileTypeMap().getContentType( fileName );

Nella sua implementazione alla vaniglia questo non fa molto (cioè funziona per .html ma non per .png). Tuttavia, è super semplice aggiungere qualsiasi tipo di contenuto di cui potresti aver bisogno:

1. Crea il file "mime.types" nella cartella META-INF nel tuo progetto
2. Aggiungi una riga per ogni tipo di mime di cui hai bisogno e l'implementazione predefinita non fornisce (ci sono centinaia di tipi di mime e la lista cresce con il passare del tempo).

Le voci di esempio per i file png e js sarebbero:

image/png png PNG
application/javascript js

Per il formato file mime.types, vedi maggiori dettagli qui: https://docs.oracle.com/javase/7/docs/api/javax/activation/MimetypesFileTypeMap.html

Determina il tipo di file dal contenuto del file

Dall'1.7, Java ha java.nio.file.spi.FileTypeDetector , che definisce un'API standard per determinare un tipo di file in modo specifico per l'implementazione .

Per recuperare il tipo mime per un file, devi semplicemente usare File e farlo nel tuo codice:

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

La definizione dell'API fornisce funzionalità che supportano la determinazione del tipo di file mime dal nome del file o dal contenuto del file (byte magici). Questo è il motivo per cui il metodo probeContentType () genera IOException, nel caso in cui un'implementazione di questa API utilizzi il percorso fornito ad essa per provare effettivamente ad aprire il file ad esso associato.

Ancora una volta, l' implementazione vaniglia di questo (quello che viene fornito con JDK) lascia molto a desiderare.

In un mondo ideale in una galassia molto, molto lontano, tutte queste librerie che provano a risolvere questo problema di tipo file-to-mime implementerebbero semplicemente java.nio.file.spi.FileTypeDetector , lascerai cadere il vaso preferito della libreria di implementazione preferita file nel tuo percorso di classe e sarebbe così.

Nel mondo reale, quello in cui hai bisogno di TL, sezione DR, dovresti trovare la libreria con la maggior parte delle stelle accanto al suo nome e usarla. Per questo caso particolare, non ne ho bisogno (ancora;)).

Ho provato diversi modi per farlo, compresi i primi detti da @Joshua Fox. Ma alcuni non riconoscono i mimetipi frequenti come per i file PDF e altri non sono affidabili con file falsi (ho provato con un file RAR con estensione modificata in TIF). La soluzione che ho trovato, come dice anche @Joshua Fox in modo superficiale, è usare MimeUtil2 , in questo modo:

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

È meglio utilizzare la convalida a due livelli per il caricamento dei file.

Per prima cosa puoi verificare il mimeType e convalidarlo.

Secondo, dovresti cercare di convertire i primi 4 byte del tuo file in esadecimali e poi confrontarlo con i numeri magici. Quindi sarà un modo davvero sicuro per verificare la convalida dei file.

Questo è il modo più semplice che ho trovato per fare questo:

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

Se si lavora con un servlet e se il contesto del servlet è disponibile, è possibile utilizzare:

getServletContext().getMimeType( fileName );

in primavera file MultipartFile ;

org.springframework.web.multipart.MultipartFile

file.getContentType();

se lavori su un sistema operativo Linux, esiste una riga di 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 "";
}

Poi

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

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

Dopo aver provato varie altre biblioteche, ho optato per 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;
}

Puoi farlo con una sola riga: MimetypesFileTypeMap (). GetContentType (nuovo file ("filename.ext")) . Guarda il codice di prova 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")));
    }
}

Questo codice produce il seguente output: 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();

L'ho fatto con il seguente codice.

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 due righe di codice.

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

Screenshot sotto