java check file extension – detectar y validar tipos de documento

Una de las tareas más comunes es java check file extension antes de procesar un documento.

¿Alguna vez subiste un archivo y tu aplicación se bloqueó porque no era del formato esperado? No estás solo. Detectar y validar formatos de archivo en Java es crucial para crear aplicaciones robustas de procesamiento de documentos, pero es más complicado que simplemente comprobar extensiones de archivo (que pueden falsificarse o ser incorrectas).

En esta guía aprenderás a detectar de forma fiable formatos de archivo en Java usando GroupDocs.Signature, una biblioteca potente que va más allá de la simple comprobación de extensiones. Ya sea que estés construyendo un sistema de gestión documental, validando cargas de usuarios o integrándote con servicios de almacenamiento en la nube, descubrirás técnicas prácticas para manejar diversos tipos de documentos con confianza.

Lo que aprenderás:

  • Cómo obtener programáticamente los formatos de archivo compatibles en Java
  • Cuándo usar detección basada en biblioteca vs. enfoques integrados de Java
  • Trampas comunes al validar tipos de archivo (y cómo evitarlas)
  • Escenarios de integración del mundo real y consejos de optimización de rendimiento
  • Estrategias de solución de problemas para detección de formatos

Al final, tendrás una implementación funcional que podrás incorporar inmediatamente en tus aplicaciones Java. Comencemos asegurándonos de que tienes todo lo necesario.

Respuestas rápidas

  • ¿Cuál es la forma más rápida de java check file extension? Usa Signature.getSupportedFileTypes() para obtener la lista completa y comparar la extensión del archivo con ella.
  • ¿Necesito una licencia para usar GroupDocs.Signature? Una prueba gratuita funciona para desarrollo; una licencia permanente elimina todas las limitaciones de evaluación.
  • ¿Puedo validar cargas sin leer todo el archivo? Sí—GroupDocs.Signature inspecciona el encabezado del archivo, lo que es mucho más barato que cargar todo el documento.
  • ¿Cuántos formatos soporta GroupDocs.Signature? Más de 50 formatos de entrada y salida, incluidos PDF, DOCX, XLSX, PPTX, JPG, PNG y muchos más.
  • ¿Es necesario almacenar en caché la lista de formatos? El caché elimina la sobrecarga de reflexión repetida y mejora el rendimiento para servicios de alto volumen.

¿Qué es java check file extension?

java check file extension se refiere al proceso de confirmar el tipo real de un archivo examinando su encabezado y metadatos en lugar de confiar únicamente en el sufijo del nombre de archivo. Esto garantiza que los archivos renombrados maliciosamente se detecten temprano, previene brechas de seguridad causadas por extensiones falsificadas y asegura que solo se procesen tipos de documento compatibles con tu aplicación.

Requisitos previos

Antes de sumergirte en la detección de formatos de archivo, asegúrate de tener lo siguiente listo:

Bibliotecas y versiones requeridas

  • GroupDocs.Signature Library: Versión 23.12 o posterior (usaremos la última versión estable)
  • Java Development Kit: JDK 1.8 o superior (JDK 11+ recomendado para mejor rendimiento)
  • Herramienta de compilación: Maven 3.x o Gradle 6.x para la gestión de dependencias

Requisitos de configuración del entorno

Deberías sentirte cómodo con:

  • Conceptos básicos de programación Java (clases, bucles, imports)
  • Uso de Maven o Gradle para gestionar dependencias
  • Ejecución de aplicaciones Java desde tu IDE o línea de comandos

Consejo rápido: Si trabajas con documentos grandes o planeas procesar archivos concurrentemente, asigna suficiente memoria heap a tu JVM (abordaremos la optimización más adelante).

Configuración de GroupDocs.Signature para Java

Incorporar GroupDocs.Signature a tu proyecto es sencillo—elige tu herramienta de compilación preferida y sigue los pasos.

Usando Maven

Agrega esta dependencia a tu archivo pom.xml:

<dependency>
    <groupId>com.groupdocs</groupId>
    <artifactId>groupdocs-signature</artifactId>
    <version>23.12</version>
</dependency>

Después de añadir la dependencia, ejecuta mvn clean install para descargar la biblioteca.

Usando Gradle

Incluye esta línea en tu archivo build.gradle:

implementation 'com.groupdocs:groupdocs-signature:23.12'

