Generowanie raportów PDF w GO

OK. Teraz generujemy PDF-y w GO!

Page content

Programatyczne generowanie dokumentów PDF może być istotną funkcjonalnością w Twojej aplikacji. W niniejszym artykule przyglądamy się krótkiej recenzji z przykładami bibliotek dostępnych w języku programowania Go (Golang) do generowania plików PDF.

Odpowiednie rozwiązania mogą być różne, np. dla prostego tworzenia dokumentów lub zaawansowanego i bogatego w funkcje generowania PDF.

go, pdf! Tak, obraz został wygenerowany przez AI, użyty model to Flux1.Dev.

Biblioteki i Narzędzia

gofpdf

GoPdf to prosta biblioteka do tworzenia plików PDF. Pozwala na dodawanie tekstu, obrazów, kształtów, tabel oraz obsługę wielu stron. Nadaje się do prostych i umiarkowanie skomplikowanych zadań związanych z tworzeniem PDF.

Pielęgnujący: Jung Kurt (projekt nieaktywny, ale nadal używany).

Ograniczenie: Brak aktualizacji, mimo że istniejące użycie przetrwało.

Przykład:

package main

import (
    "github.com/jung-kurt/gofpdf"
)

func main() {
    pdf := gofpdf.New("P", "mm", "A4", "")
    pdf.AddPage()
    pdf.SetFont("Arial", "B", 16)
    pdf.Cell(40, 10, "Hello World!")
    err := pdf.OutputFileAndClose("hello.pdf")
    if err != nil {
        panic(err)
    }
}

gopdf

Pielęgnujący: signintech (aktywnie utrzymywany).

W języku programowania Go jedną z wyróżniających się bibliotek do tego celu jest gopdf, rozwijana przez SignInTech. Ta biblioteka oferuje bezpośredni sposób na programatyczne tworzenie plików PDF bez polegania na zewnętrznych zależnościach lub bibliotekach C.

gopdf to czysta biblioteka Go zaprojektowana specjalnie do tworzenia dokumentów PDF. Oferuje prosty i wydajny API skupiający się głównie na generowaniu PDF, co ułatwia jej użycie do podstawowych zadań, zachowując jednocześnie elastyczność potrzebną do bardziej złożonych operacji.

Kluczowe funkcje:

  • Wdrożenie w czystym Go: Brak zewnętrznych zależności ani bibliotek C.
  • Proste API: Łatwe w użyciu funkcje do generowania PDF.
  • Wydajność: Optymalizacja pod kątem szybkiego i wydajnego tworzenia PDF.

Przykład użycia

Aby zilustrować, jak można używać gopdf, spójrzmy na podstawowy przykład tworzenia prostego dokumentu PDF:

package main

import (
    "github.com/signintech/gopdf"
)

func main() {
    // Create a new PDF instance
    pdf := gopdf.New()

    // Set the page size and margins
    pdf.SetPageSize(gopdf.PageSizeA4)
    pdf.AddPage()

    // Add some text to the PDF
    pdf.SetFont("Arial", "", 12)
    pdf.Write(50, 50, "Hello, World!")

    // Save the PDF to a file
    err := pdf.SaveToFile("example.pdf")
    if err != nil {
        panic(err)
    }
}

Ten przykład pokazuje, jak utworzyć nowy dokument PDF, dodać do niego tekst i zapisać jako plik.

Zaawansowane funkcje gopdf:

  • Dodawanie obrazów: Możesz wstawiać obrazy do swoich dokumentów PDF, używając metody AddImage.
  • Rysowanie kształtów: Biblioteka oferuje funkcje do rysowania linii, prostokątów i innych kształtów.
  • Ochrona PDF: Możesz ustawić ochronę hasłem dla swoich plików PDF, aby ograniczyć dostęp.

pdfcpu

Kolejną potężną biblioteką dostępną do manipulacji plikami PDF w Go jest pdfcpu. Ta biblioteka oferuje kompleksowy zestaw funkcji do tworzenia, modyfikowania i inspekcji plików PDF za pomocą zarówno API, jak i interfejsu wiersza polecenia (CLI). Poniżej szczegółowo omawiamy opis, przykłady użycia oraz kluczowe funkcjonalności pdfcpu.

