Como personalizar a aparência da assinatura com gradiente em Java

Já percebeu como alguns documentos assinados digitalmente parecem, bem… sem graça? Apenas texto simples em um fundo branco? Se você está desenvolvendo uma aplicação que precisa de assinaturas de documentos com aparência profissional — pense em contratos, notas fiscais ou certificados — você vai querer algo que se destaque, mas que ainda seja funcional. Neste tutorial, você aprenderá a personalizar a aparência da assinatura aplicando um pincel de gradiente em Java. Criar uma assinatura digital com gradiente não só adiciona polimento visual, como também reforça a identidade da marca e melhora a percepção de autenticidade.

Respostas rápidas

  • O que é uma assinatura digital com gradiente? Um elemento visual assinado digitalmente que usa um gradiente de cores para o fundo ou preenchimento do texto.
  • Qual biblioteca oferece suporte a isso em Java? GroupDocs.Signature for Java fornece suporte nativo a pincéis de gradiente.
  • Os gradientes afetam a segurança criptográfica? Não. O gradiente é puramente visual; a assinatura digital subjacente permanece inalterada.
  • Qual versão do Java é necessária? JDK 8 ou superior (JDK 11+ recomendado).
  • É necessária licença para produção? Sim — uma licença válida do GroupDocs.Signature é exigida para uso não‑avaliativo.

Como personalizar a aparência da assinatura com um pincel de gradiente em Java

Nesta seção, percorreremos todo o processo — desde a configuração da biblioteca até a aplicação de um pincel de gradiente linear a uma assinatura de texto. Ao final, você será capaz de criar objetos de assinatura digital com gradiente que parecem polidos e combinam com as cores da sua marca.

Por que usar pincéis de gradiente para assinaturas digitais?

Antes de mergulharmos no código, vamos falar sobre por que você gostaria de efeitos de gradiente em primeiro lugar.

Consistência da marca: Se sua empresa usa esquemas de cores específicos, assinaturas com gradiente ajudam a manter a consistência visual em todos os documentos. Uma empresa de serviços financeiros pode usar gradientes azul‑para‑branco para transmitir confiança, enquanto uma agência criativa pode optar por transições de cores vibrantes.

Hierarquia de documentos: Efeitos de gradiente podem ajudar a distinguir tipos de assinatura. Você pode usar gradientes sutis para aprovações padrão e gradientes mais marcantes para aprovações executivas ou autorizações legais.

Apelo visual sem comprometer: O que é legal — você obtém um estilo profissional sem sacrificar a segurança criptográfica da sua assinatura digital. O gradiente é puramente visual; a validade da assinatura permanece intacta.

Redução da percepção de falsificação: Documentos com assinaturas estilizadas costumam parecer mais autênticos para os usuários finais. Embora isso não aumente a segurança real, melhora a legitimidade percebida (o que importa para a confiança do usuário).

O que você aprenderá

Ao final deste guia, você será capaz de:

  • Configurar o GroupDocs.Signature for Java no seu projeto (Maven, Gradle ou manual)
  • Criar assinaturas baseadas em texto com efeitos de pincel de gradiente linear
  • Personalizar a aparência da assinatura, posicionamento e transparência
  • Solucionar problemas comuns que atrapalham desenvolvedores
  • Otimizar o desempenho para aplicações de produção
  • Aplicar as melhores práticas para código de assinatura sustentável

Pré‑requisitos

Antes de começar, certifique‑se de que você tem:

  • Java Development Kit (JDK): Versão 8 ou superior (recomendo JDK 11+ para melhor desempenho)
  • IDE: IntelliJ IDEA, Eclipse ou VS Code com extensões Java
  • GroupDocs.Signature for Java Library: Vamos adicioná‑la via Maven ou Gradle
  • Conhecimento básico de Java: Você deve estar confortável com objetos, métodos e tratamento de exceções

Bibliotecas necessárias

Adicione o GroupDocs.Signature ao seu projeto usando a ferramenta de build de sua preferência.

Para Maven (adicione ao seu pom.xml):

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

Para Gradle (adicione ao seu build.gradle):

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

Instalação manual: Se você não estiver usando uma ferramenta de build (embora eu recomende que use), pode baixar o arquivo JAR diretamente em GroupDocs Signatures releases e adicioná‑lo ao classpath do seu projeto.

Aquisição de licença