Luego sincroniza tu proyecto Gradle o ejecuta gradle build.

Alternativa de descarga directa

¿No usas una herramienta de compilación? Puedes descargar el JAR directamente desde GroupDocs.Signature for Java releases y añadirlo manualmente a tu classpath. (Aunque Maven o Gradle te ahorrarán dolores de cabeza a futuro.)

Pasos para adquirir una licencia

GroupDocs.Signature ofrece opciones de licenciamiento flexibles:

  • Prueba gratuita: Perfecta para pruebas—comienza de inmediato sin no credit card required
  • Licencia temporal: ¿Necesitas más tiempo para evaluar? Solicita una licencia temporal de 30 días para acceso sin restricciones
  • Compra: Cuando estés listo para producción, adquiere una licencia permanente en la GroupDocs Purchase Page

Consejo de profesional: Empieza con la prueba gratuita para explorar todas las funciones. La licencia temporal elimina marcas de agua y limitaciones si necesitas más tiempo de evaluación.

¿Qué es la clase Signature?

Signature es el punto de entrada principal para todas las operaciones en GroupDocs.Signature. Encapsula la carga de documentos, el manejo de formatos y el procesamiento de firmas. La clase ofrece métodos para abrir documentos, obtener formatos compatibles y aplicar o verificar firmas en muchos tipos de archivo.

Así es como se inicializa GroupDocs.Signature en tu aplicación Java:

import com.groupdocs.signature.Signature;

// Create an instance of Signature class
Signature signature = new Signature("sample.pdf");

Esto crea un objeto de firma para el documento especificado. Usarás este patrón al trabajar con documentos reales, pero para obtener los formatos compatibles no necesitarás un archivo específico (lo mostraremos en la siguiente sección).

Guía de implementación

Aquí es donde la cosa se vuelve práctica. Crearemos una utilidad sencilla que recupera todos los formatos de archivo compatibles—piensa en ello como un “verificador de compatibilidad” para tu canal de procesamiento de documentos.

Por qué es importante

Antes de invertir tiempo en implementar funciones de procesamiento de documentos, necesitas saber qué tipos de archivo soporta tu biblioteca. Esta implementación te brinda esa información de forma dinámica, lo que significa:

  • No codificar listas de extensiones que queden obsoletas
  • Validar fácilmente las cargas de usuarios contra formatos compatibles
  • Tener una referencia rápida para crear filtros de tipo de archivo en tu UI

Implementación paso a paso

1. Importar clases necesarias

FileType es la puerta de entrada a la detección de formatos—contiene todos los metadatos sobre los tipos de documento soportados. El método Signature.getSupportedFileTypes() devuelve una colección de objetos FileType que representan cada formato que la biblioteca puede manejar.

import com.groupdocs.signature.domain.documentpreview.FileType;
import java.util.List;

2. Crear la clase de recuperación

Aquí tienes la implementación completa:

public class GetSupportedFileFormats {
    public static void run() {
        // Retrieve a list of supported file types from the FileType utility.
        List<FileType> supportedFileTypes = FileType.getSupportedFileTypes();

        // Iterate over each FileType object and print its extension to the console.
        for (FileType fileType : supportedFileTypes) {
            System.out.print("\n" + fileType.getExtension());
        }
    }
}

Qué está ocurriendo:

  • Signature.getSupportedFileTypes() consulta el registro interno de la biblioteca y devuelve una lista completa de formatos compatibles como objetos FileType.
  • El bucle recorre cada formato y muestra su extensión (como .pdf, .docx, .xlsx).
  • Cada objeto FileType también contiene metadatos adicionales a los que puedes acceder (los exploraremos a continuación).

Más allá de las extensiones básicas

El objeto FileType te brinda más que solo extensiones. Esto es lo que también puedes obtener:

for (FileType fileType : supportedFileTypes) {
    System.out.println("Extension: " + fileType.getExtension());
    System.out.println("Format: " + fileType.getFileFormat());
    // Additional properties available depending on version
}

Esto es útil cuando necesitas mostrar nombres de formato amigables para el usuario o agrupar formatos por tipo (documentos vs. hojas de cálculo vs. imágenes).

¿Cómo java check file extension?

