Cara Menambahkan Tanda Tangan Digital ke File di Java Menggunakan Barcode dan Kode QR

Pendahuluan

Pernah bertanya-tanya bagaimana membuktikan file Anda tidak diubah menggunakan digital signature java? Atau membutuhkan cara mengautentikasi dokumen secara programatis tanpa pengaturan kriptografi yang rumit? Tanda tangan digital tradisional bisa berlebihan untuk beberapa kasus penggunaan. Terkadang Anda hanya membutuhkan metode ringan yang dapat dipindai untuk memverifikasi integritas file—terutama saat berurusan dengan arsip, cadangan, atau alur kerja otomatis. Di sinilah tanda tangan barcode dan kode QR berperan.

Dalam tutorial ini, Anda akan belajar cara mengimplementasikan tanda tangan digital di Java menggunakan GroupDocs.Signature. Kami akan fokus pada penandatanganan arsip TAR (sempurna untuk sistem cadangan dan distribusi perangkat lunak), tetapi teknik ini berlaku untuk berbagai format dokumen. Baik Anda membangun sistem manajemen dokumen atau hanya ingin menambahkan lapisan keamanan ekstra ke file Anda, Anda berada di tempat yang tepat.

Apa yang akan Anda dapatkan:

• Implementasi kerja tanda tangan barcode dan kode QR di Java
• Pemahaman kapan menggunakan masing‑masing tipe tanda tangan (dan mengapa penting)
• Solusi praktis untuk tantangan penandatanganan umum
• Pola integrasi dunia nyata yang dapat Anda gunakan hari ini
• Tips optimasi kinerja untuk sistem produksi

Mari kita mulai—tidak perlu gelar kriptografi.

Jawaban Cepat

• Perpustakaan apa yang menangani tanda tangan barcode di Java? GroupDocs.Signature untuk Java.
• Tipe tanda tangan mana yang menyimpan lebih banyak data? Kode QR (hingga 4.296 karakter alfanumerik).
• Bisakah saya menandatangani file TAR besar (>100 MB)? Ya—gunakan thread latar belakang dan tingkatkan heap JVM.
• Apakah saya memerlukan koneksi internet? Tidak, perpustakaan berfungsi sepenuhnya offline.
• Apakah lisensi diperlukan untuk produksi? Ya, lisensi GroupDocs.Signature yang valid wajib dimiliki.

Apa itu Digital Signature Java?

Digital signature java adalah proses menyematkan token visual yang dapat diverifikasi—seperti barcode atau kode QR—langsung ke dalam file yang dihasilkan Java untuk membuktikan keaslian dan integritasnya. Dengan menambahkan token visual ini, pengembang dapat menyediakan cara cepat yang dapat dibaca manusia untuk memastikan file tidak diubah sejak ditandatangani, sambil tetap memungkinkan verifikasi programatis melalui API GroupDocs.Signature.

Mengapa Menggunakan Tanda Tangan Barcode atau Kode QR?

GroupDocs.Signature mendukung 50+ format input dan output (termasuk PDF, DOCX, XLSX, HTML, PNG, dan TAR) dan dapat memproses dokumen ratusan halaman tanpa memuat seluruh file ke memori. Barcode dan kode QR memberikan bukti keaslian yang dapat dipindai dan mandiri, menghilangkan kebutuhan otoritas sertifikat eksternal dalam banyak alur kerja internal.

Prasyarat

• GroupDocs.Signature untuk Java Library – versi 23.12 atau lebih baru
• Java Development Kit (JDK) – versi 8 atau lebih tinggi
• IDE – IntelliJ IDEA, Eclipse, atau editor Java lain apa saja
• Pengetahuan dasar Java – Anda harus nyaman dengan kelas dan impor

Penyiapan Lingkungan

Menambahkan GroupDocs.Signature ke proyek Anda sangat mudah. Pilih alat build Anda:

Maven (tambahkan ini ke pom.xml Anda):

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

Gradle (tambahkan ke build.gradle Anda):

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

Unduhan Manual: Tidak menggunakan Maven atau Gradle? Unduh JAR langsung dari GroupDocs.Signature releases dan tambahkan ke classpath Anda.

Akuisisi Lisensi

GroupDocs menawarkan lisensi yang fleksibel:

• Free Trial: Ideal untuk pengujian—tanpa kartu kredit. Mulai di sini
• Temporary License: Butuh lebih banyak waktu untuk evaluasi? Minta lisensi sementara untuk akses penuh selama pengembangan
• Production License: Saat Anda siap deploy, beli lisensi sesuai kebutuhan

