Schriftarten aus Dateien, Streams und Byte-Arrays in Java laden

Laden und initialisieren Sie TrueType- (TTF), OpenType- (OTF), WOFF/WOFF2-, Embedded OpenType- (EOT), Type1- und Compact Font Format- (CFF) Schriftarten programmgesteuert mit Aspose.Font für Java. Laden Sie Schriftarten nahtlos aus Festplattenpfaden, Systemdateien, Byte-Streams oder im Speicher befindlichen Arrays, ohne auf natives Java AWT oder eine betriebssystemspezifische Installation von Schriftarten angewiesen zu sein.

Um eine beliebige Schriftart mit Aspose.Font für Java zu öffnen und zu bearbeiten, sind zwei wichtige Parameter erforderlich:

Schriftartenformat (FontType): Identifiziert die allgemeine Kategorie (z. B. FontType.TTF, FontType.Type1, FontType.CFF).
Binäre Schriftartenquelle (StreamSource/FontFileDefinition): Kapselt den zugrunde liegenden Binärstream, unabhängig davon, ob er auf der Festplatte, in einer Datenbank oder innerhalb von Dokumentstreams (z. B. PDF/DOCX) gespeichert ist.
Die zentrale Klasse FontDefinition verknüpft diese Parameter miteinander, sodass Font.open(fontDefinition) ein einheitliches com.aspose.font.Font-Objekt zurückgeben kann.

Wie lädt man eine Schriftart mit java.io.File?

Die einfachste Möglichkeit, auf lokalen Laufwerken gespeicherte Schriftarten mit FontFileDefinition(File file) zu laden.

import com.aspose.font.*;
import java.io.File;
import java.nio.file.Paths;

public class LoadFontFromFile {
    public static void main(String[] args) {
        // Step 1: Define path to font file
        String fontPath = Paths.get("data", "Montserrat-Regular.ttf").toString();

        // Step 2: Create FontFileDefinition from java.io.File
        FontFileDefinition fileDef = new FontFileDefinition(new File(fontPath));

        // Step 3: Create FontDefinition (extension is auto-detected from FontFileDefinition)
        FontDefinition fontDef = new FontDefinition(FontType.TTF, fileDef);

        // Step 4: Open and load font instance
        Font font = Font.open(fontDef);

        System.out.println("Successfully loaded font: " + font.getFontName());
    }
}

Wie lädt man eine Schriftart mit FileSystemStreamSource?

Bietet eine explizite Verarbeitung von Dateierweiterungen für eine präzise Formaterkennung beim Laden von Schriftarten aus Festplattenpfaden.

import com.aspose.font.*;
import java.nio.file.Paths;

public class LoadFontFromStreamSource {
    public static void main(String[] args) {
        String fontPath = Paths.get("data", "Montserrat-Regular.ttf").toString();

        // Pass 'ttf' explicitly to ensure proper format mapping
        FontFileDefinition fileDef = new FontFileDefinition("ttf", new FileSystemStreamSource(fontPath));
        FontDefinition fontDef = new FontDefinition(FontType.TTF, fileDef);

        Font font = Font.open(fontDef);
        System.out.println("Loaded Font Name: " + font.getFontName());
    }
}

Wie lädt man eine Schriftart aus einer direkten Stream-Quelle (ohne FontFileDefinition)?

Übergeben Sie FileSystemStreamSource direkt an FontDefinition, um das Laden zu vereinfachen.

import com.aspose.font.*;
import java.nio.file.Paths;

public class LoadFontDirectStream {
    public static void main(String[] args) {
        String fontPath = Paths.get("data", "Montserrat-Regular.ttf").toString();

        // Provide FontType, file extension, and StreamSource directly
        FontDefinition fontDef = new FontDefinition(FontType.TTF, "ttf", new FileSystemStreamSource(fontPath));

        Font font = Font.open(fontDef);
        System.out.println("Loaded Font Name: " + font.getFontName());
    }
}

Wie lädt man eine Schriftart aus einem im Speicher befindlichen Byte-Array (byte[])?

Ideal zum Laden von Schriftarten aus Datenbanken, Netzwerkanfragen, Cloud-Speichern oder eingebetteten PDF/DOCX-Ressourcen mithilfe von ByteContentStreamSource.

import com.aspose.font.*;
import java.nio.file.Files;
import java.nio.file.Paths;

public class LoadFontFromByteArray {
    public static void main(String[] args) throws Exception {
        String fontPath = Paths.get("data", "Montserrat-Regular.ttf").toString();

        // Read font binary data into byte array
        byte[] fontBytes = Files.readAllBytes(Paths.get(fontPath));

        // Initialize FontDefinition with ByteContentStreamSource
        FontDefinition fontDef = new FontDefinition(FontType.TTF, "ttf", new ByteContentStreamSource(fontBytes));

        // Open font from memory
        Font font = Font.open(fontDef);

        System.out.println("Loaded Font from Memory: " + font.getFontName());
    }
}

Installation und Einrichtung

Binden Sie Aspose.Font für Java über Maven in Ihr Projekt ein.

Package Manager Console Command

<repository>
    <id>AsposeJavaAPI</id>
    <name>Aspose Java API</name>
    <url>https://repository.aspose.com/repo/</url>
</repository>

<dependency>
    <groupId>com.aspose</groupId>
    <artifactId>aspose-font</artifactId>
    <version>Latest</version>
</dependency>

Nächste Schritte

Häufig gestellte Fragen

1. Warum muss ich beim Laden von Schriftarten sowohl FontType als auch fileExtension übergeben?

FontType steht für die allgemeine Formatfamilie (z. B. FontType.TTF), aber mehrere unterschiedliche Dateiformate gehören zu dieser Familie (z. B. .ttf, .eot und .ttc). Durch die Angabe von fileExtension wird sichergestellt, dass die Bibliothek den richtigen Parser für das jeweilige Containerformat verwendet.

2. Kann ich Schriftarten direkt aus BLOB-Feldern einer Datenbank laden?

Ja. Rufen Sie die BLOB-Daten als byte[]-Array ab und verwenden Sie ByteContentStreamSource, um FontDefinition zu initialisieren, ohne die Daten auf der Festplatte zu speichern.

3. Wie lade ich eine Schriftart, wenn die Binärdaten an einem bestimmten Offset innerhalb einer Datei beginnen?

Verwenden Sie den Konstruktor FontFileDefinition(String fileExtension, StreamSource streamSource, long offset) und übergeben Sie den Byte-Offset, an dem die Schriftartdaten beginnen.