Carga el nombre del archivo, extrae su sufijo y compáralo con la lista almacenada en caché devuelta por Signature.getSupportedFileTypes(). Este enfoque de dos pasos garantiza que estés verificando contra un catálogo actualizado en lugar de un arreglo codificado. También evita extensiones falsificadas porque GroupDocs.Signature valida el encabezado del archivo antes de cualquier procesamiento adicional, asegurando que el contenido coincida realmente con el tipo declarado.

¿Qué es GroupDocs.Signature?

GroupDocs.Signature es una biblioteca Java que permite a los desarrolladores añadir, verificar y gestionar firmas digitales en más de 50 formatos de documento. Proporciona una API unificada para PDF, Office, imágenes y muchos otros tipos, manejando escenarios complejos de validación como archivos cifrados, documentos protegidos con contraseña y firmas multipágina. La biblioteca también ofrece detección de formato basada en contenido, lo que ayuda a prevenir el procesamiento de archivos renombrados maliciosamente.

¿Por qué usar detección basada en biblioteca en lugar de los métodos integrados de Java?

La detección basada en biblioteca inspecciona el encabezado real del archivo y su estructura interna, garantizando que el contenido coincida con el formato declarado. Los métodos integrados como Files.probeContentType o la simple comprobación de sufijo pueden ser engañados al renombrar ejecutables maliciosos a .pdf. GroupDocs.Signature elimina este riesgo al realizar un análisis profundo del contenido antes de cualquier procesamiento, proporcionando una garantía de seguridad mayor para tu aplicación.

¿Cuándo debo almacenar en caché los formatos de archivo compatibles?

Almacena en caché la lista de formatos al iniciar la aplicación o la primera vez que la necesites, y reutiliza la colección inmutable durante la vida de la JVM. El caché es especialmente útil en servicios web de alto rendimiento donde cada solicitud podría desencadenar una inicialización pesada de la biblioteca, añadiendo milisegundos de latencia por llamada. Al guardar la lista una sola vez, reduces la sobrecarga de CPU y mejoras los tiempos de respuesta generales.

¿Cómo manejar formatos de archivo no compatibles en Java?

Detecta el formato no compatible temprano, registra el intento para auditoría y devuelve un mensaje de error claro al usuario que enumere las extensiones permitidas. Este enfoque mejora la experiencia del usuario y reduce la carga de procesamiento innecesaria en tu backend, al tiempo que brinda al equipo de seguridad visibilidad sobre intentos de uso indebido.

Cuándo usar este enfoque

Casos de uso perfectos

1. Validadores de carga de documentos
Cuando los usuarios suben archivos a tu aplicación, deseas validar los formatos del lado del servidor (nunca confíes solo en la validación del cliente). Este enfoque te permite comprobar contra una lista completa de formatos compatibles antes de procesar.

2. Creación de filtros dinámicos de tipo de archivo
¿Construyes un selector de archivos o una interfaz de carga? Genera tu lista de formatos permitidos de forma dinámica en lugar de mantener un arreglo estático que quede desincronizado con las capacidades de tu biblioteca.

3. Pipelines de procesamiento de documentos multiformato
Si procesas documentos de diversas fuentes (adjuntos de correo, almacenamiento en la nube, cargas de usuarios), necesitas detección fiable de formatos para enrutar los archivos a los manejadores adecuados.

4. Integración con servicios de almacenamiento en la nube
Al sincronizar con AWS S3, Google Drive o Azure Blob Storage, valida la compatibilidad del documento antes de descargar y procesar—ahorra ancho de banda y tiempo de procesamiento.

Cuando los métodos integrados de Java pueden ser suficientes

Para escenarios más simples, los enfoques integrados de Java pueden bastar:

  • Comprobación solo de extensión: file.getName().endsWith(".pdf")
  • Detección de tipo MIME: Files.probeContentType(path)
  • Validación básica: Cuando controlas la fuente de carga y confías en las extensiones de archivo

Advertencia importante: Los métodos integrados pueden engañarse. Un archivo renombrado de malicious.exe a document.pdf pasará la comprobación de extensión pero fallará la validación adecuada. GroupDocs.Signature realiza una inspección más profunda.

Problemas comunes y solución de errores

Problema 1: Lista vacía o nula devuelta

Síntoma: Signature.getSupportedFileTypes() devuelve una lista vacía o null.

Causas y soluciones:

  • Biblioteca no inicializada correctamente – verifica que la dependencia Maven/Gradle esté añadida y sincronizada.
  • Compatibilidad de versión – asegúrate de usar la versión 23.12 o posterior (las versiones anteriores pueden tener APIs diferentes).
  • Problemas de classpath – si usas JARs manuales, confirma que estén correctamente añadidos al classpath.

