Obtenir le type MIME d'un fichier en Java

Je me demandais simplement comment la plupart des gens récupèrent un type MIME à partir d'un fichier en Java? Jusqu'à présent, j'ai essayé deux utilitaires: JMimeMagic& Mime-Util.

Le premier m'a donné des exceptions de mémoire, le second ne ferme pas correctement ses flux. Je me demandais simplement si quelqu'un d'autre avait une méthode / bibliothèque qu'ils utilisaient et fonctionnaient correctement?

Dans Java 7, vous pouvez maintenant simplement utiliser Files.probeContentType(path).

Malheureusement,

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

ne fonctionne pas, car cette utilisation de l'URL laisse un fichier verrouillé, de sorte qu'il est, par exemple, non supprimable.

Cependant, vous avez ceci:

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

et également les suivants, qui ont l'avantage d'aller au-delà de la simple utilisation d'une extension de fichier, et jettent un œil au contenu

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

Cependant, comme suggéré par le commentaire ci-dessus, le tableau intégré des types MIME est assez limité, ne comprenant pas, par exemple, MSWord et PDF. Donc, si vous voulez généraliser, vous devrez aller au-delà des bibliothèques intégrées, en utilisant, par exemple, Mime-Util (qui est une excellente bibliothèque, en utilisant à la fois l'extension de fichier et le contenu).

L'API JAF fait partie de JDK 6. Regardez le javax.activationpackage.

Les classes les plus intéressantes sont javax.activation.MimeType- un détenteur de type MIME réel - et javax.activation.MimetypesFileTypeMap- une classe dont l'instance peut résoudre le type MIME en tant que chaîne pour un fichier:

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

Avec Apache Tika, vous n'avez besoin que de trois lignes de code :

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

Si vous avez une console groovy, collez et exécutez ce code pour jouer avec:

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

Gardez à l'esprit que ses API sont riches, il peut analyser "n'importe quoi". Depuis tika-core 1.14, vous avez:

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)

Voir les apidocs pour plus d'informations.

Apache Tika propose dans tika-core une détection de type mime basée sur des marqueurs magiques dans le préfixe de flux. tika-corene récupère pas les autres dépendances, ce qui le rend aussi léger que l' utilitaire de détection de type MIME actuellement non entretenu .

Exemple de code simple (Java 7), utilisant les variables theInputStreamettheFileName

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

Veuillez noter que MediaType.detect (...) ne peut pas être utilisé directement ( TIKA-1120 ). Plus d'indications sont fournies à https://tika.apache.org/0.10/detection.html .

Si vous êtes un développeur Android, vous pouvez utiliser une classe utilitaire android.webkit.MimeTypeMapqui mappe les types MIME aux extensions de fichier et vice versa.

L'extrait de code suivant peut vous aider.

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

Si vous êtes bloqué avec java 5-6, alors cette classe d'utilité de produit open source servoy .

Vous avez seulement besoin de cette fonction

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

Il sonde les premiers octets du contenu et renvoie les types de contenu en fonction de ce contenu et non par extension de fichier.

Je me demandais simplement comment la plupart des gens récupéraient un type MIME à partir d'un fichier en Java?

J'ai publié mon package Java SimpleMagic qui permet la détermination du type de contenu (type mime) à partir de fichiers et de tableaux d'octets. Il est conçu pour lire et exécuter les fichiers magiques de commande de fichier Unix (1) qui font partie de la plupart des configurations de système d'exploitation Unix.

J'ai essayé Apache Tika, mais il est énorme avec des tonnes de dépendances, URLConnectionn'utilise pas les octets des fichiers et MimetypesFileTypeMapne regarde que les noms de fichiers.

Avec SimpleMagic, vous pouvez faire quelque chose comme:

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

Pour participer avec mes 5 cents:

TL, DR

J'utilise MimetypesFileTypeMap et j'ajoute tout mime qui n'est pas là et j'en ai spécifiquement besoin, dans le fichier mime.types.

Et maintenant, la longue lecture:

Tout d'abord, la liste des types MIME est énorme , voir ici: https://www.iana.org/assignments/media-types/media-types.xhtml

J'aime d'abord utiliser les installations standard fournies par JDK, et si cela ne fonctionne pas, je vais chercher autre chose.

