Generowanie raportów PDF w GO

OK. Teraz generowanie PDFów w GO!

Page content

Generowanie dokumentów PDF w sposób programistyczny może być ważną funkcją w Twojej aplikacji. Tutaj omawiamy i dajemy krótki przegląd z przykładami bibliotek dostępnych w języku programowania Go (Golang) do generowania plików PDF biblioteki dostępne w języku programowania Go (Golang) do generowania plików PDF.

Właściwe rozwiązania mogą być różne, na przykład dla prostego tworzenia dokumentów lub złożonego i bogato funkcjonalnego generowania PDF.

go, pdf! Tak, obraz jest wygenerowany przez AI, model to Flux1.Dev.

Biblioteki i narzędzia

gofpdf

GoPdf to prosta biblioteka do tworzenia PDF. Umożliwia dodawanie tekstu, obrazów, kształtów, tabel i obsługuje wiele stron. Właściwe do prostych do umiarkowanie złożonych zadań tworzenia PDF.

Odpowiedzialny: Jung Kurt (przestał być utrzymywany, ale nadal jest używany).

Ograniczenie: Brak aktualizacji, mimo to istnieje użycie.

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

Odpowiedzialny: signintech (aktywnie utrzymywany).

W języku programowania Go jednym z bibliotek, które wyróżniają się w tym celu, jest gopdf, opracowany przez SignInTech. Ta biblioteka oferuje prosty sposób na tworzenie PDF programistycznie bez korzystania z zależności zewnętrznych lub bibliotek C.

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

Główne funkcje:

  • Implementacja czystego Go: Nie wymaga zależności zewnętrznych ani bibliotek C.
  • Prosty API: Łatwe do użycia funkcje do generowania PDF.
  • Wydajna wydajność: Optymalizowana do szybkiego i wydajnego tworzenia PDF.

Przykład użycia

Aby pokazać, jak można używać gopdf, spojrzyjmy na prosty przykład tworzenia prostego dokumentu PDF:

package main

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