Corrección rápida:

List<FileType> formats = FileType.getSupportedFileTypes();
if (formats == null || formats.isEmpty()) {
    System.err.println("Error: No file types loaded. Check library initialization.");
    return;
}

Problema 2: Falta el formato esperado

Síntoma: Un formato que esperas que funcione no aparece en la lista de compatibles.

Posibles razones:

  • Estás usando un formato especializado que requiere complementos adicionales (algunos formatos CAD o de imágenes médicas necesitan módulos separados).
  • El formato se añadió en una versión más reciente—revisa las notas de la versión.
  • El formato está soportado solo para lectura pero no para operaciones de firma (GroupDocs.Signature se centra en añadir firmas; no todas las operaciones admiten todos los formatos por igual).

Enfoque de depuración:

// Check for specific format
boolean hasPDF = supportedFileTypes.stream()
    .anyMatch(ft -> ft.getExtension().equalsIgnoreCase(".pdf"));
System.out.println("PDF supported: " + hasPDF);

Problema 3: Degradación de rendimiento con listas de formatos extensas

Síntoma: Llamar repetidamente a Signature.getSupportedFileTypes() ralentiza tu aplicación.

Solución: ¡Almacena los resultados en caché! Esta lista no cambia durante la ejecución:

public class FormatCache {
    private static List<FileType> cachedFormats = null;
    
    public static List<FileType> getSupportedFormats() {
        if (cachedFormats == null) {
            cachedFormats = FileType.getSupportedFileTypes();
        }
        return cachedFormats;
    }
}

Problema 4: Limitaciones relacionadas con la licencia

Síntoma: Recibes advertencias de evaluación o soporte limitado de formatos.

Solución:

  • Aplica tu licencia antes de llamar a cualquier método de GroupDocs.
  • Verifica que la ruta al archivo de licencia sea correcta.
  • Comprueba la fecha de expiración si usas una licencia con tiempo limitado.
try {
    License license = new License();
    license.setLicense("path/to/GroupDocs.Signature.lic");
} catch (Exception e) {
    System.err.println("License error: " + e.getMessage());
}

Mejores prácticas para la detección de formatos de archivo

1. Validar temprano, fallar rápido

Comprueba los formatos de archivo lo antes posible en tu pipeline de procesamiento:

public boolean validateFileFormat(String filePath) {
    String extension = getFileExtension(filePath);
    List<FileType> supported = FormatCache.getSupportedFormats();
    
    boolean isSupported = supported.stream()
        .anyMatch(ft -> ft.getExtension().equalsIgnoreCase(extension));
    
    if (!isSupported) {
        throw new UnsupportedFormatException(
            "File format " + extension + " is not supported"
        );
    }
    return true;
}

2. Proveer retroalimentación clara al usuario

Al rechazar archivos, indica exactamente qué formatos SON compatibles:

public String getSupportedFormatsMessage() {
    List<FileType> formats = FormatCache.getSupportedFormats();
    String extensions = formats.stream()
        .map(FileType::getExtension)
        .collect(Collectors.joining(", "));
    
    return "Supported formats: " + extensions;
}

3. No confiar solo en extensiones de archivo

Un archivo renombrado de .exe a .pdf tendrá la extensión .pdf pero no será un PDF válido. GroupDocs.Signature valida el contenido real, no solo la extensión—pero aún así deberías combinar enfoques:

// First check extension (fast)
if (!hasValidExtension(file)) {
    return false;
}

// Then validate with library (more thorough)
try (Signature signature = new Signature(file)) {
    // If initialization succeeds, format is valid
    return true;
} catch (Exception e) {
    return false;
}

4. Manejar excepciones de forma elegante

La validación de archivos puede fallar por muchas razones más allá de formatos no soportados:

public ValidationResult validateDocument(String path) {
    try {
        // Your validation logic
        return ValidationResult.success();
    } catch (UnsupportedFormatException e) {
        return ValidationResult.failure("Unsupported format: " + e.getMessage());
    } catch (IOException e) {
        return ValidationResult.failure("File access error: " + e.getMessage());
    } catch (Exception e) {
        return ValidationResult.failure("Unexpected error: " + e.getMessage());
    }
}

5. Monitorizar cambios en el soporte de formatos

