Java
Author: GroupDocs

Translate:

“—
Última actualización: 2026-03-14
Probado con: GroupDocs.Signature 23.12 for Java
Autor: GroupDocs”

Now ensure all placeholders remain unchanged. Also ensure we didn’t translate any URLs. We kept them.

Now produce final content with markdown.

Cómo personalizar la apariencia de la firma con degradado en Java

¿Alguna vez has notado cómo algunos documentos firmados digitalmente se ven, bueno… aburridos? Solo texto plano sobre un fondo blanco? Si estás construyendo una aplicación que necesita firmas de documentos con aspecto profesional —piensa en contratos, facturas o certificados— querrás algo que destaque sin dejar de ser funcional. En este tutorial, aprenderás a personalizar la apariencia de la firma aplicando un pincel de degradado en Java. Crear una firma digital con degradado no solo añade un acabado visual, sino que también refuerza la identidad de marca y mejora la autenticidad percibida.

Respuestas rápidas

  • ¿Qué es una firma digital con degradado? Un elemento visual firmado digitalmente que utiliza un degradado de color para su fondo o relleno de texto.
  • ¿Qué biblioteca soporta esto en Java? GroupDocs.Signature for Java proporciona soporte integrado para pinceles de degradado.
  • ¿Los degradados afectan la seguridad criptográfica? No. El degradado es puramente visual; la firma digital subyacente permanece sin cambios.
  • ¿Qué versión de Java se requiere? JDK 8 o superior (se recomienda JDK 11+).
  • ¿Se necesita una licencia para producción? Sí: se requiere una licencia válida de GroupDocs.Signature para uso no de evaluación.

Cómo personalizar la apariencia de la firma con un pincel de degradado en Java

En esta sección recorreremos todo el proceso —desde la configuración de la biblioteca hasta la aplicación de un pincel de degradado lineal a una firma de texto. Al final podrás crear objetos de firma digital con degradado que se vean pulidos y coincidan con los colores de tu marca.

¿Por qué usar pinceles de degradado para firmas digitales?

Antes de sumergirnos en el código, hablemos de por qué querrías efectos de degradado en primer lugar.

Consistencia de marca: Si tu empresa utiliza esquemas de color específicos, las firmas con degradado ayudan a mantener la consistencia visual en todos los documentos. Una empresa de servicios financieros podría usar degradados de azul a blanco para transmitir confianza, mientras que una agencia creativa podría ser audaz con transiciones de color vibrantes.

Jerarquía de documentos: Los efectos de degradado pueden ayudar a distinguir tipos de firma. Puedes usar degradados sutiles para aprobaciones estándar y más prominentes para firmas ejecutivas o autorizaciones legales.

Atractivo visual sin compromiso: Esto es genial: obtienes un estilo profesional sin sacrificar la seguridad criptográfica de tu firma digital. El degradado es puramente visual; la validez de tu firma permanece intacta.

Reducción de la percepción de falsificación: Los documentos con firmas estilizadas a menudo aparecen más auténticos para los usuarios finales. Aunque esto no aumenta la seguridad real, sí mejora la legitimidad percibida (lo cual es importante para la confianza del usuario).

Qué aprenderás

Al final de esta guía, podrás:

  • Configurar GroupDocs.Signature para Java en tu proyecto (Maven, Gradle o manual)
  • Crear firmas basadas en texto con efectos de pincel de degradado lineal
  • Personalizar la apariencia de la firma, posición y transparencia
  • Solucionar problemas comunes que afectan a los desarrolladores
  • Optimizar el rendimiento para aplicaciones de producción
  • Aplicar buenas prácticas para un código de firma mantenible

Requisitos previos

Antes de comenzar, asegúrate de tener:

  • Java Development Kit (JDK): Versión 8 o superior (recomiendo JDK 11+ para mejor rendimiento)
  • IDE: IntelliJ IDEA, Eclipse o VS Code con extensiones de Java
  • GroupDocs.Signature for Java Library: Lo añadiremos mediante Maven o Gradle
  • Conocimientos básicos de Java: Deberías sentirte cómodo con objetos, métodos y manejo de excepciones

