Nello sviluppo Java capita spesso di dover determinare il tipo di un file: per esempio, una funzionalità di caricamento deve verificare che il file inviato dall'utente sia di un tipo consentito. Questo articolo illustra in dettaglio i metodi per ottenere il tipo di file con Java.
I、Determinare il tipo di file tramite l'estensione
Il metodo più comune per determinare il tipo di un file consiste nel basarsi sulla sua estensione. Nel sistema operativo, la maggior parte dei file ha un'estensione specifica; per esempio, l'estensione dei file di testo è solitamente .txt，le estensioni dei file immagine sono solitamente.jpg oppure.png e così via.
Ottenere l'estensione di un file tramite un programma Java è molto semplice, basta usare String della classe substring è sufficiente usare il metodo, come mostrato nel codice seguente:
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 "";
}
}Questo metodo riceve un File oggetto come parametro, quindi utilizzare lastIndexOf il metodo individua la posizione dell'ultimo punto nel nome del file, ossia l'inizio dell'estensione, quindi usa substring per ottenere e restituire la stringa dell'estensione. Se il file non ha un'estensione, restituisce una stringa vuota.
È possibile testare questo metodo con il codice seguente：
File file = new File("C:/path/to/file.txt");
String extension = getFileExtension(file);
System.out.println(extension);Il risultato dell'esecuzione è：
txt
Questo metodo per identificare il tipo di file presenta i seguenti vantaggi：
Semplice da usare, con un'implementazione concisa del codice.
Funziona per la stragrande maggioranza dei file, perché quasi tutti hanno un'estensione.
Tuttavia, questo metodo presenta anche alcuni svantaggi:
L'estensione di un file può essere modificata, causando un risultato di identificazione errato.
Alcuni file non hanno un suffisso, per esempio gli eseguibili privi di estensione.
Per identificare il tipo di file con maggiore precisione, possiamo prendere in considerazione anche il suo numero magico.
II、Determinare il tipo di file tramite i numeri magici
Il numero magico di un file è una sequenza di byte specifici tra i primi byte del file, usata per identificarne il tipo. Riconoscendo il numero magico, possiamo determinare con precisione il tipo di file senza farci condizionare dalla sua estensione.
In Java è possibile ottenere il magic number di un file leggendone i dati binari.
2.1 Lettura dei dati binari di un file
Possiamo utilizzare FileInputStream per leggere i dati binari del file tramite la classe. Il metodo seguente restituisce un array di byte contenente i dati binari del file:
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();
}
}
}I metodi sopra descritti utilizzano FileInputStream per aprire il file, leggere i dati e memorizzarli in un array di byte. Si noti che, una volta terminata la lettura del file, occorre chiamare close chiude il flusso del file tramite il metodo, per liberare le risorse di sistema.
2.2 Determinare il tipo di file tramite il magic number
Una volta ottenuti i dati binari del file, possiamo identificarne il tipo. Ogni tipo di file ha un numero magico specifico, che permette di riconoscerlo. Di seguito sono riportati i numeri magici di alcuni tipi di file comuni e i relativi metodi di identificazione：
Il numero magico dei file di testo (.txt) è
EF BB BF（Questo è il contenuto della sequenza di byte all’inizio dei file con codifica UTF-8）, si può usare il seguente metodo per verificarlo:public static boolean isTextFile(byte[] data) { if (data.length >= 3 && data[0] == -17 && data[1] == -69 && data[2] == -65) { return true; } return false; }Il numero magico delle immagini JPEG（.jpg）è
FF D8 FF，si possono usare i seguenti metodi per verificarlo:public static boolean isJPEGFile(byte[] data) { if (data.length >= 3 && data[0] == -1 && data[1] == -40 && data[2] == -1) { return true; } return false; }Il numero magico delle immagini PNG（.png）è
89 50 4E 47 0D 0A 1A 0A，si possono usare i seguenti metodi per verificarlo: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; }
Se necessario, è possibile aggiungere altri tipi di file e i corrispondenti metodi di riconoscimento tramite numeri magici.
2.3 Esempio completo
Di seguito un esempio completo che mostra come usare i numeri magici dei file per determinarne il tipo:
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;
}
}Il codice di esempio riportato sopra determina il tipo di file in base al suo numero magico e restituisce il risultato corrispondente.
III、Usare librerie di terze parti per determinare il tipo di file
Oltre ai metodi descritti sopra, è possibile usare librerie di terze parti per identificare il tipo di file. In Java esistono alcune librerie open source di terze parti che ci aiutano a ottenere più facilmente il tipo di file.
3.1 Tika
Tika è un progetto della Apache Software Foundation che offre una libreria Java open source per analizzare diversi formati di file, tra cui testo, immagini, audio e video. Con Tika è possibile estrarre i metadati dei file, compreso il tipo di file.
Per prima cosa, occorre aggiungere la dipendenza della libreria Tika. Se si usa Maven per compilare il progetto, è possibile farlo in pom.xml Aggiungere al file le seguenti dipendenze:
<dependency> <groupId>org.apache.tika</groupId> <artifactId>tika-core</artifactId> <version>1.27</version> </dependency>
Quindi, è possibile utilizzare il codice seguente per ottenere il tipo del file：
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();
}
}
}Eseguendo il codice sopra, verrà visualizzato il tipo del file.
Tika utilizza diversi metodi per identificare il tipo di file, tra cui l'estensione e i numeri magici. Supporta anche rilevatori personalizzati, che consentono di aggiungere regole di riconoscimento dei tipi di file secondo necessità.
3.2 FileTypeDetector
Java fornisce un'API standard per rilevare il tipo di file, ossia FileTypeDetector l’interfaccia e ProbeContentType classe. Implementando questa interfaccia, è possibile definire un rilevatore personalizzato dei tipi di file.
Ecco un esempio di rilevatore personalizzato del tipo di file:
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 questo esempio, determiniamo il tipo di file in base alla sua estensione e restituiamo il tipo MIME corrispondente.
Per usare un rilevatore personalizzato del tipo di file, aggiungi il codice seguente al punto di ingresso del programma:
File file = new File("C:/path/to/file.jpg");
Path path = file.toPath();
String fileType = Files.probeContentType(path);
System.out.println("File type: " + fileType);Eseguendo il codice sopra, verrà visualizzato il tipo del file.
Si tenga presente che, per alcuni tipi particolari di file, come gli eseguibili senza estensione, questo metodo basato sull'estensione potrebbe non essere sufficientemente accurato; è quindi preferibile usare il metodo basato sui numeri magici dei file illustrato in precedenza.
IV. Riepilogo
Questo articolo presenta diversi metodi per ottenere il tipo di un file in Java. È possibile determinarlo tramite l’estensione oppure attraverso il numero magico del file. L’uso di librerie di terze parti come Tika permette di ottenere il tipo di file più facilmente. Per tipi di file particolari, è possibile realizzare un rilevatore personalizzato che li identifichi con precisione.
La scelta del metodo adatto per ottenere il tipo di file dipende dal contesto applicativo e dai requisiti specifici. Nello sviluppo concreto, scegliete il metodo di riconoscimento più adatto alle caratteristiche dei file e alle esigenze, tenendo conto anche dell'estensibilità e della compatibilità.
