Jak podpisywać pliki Java przy użyciu kodów kreskowych i kodów QR

Wprowadzenie

Czy kiedykolwiek zastanawiałeś się, jak udowodnić, że Twoje pliki nie zostały zmodyfikowane przy użyciu how to sign java? A może potrzebujesz sposobu na uwierzytelnianie dokumentów programowo, bez skomplikowanych konfiguracji kryptograficznych? Tradycyjne podpisy cyfrowe mogą być przesadą w niektórych przypadkach. Czasami wystarczy lekka, skanowalna metoda weryfikacji integralności pliku — szczególnie przy archiwach, kopiach zapasowych lub zautomatyzowanych przepływach pracy. Właśnie tutaj wchodzą w grę podpisy w postaci kodów kreskowych i QR.

W tym samouczku nauczysz się, jak wdrożyć how to sign java przy użyciu GroupDocs.Signature. Skupimy się na podpisywaniu archiwów TAR (idealnych dla systemów backupowych i dystrybucji oprogramowania), ale techniki te działają z różnymi formatami dokumentów. Niezależnie od tego, czy budujesz system zarządzania dokumentami, czy po prostu chcesz dodać dodatkową warstwę bezpieczeństwa do swoich plików, jesteś we właściwym miejscu.

Co zdobędziesz po przeczytaniu:

  • Działające wdrożenie podpisów w postaci kodów kreskowych i QR w Javie
  • Zrozumienie, kiedy używać każdego typu podpisu (i dlaczego ma to znaczenie)
  • Praktyczne rozwiązania typowych wyzwań przy podpisywaniu
  • Wzorce integracji, które możesz wykorzystać już dziś
  • Wskazówki optymalizacji wydajności dla systemów produkcyjnych

Zanurzmy się — nie potrzebujesz dyplomu z kryptografii.

Szybkie odpowiedzi

  • Jaką bibliotekę obsługuje podpisy kodów kreskowych w Javie? GroupDocs.Signature for Java.
  • Który typ podpisu przechowuje więcej danych? Kody QR (do 4 296 znaków alfanumerycznych).
  • Czy mogę podpisać duże pliki TAR (>100 MB)? Tak — użyj wątków w tle i zwiększ pamięć heap JVM.
  • Czy potrzebne jest połączenie z internetem? Nie, biblioteka działa w pełni offline.
  • Czy wymagana jest licencja do produkcji? Tak, wymagana jest ważna licencja GroupDocs.Signature.

Co to jest podpis cyfrowy w Javie?

Podpis cyfrowy w Javie to proces osadzania weryfikowalnego wizualnego tokenu — takiego jak kod kreskowy lub kod QR — bezpośrednio w pliku generowanym w Javie, aby udowodnić jego autentyczność i integralność, zapewniając szybki, czytelny dla człowieka dowód, że plik nie został zmieniony od momentu podpisania, a jednocześnie umożliwiając programową weryfikację poprzez API GroupDocs.Signature.

Dlaczego używać podpisów w postaci kodów kreskowych lub QR?

GroupDocs.Signature obsługuje ponad 50 formatów wejściowych i wyjściowych (w tym PDF, DOCX, XLSX, HTML, PNG i TAR) i potrafi przetwarzać dokumenty wielostronicowe bez ładowania całego pliku do pamięci. Kody kreskowe i QR dają skanowalny, samodzielny dowód autentyczności, eliminując potrzebę zewnętrznych urzędów certyfikacji w wielu wewnętrznych przepływach pracy.

CzynnikKod kreskowy (Code128)Kod QR
Pojemność danych~80 znakówDo 4 296 znaków alfanumerycznych
CzytelnośćWymaga skanera kodów kreskowychDziała z kamerami smartfonów
Efektywność przestrzeniBardziej kompaktowy w poziomieWymaga kwadratowego obszaru
Najlepsze zastosowanieProste identyfikatory, znaczniki czasu, krótkie kodyAdresy URL, dane JSON, szczegółowe metadane
Korekcja błędówMinimalnaWbudowana (może odzyskać po uszkodzeniu)