Bibliotecas requeridas

Agrega GroupDocs.Signature a tu proyecto usando la herramienta de compilación que prefieras.

Para Maven (agrega a tu pom.xml):

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

Para Gradle (agrega a tu build.gradle):

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

Instalación manual: Si no estás usando una herramienta de compilación (aunque lo recomendaría), puedes descargar el archivo JAR directamente desde GroupDocs Signatures releases y añadirlo al classpath de tu proyecto.

Obtención de licencia

GroupDocs ofrece una prueba gratuita que es perfecta para pruebas y desarrollo. Para uso en producción, necesitarás una licencia. Así es como puedes comenzar:

  1. Prueba gratuita: Visita GroupDocs Free Trial para descargar sin compromiso
  2. Licencia temporal: Obtén una licencia temporal de 30 días en GroupDocs Temporary License para pruebas con todas las funciones
  3. Licencia completa: Cuando estés listo para producción, revisa sus opciones de precios

La versión de prueba tiene marcas de agua de evaluación, así que obtén una licencia temporal si estás construyendo algo orientado al cliente.

Configuración de GroupDocs.Signature para Java

Preparemos tu entorno de desarrollo. Esta configuración funciona tanto si inicias un nuevo proyecto como si lo integras en una aplicación existente.

Pasos de instalación

1. Añadir la dependencia (ya lo cubrimos arriba — Maven o Gradle)

2. Verificar la instalación creando una clase de prueba simple:

import com.groupdocs.signature.Signature;

public class SignatureTest {
    public static void main(String[] args) {
        System.out.println("GroupDocs.Signature loaded successfully!");
    }
}

3. Configura la estructura de directorios de tus documentos. Me gusta organizarlo así:

project-root/
├── src/
├── resources/
│   ├── input/        // Source documents to sign
│   └── output/       // Signed documents
└── pom.xml (or build.gradle)

4. Inicialización básica (aquí es donde comienza la magia):

import com.groupdocs.signature.Signature;
import com.groupdocs.signature.exception.GroupDocsSignatureException;