pdfcpu to biblioteka do przetwarzania PDF oparta na Go, która obsługuje szyfrowanie i oferuje solidne narzędzia do obsługi różnych aspektów dokumentów PDF. Jest kompatybilna ze wszystkimi wersjami PDF, w tym z ciągłymi ulepszeniami dla PDF 2.0 (ISO-32000-2). Biblioteka ma na celu zapewnienie kompleksowego zakresu funkcji przetwarzania PDF, co czyni ją odpowiednią zarówno do prostych, jak i złożonych przypadków użycia.

Kluczowe funkcje

  • Obsługa szyfrowania: pdfcpu obsługuje szyfrowanie, pozwalając deweloperom skutecznie chronić swoje dokumenty PDF.
  • API i CLI: Oferuje zarówno API do dostępu programistycznego, jak i interfejs wiersza polecenia (CLI) do szybkich operacji.
  • Przetwarzanie wsadowe: Silna obsługa przetwarzania wsadowego za pomocą rozbudowanego wiersza polecenia sprawia, że jest wydajne przy obsłudze wielu plików jednocześnie.
  • Kompatybilność: Kompatybilna ze wszystkimi wersjami PDF, w tym podstawowa obsługa i ciągłe ulepszenia dla PDF 2.0.

Aby rozpocząć pracę z pdfcpu, należy go zainstalować za pomocą systemu zarządzania pakietami Go:

go get github.com/pdfcpu/pdfcpu

Podstawowe operacje w wierszu polecenia

pdfcpu oferuje różnorodne komendy do różnych operacji. Oto kilka przykładów:

Tworzenie PDF z obrazów

Możesz przekonwertować jeden lub więcej plików graficznych na plik PDF za pomocą poniższej komendy:

pdfcpu img2pdf out.pdf image1.jpg image2.png

Ta komenda utworzy PDF, w którym każdy obraz będzie renderowany na osobnej stronie.

Aby połączyć wiele plików PDF w jeden dokument, użyj komendy merge:

pdfcpu merge output.pdf file1.pdf file2.pdf

Przykład użycia pdfcpu

Dla bardziej złożonych operacji można użyć API dostarczanego przez pdfcpu. Poniżej znajduje się przykład, jak utworzyć nowy PDF i dodać tekst, używając kodu Go:

package main

import (
    "github.com/pdfcpu/pdfcpu"
    "log"
)

func main() {
    // Create a new PDF document
    doc := pdfcpu.NewPDF(0, 0)
    defer doc.Close()

    // Add a page to the document
    page := doc.AddPage()
    page.SetMediaBox(pdfcpu.MediaBox{
        LLX: 0,
        LLY: 0,
        URX: 612,
        URY: 792,
    })

    // Add text to the page
    content := "Hello, World!"
    font := pdfcpu.NewFont("Helvetica", "")
    page.AddText(content, font, 12, 100, 750)

    // Save the document
    err := doc.Save("output.pdf")
    if err != nil {
        log.Fatal(err)
    }
}

Ten przykład demonstruje, jak utworzyć nowy PDF, dodać stronę i napisać na niej tekst, używając API pdfcpu.

