comprobar extensión de archivo java – Detección de formato de archivo Java: Validar y comprobar tipos de documentos

Una de las tareas más comunes es comprobar la extensión de archivo java 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 (las cuales pueden falsificarse o ser incorrectas fácilmente).

En esta guía aprenderás a detectar de forma fiable los 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 la detección basada en la biblioteca versus los 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 incidencias de 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 comprobar extensión de archivo java? 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 la cabecera del archivo, lo que es mucho más barato que cargar el documento completo.
  • ¿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 almacenamiento en caché elimina la sobrecarga de reflexión repetida y mejora el rendimiento para servicios de alto volumen.

Requisitos previos

Antes de sumergirte en la detección de formatos de archivo, asegúrate de tener estos elementos esenciales listos:

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 (se recomienda JDK 11+ 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

Debes 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 de forma concurrente, asigna suficiente memoria heap a tu JVM (abordaremos la optimización más adelante).

Con el entorno listo, pasemos a configurar GroupDocs.Signature en tu proyecto.

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 utilizas una herramienta de compilación? Puedes descargar el JAR directamente desde GroupDocs.Signature for Java releases y añadirlo manualmente a tu classpath. (Aunque, sinceramente, usar Maven o Gradle te ahorrará dolores de cabeza a futuro.)

Pasos para adquirir una licencia

GroupDocs.Signature ofrece opciones de licencia flexibles:

  • Prueba gratuita: Perfecta para pruebas—comienza de inmediato sin tarjeta de crédito requerida
  • 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 Página de compra de GroupDocs

Consejo 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.

Inicialización y configuración básica

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.

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. Utilizará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).

Con la configuración completa, implementemos la funcionalidad central para detectar y obtener los formatos de archivo compatibles.

Guía de implementación

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

Por qué es importante

Antes de invertir tiempo en implementar funcionalidades de procesamiento, 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 hay listas de extensiones codificadas que queden obsoletas
  • Validación fácil de cargas de usuarios contra formatos compatibles
  • 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.

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

La clase FileType es el descriptor de GroupDocs.Signature para cada formato compatible, exponiendo propiedades como extensión, tipo MIME y descripción.

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é ocurre aquí:

  • getSupportedFileTypes(): Este método estático consulta el registro interno de la biblioteca y devuelve una lista completa de formatos compatibles como objetos FileType
  • El bucle itera sobre 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 al usuario o agrupar formatos por tipo (documentos vs. hojas de cálculo vs. imágenes).

Cuándo usar este enfoque

No todas las situaciones requieren una solución basada en biblioteca. Aquí tienes los casos en los que la detección de GroupDocs.Signature brilla:

Casos de uso perfectos

1. Constructores de 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
¿Construyendo 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 desactualizado.

3. Pipelines de procesamiento de documentos multiformato
Si procesas documentos de diversas fuentes (adjuntos de correo, almacenamiento en la nube, cargas de usuarios), necesitas una detección fiable 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.

Cuándo los métodos integrados de Java pueden ser suficientes

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

  • Solo comprobación 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

Advertencia importante: Los métodos nativos pueden ser engañados. 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 problemas

A continuación, los problemas que probablemente encontrarás y cómo resolverlos rápidamente.

Problema 1: Lista vacía o nula devuelta

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

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 es compatible para lectura pero no para operaciones de firma (GroupDocs.Signature está centrado en firmas, no todos los formatos tienen soporte total)

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

Este patrón garantiza que solo consultes la biblioteca una vez por ciclo de vida de la aplicación.

Problema 4: Limitaciones relacionadas con la licencia

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

Solución:

  • Aplica tu licencia antes de invocar 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

Sigue estas directrices para crear detección de formatos robusta y mantenible.

1. Validar temprano, fallar rápido

Comprueba los formatos 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;
}

Esto evita tiempo de procesamiento desperdiciado en formatos no soportados.

2. Proporcionar 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 las extensiones

Un archivo renombrado de .exe a .pdf tendrá extensión .pdf pero no será un PDF válido. GroupDocs.Signature valida el contenido real, pero aún así combina 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 con elegancia

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

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

@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 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 la lista de formatos soportados:

// 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 una caché segura para hilos (el ejemplo anterior es inmutable, por lo que es seguro)
  • 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 la paralelización:

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 cuello de botella es I/O (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:

  • Aumenta el 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 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 soportados, 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. Construcción de selectores de tipo de archivo

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

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

¿Cómo comprobar extensión de archivo java?

Carga el nombre del archivo, extrae su sufijo y compáralo con la lista en caché devuelta por Signature.getSupportedFileTypes(). Este enfoque de dos pasos garantiza que estás comprobando contra un catálogo actualizado en lugar de un arreglo codificado, y también previene extensiones falsificadas porque GroupDocs.Signature valida la cabecera del archivo antes de cualquier procesamiento adicional.

¿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.

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

La detección basada en biblioteca inspecciona la cabecera real del archivo y su estructura interna, asegurando que el contenido coincida verdaderamente con el formato declarado. Los métodos nativos como Files.probeContentType o simples comprobaciones 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 posterior.

¿Cuándo debería almacenar en caché los formatos de archivo compatibles?

Almacena la lista de formatos al iniciar la aplicación o la primera vez que la necesites, y reutiliza la colección inmutable durante toda la vida de la JVM. El almacenamiento en caché es especialmente beneficioso en servicios web de alto rendimiento donde cada solicitud podría desencadenar una inicialización pesada de reflexión, añadiendo milisegundos de latencia por llamada.

¿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 innecesario en tu backend.

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 notas de la versión para cambios incompatibles.

P: ¿GroupDocs.Signature puede detectar formatos de archivo 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 durante el procesamiento. 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 ofrece 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 soportadas son: .pdf, .docx, .xlsx, .png, .jpg.” Registra el incidente para monitoreo de seguridad y considera notificar al usuario con una herramienta UI que liste los tipos permitidos.

P: ¿GroupDocs.Signature funciona con archivos cifrados o protegidos por 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 (como 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 licencias:

Soporte y comunidad:

Última actualización: 2026-05-11
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