public class BasicSignatureSetup {
    public static void main(String[] args) {
        try {
            // Initialize with your source document path
            Signature signature = new Signature("resources/input/sample.pdf");
            
            // Your signing code will go here
            
            signature.dispose(); // Always clean up resources
        } catch (GroupDocsSignatureException e) {
            System.err.println("Signature error: " + e.getMessage());
            e.printStackTrace();
        } catch (Exception e) {
            System.err.println("General error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Consejo profesional: Siempre envuelve tu objeto Signature en una sentencia try‑with‑resources o llama manualmente a dispose(). GroupDocs mantiene manejadores de archivos, y olvidar liberarlos provocará errores de “archivo en uso” (pregúntame cómo lo sé).

Guía de implementación: Crear firmas con degradado

Ahora viene la parte divertida — construyamos una firma con efecto de pincel de degradado. Comenzaremos simple y añadiremos complejidad a medida que avanzamos.

Paso 1: Inicializar opciones de firma

Primero, definimos qué dirá nuestra firma y cómo se comportará. La clase TextSignOptions maneja firmas basadas en texto:

import com.groupdocs.signature.domain.enums.HorizontalAlignment;
import com.groupdocs.signature.domain.enums.VerticalAlignment;
import com.groupdocs.signature.domain.signatures.TextSignOptions;

TextSignOptions options = new TextSignOptions("John Smith");

Esto crea una firma básica con el texto “John Smith”. Suficientemente simple, ¿verdad? Pero por sí sola, sería solo texto negro sobre un fondo transparente —aburrido. Ahí es donde entran los degradados.

¿Por qué separar las opciones del objeto de firma? Este patrón de diseño te permite reutilizar la misma configuración de firma en varios documentos. Configúralo una vez, aplícalo en todas partes.

Paso 2: Personalizar el fondo con pincel de degradado

Aquí es donde tu firma comienza a verse profesional. Crearemos un degradado lineal que transita de verde a blanco:

import com.groupdocs.signature.domain.Background;
import com.groupdocs.signature.domain.extensions.brushes.LinearGradientBrush;
import java.awt.Color;

// Create the background container
Background background = new Background();
background.setColor(Color.GREEN);        // Fallback color (rarely seen)
background.setTransparency(0.5f);         // 50% transparency (0.0 = opaque, 1.0 = invisible)

// Define the gradient: start color, end color, and angle
LinearGradientBrush brush = new LinearGradientBrush(
    Color.GREEN,    // Start color (left/top)
    Color.WHITE,    // End color (right/bottom)
    45              // Angle in degrees (45 = diagonal)
);

// Apply the brush to the background
background.setBrush(brush);
options.setBackground(background);

Desglosemos lo que está sucediendo aquí:

  • Color base: setColor(Color.GREEN) establece un respaldo sólido. Si los degradados fallan (raro, pero posible), este color aparecerá en su lugar.
  • Transparencia: setTransparency(0.5f) hace que tu firma sea semi‑transparente. Esto es crucial para documentos donde no deseas ocultar el texto subyacente. Valores más cercanos a 0 son más opacos; más cercanos a 1 son más transparentes.
  • Ángulo del degradado: El 45 indica que el degradado fluye diagonalmente de arriba‑izquierda a abajo‑derecha. Usa 0 para horizontal (izquierda → derecha), 90 para vertical (arriba → abajo), o cualquier ángulo intermedio.

La elección de colores importa: De verde a blanco sugiere aprobación o confirmación (piensa en señales de “avanzar”). De azul a blanco transmite confianza y profesionalismo. De rojo a blanco puede indicar urgencia o importancia. Elige colores que se alineen con el propósito de tu documento y la identidad de tu marca.

Paso 3: Establecer la posición de la firma

Ahora necesitamos indicar a la firma dónde aparecer en tu documento. El posicionamiento es más complicado de lo que parece porque debes equilibrar la visibilidad sin cubrir contenido importante:

import com.groupdocs.signature.domain.Padding;

// Set signature dimensions (in pixels or points, depending on document)
options.setWidth(100);
options.setHeight(80);

// Center the signature both horizontally and vertically
options.setVerticalAlignment(VerticalAlignment.Center);
options.setHorizontalAlignment(HorizontalAlignment.Center);

// Add margins to fine‑tune positioning
Padding padding = new Padding();
padding.setTop(20);      // 20 units from the alignment point
padding.setRight(20);    // 20 units from the right edge
options.setMargin(padding);

Entender alineación vs. margen: Piensa en la alineación como el punto de anclaje y el margen como el desplazamiento. Si estableces HorizontalAlignment.Center, la firma se centra en la página, luego el margen la desplaza respecto a ese punto central. Este enfoque de dos pasos te brinda un control preciso.

Patrones comunes de posicionamiento:

  • Esquina inferior‑derecha: HorizontalAlignment.Right, VerticalAlignment.Bottom, con margen superior negativo
  • Área de encabezado: VerticalAlignment.Top, HorizontalAlignment.Right, con relleno
  • Centro de la página: Ambas alineaciones establecidas en Center, ajusta los márgenes a tu gusto

Consideraciones de tamaño: Los valores setWidth(100) y setHeight(80) funcionan para la mayoría de documentos estándar, pero podrías necesitar ajustarlos según el tamaño del documento y la longitud del texto de la firma. Si tu texto se corta, aumenta el ancho. Si se ve demasiado apretado, aumenta la altura o reduce el tamaño de fuente.

Paso 4: Aplicar la firma y guardar

Finalmente, firmemos el documento y guardemos la salida. Aquí es donde toda tu configuración se combina:

import com.groupdocs.signature.Signature;
import com.groupdocs.signature.domain.SignResult;

try {
    // Initialize signature with source document
    Signature signature = new Signature("resources/input/sample.pdf");
    
    // Apply the signature options we configured above
    SignResult result = signature.sign("resources/output/SignedWithGradient.pdf", options);
    
    // Check the result
    if (result.getSucceeded().size() > 0) {
        System.out.println("Document signed successfully!");
        System.out.println("Signed with " + result.getSucceeded().size() + " signature(s)");
    } else {
        System.out.println("No signatures were applied.");
    }
    
    // Clean up
    signature.dispose();
    
} catch (Exception e) {
    System.err.println("Error signing document: " + e.getMessage());
    e.printStackTrace();
}

¿Qué ocurre en el método sign()? Toma tu documento fuente, aplica las opciones de firma configuradas y escribe un nuevo archivo con la firma incrustada. El archivo original permanece intacto (buena práctica: nunca modificar directamente los documentos fuente).

El objeto SignResult te indica lo que ocurrió. Revisa getSucceeded() para ver qué firmas se aplicaron con éxito y getFailed() para detectar las que no funcionaron.

Ejemplo completo funcional

Aquí tienes todo unido en una sola clase ejecutable que puedes copiar y probar ahora mismo:

import com.groupdocs.signature.Signature;
import com.groupdocs.signature.domain.Background;
import com.groupdocs.signature.domain.Padding;
import com.groupdocs.signature.domain.SignResult;
import com.groupdocs.signature.domain.enums.HorizontalAlignment;
import com.groupdocs.signature.domain.enums.VerticalAlignment;
import com.groupdocs.signature.domain.extensions.brushes.LinearGradientBrush;
import com.groupdocs.signature.domain.signatures.TextSignOptions;
import java.awt.Color;

public class GradientSignatureExample {
    public static void main(String[] args) {
        try {
            // Initialize signature object with source document
            Signature signature = new Signature("resources/input/sample.pdf");
            
            // Configure text signature options
            TextSignOptions options = new TextSignOptions("John Smith");
            
            // Create gradient background
            Background background = new Background();
            background.setColor(Color.GREEN);
            background.setTransparency(0.5f);
            
            LinearGradientBrush brush = new LinearGradientBrush(
                Color.GREEN,  // Start color
                Color.WHITE,  // End color
                45            // Angle
            );
            
            background.setBrush(brush);
            options.setBackground(background);
            
            // Set positioning
            options.setWidth(100);
            options.setHeight(80);
            options.setVerticalAlignment(VerticalAlignment.Center);
            options.setHorizontalAlignment(HorizontalAlignment.Center);
            
            Padding padding = new Padding();
            padding.setTop(20);
            padding.setRight(20);
            options.setMargin(padding);
            
            // Sign and save
            SignResult result = signature.sign(
                "resources/output/SignedWithGradient.pdf", 
                options
            );
            
            System.out.println("Success! Signatures applied: " + 
                result.getSucceeded().size());
            
            signature.dispose();
            
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Ejecuta este código con un archivo PDF en tu directorio resources/input/, y obtendrás una versión firmada con un hermoso efecto de degradado.

Casos de uso comunes

Veamos cuándo y dónde las firmas con degradado tienen más sentido en aplicaciones reales.

1. Sistemas empresariales de gestión de contratos

Escenario: Estás construyendo un flujo de trabajo de aprobación de contratos donde múltiples partes interesadas firman documentos en diferentes etapas.
Aplicación: Usa diferentes colores de degradado para representar distintos niveles de aprobación —los jefes de departamento obtienen un degradado de azul a blanco, los revisores legales un degradado de oro a blanco, los ejecutivos un degradado de azul oscuro a azul claro. Esta jerarquía visual ayuda a los usuarios a ver instantáneamente quién ha firmado y a qué nivel.

2. Procesamiento automatizado de facturas

Escenario: Tu sistema contable firma automáticamente facturas generadas antes de enviarlas a los clientes.
Aplicación: Un degradado sutil del color de la marca (coincidiendo con los colores de tu empresa) hace que las facturas se vean más profesionales y más difíciles de falsificar. Mantén el degradado moderado para que la factura siga siendo legible.

3. Generación de certificados

Escenario: Generas certificados de finalización para cursos en línea o programas de capacitación.
Aplicación: Degradados vibrantes y festivos (de oro a amarillo o de azul a púrpura) hacen que los certificados parezcan oficiales y dignos de compartir. El atractivo visual aumenta el valor percibido y fomenta el intercambio en redes sociales.

4. Marca de agua en documentos

Escenario: Necesitas marcar documentos como “Borrador”, “Confidencial” o “Aprobado”.
Aplicación: Aunque no es una firma per se, puedes reutilizar la técnica de degradado con texto transparente para crear marcas de agua llamativas que no ocultan el contenido subyacente. Establece la transparencia entre 0.7‑0.8 para un efecto sutil.

Solución de problemas comunes

Estos son los problemas que he encontrado (y resuelto) al trabajar con firmas de degradado. Ahórrate tiempo de depuración.

Problema 1: “El archivo está siendo usado por otro proceso”

Síntomas: Tu aplicación lanza una excepción indicando que no puede acceder al archivo, aunque ningún otro programa lo tenga abierto.
Causa: Olvidaste llamar a signature.dispose() o cerrar correctamente el objeto Signature. Java mantiene el manejador del archivo hasta que el objeto sea recolectado por el garbage collector.
Solución:

// Always use try‑with‑resources (Java 7+)
try (Signature signature = new Signature("path/to/document.pdf")) {
    // Your signing code here
} catch (Exception e) {
    // Handle errors
}
// File handle automatically released when try block exits

O manualmente:

Signature signature = null;
try {
    signature = new Signature("path/to/document.pdf");
    // Your signing code
} finally {
    if (signature != null) {
        signature.dispose();
    }
}

Problema 2: La firma aparece pero el degradado no se muestra

Síntomas: Ves el texto de la firma, pero es solo un color sólido.
Posibles causas:

  1. El visor de PDF no soporta degradados —pruébalo con Adobe Acrobat, Foxit Reader o un navegador moderno.
  2. Transparencia demasiado alta —setTransparency(1.0f) hace invisible el degradado. Prueba 0.3‑0.7.
  3. Pincel no aplicado —asegúrate de haber llamado a background.setBrush(brush) y options.setBackground(background).

Consejo de depuración: Usa colores de alto contraste (p. ej., Color.RED a Color.BLUE) primero. Si aún no ves un degradado, la configuración es incorrecta, no los colores.

Problema 3: La firma se superpone al contenido importante del documento

Síntomas: Tu firma con degradado se ve bien pero cubre texto crítico o campos de formulario.
Solución: Ajusta el posicionamiento dinámicamente según el contenido del documento. Aquí tienes un patrón que uso:

// For documents with content primarily at the top
options.setVerticalAlignment(VerticalAlignment.Bottom);
Padding padding = new Padding();
padding.setBottom(30);  // Leave space from bottom edge
options.setMargin(padding);

// For documents that need signatures in specific locations
options.setVerticalAlignment(VerticalAlignment.Top);
options.setHorizontalAlignment(HorizontalAlignment.Left);
padding.setTop(600);     // Absolute Y position
padding.setLeft(400);    // Absolute X position
options.setMargin(padding);

Enfoque mejor: Analiza el documento primero para encontrar espacios vacíos, luego posiciona las firmas allí programáticamente.

Problema 4: Problemas de rendimiento con documentos grandes

Síntomas: Firmar lleva mucho tiempo en PDFs con muchas páginas o imágenes de alta resolución.
Causa: GroupDocs procesa todo el documento, y los degradados complejos añaden sobrecarga de renderizado.
Soluciones:

  1. Firmar solo páginas específicas en lugar de todo el archivo.
  2. Usar degradados más simples —los degradados lineales de dos colores son más rápidos que los radiales o con múltiples paradas.
  3. Reducir el tamaño de la firma —anchura/altura menores implican menos trabajo de renderizado.
  4. Procesar de forma asíncrona —no bloquees el hilo principal mientras firmas.

Ejemplo de rendimiento:

// Faster configuration
TextSignOptions options = new TextSignOptions("Approved");
options.setWidth(80);   // Smaller than default 100
options.setHeight(60);  // Smaller than default 80

// Simple horizontal gradient (fastest)
LinearGradientBrush brush = new LinearGradientBrush(
    Color.BLUE, 
    Color.WHITE, 
    0  // Horizontal gradient
);

Problema 5: El color no coincide con lo esperado

Síntomas: Tu degradado se ve diferente a lo que especificaste en el código.
Causas:

  1. Diferencias en el espacio de color RGB — Color de Java usa sRGB, pero los PDFs pueden renderizar en un espacio distinto.
  2. Interacciones de transparencia — Los degradados semi‑transparentes se mezclan con el fondo del documento, alterando el color percibido.
  3. Calibración del monitor — Lo que ves en tu pantalla puede diferir del de otros.

Solución: Prueba los documentos firmados en varios dispositivos y visores de PDF. Si la consistencia de marca es crítica, usa valores RGB exactos y verifica en todas las plataformas. Mantén la opacidad alrededor de 0.3‑0.5 para minimizar cambios de color.

Mejores prácticas para aplicaciones de producción

Esto es lo que he aprendido al usar firmas con degradado en sistemas del mundo real.

1. Centralizar la configuración de la firma

No disperses el estilo por todo tu código. Crea una clase auxiliar:

public class SignatureStyles {
    public static TextSignOptions getApprovalSignature(String signerName) {
        TextSignOptions options = new TextSignOptions(signerName);
        
        Background background = new Background();
        background.setTransparency(0.4f);
        
        LinearGradientBrush brush = new LinearGradientBrush(
            new Color(0, 102, 204),  // Brand blue
            Color.WHITE,
            45
        );
        
        background.setBrush(brush);
        options.setBackground(background);
        
        // Standard positioning
        options.setWidth(100);
        options.setHeight(70);
        
        return options;
    }
    
    // Add more style methods as needed
}

Ahora puedes reutilizar estilos de forma consistente: SignatureStyles.getApprovalSignature("Jane Doe").

2. Validar documentos antes de firmar

Siempre verifica que el documento fuente sea válido:

try {
    Signature signature = new Signature("path/to/document.pdf");
    
    // Validate format
    if (!"PDF".equalsIgnoreCase(signature.getDocumentInfo().getFileType())) {
        throw new IllegalArgumentException("Only PDF files supported");
    }
    
    // Ensure at least one page
    if (signature.getDocumentInfo().getPageCount() < 1) {
        throw new IllegalArgumentException("Document has no pages");
    }
    
    // Proceed with signing...
    
} catch (Exception e) {
    // Handle validation errors
}

3. Registrar operaciones de firma

Mantén un registro de auditoría:

SignResult result = signature.sign(outputPath, options);
logger.info("Document signed: " + outputPath);
logger.info("Signatures applied: " + result.getSucceeded().size());
logger.info("Signer: " + signerName);
logger.info("Timestamp: " + LocalDateTime.now());

if (!result.getFailed().isEmpty()) {
    logger.warn("Failed signatures: " + result.getFailed().size());
}

4. Manejar excepciones de forma adecuada

Nunca permitas que una falla de firma haga caer tu servicio:

try {
    SignResult result = signature.sign(outputPath, options);
    return result.getSucceeded().size() > 0;
} catch (GroupDocsSignatureException e) {
    logger.error("Signature error: " + e.getMessage());
    return false;
} catch (IOException e) {
    logger.error("File I/O error: " + e.getMessage());
    return false;
} catch (Exception e) {
    logger.error("Unexpected error during signing: " + e.getMessage());
    return false;
}

5. Probar con documentos del mundo real

No te bases solo en PDFs de ejemplo. Usa archivos reales de tu flujo de trabajo:

  • Formularios con campos existentes
  • Contratos de varias páginas
  • Imágenes escaneadas (PDFs basados en imágenes)
  • Documentos que ya contienen firmas

Cada tipo puede comportarse de forma diferente con el renderizado de degradados.

Consejos profesionales para usuarios avanzados

¿Listo para subir de nivel? Aquí tienes algunas técnicas avanzadas.

Consejo 1: Crear esquemas de color personalizados

Define paletas de marca una vez y reutilízalas:

public class BrandColors {
    public static final Color PRIMARY   = new Color(0, 102, 204);
    public static final Color SECONDARY = new Color(102, 178, 255);
    public static final Color ACCENT    = new Color(255, 193, 7);
    
    public static LinearGradientBrush getPrimaryGradient(int angle) {
        return new LinearGradientBrush(PRIMARY, Color.WHITE, angle);
    }
}

Consejo 2: Transparencia dinámica según el tipo de documento

public static float getOptimalTransparency(Signature signature) {
    if (hasComplexBackground(signature)) {
        return 0.6f; // More transparent for image‑heavy docs
    }
    return 0.4f;
}

Consejo 3: Procesamiento por lotes con pools de hilos

ExecutorService executor = Executors.newFixedThreadPool(4);
List<String> files = getDocumentsToSign();

for (String file : files) {
    executor.submit(() -> {
        try {
            signDocument(file);
        } catch (Exception e) {
            logger.error("Failed to sign: " + file, e);
        }
    });
}
executor.shutdown();
executor.awaitTermination(5, TimeUnit.MINUTES);

Consejo 4: Estilizado condicional según el tipo de firma

public static TextSignOptions getStyledSignature(String name, SignatureType type) {
    TextSignOptions options = new TextSignOptions(name);
    LinearGradientBrush brush;
    switch (type) {
        case APPROVAL:   brush = new LinearGradientBrush(Color.GREEN, Color.WHITE, 45); break;
        case REJECTION:  brush = new LinearGradientBrush(Color.RED,   Color.WHITE, 45); break;
        case REVIEW:     brush = new LinearGradientBrush(Color.ORANGE,Color.WHITE,45); break;
        default:         brush = new LinearGradientBrush(Color.BLUE,  Color.WHITE,45);
    }
    Background bg = new Background();
    bg.setBrush(brush);
    bg.setTransparency(0.5f);
    options.setBackground(bg);
    return options;
}

Preguntas frecuentes

P: ¿Puedo usar esto en un servicio Java basado en web?
R: Sí. GroupDocs.Signature es puro Java y funciona en cualquier backend basado en Java, incluyendo servicios Spring Boot o Jakarta EE.

P: ¿El degradado afecta el tamaño del PDF firmado?
R: Solo marginalmente. El degradado se almacena como parte del flujo de apariencia visual, típicamente añadiendo unos pocos kilobytes.

P: ¿Cómo firmo PDFs protegidos con contraseña?
R: Pasa la contraseña al crear el objeto Signature: new Signature("file.pdf", "password").

P: ¿Es posible aplicar el degradado a una firma basada en imagen en lugar de texto?
R: Absolutamente. Usa ImageSignOptions y establece su Background con un LinearGradientBrush igual que en el ejemplo de texto.

P: ¿Qué pasa si necesito un degradado radial en lugar de lineal?
R: GroupDocs actualmente soporta LinearGradientBrush. Para efectos radiales, puedes pre‑crear una imagen con degradado radial y usarla como imagen de fondo.

Última actualización: 2026-03-14
Probado con: GroupDocs.Signature 23.12 for Java
Autor: GroupDocs