En el desarrollo con Java, a menudo es necesario determinar el tipo de un archivo. Por ejemplo, en una función de carga de archivos, hay que comprobar si el archivo que sube el usuario es de uno de los tipos permitidos. Este artículo explicará detalladamente cómo obtener el tipo de un archivo con Java.
I、Determinar el tipo de archivo mediante su extensión
La forma más habitual de identificar el tipo de un archivo es por su extensión. La mayoría de los archivos tienen una extensión específica en el sistema operativo; por ejemplo, la extensión de los archivos de texto suele ser.txt，la extensión de los archivos de imagen suele ser.jpg o.png Etcétera.
Obtener la extensión de un archivo mediante un programa Java es muy sencillo, basta con utilizar String de la clase substring basta con utilizar el método, como se muestra en el siguiente código：
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 "";
}
}Este método recibe un File el objeto como parámetro y después utilizar lastIndexOf el método encuentra la posición del último punto del nombre del archivo, es decir, el inicio de la extensión, y después utiliza substring El método obtiene la cadena de la extensión y la devuelve. Si el archivo no tiene extensión, devuelve una cadena vacía.
Se puede probar este método con el siguiente código：
File file = new File("C:/path/to/file.txt");
String extension = getFileExtension(file);
System.out.println(extension);El resultado de la ejecución es：
txt
Utilizar este método para determinar el tipo de archivo ofrece las siguientes ventajas：
Fácil de usar y con una implementación de código sencilla.
Funciona con la inmensa mayoría de los archivos, porque la inmensa mayoría tienen una extensión.
Sin embargo, este método también presenta algunas desventajas:
La extensión del archivo puede haberse modificado, lo que provocaría una identificación incorrecta.
Algunos archivos no tienen extensión, por ejemplo, ciertos archivos ejecutables.
Para determinar con mayor precisión el tipo de archivo, podemos tener en cuenta su número mágico.
II. Determinar el tipo de archivo mediante su número mágico
La firma mágica de un archivo consiste en determinados bytes situados entre sus primeros bytes y sirve para identificar su tipo. Al reconocer esta firma, podemos determinar con precisión el tipo de archivo, sin que influya su extensión.
En Java, podemos obtener la firma mágica de un archivo leyendo sus datos binarios.
2.1 Leer los datos binarios del archivo
Podemos utilizar FileInputStream para leer los datos binarios del archivo mediante esta clase. El siguiente método devuelve un array de bytes que contiene los datos binarios del archivo：
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();
}
}
}Los métodos anteriores utilizan FileInputStream para abrir el archivo, leer los datos y almacenarlos en un array de bytes. Ten en cuenta que, una vez terminada la lectura del archivo, es necesario llamar a close el método cierra el flujo del archivo para liberar recursos del sistema.
2.2 Identificar el tipo de archivo mediante su número mágico
Una vez que tenemos los datos binarios del archivo, podemos determinar su tipo. Cada tipo de archivo tiene un número mágico específico que permite identificarlo. A continuación se muestran los números mágicos de algunos tipos de archivo comunes y los métodos correspondientes para identificarlos：
El número mágico de los archivos de texto（.txt）es
EF BB BF（los archivos codificados en UTF-8 tienen esta secuencia de bytes al principio），se puede comprobar con el siguiente método：public static boolean isTextFile(byte[] data) { if (data.length >= 3 && data[0] == -17 && data[1] == -69 && data[2] == -65) { return true; } return false; }El número mágico de las imágenes JPEG (.jpg) es
FF D8 FF, puede comprobarse con el siguiente método:public static boolean isJPEGFile(byte[] data) { if (data.length >= 3 && data[0] == -1 && data[1] == -40 && data[2] == -1) { return true; } return false; }El número mágico de las imágenes PNG（.png）es
89 50 4E 47 0D 0A 1A 0A, puede comprobarse con el siguiente método: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; }
Según sea necesario, se pueden añadir más tipos de archivo y sus correspondientes métodos de identificación mediante números mágicos。
2.3 Ejemplo completo
A continuación se muestra un ejemplo completo de cómo utilizar los números mágicos para determinar el tipo de archivo:
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;
}
}El código de ejemplo anterior determina el tipo de archivo a partir de su número mágico y muestra el resultado correspondiente.
III、Utilizar bibliotecas de terceros para identificar el tipo de archivo
Además de los métodos anteriores, también se pueden utilizar bibliotecas de terceros para determinar el tipo de archivo. En Java existen algunas bibliotecas de terceros de código abierto que facilitan la obtención del tipo de archivo.
3.1 Tika
Tika es un proyecto de Apache Software Foundation que proporciona una biblioteca Java de código abierto para analizar diversos formatos de archivo, incluidos texto, imágenes, audio y vídeo. Tika permite extraer los metadatos de un archivo, incluido su tipo.
Primero, hay que añadir la dependencia de la biblioteca Tika. Si el proyecto se compila con Maven, se puede añadir en pom.xml Añade las siguientes dependencias al archivo:
<dependency> <groupId>org.apache.tika</groupId> <artifactId>tika-core</artifactId> <version>1.27</version> </dependency>
Después, se puede utilizar el siguiente código para obtener el tipo de archivo:
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();
}
}
}Al ejecutar el código anterior, se mostrará el tipo de archivo.
Tika utiliza varios métodos para identificar el tipo de archivo, como la extensión y los números mágicos. También admite detectores personalizados, lo que permite añadir reglas propias para determinar tipos de archivo según sea necesario。
3.2 FileTypeDetector
Java proporciona una API estándar para detectar tipos de archivo, a saber, FileTypeDetector interfaz y ProbeContentType clase. Implementando esta interfaz, se puede personalizar un detector de tipos de archivo.
A continuación se muestra un ejemplo de detector personalizado de tipos de archivo：
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 "";
}
}
}En este ejemplo, determinamos el tipo de archivo a partir de su extensión y devolvemos el tipo MIME correspondiente.
Para utilizar el detector personalizado de tipos de archivo, añade el siguiente código en el punto de entrada del programa：
File file = new File("C:/path/to/file.jpg");
Path path = file.toPath();
String fileType = Files.probeContentType(path);
System.out.println("File type: " + fileType);Al ejecutar el código anterior, se mostrará el tipo de archivo.
Ten en cuenta que, para algunos tipos especiales de archivo, como los ejecutables sin extensión, este método basado en la extensión puede no ser lo suficientemente preciso; por eso se recomienda más el método basado en números mágicos de archivo presentado anteriormente.
IV、Conclusión
Este artículo presenta varios métodos para obtener el tipo de un archivo en Java. Se puede determinar mediante su extensión o sus números mágicos. Las bibliotecas de terceros, como Tika, permiten obtenerlo con mayor facilidad. Para tipos de archivo especiales, se puede implementar un detector personalizado que permita identificarlos con precisión.
La elección de un método adecuado para obtener el tipo de archivo depende del contexto de aplicación y de los requisitos concretos. En el desarrollo real, se debe elegir el método de identificación más apropiado según las características del archivo y las necesidades, teniendo en cuenta la extensibilidad y la compatibilidad.