Al actualizar la biblioteca GroupDocs.Signature, revisa las notas de la versión para:

  • Nuevos formatos soportados
  • Formatos obsoletos
  • Cambios en el comportamiento de detección de formatos

Considera añadir pruebas unitarias que verifiquen que los formatos esperados siguen siendo compatibles:

@Test
public void testEssentialFormatsSupported() {
    List<String> required = Arrays.asList(".pdf", ".docx", ".xlsx");
    List<FileType> supported = FileType.getSupportedFileTypes();
    
    for (String format : required) {
        assertTrue(
            supported.stream().anyMatch(ft -> ft.getExtension().equals(format)),
            format + " should be supported"
        );
    }
}

Consideraciones de rendimiento

Optimizar la detección de formatos de archivo puede parecer menor, pero importa cuando procesas miles de documentos o manejas cargas concurrentes.

Gestión de memoria

Estrategia de caché: Como se mencionó antes, almacena en caché la lista de formatos compatibles:

// Good: Load once, reuse many times
private static final List<FileType> SUPPORTED_FORMATS = 
    FileType.getSupportedFileTypes();

// Bad: Loads list every time method is called
public boolean isSupported(String ext) {
    return FileType.getSupportedFileTypes().stream()
        .anyMatch(ft -> ft.getExtension().equals(ext));
}

Por qué importa: Cargar la lista implica reflexión e inicialización interna de la biblioteca. Hacerlo una sola vez ahorra ciclos de CPU y asignaciones de memoria.

Directrices de uso de recursos

Para escenarios de alto volumen:

  • Usa un caché thread‑safe para listas de formatos (el ejemplo anterior es thread‑safe al ser inmutable).
  • Considera la inicialización perezosa si tu aplicación no siempre necesita detección de formatos.
  • Al procesar documentos, cierra los objetos Signature rápidamente para liberar recursos.
try (Signature signature = new Signature(filePath)) {
    // Process document
} // Automatically closed, resources freed

Optimización de procesamiento por lotes

Si validas varios archivos, considera paralelizar:

List<String> files = Arrays.asList("doc1.pdf", "doc2.docx", "doc3.xlsx");

// Process in parallel
files.parallelStream()
    .forEach(file -> {
        if (validateFileFormat(file)) {
            processDocument(file);
        }
    });

Precaución: No sobre‑paralelices. Si tu carga es I/O‑bound (lectura de disco), demasiados hilos no ayudarán. Prueba para encontrar el número óptimo de hilos.

Consejos de afinado de la JVM

Para aplicaciones con gran carga documental:

  • Incrementa el tamaño del heap: -Xmx2g (ajusta según tus necesidades).
  • Monitorea la recolección de basura: Usa -XX:+PrintGCDetails para identificar problemas.
  • Considera G1GC para mejores tiempos de pausa: -XX:+UseG1GC.

Aplicaciones prácticas e integración

Veamos escenarios reales donde la detección de formatos de archivo es esencial.

1. Sistemas de gestión documental

Escenario: Los usuarios suben documentos que deben indexarse, procesarse y almacenarse.

Patrón de implementación:

public class DocumentUploadHandler {
    public void handleUpload(MultipartFile file) {
        // Validate format first
        if (!isFormatSupported(file.getOriginalFilename())) {
            throw new InvalidFormatException(
                "Please upload: " + getSupportedFormatsString()
            );
        }
        
        // Process valid document
        processAndStore(file);
    }
    
    private boolean isFormatSupported(String filename) {
        String ext = getExtension(filename);
        return FormatCache.getSupportedFormats().stream()
            .anyMatch(ft -> ft.getExtension().equalsIgnoreCase(ext));
    }
}

2. Integración con almacenamiento en la nube

Escenario: Sincronizar documentos desde AWS S3 o Google Drive y procesar solo los formatos compatibles.

Por qué es útil: Evita descargar y intentar procesar archivos no compatibles, ahorrando ancho de banda y tiempo de procesamiento.

public void syncFromS3(String bucketName) {
    S3Client s3 = S3Client.create();
    ListObjectsV2Request listReq = ListObjectsV2Request.builder()
        .bucket(bucketName)
        .build();
    
    ListObjectsV2Response listing = s3.listObjectsV2(listReq);
    
    for (S3Object object : listing.contents()) {
        if (isFormatSupported(object.key())) {
            // Download and process only supported formats
            downloadAndProcess(bucketName, object.key());
        } else {
            logger.info("Skipping unsupported format: " + object.key());
        }
    }
}