Zasada:

  • Używaj kodów kreskowych do szybkich, skanowalnych identyfikatorów lub znaczników czasu.
  • Używaj kodów QR, gdy potrzebujesz osadzić bogatsze dane lub zapewnić kompatybilność ze smartfonami.
  • Łącz oba typy, aby uzyskać maksymalną redundancję i audytowalność.

Wymagania wstępne

  • GroupDocs.Signature for Java Library – wersja 23.12 lub nowsza
  • Java Development Kit (JDK) – wersja 8 lub wyższa
  • IDE – IntelliJ IDEA, Eclipse lub dowolny edytor kompatybilny z Javą
  • Podstawowa znajomość Javy – powinieneś być pewny klas i importów

Konfiguracja środowiska

Dodanie GroupDocs.Signature do projektu jest proste. Wybierz narzędzie budowania:

Maven (dodaj do pliku pom.xml):

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

Gradle (dodaj do build.gradle):

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

Ręczne pobranie: Nie używasz Maven ani Gradle? Pobierz JAR bezpośrednio z GroupDocs.Signature releases i dodaj go do classpath.

Uzyskanie licencji

GroupDocs oferuje elastyczne modele licencjonowania:

  • Bezpłatna wersja próbna: Idealna do testów — nie wymaga karty kredytowej. Rozpocznij tutaj
  • Licencja tymczasowa: Potrzebujesz więcej czasu na ocenę? Poproś o licencję tymczasową aby uzyskać pełny dostęp podczas rozwoju
  • Licencja produkcyjna: Gdy jesteś gotowy do wdrożenia, zakup licencję dopasowaną do Twoich potrzeb

Dodatkowe przydatne linki

Wskazówka: Zacznij od wersji próbnej, aby prototypować rozwiązanie, a potem przejdź na licencję tymczasową, jeśli potrzebujesz więcej czasu przed podjęciem ostatecznej decyzji.

Konfiguracja GroupDocs.Signature dla Javy

Klasa Signature jest punktem wejścia dla wszystkich operacji podpisywania w GroupDocs.Signature. Reprezentuje pojedynczy plik załadowany do pamięci i udostępnia metody dodawania, wyszukiwania lub usuwania podpisów wizualnych.

Utwórz instancję Signature wskazującą na plik TAR. To załaduje plik do pamięci w celu przetworzenia:

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

Ważne: Zawsze zamykaj obiekt Signature, gdy skończysz (lub użyj try‑with‑resources), aby uniknąć wycieków pamięci przy dużych plikach.

Wybór między kodem kreskowym a kodem QR

Nie wiesz, którego typu użyć? Oto szybki przewodnik decyzyjny:

CzynnikKod kreskowy (Code128)Kod QR
Pojemność danych~80 znakówDo 4 296 znaków alfanumerycznych
CzytelnośćWymaga skanera kodów kreskowychDziała z kamerami smartfonów
Efektywność przestrzeniBardziej kompaktowy w poziomieWymaga kwadratowego obszaru
Najlepsze zastosowanieProste identyfikatory, znaczniki czasu, krótkie kodyAdresy URL, dane JSON, szczegółowe metadane
Korekcja błędówMinimalnaWbudowana (może odzyskać po uszkodzeniu)

Zasada:

  • Używaj kodów kreskowych do szybkich, skanowalnych identyfikatorów lub znaczników czasu.
  • Używaj kodów QR, gdy potrzebujesz osadzić bogatsze dane lub zapewnić kompatybilność ze smartfonami.
  • Łącz oba typy, aby uzyskać maksymalną redundancję i audytowalność.

Przewodnik implementacji

Podpisywanie archiwum TAR kodem kreskowym

Dlaczego kod kreskowy?

Kody kreskowe są idealne dla archiwów TAR, ponieważ są kompaktowe i skanowalne. Możesz osadzić znaczniki czasu, numery wersji, identyfikatory użytkowników lub sumy kontrolne dla szybkiej weryfikacji.

Kroki

1. Inicjalizacja podpisu
Najpierw utwórz instancję Signature dla pliku TAR:

import com.groupdocs.signature.Signature;

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

Wskazówka: Dla dużych plików TAR (powyżej 100 MB) uruchom operację podpisywania w wątku w tle, aby UI pozostało responsywne.