GroupDocs oferece um teste gratuito perfeito para testes e desenvolvimento. Para uso em produção, você precisará de uma licença. Veja como começar:

  1. Teste gratuito: Visite GroupDocs Free Trial para baixar sem compromisso
  2. Licença temporária: Obtenha uma licença temporária de 30 dias em GroupDocs Temporary License para testes com todos os recursos
  3. Licença completa: Quando estiver pronto para produção, confira as opções de preço

A versão de teste possui marcas d’água de avaliação, então obtenha uma licença temporária se estiver construindo algo voltado ao cliente.

Configurando o GroupDocs.Signature for Java

Vamos preparar seu ambiente de desenvolvimento. Esta configuração funciona tanto para um novo projeto quanto para integração em uma aplicação existente.

Etapas de instalação

1. Adicione a dependência (já cobrimos isso acima — Maven ou Gradle)

2. Verifique a instalação criando uma classe de teste simples:

import com.groupdocs.signature.Signature;

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

Se isso compilar sem erros, você está pronto para prosseguir.

3. Configure a estrutura de diretórios dos documentos. Eu gosto de organizar assim:

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

4. Inicialização básica (é aqui que a mágica começa):

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

Dica profissional: Sempre envolva seu objeto Signature em uma instrução try‑with‑resources ou chame dispose() manualmente. O GroupDocs mantém handles de arquivos, e esquecer de liberá‑los causará erros de “arquivo em uso” (pergunte como eu sei).

Guia de implementação: Criar assinaturas com gradiente

Agora vem a parte divertida — vamos construir uma assinatura com efeito de pincel de gradiente. Começaremos simples e adicionaremos complexidade conforme avançamos.

Etapa 1: Inicializar as opções de assinatura

Primeiro, definimos o que nossa assinatura dirá e como ela se comportará. A classe TextSignOptions lida com assinaturas baseadas em 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");

Isso cria uma assinatura básica com o texto “John Smith”. Simples, certo? Mas, por si só, isso seria apenas texto preto simples sobre um fundo transparente — entediante. É aí que os gradientes entram.

Por que separar opções do objeto de assinatura? Esse padrão de design permite reutilizar a mesma configuração de assinatura em vários documentos. Configure uma vez, aplique em todos os lugares.

Etapa 2: Personalizar o fundo com pincel de gradiente

É aqui que sua assinatura começa a parecer profissional. Criaremos um gradiente linear que transita de verde para branco:

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);

Vamos detalhar o que está acontecendo:

  • Cor base: setColor(Color.GREEN) define um fallback sólido. Se o gradiente falhar (raro, mas possível), essa cor aparecerá.
  • Transparência: setTransparency(0.5f) torna sua assinatura semitransparente. Isso é crucial para documentos onde você não quer ocultar o texto subjacente. Valores mais próximos de 0 são mais opacos; mais próximos de 1 são mais transparentes.
  • Ângulo do gradiente: O 45 indica que o gradiente flui diagonalmente do canto superior‑esquerdo ao inferior‑direito. Use 0 para horizontal (esquerda → direita), 90 para vertical (topo → base) ou qualquer ângulo intermediário.

A escolha das cores importa: Verde‑para‑branco sugere aprovação ou confirmação (pense em sinais de “go”). Azul‑para‑branco transmite confiança e profissionalismo. Vermelho‑para‑branco pode indicar urgência ou importância. Escolha cores que estejam alinhadas ao propósito do documento e à identidade da sua marca.

Etapa 3: Definir o posicionamento da assinatura

Agora precisamos dizer onde a assinatura aparecerá no documento. O posicionamento é mais complicado do que parece porque você precisa equilibrar visibilidade e não cobrir conteúdo 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);

Entendendo alinhamento vs. margem: Pense no alinhamento como o ponto de ancoragem e a margem como o deslocamento. Se você definir HorizontalAlignment.Center, a assinatura fica centralizada na página, e a margem a desloca em relação a esse ponto central. Essa abordagem em duas etapas oferece controle preciso.

Padrões de posicionamento comuns:

  • Canto inferior‑direito: HorizontalAlignment.Right, VerticalAlignment.Bottom, com margem superior negativa
  • Área de cabeçalho: VerticalAlignment.Top, HorizontalAlignment.Right, com preenchimento
  • Centro da página: Ambos os alinhamentos definidos como Center, ajuste as margens conforme necessário