3. Automatización de flujos de trabajo empresarial

Escenario: Enrutar documentos a diferentes pipelines según su tipo.

Ejemplo: PDFs van al flujo de firmas, hojas de cálculo a extracción de datos, imágenes a OCR.

public void routeDocument(String filePath) {
    try (Signature signature = new Signature(filePath)) {
        FileType type = signature.getDocumentInfo().getFileType();
        
        switch (type.getExtension()) {
            case ".pdf":
            case ".docx":
                sendToSignatureWorkflow(filePath);
                break;
            case ".xlsx":
            case ".csv":
                sendToDataExtractionWorkflow(filePath);
                break;
            case ".jpg":
            case ".png":
                sendToOCRWorkflow(filePath);
                break;
            default:
                logger.warn("No workflow defined for: " + type.getExtension());
        }
    }
}

4. Creación de selectores de tipo de archivo

Escenario: Construir componentes UI con soporte dinámico de formatos.

Ejemplo de integración frontend:

@RestController
public class FormatController {
    @GetMapping("/api/supported-formats")
    public ResponseEntity<List<String>> getSupportedFormats() {
        List<String> extensions = FileType.getSupportedFileTypes().stream()
            .map(FileType::getExtension)
            .sorted()
            .collect(Collectors.toList());
        
        return ResponseEntity.ok(extensions);
    }
}

Tu frontend puede usar esto para configurar componentes de carga de archivos:

// Frontend code (for context, not part of Java implementation)
fetch('/api/supported-formats')
    .then(res => res.json())
    .then(formats => {
        fileInput.accept = formats.join(',');
    });

Preguntas frecuentes

P: ¿Cómo actualizo la versión de mi biblioteca GroupDocs.Signature en Maven?
R: Cambia la etiqueta <version> en tu pom.xml a la versión deseada y luego ejecuta mvn clean install. Siempre revisa las release notes para cambios que puedan romper compatibilidad.

P: ¿GroupDocs.Signature puede detectar formatos aunque la extensión sea incorrecta?
R: Sí. La biblioteca realiza validación basada en contenido, por lo que un archivo renombrado de .exe a .pdf será rechazado como no válido para PDF. getSupportedFileTypes() solo enumera los formatos que la biblioteca puede manejar; aún necesitas intentar abrir el archivo para verificar su tipo real.

P: ¿Cuál es la diferencia entre una prueba gratuita y una licencia temporal?
R: La prueba gratuita brinda acceso inmediato pero incluye marcas de agua de evaluación y algunas limitaciones de funciones. Una licencia temporal otorga acceso completo durante 30 días sin marcas de agua, ideal para pruebas exhaustivas en un entorno similar a producción.

P: ¿Cómo debo manejar formatos de archivo no compatibles en mi aplicación?
R: Devuelve un error conciso como “Formato no compatible. Las extensiones admitidas son: .pdf, .docx, .xlsx, .png, .jpg.” Registra el incidente para monitoreo de seguridad y considera notificar al usuario con una pista UI que enumere los tipos permitidos.

P: ¿GroupDocs.Signature funciona con archivos cifrados o protegidos con contraseña?
R: Sí, pero debes proporcionar la contraseña al crear la instancia Signature. La detección de formato en sí no requiere la contraseña, aunque cualquier procesamiento posterior (por ejemplo, añadir una firma) sí lo hará.

P: ¿Existe una comunidad o foro de soporte para GroupDocs.Signature?
R: ¡Claro! Visita el GroupDocs Forum para discusiones comunitarias, ejemplos de código y respuestas directas del equipo de GroupDocs.

Recursos

Documentación:

Descargas y licenciamiento:

Soporte y comunidad:

Última actualización: 2026-08-19
Probado con: GroupDocs.Signature 23.12 para Java
Autor: GroupDocs

<version>24.1</version>  <!-- Update to newer version -->

try {
    validateAndProcess(file);
} catch (UnsupportedFormatException e) {
    return ResponseEntity
        .badRequest()
        .body("Unsupported format. Please upload: " + getSupportedFormatsString());
}

LoadOptions loadOptions = new LoadOptions();
loadOptions.setPassword("your-password");
Signature signature = new Signature("protected.pdf", loadOptions);

Tutoriales relacionados