2. Konfiguracja opcji kodu kreskowego
Klasa BarcodeSignature definiuje zawartość, typ i położenie kodu. Obiekt BarcodeOptions przechowuje te ustawienia:

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 pozwala określić wygląd i pozycję kodu.
BarcodeTypes to enum wymieniający obsługiwane symbologie, takie jak Code128, Code39 itd.

Co się dzieje?

  • "12345678" to dane zakodowane w kodzie — zamień je na własny identyfikator, znacznik czasu lub kod weryfikacyjny.
  • BarcodeTypes.Code128 zapewnia dobrą równowagę między pojemnością a niezawodnością skanowania.
  • Wartości pozycji (100, 100) umieszczają kod 100 px od lewego górnego rogu.

Opcje personalizacji, które możesz rozważyć:

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. Podpisz i zapisz dokument
Wykonaj operację podpisywania i zapisz podpisane archiwum:

import com.groupdocs.signature.domain.SignResult;

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

Obiekt SignResult informuje, czy operacja się powiodła i gdzie umieszczono podpis.
Częsty problem: Upewnij się, że katalog wyjściowy istnieje przed wywołaniem sign(). Biblioteka nie tworzy automatycznie katalogów nadrzędnych.

Podpisywanie archiwum TAR kodem QR

Kiedy używać kodów QR

Kody QR błyszczą, gdy trzeba przechowywać dane strukturalne (JSON, XML), osadzać adresy weryfikacyjne lub umożliwić skanowanie smartfonem.

Kroki

1. Inicjalizacja podpisu
Tak samo jak wcześniej — utwórz instancję Signature:

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

2. Konfiguracja opcji kodu QR
Ustaw kod QR z danymi, które chcesz osadzić:

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 to enum określający typ generowanego kodu QR (standardowy QR, DataMatrix, Aztec itd.).

Przykład z życia – osadź ładunek JSON z danymi weryfikacyjnymi:

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

Opcje typów kodu QR:

  • QrCodeTypes.QR – standardowy kod QR (najczęstszy)
  • QrCodeTypes.DataMatrix – bardziej kompaktowy przy małej ilości danych
  • QrCodeTypes.Aztec – dobry dla zakrzywionych powierzchni

3. Podpisz i zapisz dokument
Zakończ proces tak samo jak przy kodach kreskowych:

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

Uwaga o wydajności: Generowanie kodu QR jest nieco wolniejsze niż kodu kreskowego ze względu na obliczenia korekcji błędów, ale różnica jest pomijalna w większości zastosowań (zwykle kilka milisekund).

Podpisywanie archiwum TAR wieloma podpisami

Dlaczego wiele podpisów?

  • Redundancja – jeśli jeden podpis zostanie uszkodzony, drugi nadal może zweryfikować plik.
  • Różne grupy odbiorców – kody kreskowe dla skanerów, kody QR dla smartfonów.
  • Warstwowe dane – szybki identyfikator w kodzie kreskowym, szczegółowe metadane w kodzie QR.
  • Zgodność – niektóre regulacje wymagają wielu metod weryfikacji.

Kroki

1. Inicjalizacja podpisu
Jak wyżej:

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

2. Konfiguracja wielu opcji
Utwórz oba typy podpisów i połącz je w listę:

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

Wskazówka: Umieszczaj podpisy strategicznie — w rogach lub w obszarach niezakłócających się, co sprawdza się najlepiej w archiwach TAR.

3. Podpisz i zapisz dokument
Przekaż listę opcji do metody sign():

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

GroupDocs przetwarza każdy podpis kolejno, osadzając je w metadanych dokumentu. Kolejność w liście nie wpływa na weryfikację.

Przykłady zastosowań w rzeczywistym świecie

1. Pipeline dystrybucji oprogramowania

Scenariusz: Dystrybucja pakietów oprogramowania jako archiwa TAR i dowód, że nie zostały zmodyfikowane.
Rozwiązanie: Podpisz każdą wersję kodem QR zawierającym ładunek JSON:

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

Dlaczego działa: Użytkownicy mogą zeskanować kod QR, aby zweryfikować integralność pakietu przed instalacją — bez konieczności zarządzania kluczami GPG.

2. Zautomatyzowane systemy backupu

