Java'da Dosyanın Mime Türünü Alma

Sadece çoğu insanın Java'daki bir dosyadan nasıl bir mime türü aldığını merak ediyordum? Şimdiye kadar iki araç denedim: JMimeMagic& Mime-Util.

Birincisi bana bellek istisnaları verdi, ikincisi akışlarını düzgün bir şekilde kapatmıyor. Ben sadece başkalarının kullandıkları yöntem ve kütüphane doğru kullandım ve doğru çalışıp çalışmadığını merak ediyordum?

Java 7'de artık kullanabilirsiniz Files.probeContentType(path).

Ne yazık ki,

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

URL'nin bu kullanımı bir dosyayı kilitli bıraktığından, örneğin silinemez olması için çalışmaz.

Ancak, bu var:

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

ve ayrıca, yalnızca dosya uzantısını kullanmanın ötesine geçme avantajına sahip olan ve içeriğe bir göz atan

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

Bununla birlikte, yukarıdaki yorumda önerildiği gibi, mime tiplerinin yerleşik tablosu oldukça sınırlıdır, örneğin MSWord ve PDF dahil değildir. Bu nedenle, genelleştirmek istiyorsanız, örneğin Mime-Util'i (hem dosya uzantısı hem de içerik kullanan harika bir kütüphane olan) kullanarak yerleşik kitaplıkların ötesine geçmeniz gerekir.

JAF API, JDK 6'nın bir parçasıdır. javax.activationPakete bakın .

En ilginç sınıflar javax.activation.MimeType- gerçek bir MIME türü sahibi - ve javax.activation.MimetypesFileTypeMapörneği MIME türünü bir dosya için Dize olarak çözebilen sınıftır:

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

Apache Tika ile sadece üç satır kod gerekir :

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

Mükemmel bir konsolunuz varsa, onunla oynamak için bu kodu yapıştırın ve çalıştırın:

@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'lerinin zengin olduğunu ve "her şeyi" ayrıştırabileceğini unutmayın. Tika-çekirdek 1.14'ten itibaren:

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)

Daha fazla bilgi için apidoklara bakınız .

Apache Tika , tika çekirdeğinde , akış önekindeki sihirli işaretleyicilere dayanan bir mime tipi algılama sunar. tika-corediğer bağımlılıkları getirmez, bu da onu şu anda korunmayan Mime Tipi Algılama Yardımcı Programı kadar hafif yapar .

Basit kod örneği (Java 7), değişkenleri theInputStreamvetheFileName

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

Lütfen MediaType.detect (...) öğesinin doğrudan kullanılamayacağını unutmayın ( TIKA-1120 ). Daha fazla ipucu https://tika.apache.org/0.10/detection.html adresinde sunulmaktadır .

Android geliştiricisiyseniz bir yardımcı program sınıfı kullanabilirsiniz android.webkit.MimeTypeMap MIME türlerini dosya uzantılarıyla veya tam tersini eşleyen .

Aşağıdaki kod snippet'i size yardımcı olabilir.

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

Gönderen roseindia :

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

Java 5-6 ile sıkışmışsanız , servoy açık kaynaklı üründen bu yardımcı sınıf .

Sadece bu işleve ihtiyacınız var

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

İçeriğin ilk baytını inceler ve dosya türüne göre değil, o içeriğe göre içerik türlerini döndürür.

Sadece çoğu insanın Java'daki bir dosyadan nasıl bir mime türü aldığını merak ediyordum?

Dosyalardan ve bayt dizilerinden içerik türü (mime türü) belirlemesine izin veren SimpleMagic Java paketimi yayınladım . Çoğu ~ Unix OS yapılandırmasının bir parçası olan Unix dosyası (1) komut sihirli dosyalarını okumak ve çalıştırmak için tasarlanmıştır.

Apache Tika'yı denedim ama tonlarca bağımlılık ile çok büyükURLConnection , dosyaların baytlarını kullanmıyor veMimetypesFileTypeMap sadece dosya adlarına bakıyor.

SimpleMagic ile aşağıdakileri yapabilirsiniz:

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

5 sent ile giriş yapmak için:

TP, DR

MimetypesFileTypeMap kullanın ve orada olmayan herhangi bir mime ekleyin ve özellikle mime.types dosyasına ihtiyaç duyuyorum.

Ve şimdi, uzun okuma:

Her şeyden önce, MIME türleri listesi çok büyük , buraya bakın: https://www.iana.org/assignments/media-types/media-types.xhtml

Öncelikle JDK tarafından sağlanan standart olanakları kullanmayı seviyorum ve bu işe yaramazsa, gidip başka bir şey arayacağım.