Déterminer le type de fichier à partir de l'extension de fichier

Depuis 1.6, Java a MimetypesFileTypeMap, comme indiqué dans l'une des réponses ci-dessus, et c'est le moyen le plus simple de déterminer le type MIME:

new MimetypesFileTypeMap().getContentType( fileName );

Dans son implémentation vanilla, cela ne fait pas grand-chose (c'est-à-dire que cela fonctionne pour .html mais pas pour .png). Il est cependant très simple d'ajouter tout type de contenu dont vous pourriez avoir besoin:

1. Créez un fichier nommé 'mime.types' dans le dossier META-INF de votre projet
2. Ajoutez une ligne pour chaque type MIME dont vous avez besoin et l'implémentation par défaut ne fournit pas (il existe des centaines de types MIME et la liste s'allonge au fil du temps).

Des exemples d'entrées pour les fichiers png et js seraient:

image/png png PNG
application/javascript js

Pour le format de fichier mime.types, voir plus de détails ici: https://docs.oracle.com/javase/7/docs/api/javax/activation/MimetypesFileTypeMap.html

Déterminer le type de fichier à partir du contenu du fichier

Depuis la version 1.7, Java a java.nio.file.spi.FileTypeDetector , qui définit une API standard pour déterminer un type de fichier de manière spécifique à l' implémentation .

Pour récupérer le type MIME pour un fichier, vous devez simplement utiliser Fichiers et le faire dans votre code:

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

La définition de l'API fournit des fonctionnalités qui prennent en charge la détermination du type de mime de fichier à partir du nom de fichier ou du contenu du fichier (octets magiques). C'est pourquoi probeContentType () méthode lève IOException, dans le cas où une implémentation de cette API utilise le chemin d'accès qui lui est fourni pour réellement essayer d'ouvrir le fichier qui lui est associé.

Encore une fois, l' implémentation vanilla de celle-ci (celle qui vient avec JDK) laisse beaucoup à désirer.

Dans un monde idéal dans une galaxie lointaine, très lointaine, toutes ces bibliothèques qui tentent de résoudre ce problème de type fichier à mime implémenteraient simplement java.nio.file.spi.FileTypeDetector , vous déposeriez dans le pot de la bibliothèque d'implémentation préférée fichier dans votre chemin de classe et ce serait tout.

Dans le monde réel, celui où vous avez besoin de la section TL, DR, vous devriez trouver la bibliothèque avec la plupart des étoiles à côté de son nom et l'utiliser. Pour ce cas particulier, je n'en ai pas besoin (encore;)).

J'ai essayé plusieurs façons de le faire, y compris les premières dites par @Joshua Fox. Mais certains ne reconnaissent pas les mimetypes fréquents comme pour les fichiers PDF, et d'autres ne peuvent pas être fiables avec de faux fichiers (j'ai essayé avec un fichier RAR avec une extension changée en TIF). La solution que j'ai trouvée, comme le dit également @Joshua Fox de manière superficielle, consiste à utiliser MimeUtil2 , comme ceci:

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

Il est préférable d'utiliser une validation à deux couches pour le téléchargement de fichiers.

Vous pouvez d'abord vérifier le mimeType et le valider.

Deuxièmement, vous devriez chercher à convertir les 4 premiers octets de votre fichier en hexadécimal, puis à le comparer avec les nombres magiques. Ce sera alors un moyen très sûr de vérifier les validations de fichiers.

C'est la manière la plus simple que j'ai trouvée pour faire ceci:

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

Si vous travaillez avec un servlet et si le contexte du servlet est à votre disposition, vous pouvez utiliser:

getServletContext().getMimeType( fileName );

au printemps fichier MultipartFile ;

org.springframework.web.multipart.MultipartFile

file.getContentType();

si vous travaillez sur Linux OS, il y a une ligne de commande 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 "";
}

ensuite

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

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

Après avoir essayé plusieurs autres bibliothèques, je me suis installé avec 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;
}

Vous pouvez le faire avec une seule ligne: MimetypesFileTypeMap (). GetContentType (new File ("filename.ext")) . Regardez le code de test complet (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")));
    }
}

Ce code produit la sortie suivante: 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();

Je l'ai fait avec le code suivant.

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>

et Deux lignes de code.

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

Capture d'écran ci-dessous