Scenariusz: Codzienne archiwa backupowe TAR wymagają ścieżki audytu.
Rozwiązanie: Dodaj kod kreskowy z znacznikiem czasu backupu i identyfikatorem serwera:

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

Dlaczego działa: Szybka wizualna weryfikacja autentyczności backupu bez otwierania archiwum.

3. Systemy zarządzania dokumentami

Scenariusz: Dokumenty prawne przechowywane jako archiwa wymagają ochrony przed manipulacją.
Rozwiązanie: Użyj zarówno kodu kreskowego (szybkie skanowanie), jak i kodu QR (szczegółowe metadane) na tym samym archiwum.

4. Śledzenie w łańcuchu dostaw

Scenariusz: Śledzenie pakietów plików przez wiele organizacji.
Rozwiązanie: Osadź kody QR z adresami URL prowadzącymi do API weryfikacyjnego:

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

Typowe problemy i rozwiązania

Problem 1: „Signature not found” po podpisaniu

Objaw: sign() zakończyło się sukcesem, ale podpis nie jest widoczny.
Przyczyny: Nieprawidłowe położenie, nadpisanie oryginalnego pliku, ograniczenia przeglądarki TAR.
Rozwiązanie:

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

Problem 2: OutOfMemoryError przy dużych plikach TAR

Objaw: JVM się wyłącza przy archiwach > 500 MB.
Rozwiązanie: Zwiększ rozmiar heap (-Xmx) i szybko zwalniaj obiekty Signature:

java -Xmx2G -jar your-application.jar

Albo zastosuj przetwarzanie w partiach:

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

Problem 3: Dane podpisu są obcinane

Objaw: Długie ciągi są ucinane.
Przyczyna: Przekroczono pojemność Code128 (≈ 80 znaków).
Rozwiązanie: Przejdź na kody QR dla dłuższych ładunków:

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

Problem 4: Błędy walidacji licencji

Objaw: LicenseException lub ostrzeżenia „Trial version” w środowisku produkcyjnym.
Rozwiązanie: Załaduj licencję przed tworzeniem jakichkolwiek instancji Signature:

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

Wskazówka: Ładuj licencję raz przy starcie aplikacji, nie przed każdym podpisem.

Problem 5: Wartości pozycji nie działają zgodnie z oczekiwaniami

Objaw: Podpisy pojawiają się w nieoczekiwanych miejscach.
Przyczyna: Mieszanie pikseli i punktów.
Rozwiązanie: GroupDocs używa domyślnie pikseli. Dla precyzyjnego położenia:

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

Wzorce integracji

Wzorzec 1: Usługa REST API

Udostępnij podpisywanie jako mikroserwis:

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

Wzorzec 2: Przetwarzanie wsadowe

Podpisuj wiele archiwów w potoku:

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

Wzorzec 3: Architektura zdarzeniowa

Wyzwalaj podpisywanie przy tworzeniu archiwów:

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

Rozważania wydajnościowe

Zarządzanie pamięcią

Problem: Każda instancja Signature ładuje cały plik do pamięci.
Najlepsze praktyki:

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

Optymalizacja rozmiaru pliku

  • Małe pliki (< 10 MB) – podpisuj synchronicznie.
  • Średnie pliki (10‑100 MB) – używaj wątków w tle.
  • Duże pliki (> 100 MB) – rozważ podpisywanie tylko metadanych lub użycie API strumieniowego.

Złożoność podpisu (przybliżone czasy na standardowym serwerze)

Typ podpisuCzas na dokument
Jeden kod kreskowy50‑100 ms
Jeden kod QR100‑200 ms
Wiele podpisów150‑300 ms

Wskazówka optymalizacyjna: Przy tysiącach plików grupuj je i używaj puli wątków (zobacz wzorzec przetwarzania wsadowego powyżej).

Aktualizacje biblioteki

GroupDocs regularnie wydaje poprawki wydajności. Zawsze sprawdzaj changelog przed dużymi wdrożeniami.

Strategia aktualizacji:

  1. Testuj nowe wersje w środowisku staging.
  2. Przeglądaj zmiany łamiące kompatybilność.
  3. Benchmarkuj na rzeczywistych plikach.
  4. Wdrażaj stopniowo.

