Obtener el tipo Mime de un archivo en Java

Me preguntaba cómo la mayoría de las personas obtienen un tipo MIME de un archivo en Java. Hasta ahora he probado dos utilidades: JMimeMagic& Mime-Util.

El primero me dio excepciones de memoria, el segundo no cierra sus secuencias correctamente. Me preguntaba si alguien más tenía un método / biblioteca que usaban y funcionaban correctamente.

En Java 7 ahora solo puede usar Files.probeContentType(path).

Desafortunadamente,

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

no funciona, ya que este uso de URL deja un archivo bloqueado, por lo que, por ejemplo, no se puede borrar.

Sin embargo, tienes esto:

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

y también lo siguiente, que tiene la ventaja de ir más allá del mero uso de la extensión de archivo, y echa un vistazo al contenido

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

Sin embargo, como lo sugiere el comentario anterior, la tabla integrada de tipos MIME es bastante limitada, sin incluir, por ejemplo, MSWord y PDF. Por lo tanto, si desea generalizar, deberá ir más allá de las bibliotecas integradas, utilizando, por ejemplo, Mime-Util (que es una gran biblioteca, que utiliza tanto la extensión de archivo como el contenido).

La API JAF es parte de JDK 6. Mira el javax.activationpaquete.

Las clases más interesantes son javax.activation.MimeType- un titular de tipo MIME real - y javax.activation.MimetypesFileTypeMap- clase cuya instancia puede resolver el tipo MIME como Cadena para un archivo:

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 solo necesita tres líneas de código :

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

Si tiene una consola maravillosa, simplemente pegue y ejecute este código para jugar con él:

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

Tenga en cuenta que sus API son ricas, puede analizar "cualquier cosa". A partir de tika-core 1.14, tiene:

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)

Vea las apidocs para más información.

Apache Tika ofrece en tika-core una detección de tipo mime basada en marcadores mágicos en el prefijo de transmisión. tika-coreno busca otras dependencias, lo que lo hace tan liviano como la utilidad de detección de tipo Mime actualmente no mantenida .

Ejemplo de código simple (Java 7), usando las variables theInputStreamytheFileName

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

Tenga en cuenta que MediaType.detect (...) no se puede usar directamente ( TIKA-1120 ). Se proporcionan más sugerencias en https://tika.apache.org/0.10/detection.html .

Si es un desarrollador de Android, puede usar una clase de utilidad android.webkit.MimeTypeMapque asigna tipos MIME a extensiones de archivo y viceversa.

El siguiente fragmento de código puede ayudarlo.

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 está atascado con Java 5-6, entonces esta clase de utilidad del producto de código abierto servo .

Solo necesitas esta función

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

Sondea los primeros bytes del contenido y devuelve los tipos de contenido en función de ese contenido y no por extensión de archivo.

Me preguntaba cómo la mayoría de las personas obtienen un tipo MIME de un archivo en Java.

He publicado mi paquete Java SimpleMagic que permite la determinación del tipo de contenido (tipo mime) a partir de archivos y conjuntos de bytes. Está diseñado para leer y ejecutar los archivos mágicos de comando del archivo Unix (1) que forman parte de la mayoría de las configuraciones de ~ Unix OS.

Intenté Apache Tika pero es enorme con toneladas de dependencias, URLConnectionno usa los bytes de los archivos y MimetypesFileTypeMaptambién solo mira los nombres de los archivos.

Con SimpleMagic puedes hacer 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 contribuir con mis 5 centavos:

TL, DR

Uso MimetypesFileTypeMap y agrego cualquier mime que no está allí y lo necesito específicamente, en el archivo mime.types.

Y ahora, la lectura larga:

En primer lugar, la lista de tipos MIME es enorme , consulte aquí: https://www.iana.org/assignments/media-types/media-types.xhtml

Me gusta usar las instalaciones estándar proporcionadas por JDK primero, y si eso no funciona, iré a buscar otra cosa.

Determinar el tipo de archivo desde la extensión del archivo

Desde 1.6, Java tiene MimetypesFileTypeMap, como se señala en una de las respuestas anteriores, y es la forma más sencilla de determinar el tipo mime:

new MimetypesFileTypeMap().getContentType( fileName );

En su implementación de vainilla esto no hace mucho (es decir, funciona para .html pero no para .png). Sin embargo, es muy simple agregar cualquier tipo de contenido que pueda necesitar:

1. Cree un archivo llamado 'mime.types' en la carpeta META-INF de su proyecto
2. Agregue una línea para cada tipo de mime que necesite y la implementación predeterminada no proporciona (hay cientos de tipos de mime y la lista crece a medida que pasa el tiempo).

Las entradas de ejemplo para archivos png y js serían:

image/png png PNG
application/javascript js

Para el formato de archivo mime.types, vea más detalles aquí: https://docs.oracle.com/javase/7/docs/api/javax/activation/MimetypesFileTypeMap.html

Determinar el tipo de archivo a partir del contenido del archivo

Desde 1.7, Java tiene java.nio.file.spi.FileTypeDetector , que define una API estándar para determinar un tipo de archivo en forma específica de implementación .

Para buscar el tipo mime para un archivo, simplemente use Archivos y haga esto en su código:

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

La definición de API proporciona recursos que admiten la determinación del tipo de archivo MIME a partir del nombre del archivo o del contenido del archivo (bytes mágicos). Es por eso que el método probeContentType () arroja IOException, en caso de que una implementación de esta API utilice la ruta que se le proporciona para intentar abrir el archivo asociado.

Nuevamente, la implementación vainilla de esto (la que viene con JDK) deja mucho que desear.

En un mundo ideal en una galaxia muy, muy lejana, todas estas bibliotecas que intentan resolver este problema de tipo de archivo a mimo simplemente implementarían java.nio.file.spi.FileTypeDetector , colocarías el jar de la biblioteca de implementación preferida archivo en su classpath y eso sería todo.

En el mundo real, en el que necesita la sección TL, DR, debe encontrar la biblioteca con la mayoría de las estrellas al lado de su nombre y usarla. Para este caso en particular, no necesito uno (todavía;)).

Intenté varias formas de hacerlo, incluidas las primeras que dijo @Joshua Fox. Pero algunos no reconocen los tipos MIME frecuentes, como los archivos PDF, y otros no pueden ser confiables con archivos falsos (intenté con un archivo RAR con la extensión cambiada a TIF). La solución que encontré, como también lo dijo @Joshua Fox de manera superficial, es usar MimeUtil2 , así:

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

Es mejor utilizar la validación de dos capas para cargar archivos.

Primero puede verificar el mimeType y validarlo.

En segundo lugar, debe buscar convertir los primeros 4 bytes de su archivo a hexadecimal y luego compararlo con los números mágicos. Entonces será una forma realmente segura de verificar las validaciones de archivos.

Esta es la forma más simple que encontré para hacer esto:

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

Si está trabajando con un Servlet y el contexto del servlet está disponible para usted, puede usar:

getServletContext().getMimeType( fileName );

en primavera archivo MultipartFile ;

org.springframework.web.multipart.MultipartFile

file.getContentType();

Si trabaja en Linux OS, hay una línea 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 "";
}

Luego

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

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

Después de probar varias otras bibliotecas, me decidí por 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;
}

Puede hacerlo con una sola línea: MimetypesFileTypeMap (). GetContentType (nuevo archivo ("filename.ext")) . Mira el código de prueba 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 produce el siguiente resultado: 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();

Lo hice con el siguiente 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>

y dos líneas de código.

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

Captura de pantalla a continuación