Maroto

  • Pielęgnujący: Zespół go-playground (https://github.com/go-playground/maroto).
  • Przypadki użycia: Deweloperzy preferujący podejście projektowe (podobne do Bootstrap).
  • Inspirowana Bootstrapem; zaprojektowana, aby być łatwa w użyciu z deklaratywnym stylem podobnym do HTML/CSS.
  • Zbudowana na podstawie gofpdf, upraszcza proces tworzenia, zachowując jednocześnie potężne opcje personalizacji.

Maroto to kolejna biblioteka Go do tworzenia PDF, ale koncentruje się na uproszczeniu procesu, abstrahując od szczegółów niskopoziomowych. Opiera się na bibliotece gofpdf i oferuje bardziej przyjazne użytkownikowi API do generowania dokumentów.

Przykład użycia Maroto

Poniżej znajduje się przykład, jak można użyć Maroto do tworzenia prostego PDF:

package main

import (
    "github.com/andreyhoffmann1103/maroto"
)

func main() {
    // Create a new PDF document with specified dimensions
    m := maroto.NewPDF(595, 842) // A4 size in points

    // Add some text to the first page
    m.AddText("Hello, Maroto!", 0, 0)

    // Save the PDF to a file
    err := m.OutputFileAndClose("example.pdf")
    if err != nil {
        panic(err)
    }
}

Ten przykład pokazuje, jak utworzyć nowy dokument PDF z jedną stroną i dodać do niego tekst, używając Maroto.

Unipdf

UniPDF to kolejna potężna i kompleksowa biblioteka do tworzenia i przetwarzania plików PDF w Golang (Go). Oferuje szeroki zakres funkcji, co czyni ją popularną wśród deweloperów, którzy muszą generować, modyfikować i wyciągać treści z dokumentów PDF.

  • Pielęgnujący: UnidocLib (https://unidoc.io).
  • Przypadki użycia: Zaawansowane przetwarzanie PDF (szyfrowanie, łączenie, skrypty).
  • Potężna biblioteka do tworzenia i przetwarzania PDF (czysty Go).
  • Oferuje rozległe funkcje, w tym elementy interaktywne, takie jak linki, zakładki, łączenie/dzielnie, szyfrowanie i inne.
  • Kompleksowe API do odczytu i zapisu obiektów PDF (słowniki, strumienie).
  • Odpowiednia dla aplikacji wymagających solidnych możliwości generowania PDF.

Instalacja UniPDF

Aby rozpocząć pracę z UniPDF, należy zainstalować bibliotekę. Postępuj zgodnie z następującymi krokami:

# Create a New Directory:
mkdir go-pdf-generator cd go-pdf-generator
# Initialize the Go Module:
go mod init go-pdf-generator
# Install UniPDF Library:
go get github.com/unidoc/unipdf/v3

Ustawi to Twój projekt i zainstaluje niezbędne zależności.

Przykład podstawowego użycia

Poniżej znajduje się prosty przykład tworzenia dokumentu PDF za pomocą UniPDF:

package main

import (
    "github.com/unidoc/unipdf/v3/core"
    "github.com/unidoc/unipdf/v3/model"
    "github.com/unidoc/unipdf/v3/creator"
)

func main() {
    // Create a new PDF document
    pdf := creator.New()

    // Add a page to the PDF
    page := pdf.NewPage()

    // Set up the content stream for the page
    contentStream := model.NewContentStream()
    page.SetContents(contentStream)

    // Add text to the page
    text := "Hello, UniPDF!"
    font := creator.NewStandardFont(creator.FontHelvetica)
    textObject := model.NewText(text, font, 12)
    contentStream.Add(textObject)

    // Save the PDF document
    err := pdf.WriteToFile("example.pdf")
    if err != nil {
        panic(err)
    }
}

Ten przykład demonstruje, jak utworzyć nowy dokument PDF, dodać stronę i zapisać na niej tekst. Powstający plik example.pdf będzie zawierał tekst “Hello, UniPDF!”.

Wrapper wkhtmltopdf

Funkcje:

  • Konwertuje szablony HTML (renderowane przez html/template w Go) na PDF.
  • Konfigurowalne marginesy, orientacja strony oraz nagłówki/stopki.
  • Odpowiedni, gdy projekt dokumentu jest złożony i obejmuje stylizację HTML/CSS.
  • Używa wkhtmltopdf jako silnika do konwersji treści HTML na format PDF.

Przykład użycia go-wkhtmltopdf

import (
    "bytes"
    "github.com/SebastiaanKlippert/go-wkhtmltopdf"
    "html/template"
)

type PDFService struct {}

func NewPDFService() *PDFService {
    return &PDFService{}
}

func (p PDFService) GeneratePDF(data interface{}) ([]byte, error) {
    var templ *template.Template
    var err error

    if templ, err = template.ParseFiles("pdf-template.html"); err != nil {
        return nil, err
    }

    var body bytes.Buffer
    if err := templ.Execute(&body, data); err != nil {
        return nil, err
    }

    pdfg, err := wkhtmltopdf.NewPDFGenerator()
    if err != nil {
        return nil, err
    }

    page := wkhtmltopdf.NewPageReader(bytes.NewReader(body.Bytes()))
    page.EnableLocalFileAccess.Set(true)

    pdfg.AddPage(page)
    pdfg.MarginLeft.Set(0)
    pdfg.MarginRight.Set(0)
    pdfg.Dpi.Set(300)
    pdfg.PageSize.Set(wkhtmltopdf.PageSizeA4)
    pdfg.Orientation.Set(wkhtmltopdf.OrientationLandscape)

    err = pdfg.Create()
    if err != nil {
        return nil, err
    }

    return pdfg.Bytes(), nil
}

pdflib (z EndFirstCorp):

  • Narzędzie wiersza polecenia do różnych operacji PDF, takich jak walidacja, optymalizacja, dzielenie/łączenie.
  • Przydatne do przetwarzania wsadowego i zadań administracyjnych związanych z dokumentami PDF.

Przegląd pdflib

Biblioteka pdflib jest zaprojektowana jako kompleksowy procesor PDF dla języka programowania Go. Obsługuje różne funkcjonalności, takie jak walidacja, optymalizacja, dzielenie, łączenie, wyciąganie treści oraz przycinanie PDF. Biblioteka przestrzega standardu PDF 32000-1:2008 (PDF 1.7), zapewniając kompatybilność z szerokim zakresem dokumentów PDF.

Kluczowe funkcje

  • Walidacja: Zapewnia, że pliki PDF są zgodne ze standardem PDF 1.7.
  • Optymalizacja: Zmniejsza rozmiar pliku poprzez eliminację zbędnych zasobów.
  • Dzielenie i łączenie: Pozwala dzielić wielostronicowe PDF na PDF jednopstronicowe lub łączyć wiele PDF w jeden.
  • Wyciąganie: Wyciąga obrazy, czcionki, treści i strony z PDF.
  • Przycinanie: Tworzy przycięte wersje dokumentów PDF.

Instalacja

Aby używać pdflib, należy go zainstalować za pomocą systemu zarządzania pakietami Go. Można to zrobić, uruchamiając:

go get github.com/EndFirstCorp/pdflib

Przykład podstawowego użycia - Walidacja PDF

Poniżej znajduje się prosty przykład demonstrujący, jak używać biblioteki pdflib do wykonywania podstawowych operacji PDF:

Aby zwalidować PDF ze standardem PDF 1.7, można użyć następującego kodu:

package main

import ( "fmt" "github.com/EndFirstCorp/pdflib/cmd/pdflib" )

func main() {
   // Validate a PDF file
   err := pdflib.Validate("example.pdf")
   if err != nil {
     fmt.Println("Validation failed:", err)
   } else {
     fmt.Println("PDF is valid.")
   }
}

Wniosek

Wybór biblioteki do generowania PDF w Go zależy od złożoności i konkretnych wymagań Twojego projektu. Poniżej przedstawiono zalecenia:

  • Proste dokumenty: Użyj gofpdf lub Maroto. Te biblioteki oferują prostotę i łatwość użycia do prostych zadań.
  • Złożone projekty z HTML/CSS: Wykorzystaj wkhtmltopdf Wrapper, który wykorzystuje wkhtmltopdf do obsługi złożonych treści HTML i stylizacji.
  • Zaawansowane przetwarzanie PDF: Wybierz Unipdf lub pdfcpu, jeśli Twoja aplikacja wymaga zaawansowanych funkcji, takich jak szyfrowanie, elementy interaktywne, szczegółowe formatowanie i kompleksowe możliwości manipulacji.

Każda z tych bibliotek oferuje unikalne mocne strony odpowiadające na różne potrzeby w generowaniu PDF, dając deweloperom szeroki wybór narzędzi w oparciu o ich konkretne wymagania.

Linki do bibliotek

Inne przydatne linki

Subskrybuj

Otrzymuj nowe wpisy o systemach, infrastrukturze i inżynierii AI.