Najlepsze praktyki dla produkcji

1. Walidacja statusu licencji

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

2. Solidna obsługa błędów

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. Używaj opisowych danych podpisu

// 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. Wersjonowanie formatu podpisu Umieść numer wersji w osadzonym JSON, aby zabezpieczyć przyszłą weryfikację:

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

5. Testuj na rzeczywistych plikach – zawsze weryfikuj na archiwach o rozmiarach produkcyjnych, aby wcześnie wykryć problemy z pamięcią i wydajnością.

Podsumowanie

Masz teraz solidne podstawy do implementacji how to sign java przy użyciu kodów kreskowych i QR. Oto, czego się nauczyłeś:

  • Jak podpisać archiwa TAR (i inne dokumenty) zarówno kodem kreskowym, jak i QR
  • Kiedy wybrać konkretny typ podpisu w zależności od potrzeb
  • Jak rozwiązywać typowe problemy przed wdrożeniem do produkcji
  • Przykładowe wzorce integracji dla API REST, przetwarzania wsadowego i architektury zdarzeniowej
  • Techniki optymalizacji wydajności dla plików dowolnego rozmiaru

Kolejne kroki:

  1. Zbadaj weryfikację podpisów metodą search().
  2. Wypróbuj inne formaty dokumentów — GroupDocs.Signature obsługuje PDF, DOCX, XLSX, PNG i wiele innych.
  3. Dostosuj wygląd podpisu (kolory, rozmiary, obramowania).
  4. Zbuduj API weryfikacyjne, aby programowo sprawdzać podpisy.

Możliwości GroupDocs.Signature wykraczają daleko poza ten przewodnik. Zapoznaj się z GroupDocs.Signature for Java Documentation, aby odkryć zaawansowane funkcje, takie jak podpisy tekstowe, obrazkowe i ekstrakcja metadanych.

Masz pytania lub chcesz podzielić się swoim rozwiązaniem? Dołącz do forum społeczności GroupDocs, aby uzyskać pomoc od innych deweloperów.

Najczęściej zadawane pytania

Q: Czy mogę podpisywać dokumenty inne niż archiwa TAR?
A: Oczywiście! GroupDocs.Signature obsługuje ponad 50 formatów, w tym PDF, DOCX, XLSX, PNG i inne. Wystarczy zmienić rozszerzenie w konstruktorze Signature, aby pracować z dowolnym obsługiwanym typem.

Q: Jak zweryfikować podpisy po ich utworzeniu?
A: Użyj metody search(), aby znaleźć i zweryfikować podpisy:

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

Q: Czy podpisy są bezpieczne przed manipulacją?
A: Kody kreskowe i QR zapewniają wizualną weryfikację, ale nie są kryptograficznie tak silne jak certyfikaty cyfrowe. Dla maksymalnego bezpieczeństwa łącz je z tradycyjnym PKI lub przechowuj hashe podpisów w zewnętrznej bazie danych.

Q: Jaka jest maksymalna ilość danych, którą mogę przechowywać w podpisie?

  • Kod kreskowy Code128: ~80 znaków alfanumerycznych
  • Kod QR (wersja 40): do 4 296 znaków alfanumerycznych lub 7 089 znaków numerycznych

Q: Czy mogę dostosować wygląd podpisu?
A: Tak! Kontroluj kolory, rozmiary, obramowania i inne elementy:

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

Q: Co się stanie, jeśli podpiszę plik dwukrotnie?
A: Każde wywołanie sign() dodaje nowy podpis. Aby zastąpić istniejący, najpierw usuń go metodą delete().

Q: Jak radzić sobie z dużymi plikami, aby nie wyczerpać pamięci?
A: Zwiększ heap JVM (-Xmx), szybko zwalniaj obiekty Signature i rozważ podpisywanie tylko metadanych przy archiwach wielogigabajtowych.

Q: Czy potrzebne jest połączenie z internetem, aby podpisywać dokumenty?
A: Nie. GroupDocs.Signature działa całkowicie offline po zainstalowaniu biblioteki.


Ostatnia aktualizacja: 2026-10-06
Testowane z: GroupDocs.Signature 23.12 for Java
Autor: GroupDocs

Powiązane samouczki