Tautan berguna tambahan

• GroupDocs.Signature untuk Java Documentation
• API Reference Guide
• Community Support Forum
• Latest Library Releases
• Free Trial Download
• Request Temporary License
• Purchase Full License

Tip pro: Mulailah dengan trial gratis untuk membuat prototipe, lalu dapatkan lisensi sementara jika Anda butuh lebih banyak waktu sebelum berkomitmen.

Menyiapkan GroupDocs.Signature untuk Java

Kelas Signature adalah titik masuk untuk semua operasi penandatanganan di GroupDocs.Signature. Ia mewakili satu file yang dimuat ke memori dan menyediakan metode untuk menambah, mencari, atau menghapus tanda tangan visual.

Buat instance Signature yang menunjuk ke file TAR Anda. Ini akan memuat file ke memori untuk diproses:

import com.groupdocs.signature.Signature;

public class InitializeSignature {
    public static void main(String[] args) {
        Signature signature = new Signature("your-document-path");
        // Additional setup and usage here...
    }
}

Penting: Selalu tutup objek Signature setelah selesai (atau gunakan try‑with‑resources) untuk menghindari kebocoran memori pada file besar.

Memilih Antara Tanda Tangan Barcode dan Kode QR

Tidak yakin tipe tanda tangan mana yang dipakai? Berikut panduan keputusan cepat:

Aturan praktis:

• Gunakan barcode untuk ID cepat yang dapat dipindai atau cap waktu.
• Gunakan kode QR ketika Anda perlu menyematkan data lebih kaya atau menginginkan kompatibilitas smartphone.
• Gabungkan keduanya untuk redundansi dan auditabilitas maksimal.

Panduan Implementasi

Menandatangani Arsip TAR dengan Barcode

Mengapa Menandatangani dengan Barcode?

Barcode cocok untuk arsip TAR karena kompak dan dapat dipindai. Anda dapat menyematkan cap waktu, nomor versi, ID pengguna, atau nilai checksum untuk verifikasi cepat.

Langkah‑langkah

1. Inisialisasi Signature
Pertama, buat instance Signature untuk file TAR:

import com.groupdocs.signature.Signature;

final Signature signature = new Signature("path/to/your/archive.tar");

Tip pro: Untuk file TAR besar (lebih dari 100 MB), jalankan operasi penandatanganan di thread latar belakang agar UI tetap responsif.

2. Konfigurasi Opsi Barcode
Kelas BarcodeSignature menentukan konten, tipe, dan penempatan barcode. Objek BarcodeOptions menyimpan pengaturan ini:

import com.groupdocs.signature.options.sign.BarcodeSignOptions;
import com.groupdocs.signature.domain.barcodes.BarcodeTypes;

BarcodeSignOptions bcOptions = new BarcodeSignOptions("12345678", BarcodeTypes.Code128);
bcOptions.setLeft(100);  // X position in pixels
bcOptions.setTop(100);   // Y position in pixels

BarcodeOptions memungkinkan Anda menentukan tampilan visual dan posisi barcode.
BarcodeTypes adalah enum yang berisi simbol barcode yang didukung seperti Code128, Code39, dll.

Apa yang terjadi di sini?

• "12345678" adalah data yang dikodekan dalam barcode—ganti dengan ID, cap waktu, atau kode verifikasi Anda.
• BarcodeTypes.Code128 menyeimbangkan kapasitas data dengan keandalan pemindaian.
• Nilai posisi (100, 100) menempatkan barcode 100 px dari sudut kiri‑atas.

Opsi kustomisasi yang mungkin Anda inginkan:

bcOptions.setWidth(200);        // Barcode width in pixels
bcOptions.setHeight(50);        // Barcode height in pixels
bcOptions.setForeColor(Color.BLACK);  // Barcode color
bcOptions.setBackgroundColor(Color.WHITE);  // Background color

3. Tandatangani dan Simpan Dokumen
Jalankan operasi penandatanganan dan simpan arsip yang telah ditandatangani:

import com.groupdocs.signature.domain.SignResult;

String outputFilePath = "output/path/SignWithBarcode/archive_signed.tar";
SignResult signResult = signature.sign(outputFilePath, bcOptions);

Objek SignResult yang dikembalikan memberi tahu apakah operasi berhasil dan di mana tanda tangan ditempatkan.
Kesalahan umum: Pastikan direktori output ada sebelum memanggil sign(). Perpustakaan tidak akan membuat direktori induk secara otomatis.