func main() {
    // Utwórz nową instancję PDF
    pdf := gopdf.New()

    // Ustaw rozmiar strony i marginesy
    pdf.SetPageSize(gopdf.PageSizeA4)
    pdf.AddPage()

    // Dodaj pewien tekst do PDF
    pdf.SetFont("Arial", "", 12)
    pdf.Write(50, 50, "Hello, World!")

    // Zapisz PDF do pliku
    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ć go jako plik.

Zaawansowane funkcje gopdf:

  • Dodawanie obrazów: Możesz wstawiać obrazy do swoich dokumentów PDF za pomocą 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ć hasło do ochrony swoich PDF, aby ograniczyć dostęp.

pdfcpu

Inną z potężnych bibliotek dostępnych do manipulowania PDF w Go jest pdfcpu. Ta biblioteka oferuje pełny zestaw funkcji do tworzenia, modyfikowania i analizowania plików PDF poprzez zarówno API, jak i interfejs wiersza poleceń (CLI). Poniżej omawiamy opis, przykłady użycia i kluczowe funkcje pdfcpu.

pdfcpu to biblioteka 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 z wszystkimi wersjami PDF, w tym z trwającymi poprawkami dla PDF 2.0 (ISO-32000-2). Biblioteka ma na celu dostarczenie pełnego zakresu funkcji przetwarzania PDF, czyniąc ją odpowiednią zarówno dla prostych, jak i złożonych przypadków użycia.

Główne funkcje

  • Obsługa szyfrowania: pdfcpu obsługuje szyfrowanie, pozwalając programistom skutecznie zabezpieczać swoje dokumenty PDF.
  • API i CLI: Oferuje zarówno API dla dostępu programistycznego, jak i interfejs wiersza poleceń (CLI) do szybkich operacji.
  • Przetwarzanie wsadowe: Silna obsługa przetwarzania wsadowego poprzez bogaty interfejs wiersza poleceń czyni ją wydajną w obsłudze wielu plików naraz.
  • Kompatybilność: Kompatybilna z wszystkimi wersjami PDF, w tym z podstawową obsługą i trwającymi poprawkami dla PDF 2.0.

Aby rozpocząć korzystanie z pdfcpu, musisz zainstalować ją za pomocą systemu zarządzania pakietami Go:

go get github.com/pdfcpu/pdfcpu

Podstawowe operacje wiersza poleceń

pdfcpu oferuje wiele poleceń do różnych operacji. Oto kilka przykładów:

Tworzenie PDF z obrazów

Możesz przekształcić jeden lub więcej plików obrazowych w plik PDF za pomocą poniższego polecenia:

pdfcpu img2pdf out.pdf image1.jpg image2.png

To polecenie utworzy PDF, w którym każdy obraz zostanie wyrenderowany na osobnej stronie.

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

pdfcpu merge output.pdf file1.pdf file2.pdf

Przykład użycia pdfcpu

Dla bardziej złożonych operacji możesz użyć API dostarczonego przez pdfcpu. Oto przykład, jak utworzyć nowy PDF i dodać tekst za pomocą kodu Go:

package main

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

func main() {
    // Utwórz nowy dokument PDF
    doc := pdfcpu.NewPDF(0, 0)
    defer doc.Close()

    // Dodaj stronę do dokumentu
    page := doc.AddPage()
    page.SetMediaBox(pdfcpu.MediaBox{
        LLX: 0,
        LLY: 0,
        URX: 612,
        URY: 792,
    })

    // Dodaj tekst do strony
    content := "Hello, World!"
    font := pdfcpu.NewFont("Helvetica", "")
    page.AddText(content, font, 12, 100, 750)

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

Ten przykład pokazuje, jak utworzyć nowy PDF, dodać stronę i napisać tekst na niej za pomocą API pdfcpu.

Maroto

  • Odpowiedzialny: zespół go-playground (https://github.com/go-playground/maroto).
  • Zastosowania: Programiści preferujący podejście oparte na projektowaniu (podobne do Bootstrapa).
  • Wzorowany na Bootstrap; zaprojektowany do łatwego użycia z deklaratywnym stylem podobnym do HTML/CSS.
  • Zbudowany na podstawie gofpdf, upraszcza proces tworzenia, jednocześnie zachowując silne opcje dostosowywania.

Maroto to kolejna biblioteka Go do tworzenia PDF, ale skupia się na uproszczeniu procesu, abstrahując od szczegółów niskopoziomowych. Buduje się na bibliotece gofpdf i oferuje bardziej przyjazny API do generowania dokumentów.

Przykład użycia Maroto

Oto przykład, jak możesz użyć Maroto do utworzenia prostego PDF:

package main

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

func main() {
    // Utwórz nowy dokument PDF z określonymi wymiarami
    m := maroto.NewPDF(595, 842) // Wymiary A4 w punktach

    // Dodaj pewien tekst do pierwszej strony
    m.AddText("Hello, Maroto!", 0, 0)

    // Zapisz PDF do pliku
    err := m.OutputFileAndClose("example.pdf")
    if err != nil {
        panic(err)
    }
}

Ten przykład pokazuje, jak utworzyć nowy dokument PDF z jedną stroną i dodać tekst do niego za pomocą Maroto.

Unipdf

UniPDF to kolejna potężna i kompletna biblioteka do tworzenia i przetwarzania plików PDF w Golang (Go). Oferuje szeroki zakres funkcji, które czynią ją popularną wśród programistów potrzebujących generowania, modyfikowania i ekstrahowania treści z dokumentów PDF.

  • Odpowiedzialny: UnidocLib (https://unidoc.io).
  • Zastosowania: Zaawansowane przetwarzanie PDF (szyfrowanie, łączenie, skryptowanie).
  • Potężna biblioteka do tworzenia i przetwarzania PDF (czysty Go).
  • Oferuje szeroki zakres funkcji, w tym interaktywne elementy takie jak linki, zakładki, łączenie/rozdzielanie, szyfrowanie i wiele więcej.
  • Kompletny API do odczytywania i zapisywania obiektów PDF (słowniki, strumienie).
  • Właściwa do aplikacji wymagających solidnych możliwości generowania PDF.

Instalacja UniPDF

Aby rozpocząć korzystanie z UniPDF, musisz zainstalować bibliotekę. Postępuj zgodnie z poniższymi krokami:

# Utwórz nowy katalog:
mkdir go-pdf-generator cd go-pdf-generator
# Inicjalizuj moduł Go:
go mod init go-pdf-generator
# Zainstaluj bibliotekę UniPDF:
go get github.com/unidoc/unipdf/v3

To przygotuje Twój projekt i zainstaluje wymagane zależności.

Przykład podstawowego użycia

Oto 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() {
    // Utwórz nowy dokument PDF
    pdf := creator.New()

    // Dodaj stronę do PDF
    page := pdf.NewPage()

    // Ustaw strumień zawartości dla strony
    contentStream := model.NewContentStream()
    page.SetContents(contentStream)

    // Dodaj tekst do strony
    text := "Hello, UniPDF!"
    font := creator.NewStandardFont(creator.FontHelvetica)
    textObject := model.NewText(text, font, 12)
    contentStream.Add(textObject)

    // Zapisz dokument PDF
    err := pdf.WriteToFile("example.pdf")
    if err != nil {
        panic(err)
    }
}

Ten przykład pokazuje, jak utworzyć nowy dokument PDF, dodać stronę i napisać tekst na niej. Wynikowy plik example.pdf będzie zawierał tekst “Hello, UniPDF!”.

Wrapper do wkhtmltopdf

Funkcje:

  • Konwertuje szablony HTML (wyrenderowane za pomocą html/template w Go) na PDF.
  • Dostosowalne marginesy, orientacja strony i nagłówki/stopki.
  • Właściwe, gdy projekt dokumentu jest złożony i obejmuje stylizację HTML/CSS.
  • Używa wkhtmltopdf jako backendu do konwersji treści HTML w 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 poleceń do różnych operacji PDF takich jak walidacja, optymalizacja, dzielenie/łączenie.
  • Przydatne do przetwarzania wsadowego i zadań administracyjnych związanych z dokumentami PDF.

Omówienie pdflib

Biblioteka pdflib została zaprojektowana, aby być kompleksowym przetwornikiem PDF dla języka programowania Go. Obsługuje różne funkcje, takie jak walidacja, optymalizacja, dzielenie, łączenie, ekstrakcję treści i przycinanie PDF. Biblioteka przestrzega standardu PDF 32000-1:2008 (PDF 1.7), zapewniając kompatybilność z szerokim zakresem dokumentów PDF.

Główne funkcje

  • Walidacja: Zapewnia, że pliki PDF są zgodne ze standardem PDF 1.7.
  • Optymalizacja: Zmniejsza rozmiar pliku usuwając zbędne zasoby.
  • Dzielenie i łączenie: Pozwala dzielić wielostronicowe PDF na pojedyncze PDF lub łączyć wiele PDF w jeden.
  • Ekstrakcja: Ekstrahuje obrazy, czcionki, treści i strony z PDF.
  • Przycinanie: Tworzy przycięte wersje dokumentów PDF.

Instalacja

Aby użyć pdflib, musisz zainstalować ją za pomocą systemu zarządzania pakietami Go. Możesz to zrobić, uruchamiając:

go get github.com/EndFirstCorp/pdflib

Przykład podstawowego użycia - walidacja PDF

Oto prosty przykład pokazujący, jak używać biblioteki pdflib do wykonywania podstawowych operacji PDF:

Aby zweryfikować PDF względem standardu PDF 1.7, możesz użyć poniższego kodu:

package main

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

func main() {
   // Walidacja pliku PDF
   err := pdflib.Validate("example.pdf")
   if err != nil {
     fmt.Println("Walidacja nie powiodła się:", err)
   } else {
     fmt.Println("PDF jest ważny.")
   }
}

Podsumowanie

Dla generowania PDF w Go, wybór biblioteki zależy od złożoności i konkretnych wymagań projektu. Poniżej podajemy rekomendacje:

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

Każda z tych bibliotek oferuje unikalne zalety, które odpowiadają różnym potrzebom w generowaniu PDF, zapewniając programistom różne narzędzia do wyboru w zależności od ich konkretnych wymagań.

Linki do bibliotek

Inne przydatne linki