Dosya uzantısından dosya türünü belirleme

1.6'dan beri Java, yukarıdaki cevaplardan birinde işaret edildiği gibi MimetypesFileTypeMap'e sahiptir ve mime türünü belirlemenin en basit yoludur:

new MimetypesFileTypeMap().getContentType( fileName );

Vanilya uygulamasında bu pek bir şey yapmaz (yani .html için çalışır, ancak .png için çalışmaz). Bununla birlikte, ihtiyacınız olabilecek herhangi bir içerik türünü eklemek çok basittir:

1. Projenizdeki META-INF klasöründe 'mime.types' adlı bir dosya oluşturun
2. İhtiyacınız olan ve varsayılan uygulamanın sağlamadığı her mim türü için bir satır ekleyin (yüzlerce mim türü vardır ve zaman geçtikçe liste büyür).

Png ve js dosyaları için örnek girişler:

image/png png PNG
application/javascript js

Mime.types dosya biçimi için daha fazla ayrıntıya buradan bakın: https://docs.oracle.com/javase/7/docs/api/javax/activation/MimetypesFileTypeMap.html

Dosya içeriğinden dosya türünü belirleme

1.7'den beri Java, bir dosya türünü uygulamaya özel bir şekilde belirlemek için standart bir API tanımlayan java.nio.file.spi.FileTypeDetector'a sahiptir .

Bir dosya için mime türünü getirmek için Dosyalar'ı kullanmanız ve bunu kodunuzda yapmanız yeterlidir :

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

API tanımı, dosya adından veya dosya içeriğinden (sihirli bayt) dosya mime türünün belirlenmesini destekleyen özellikler sağlar. Bu yüzden probeContentType () , bu API'nin bir uygulamasının, kendisiyle ilişkilendirilmiş dosyayı açmaya çalışmak için kendisine sağlanan durumunda yöntemi IOException özel durumunu oluşturur.

Yine vanilya uygulaması (JDK ile birlikte gelen) arzulanan çok şey bırakıyor.

Uzak, çok uzak bir galaksideki bazı ideal dünyada, bu dosyadan mime tipi sorunu çözmeye çalışan tüm bu kütüphaneler java.nio.file.spi.FileTypeDetector'ı uygular , tercih edilen uygulama kütüphanesinin kavanozuna sınıf yolunuza dosya ve bu olurdu.

TL, DR bölümüne ihtiyacınız olan gerçek dünyada, adının yanında en çok yıldız bulunan kütüphaneyi bulmalı ve kullanmalısınız. Bu özel durum için bir (henüz;)) ihtiyacım yok.

@Joshua Fox tarafından söylenen ilk olanlar da dahil olmak üzere bunu yapmanın birkaç yolunu denedim. Ancak bazıları PDF dosyaları gibi sık mime türlerini tanımıyor ve diğerleri sahte dosyalar ile güvenilir olamazdı (uzantısı TIF olarak değiştirilmiş bir RAR dosyası ile denedim). @Joshua Fox tarafından yüzeysel bir şekilde söylendiği gibi bulduğum çözüm , MimeUtil2'yi şu şekilde kullanmaktır :

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

Dosya yüklemek için iki katman doğrulaması kullanmak daha iyidir.

İlk önce mimeType'ı kontrol edebilir ve doğrulayabilirsiniz.

İkincisi, dosyanızın ilk 4 baytını onaltılık biçime dönüştürmeli ve ardından sihirli sayılarla karşılaştırmalısınız. O zaman dosya doğrulamalarını kontrol etmek gerçekten güvenli bir yol olacaktır.

Bunu yapmak için bulduğum en basit yol budur:

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

Bir Servlet ile çalışıyorsanız ve sunucu uygulaması bağlamı kullanabiliyorsanız şunları kullanabilirsiniz:

getServletContext().getMimeType( fileName );

ilkbaharda MultipartFile dosyası;

org.springframework.web.multipart.MultipartFile

file.getContentType();

Linux işletim sisteminde çalışıyorsanız, bir komut satırı vardır 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 "";
}

Sonra

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

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

Diğer kütüphaneleri denedikten sonra mime-util ile yerleştim.

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

Bunu sadece bir satırla yapabilirsiniz: MimetypesFileTypeMap (). GetContentType (new File ("filename.ext")) . Tam test koduna bakın (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")));
    }
}

Bu kod aşağıdaki çıktıyı üretir: 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();

Aşağıdaki kod ile yaptım.

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>

ve İki satırlık kod.

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

Aşağıdaki ekran görüntüsü