Menandatangani Arsip TAR dengan Kode QR

Kapan Menggunakan Kode QR

Kode QR bersinar ketika Anda perlu menyimpan data terstruktur (JSON, XML), menyematkan URL verifikasi, atau memungkinkan pemindaian smartphone.

Langkah‑langkah

1. Inisialisasi Signature
Sama seperti sebelumnya—buat instance Signature Anda:

final Signature signature = new Signature("path/to/your/archive.tar");

2. Konfigurasi Opsi Kode QR
Siapkan kode QR dengan data yang ingin Anda sematkan:

import com.groupdocs.signature.options.sign.QrCodeSignOptions;
import com.groupdocs.signature.domain.qrcodes.QrCodeTypes;

QrCodeSignOptions qrOptions = new QrCodeSignOptions("12345678", QrCodeTypes.QR);
qrOptions.setLeft(400);  // X position
qrOptions.setTop(400);   // Y position

QrCodeTypes adalah enum yang menentukan tipe kode QR yang dihasilkan (QR standar, DataMatrix, Aztec, dll.).

Contoh dunia nyata – sematkan payload JSON dengan data verifikasi:

String verificationData = "{\"version\":\"1.0\",\"timestamp\":\"2025-01-02T10:30:00Z\",\"user\":\"john.doe\"}";
QrCodeSignOptions qrOptions = new QrCodeSignOptions(verificationData, QrCodeTypes.QR);

Opsi tipe Kode QR:

• QrCodeTypes.QR – kode QR standar (paling umum)
• QrCodeTypes.DataMatrix – lebih kompak untuk data kecil
• QrCodeTypes.Aztec – cocok untuk permukaan melengkung

3. Tandatangani dan Simpan Dokumen
Selesaikan proses penandatanganan seperti pada barcode:

String outputFilePath = "output/path/SignWithQRCode/archive_signed.tar";
SignResult signResult = signature.sign(outputFilePath, qrOptions);

Catatan kinerja: Pembuatan kode QR sedikit lebih lambat daripada barcode karena perhitungan koreksi kesalahan, tetapi perbedaannya tidak signifikan untuk kebanyakan kasus (biasanya beberapa milidetik).

Menandatangani Arsip TAR dengan Beberapa Tanda Tangan

Mengapa Menggunakan Beberapa Tanda Tangan?

• Redundansi – jika satu tanda tangan rusak, yang lain masih dapat memverifikasi.
• Audiens berbeda – barcode untuk pemindai, kode QR untuk smartphone.
• Data berlapis – ID cepat di barcode, metadata detail di kode QR.
• Kepatuhan – beberapa regulasi mengharuskan metode verifikasi ganda.

Langkah‑langkah

1. Inisialisasi Signature
Sama seperti sebelumnya:

final Signature signature = new Signature("path/to/your/archive.tar");

2. Konfigurasi Beberapa Opsi
Buat kedua tipe tanda tangan dan gabungkan dalam sebuah daftar:

import java.util.ArrayList;
import java.util.List;

// Set up barcode (reusing from earlier example)
BarcodeSignOptions bcOptions = new BarcodeSignOptions("12345678", BarcodeTypes.Code128);
bcOptions.setLeft(100);
bcOptions.setTop(100);

// Set up QR code (different position to avoid overlap)
QrCodeSignOptions qrOptions = new QrCodeSignOptions("12345678", QrCodeTypes.QR);
qrOptions.setLeft(400);
qrOptions.setTop(400);

// Combine them
List<com.groupdocs.signature.options.sign.SignOptions> listOptions = new ArrayList<>();
listOptions.add(bcOptions);
listOptions.add(qrOptions);

Tip pro: Tempatkan tanda tangan secara strategis—pintu sudut atau area yang tidak mengganggu paling cocok untuk arsip TAR.

3. Tandatangani dan Simpan Dokumen
Berikan daftar opsi ke metode sign():

String outputFilePath = "output/path/SignWithMultipleSignatures/archive_signed.tar";
SignResult signResult = signature.sign(outputFilePath, listOptions);

GroupDocs memproses setiap tanda tangan secara berurutan, menyematkannya ke metadata dokumen. Urutan dalam daftar tidak memengaruhi verifikasi.

Kasus Penggunaan Dunia Nyata

1. Pipeline Distribusi Perangkat Lunak

Skenario: Mendistribusikan paket perangkat lunak sebagai arsip TAR dan membuktikan bahwa paket tidak dimodifikasi.
Solusi: Tandatangani setiap rilis dengan kode QR yang berisi payload JSON:

String releaseData = String.format(
    "{\"version\":\"%s\",\"buildDate\":\"%s\",\"sha256\":\"%s\"}",
    version, buildDate, checksum
);

Mengapa berhasil: Pengguna dapat memindai kode QR untuk memverifikasi integritas paket sebelum instalasi—tanpa perlu manajemen kunci GPG.

2. Sistem Cadangan Otomatis

Skenario: Arsip TAR cadangan harian memerlukan jejak audit.
Solusi: Tambahkan barcode dengan cap waktu cadangan dan ID server:

String backupId = String.format("SRV01-%s", LocalDateTime.now().format(formatter));
BarcodeSignOptions bcOptions = new BarcodeSignOptions(backupId, BarcodeTypes.Code128);

Mengapa berhasil: Verifikasi visual cepat atas keaslian cadangan tanpa membuka arsip.

3. Sistem Manajemen Dokumen

Skenario: Dokumen hukum yang disimpan sebagai arsip memerlukan verifikasi anti‑tamper.
Solusi: Gunakan barcode (pemindaian cepat) dan kode QR (metadata detail) pada arsip yang sama.

4. Pelacakan Rantai Pasokan

Skenario: Melacak paket file melalui banyak organisasi.
Solusi: Sematkan kode QR dengan URL pelacakan yang mengarah ke API verifikasi:

String trackingUrl = "https://verify.yourcompany.com/track/" + uniqueId;
QrCodeSignOptions qrOptions = new QrCodeSignOptions(trackingUrl, QrCodeTypes.QR);

Masalah Umum dan Solusinya

Masalah 1: “Signature Not Found” Setelah Menandatangani

Gejala: sign() berhasil, tetapi tanda tangan tidak terlihat.
Penyebab: Penempatan salah, menimpa file asli, atau keterbatasan penampil TAR.
Solusi:

// Always verify the signing succeeded
SignResult result = signature.sign(outputFilePath, bcOptions);
if (result.getSucceeded().size() > 0) {
    System.out.println("Signature added successfully at: " + outputFilePath);
} else {
    System.err.println("Signing failed: " + result.getFailed());
}

// Use absolute paths to avoid confusion
String absolutePath = new File(outputFilePath).getAbsolutePath();

Masalah 2: OutOfMemoryError dengan Arsip TAR Besar

Gejala: JVM crash untuk arsip > 500 MB.
Solusi: Tingkatkan ukuran heap (-Xmx) dan segera dispose objek Signature:

java -Xmx2G -jar your-application.jar

Atau terapkan pemrosesan berbasis potongan:

// For very large files, consider signing metadata separately
// rather than embedding in the TAR itself

Masalah 3: Data Tanda Tangan Terpotong

Gejala: String panjang terpotong.
Penyebab: Kapasitas Code128 terlampaui (≈ 80 karakter).
Solusi: Beralih ke kode QR untuk payload lebih panjang:

// Bad: Too much data for Code128
BarcodeSignOptions bcOptions = new BarcodeSignOptions(veryLongString, BarcodeTypes.Code128);

// Good: Use QR code instead
QrCodeSignOptions qrOptions = new QrCodeSignOptions(veryLongString, QrCodeTypes.QR);

Masalah 4: Kesalahan Validasi Lisensi

Gejala: LicenseException atau peringatan “Trial version” di produksi.
Solusi: Muat lisensi sebelum membuat instance Signature apa pun:

import com.groupdocs.signature.License;

License license = new License();
license.setLicense("path/to/GroupDocs.Signature.lic");

// Now create signatures
Signature signature = new Signature("document.tar");

Tip pro: Muat lisensi sekali saat aplikasi mulai, bukan sebelum setiap operasi penandatanganan.

Masalah 5: Nilai Posisi Tidak Berfungsi Seperti Diharapkan

Gejala: Tanda tangan muncul di lokasi tak terduga.
Penyebab: Kebingungan antara piksel dan poin.
Solusi: GroupDocs menggunakan piksel secara default. Untuk penempatan presisi:

bcOptions.setLeft(100);  // 100 pixels from left edge
bcOptions.setTop(100);   // 100 pixels from top edge

// If you need percentage-based positioning:
bcOptions.setHorizontalAlignment(HorizontalAlignment.Center);
bcOptions.setVerticalAlignment(VerticalAlignment.Center);

Pola Integrasi

Pola 1: Layanan REST API

Ekspos penandatanganan sebagai microservice:

@RestController
@RequestMapping("/api/signature")
public class SignatureController {
    
    @PostMapping("/sign")
    public ResponseEntity<SignatureResponse> signFile(
            @RequestParam("file") MultipartFile file,
            @RequestParam("signatureType") String type) {
        
        try {
            // Save uploaded file temporarily
            File tempFile = File.createTempFile("upload-", ".tar");
            file.transferTo(tempFile);
            
            // Sign based on type
            Signature signature = new Signature(tempFile.getAbsolutePath());
            
            SignOptions options = type.equals("barcode") 
                ? createBarcodeOptions() 
                : createQROptions();
            
            String outputPath = generateOutputPath();
            SignResult result = signature.sign(outputPath, options);
            
            // Return signed file
            return ResponseEntity.ok(new SignatureResponse(outputPath, result));
            
        } catch (Exception e) {
            return ResponseEntity.status(500).body(null);
        }
    }
}

Pola 2: Pipeline Pemrosesan Batch

Tandatangani banyak arsip dalam pipeline:

public class BatchSigner {
    
    public void signArchiveBatch(List<File> archives) {
        ExecutorService executor = Executors.newFixedThreadPool(4);
        
        archives.forEach(archive -> {
            executor.submit(() -> {
                try {
                    signSingleArchive(archive);
                } catch (Exception e) {
                    logger.error("Failed to sign: " + archive.getName(), e);
                }
            });
        });
        
        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.HOURS);
    }
    
    private void signSingleArchive(File archive) throws Exception {
        Signature signature = new Signature(archive.getAbsolutePath());
        // ... signing logic
    }
}

Pola 3: Arsitektur Berbasis Event

Trigger penandatanganan saat arsip dibuat:

@Component
public class ArchiveCreatedListener {
    
    @EventListener
    public void onArchiveCreated(ArchiveCreatedEvent event) {
        CompletableFuture.runAsync(() -> {
            signArchive(event.getFilePath());
        });
    }
    
    private void signArchive(String filePath) {
        // ... signing logic
    }
}

Pertimbangan Kinerja

Manajemen Memori

Masalah: Setiap instance Signature memuat seluruh file ke memori.
Praktik terbaik:

// Bad: Creating multiple instances for same file
Signature sig1 = new Signature("file.tar");
Signature sig2 = new Signature("file.tar");  // Loads again!

// Good: Reuse the instance
try (Signature signature = new Signature("file.tar")) {
    signature.sign(output1, options1);
    signature.sign(output2, options2);  // Same instance, different outputs
}

Optimasi Ukuran File

• File kecil (< 10 MB) – tandatangani secara sinkron.
• File menengah (10‑100 MB) – gunakan thread latar belakang.
• File besar (> 100 MB) – pertimbangkan menandatangani metadata terpisah atau menggunakan API streaming.

Kompleksitas Tanda Tangan (perkiraan waktu pada server standar)

Tip optimasi: Untuk ribuan file, batch mereka dan gunakan thread pool (lihat pola pemrosesan batch di atas).

Pembaruan Perpustakaan

GroupDocs secara rutin merilis perbaikan kinerja. Selalu periksa changelog sebelum melakukan deployment besar.

Strategi pembaruan:

1. Uji versi baru di staging.
2. Tinjau perubahan yang dapat memecah kompatibilitas.
3. Benchmark dengan file nyata.
4. Roll out secara bertahap.

Praktik Terbaik untuk Produksi

1. Validasi Status Lisensi

License license = new License();
if (!license.isLicensed()) {
    logger.warn("Running in trial mode - features may be limited");
}

2. Implementasikan Penanganan Error yang Kuat

try {
    signature.sign(outputPath, options);
} catch (Exception e) {
    logger.error("Signature failed", e);
    // Don't just swallow exceptions - log or re-throw
    throw new SignatureException("Failed to sign document", e);
}

3. Gunakan Data Tanda Tangan yang Deskriptif

// Bad: Meaningless ID
new BarcodeSignOptions("12345678", BarcodeTypes.Code128);

// Good: Self-documenting data
String signatureData = String.format("DOC-%s-%s", 
    docType, 
    LocalDateTime.now().format(DateTimeFormatter.ISO_DATE_TIME)
);
new BarcodeSignOptions(signatureData, BarcodeTypes.Code128);

4. Versi Format Tanda Tangan Anda
Sertakan nomor versi dalam JSON yang disematkan untuk mempersiapkan verifikasi di masa depan:

String qrData = String.format(
    "{\"v\":\"1.0\",\"type\":\"archive\",\"timestamp\":\"%s\"}", 
    timestamp
);

5. Uji dengan File Dunia Nyata – selalu validasi dengan arsip berukuran produksi untuk menemukan masalah memori dan kinerja lebih awal.

Kesimpulan

Anda kini memiliki fondasi kuat untuk mengimplementasikan digital signature java menggunakan barcode dan kode QR. Berikut yang telah Anda pelajari:

• Cara menandatangani arsip TAR (dan dokumen lain) dengan barcode serta kode QR
• Kapan memilih tiap tipe tanda tangan berdasarkan kebutuhan spesifik
• Cara mengatasi masalah umum sebelum masuk produksi
• Pola integrasi dunia nyata untuk REST API, pemrosesan batch, dan arsitektur berbasis event
• Teknik optimasi kinerja untuk menangani file berukuran apa pun

Langkah selanjutnya:

1. Jelajahi verifikasi tanda tangan dengan metode search().
2. Coba format dokumen lain—GroupDocs.Signature mendukung PDF, DOCX, XLSX, PNG, dan lainnya.
3. Kustomisasi tampilan tanda tangan (warna, ukuran, border).
4. Bangun API verifikasi untuk memvalidasi tanda tangan secara programatis.

Kekuatan GroupDocs.Signature jauh melampaui panduan ini. Kunjungi dokumentasi lengkap untuk menemukan fitur lanjutan seperti tanda tangan teks, gambar, dan ekstraksi metadata.

Punya pertanyaan atau ingin berbagi implementasi? Bergabunglah dengan forum komunitas GroupDocs untuk bantuan dari pengembang lain.

Pertanyaan yang Sering Diajukan

T: Bisakah saya menandatangani dokumen selain arsip TAR?
J: Tentu! GroupDocs.Signature mendukung lebih dari 50 format file, termasuk PDF, DOCX, XLSX, PNG, dan lainnya. Ganti saja ekstensi file pada konstruktor Signature untuk bekerja dengan tipe yang didukung.

T: Bagaimana cara memverifikasi tanda tangan setelah menandatangani?
J: Gunakan metode search() untuk menemukan dan memvalidasi tanda tangan:

Signature signature = new Signature("signed-document.tar");
BarcodeSearchOptions searchOptions = new BarcodeSearchOptions();
List<BarcodeSignature> signatures = signature.search(BarcodeSignature.class, searchOptions);

T: Apakah tanda tangan ini aman dari manipulasi?
J: Tanda tangan barcode dan kode QR memberikan verifikasi visual tetapi tidak sekuat sertifikat digital kriptografis. Untuk keamanan maksimal, gabungkan dengan PKI tradisional atau simpan hash tanda tangan di basis data eksternal.

T: Berapa data maksimum yang dapat disimpan dalam tanda tangan?

• Barcode Code128: ~80 karakter alfanumerik
• Kode QR (Versi 40): hingga 4.296 karakter alfanumerik atau 7.089 karakter numerik

T: Bisakah saya menyesuaikan tampilan tanda tangan?
J: Ya! Kendalikan warna, ukuran, border, dan lainnya:

bcOptions.setForeColor(Color.BLUE);
bcOptions.setBackgroundColor(Color.YELLOW);
bcOptions.setBorder(new Border());
bcOptions.getBorder().setColor(Color.RED);
bcOptions.getBorder().setWeight(2);

T: Apa yang terjadi jika saya menandatangani file dua kali?
J: Setiap pemanggilan sign() menambahkan tanda tangan baru. Untuk mengganti yang lama, hapus terlebih dahulu dengan metode delete().

T: Bagaimana menangani file besar tanpa kehabisan memori?
J: Tingkatkan heap JVM (-Xmx), segera dispose objek Signature, dan pertimbangkan menandatangani metadata terpisah untuk arsip multi‑gigabyte.

T: Apakah saya memerlukan koneksi internet untuk menandatangani dokumen?
J: Tidak. GroupDocs.Signature berfungsi sepenuhnya offline setelah perpustakaan terinstal.

Terakhir Diperbarui: 2026-05-21
Diuji Dengan: GroupDocs.Signature 23.12 untuk Java
Penulis: GroupDocs

Tutorial Terkait

• Digital Signature in Java - Complete Guide to Certificate Loading and Document Signing
• Java Signature Verification Tutorial - Validate Documents with Text, Barcode & QR Codes
• Sign ZIP Files in Java with Barcodes & QR Codes