Considerações de tamanho: Os valores setWidth(100) e setHeight(80) funcionam na maioria dos documentos padrão, mas você pode precisar ajustá‑los conforme o tamanho do documento e o comprimento do texto da assinatura. Se o texto for cortado, aumente a largura. Se parecer muito apertado, aumente a altura ou reduza o tamanho da fonte.

Etapa 4: Aplicar a assinatura e salvar

Finalmente, vamos assinar o documento e salvar a saída. É aqui que toda a sua configuração se reúne:

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

O que acontece no método sign()? Ele recebe seu documento de origem, aplica as opções de assinatura configuradas e grava um novo arquivo com a assinatura incorporada. O arquivo original permanece intacto (boa prática — nunca modifique documentos de origem diretamente).

O objeto SignResult informa o que ocorreu. Verifique getSucceeded() para ver quais assinaturas foram aplicadas com sucesso e getFailed() para capturar as que falharam.

Exemplo completo em funcionamento

Aqui está tudo reunido em uma única classe executável que você pode copiar e testar agora:

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

Execute este código com um arquivo PDF na sua pasta resources/input/ e você obterá uma versão assinada com um belo efeito de gradiente.

Casos de uso comuns

Vamos ver quando e onde assinaturas com gradiente fazem mais sentido em aplicações reais.

1. Sistemas de gerenciamento de contratos corporativos

Cenário: Você está construindo um fluxo de aprovação de contratos onde múltiplas partes assinam documentos em diferentes estágios.
Aplicação: Use cores de gradiente diferentes para representar níveis de aprovação — chefes de departamento recebem um gradiente azul‑para‑branco, revisores jurídicos um gradiente ouro‑para‑branco, executivos um gradiente azul‑escuro‑para‑azul‑claro. Essa hierarquia visual ajuda os usuários a identificar instantaneamente quem assinou e em que nível.

2. Processamento automatizado de notas fiscais

Cenário: Seu sistema de contabilidade assina automaticamente notas fiscais geradas antes de enviá‑las aos clientes.
Aplicação: Um gradiente sutil nas cores da marca (correspondente às cores da sua empresa) torna as notas fiscais mais profissionais e mais difíceis de falsificar. Mantenha o gradiente discreto para que a nota permaneça legível.

3. Geração de certificados

Cenário: Você gera certificados de conclusão para cursos online ou programas de treinamento.
Aplicação: Gradientes vibrantes e comemorativos (ouro‑para‑amarelo ou azul‑para‑roxo) dão aos certificados um ar oficial e digno de compartilhamento. O apelo visual aumenta o valor percebido e incentiva o compartilhamento nas redes sociais.

4. Marcação d’água de documentos

Cenário: Você precisa marcar documentos como “Rascunho”, “Confidencial” ou “Aprovado”.
Aplicação: Embora não seja exatamente uma assinatura, você pode reutilizar a técnica de gradiente com texto transparente para criar marcas‑d’água chamativas que não obscurecem o conteúdo subjacente. Defina a transparência entre 0.7‑0.8 para um efeito sutil.

Solução de problemas comuns

Aqui estão os problemas que encontrei (e resolvi) ao trabalhar com assinaturas de gradiente. Economize tempo de depuração.

Problema 1: “Arquivo está sendo usado por outro processo”

Sintomas: Sua aplicação lança uma exceção dizendo que não pode acessar o arquivo, mesmo que nenhum outro programa o tenha aberto.
Causa: Você esqueceu de chamar signature.dispose() ou fechar adequadamente o objeto Signature. O Java mantém o handle do arquivo até que o objeto seja coletado pelo garbage collector.
Solução:

// 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

Ou manualmente:

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

Problema 2: A assinatura aparece, mas o gradiente não é exibido

Sintomas: Você vê o texto da assinatura, mas ele está apenas em uma cor sólida.
Possíveis causas:

  1. O visualizador de PDF não suporta gradientes – teste com Adobe Acrobat, Foxit Reader ou um navegador moderno.
  2. Transparência definida muito alta – setTransparency(1.0f) torna o gradiente invisível. Tente 0.3‑0.7.
  3. Pincel não aplicado – certifique‑se de ter chamado background.setBrush(brush) e options.setBackground(background).

Dica de depuração: Use cores de alto contraste (por exemplo, Color.RED para Color.BLUE) primeiro. Se ainda não vir o gradiente, a configuração está errada, não as cores.

Problema 3: A assinatura sobrepõe conteúdo importante do documento

