Bei der Java-Entwicklung muss häufig der Typ einer Datei bestimmt werden, etwa um bei einer Upload-Funktion zu prüfen, ob die vom Nutzer hochgeladene Datei einem zulässigen Typ entspricht. Dieser Artikel erläutert ausführlich, wie sich Dateitypen mit Java ermitteln lassen.
I. Den Dateityp anhand der Dateiendung bestimmen
Die gebräuchlichste Methode zur Bestimmung des Dateityps richtet sich nach der Dateiendung. Die meisten Dateien haben im Betriebssystem eine bestimmte Endung; beispielsweise lautet die Endung von Textdateien üblicherweise .txt，die Dateiendung von Bilddateien lautet gewöhnlich .jpg oder.png und so weiter。
Die Dateiendung mit einem Java-Programm zu ermitteln, ist sehr einfach. Man muss lediglich String der Klasse substring Methode genügt, der Code sieht wie folgt aus：
public static String getFileExtension(File file) {
String fileName = file.getName();
if (fileName.lastIndexOf(".") != -1 && fileName.lastIndexOf(".") != 0) {
return fileName.substring(fileName.lastIndexOf(".") + 1);
} else {
return "";
}
}Diese Methode nimmt ein File Objekt als Parameter, anschließend unter Verwendung von lastIndexOf Methode die Position des letzten Punkts im Dateinamen ermitteln, also den Beginn der Dateiendung, und anschließend mit substring Methode die Zeichenfolge der Dateiendung ermitteln und zurückgeben. Hat die Datei keine Endung, wird eine leere Zeichenfolge zurückgegeben.
Mit dem folgenden Code lässt sich diese Methode testen：
File file = new File("C:/path/to/file.txt");
String extension = getFileExtension(file);
System.out.println(extension);Das Ausführungsergebnis lautet:
txt
Diese Methode zur Bestimmung des Dateityps bietet folgende Vorteile：
Einfach zu verwenden, mit einer knappen Codeimplementierung.
Funktioniert bei den allermeisten Dateien, da die allermeisten Dateien eine Dateinamenserweiterung haben.
Diese Methode hat jedoch auch einige Nachteile：
Die Dateiendung könnte verändert worden sein, wodurch die Beurteilung falsch ausfällt.
Manche Dateien haben keine Dateiendung, beispielsweise ausführbare Dateien ohne Erweiterung.
Um den Dateityp genauer zu bestimmen, können wir zusätzlich die magische Zahl der Datei prüfen.
II. Dateitypen anhand von magischen Dateikennungen bestimmen
Die magische Zahl einer Datei besteht aus bestimmten Bytes unter den ersten Bytes der Datei und dient dazu, den Dateityp zu erkennen. Durch die Erkennung dieser magischen Zahl lässt sich der Dateityp genau bestimmen, ohne von der Dateiendung beeinflusst zu werden.
In Java lässt sich die magische Zahl einer Datei durch das Lesen ihrer Binärdaten ermitteln.
2.1 Binärdaten einer Datei lesen
Wir können FileInputStream Klasse verwenden, um die Binärdaten der Datei zu lesen. Die folgende Methode gibt ein Byte-Array zurück, das die Binärdaten der Datei enthält：
public static byte[] readFileToByteArray(File file) throws IOException {
FileInputStream fis = null;
try {
fis = new FileInputStream(file);
byte[] data = new byte[(int)file.length()];
fis.read(data);
return data;
} finally {
if (fis != null) {
fis.close();
}
}
}Die obige Methode verwendet FileInputStream um die Datei zu öffnen, die Daten zu lesen und in einem Byte-Array zu speichern. Bitte beachten Sie, dass nach Abschluss des Dateilesens Folgendes aufgerufen werden muss:close Methode den Dateistream schließen, um Systemressourcen freizugeben.
2.2 Den Dateityp anhand der magischen Dateikennung bestimmen
Sobald uns die Binärdaten einer Datei vorliegen, können wir ihren Dateityp bestimmen. Jeder Dateityp besitzt eine bestimmte magische Zahl, anhand derer sich der Typ erkennen lässt. Hier sind die magischen Zahlen einiger gängiger Dateitypen und die entsprechenden Erkennungsmethoden:
Die magische Zahl von Textdateien (.txt) lautet
EF BB BF（Bei UTF-8-kodierten Dateien steht diese Bytefolge am Dateianfang），zur Erkennung kann folgende Methode verwendet werden:public static boolean isTextFile(byte[] data) { if (data.length >= 3 && data[0] == -17 && data[1] == -69 && data[2] == -65) { return true; } return false; }Die magische Zahl von JPEG-Bildern (.jpg) lautet
FF D8 FF，lässt sich dies mit den folgenden Methoden feststellen:public static boolean isJPEGFile(byte[] data) { if (data.length >= 3 && data[0] == -1 && data[1] == -40 && data[2] == -1) { return true; } return false; }Die magische Zahl von PNG-Bildern (.png) lautet
89 50 4E 47 0D 0A 1A 0A，lässt sich dies mit den folgenden Methoden feststellen:public static boolean isPNGFile(byte[] data) { if (data.length >= 8 && data[0] == -119 && data[1] == 80 && data[2] == 78 && data[3] == 71 && data[4] == 13 && data[5] == 10 && data[6] == 26 && data[7] == 10) { return true; } return false; }
Bei Bedarf können weitere Dateitypen und entsprechende Methoden zur Prüfung ihrer magischen Zahlen hinzugefügt werden.
2.3 Vollständiges Beispiel
Hier ist ein vollständiges Beispiel, das zeigt, wie sich der Dateityp anhand der magischen Dateikennung bestimmen lässt:
import java.io.File;import java.io.FileInputStream;import java.io.IOException;public class FileTypeChecker {
public static void main(String[] args) {
File file = new File("C:/path/to/file.jpg");
try {
byte[] data = readFileToByteArray(file);
if (isJPEGFile(data)) {
System.out.println("This is a JPEG file.");
} else if (isPNGFile(data)) {
System.out.println("This is a PNG file.");
} else if (isTextFile(data)) {
System.out.println("This is a text file.");
} else {
System.out.println("Unknown file type.");
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static byte[] readFileToByteArray(File file) throws IOException {
FileInputStream fis = null;
try {
fis = new FileInputStream(file);
byte[] data = new byte[(int)file.length()];
fis.read(data);
return data;
} finally {
if (fis != null) {
fis.close();
}
}
}
public static boolean isTextFile(byte[] data) {
if (data.length >= 3 && data[0] == -17 && data[1] == -69 && data[2] == -65) {
return true;
}
return false;
}
public static boolean isJPEGFile(byte[] data) {
if (data.length >= 3 && data[0] == -1 && data[1] == -40 && data[2] == -1) {
return true;
}
return false;
}
public static boolean isPNGFile(byte[] data) {
if (data.length >= 8 && data[0] == -119 && data[1] == 80 && data[2] == 78 && data[3] == 71 &&
data[4] == 13 && data[5] == 10 && data[6] == 26 && data[7] == 10) {
return true;
}
return false;
}
}Der obige Beispielcode bestimmt den Dateityp anhand der magischen Zahl der Datei und gibt das entsprechende Ergebnis aus.
III、Dateitypen mithilfe von Bibliotheken von Drittanbietern bestimmen
Neben den genannten Methoden lassen sich auch Bibliotheken von Drittanbietern verwenden, um den Dateityp zu bestimmen. Für Java gibt es einige quelloffene Bibliotheken von Drittanbietern, die uns die Ermittlung des Dateityps erleichtern.
3.1 Tika
Tika ist ein Projekt der Apache Software Foundation. Es stellt eine quelloffene Java-Bibliothek zum Parsen verschiedener Dateiformate bereit, darunter Text, Bilder, Audio und Video. Mit Tika lassen sich Metadaten von Dateien extrahieren, darunter der Dateityp.
Zunächst muss die Abhängigkeit für die Tika-Bibliothek eingebunden werden. Wenn das Projekt mit Maven gebaut wird, kann man in pom.xml Datei die folgenden Abhängigkeiten hinzufügen：
<dependency> <groupId>org.apache.tika</groupId> <artifactId>tika-core</artifactId> <version>1.27</version> </dependency>
Anschließend lässt sich mit folgendem Code der Dateityp ermitteln:
import org.apache.tika.Tika;
public class FileTypeChecker {
public static void main(String[] args) {
Tika tika = new Tika();
try {
File file = new File("C:/path/to/file.jpg");
String fileType = tika.detect(file);
System.out.println("File type: " + fileType);
} catch (IOException e) {
e.printStackTrace();
}
}
}Beim Ausführen des obigen Codes wird der Dateityp ausgegeben.
Tika verwendet verschiedene Verfahren zur Erkennung von Dateitypen, darunter Dateiendungen und magische Zahlen. Es unterstützt auch benutzerdefinierte Detektoren, mit denen sich bei Bedarf eigene Regeln zur Dateityperkennung hinzufügen lassen.
3.2 FileTypeDetector
Java stellt eine Standard-API zur Erkennung von Dateitypen bereit, nämlich FileTypeDetector Schnittstelle und ProbeContentType Klasse. Durch Implementieren dieser Schnittstelle lässt sich ein eigener Dateitypdetektor erstellen.
Hier ist ein Beispiel für einen benutzerdefinierten Dateitypdetektor:
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.spi.FileTypeDetector;
public class CustomFileTypeDetector extends FileTypeDetector {
@Override
public String probeContentType(Path path) throws IOException {
String extension = getFileExtension(path.toFile());
if ("txt".equals(extension)) {
return "text/plain";
} else if ("jpg".equals(extension) || "jpeg".equals(extension)) {
return "image/jpeg";
} else if ("png".equals(extension)) {
return "image/png";
} else {
return null;
}
}
private String getFileExtension(File file) {
String fileName = file.getName();
if (fileName.lastIndexOf(".") != -1 && fileName.lastIndexOf(".") != 0) {
return fileName.substring(fileName.lastIndexOf(".") + 1);
} else {
return "";
}
}
}In diesem Beispiel bestimmen wir den Dateityp anhand der Dateiendung und geben den entsprechenden MIME-Typ zurück.
Um einen benutzerdefinierten Dateitypdetektor zu verwenden, fügen Sie den folgenden Code am Einstiegspunkt des Programms hinzu:
File file = new File("C:/path/to/file.jpg");
Path path = file.toPath();
String fileType = Files.probeContentType(path);
System.out.println("File type: " + fileType);Beim Ausführen des obigen Codes wird der Dateityp ausgegeben.
Bitte beachten Sie, dass diese auf Dateiendungen beruhende Methode bei einigen besonderen Dateitypen, beispielsweise ausführbaren Dateien ohne Endung, möglicherweise nicht genau genug ist. Daher empfiehlt sich eher die zuvor vorgestellte Methode anhand der magischen Zahl der Datei.
IV、Zusammenfassung
Dieser Artikel stellt mehrere Methoden vor, um in Java den Dateityp zu ermitteln. Der Dateityp lässt sich anhand der Dateiendung oder der magischen Bytes bestimmen. Mit Bibliotheken von Drittanbietern wie Tika lässt er sich bequemer ermitteln. Für besondere Dateitypen kann ein eigener Dateitypdetektor implementiert werden, um eine präzise Bestimmung zu ermöglichen.
Welche Methode zur Ermittlung des Dateityps geeignet ist, hängt vom konkreten Anwendungsfall und den Anforderungen ab. In der Praxis sollte anhand der Dateieigenschaften und Anforderungen die passendste Erkennungsmethode gewählt werden, wobei Erweiterbarkeit und Kompatibilität zu berücksichtigen sind.