Sintomas: Seu gradiente fica ótimo, mas cobre texto crítico ou campos de formulário.
Solução: Ajuste o posicionamento dinamicamente com base no conteúdo do documento. Aqui está um padrão 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);

Abordagem melhor: Analise o documento primeiro para encontrar espaços vazios e posicione as assinaturas nesses locais programaticamente.

Problema 4: Problemas de desempenho com documentos grandes

Sintomas: A assinatura demora muito em PDFs com muitas páginas ou imagens de alta resolução.
Causa: O GroupDocs processa o documento inteiro, e gradientes complexos adicionam sobrecarga de renderização.
Soluções:

  1. Assine apenas páginas específicas em vez de todo o arquivo.
  2. Use gradientes mais simples — gradientes lineares de duas cores são mais rápidos que radiais ou com múltiplas paradas.
  3. Reduza o tamanho da assinatura — largura/altura menores significam menos trabalho de renderização.
  4. Processamento assíncrono — não bloqueie a thread principal enquanto assina.

Exemplo de desempenho:

// 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: A cor não corresponde ao esperado

Sintomas: Seu gradiente parece diferente do especificado no código.
Causas:

  1. Diferenças no espaço de cores RGB — o Color do Java usa sRGB, mas PDFs podem renderizar em outro espaço.
  2. Interações de transparência — gradientes semitransparentes se misturam com o fundo do documento, alterando a cor percebida.
  3. Calibração do monitor — o que você vê na tela pode diferir de outros dispositivos.

Solução: Teste documentos assinados em vários dispositivos e visualizadores de PDF. Se a consistência da marca for crítica, use valores RGB exatos e verifique em diferentes plataformas. Mantenha a opacidade entre 0.3‑0.5 para minimizar alterações de cor.

Melhores práticas para aplicações de produção

Aqui está o que aprendi ao usar assinaturas com gradiente em sistemas reais.

1. Centralizar a configuração da assinatura

Não espalhe estilos pelo código. Crie uma classe 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
}

Agora você pode reutilizar estilos consistentemente: SignatureStyles.getApprovalSignature("Jane Doe").

2. Validar documentos antes de assinar

Sempre verifique se o documento de origem é 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 operações de assinatura

Mantenha um registro de auditoria:

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. Tratar exceções de forma elegante

Nunca deixe uma falha de assinatura derrubar seu serviço:

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. Testar com documentos do mundo real

Não dependa apenas de PDFs de exemplo. Use arquivos reais do seu fluxo de trabalho:

  • Formulários com campos existentes
  • Contratos de múltiplas páginas
  • Imagens escaneadas (PDFs baseados em imagens)
  • Documentos que já contenham assinaturas

Cada tipo pode se comportar de forma diferente com a renderização de gradientes.

Dicas avançadas para usuários experientes

Pronto para elevar o nível? Aqui vão algumas técnicas avançadas.

Dica 1: Criar esquemas de cores personalizados

Defina paletas de marca uma vez e reutilize-as:

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);
    }
}

Dica 2: Transparência dinâmica baseada no tipo de documento

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

Dica 3: Processamento em lote com pools de threads

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);

Dica 4: Estilização condicional baseada no tipo de assinatura

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;
}

Perguntas frequentes

P: Posso usar isso em um serviço Java baseado na web?
R: Sim. O GroupDocs.Signature é puro Java e funciona em qualquer backend Java, incluindo serviços Spring Boot ou Jakarta EE.

P: O gradiente afeta o tamanho do PDF assinado?
R: Apenas marginalmente. O gradiente é armazenado como parte do fluxo de aparência visual, geralmente adicionando alguns kilobytes.

P: Como assino PDFs protegidos por senha?
R: Passe a senha ao criar o objeto Signature: new Signature("file.pdf", "password").

P: É possível aplicar o gradiente a uma assinatura baseada em imagem em vez de texto?
R: Absolutamente. Use ImageSignOptions e defina seu Background com um LinearGradientBrush assim como no exemplo de texto.

P: E se eu precisar de um gradiente radial em vez de linear?
R: O GroupDocs atualmente suporta LinearGradientBrush. Para efeitos radiais, você pode criar uma imagem com gradiente radial pré‑gerada e usá‑la como imagem de fundo.

Última atualização: 2026-03-14
Testado com: GroupDocs.Signature 23.12 for Java
Autor: GroupDocs