Kapitel 7. Typische Anwendungsbeispiele

Dieses Beispiel zeigt die Erstellung einer FontManager Instanz. Die ID ist ein frei wählbarer eindeutiger String, der zur späteren Identifikation (beispielsweise in Log-Ausgaben) dient. Die Erzeugung erfolgt synchron auf dem aktuellen Thread.

String id = "any unique identifier";
FontManagerFuture future = FontManagers.startBuilding(id)
        .synchronously()
        .withSystemFonts()
        .finish();
FontManager fontManager = future.get();

Ähnlich zum vorhergehenden Beispiel wird hier ebenfalls ein FontManager erzeugt. Inhalt und ID sind identisch. Die Erzeugung erfolgt jedoch asynchron im Hintergrund.

String id = "any unique identifier";
FontManagerFuture future = FontManagers.startBuilding(id)
        .asynchronously()
        .withSystemFonts()
        .finish();
…                                                                              
FontManager fontManager = future.get();

Das folgende Beispiel zeigt die Erzeugung eines FontManagers, der Open Source Alternativen für die allgemein gebräuchlichen Standard-14 Fonts enthält. Die jar-Datei welche die Font-Dateien beinhaltet, muss dabei auf dem Klassenpfad liegen.

FontManagers.startBuilding("Standard-14 Font Manager")
        .asynchronously()
        .withStandard14()
        .finish();

Der folgende Quelltext zeigt einige Möglichkeiten zur Definition der Inhalte eines FontManagers. Die zu verwendeten Font-Dateien können auf verschiedene Wege bekannt gemacht werden.

FontManagers.startBuilding("big Font Manager")
        .asynchronously()
        .withStandard14()
        .withSystemFonts()
        .with(Paths.get("path/to/local/fonts"))
        .with(new File("additional/local/fonts"))
        .with(new FileInputStream("some/folder/arial.ttf"))
        .finish();

Das Beispiel zeigt das Grundgerüst einer typischen FontFactory Realisierung. Die asynchrone Erzeugung des FontManagers sollte generell möglichst frühzeitig im Programmablauf angestoßen werden. Der Einfachheit halber wird sie hier im Konstruktor dargestellt. Alternativ könnte das FontManagerFuture dem Konstruktor von außen übergeben werden. Da der Aufbau des FontManagers im Hintergrund läuft, kann parallel dazu die weitere Initialisierung der Anwendung durchgeführt werden.

Der Abruf des FontManagers vom FontManagerFuture erfolgt zum spätestmöglichen Zeitpunkt – also dann, wenn ein Font benötigt wird damit ein Dokument geladen werden kann. Falls die asynchrone Erzeugung des FontManagers zu diesem Zeitpunkt bereits abgeschlossen ist, entsteht keine zusätzliche Wartezeit. Andernfalls pausiert der Dokument-Ladevorgang bis der FontManager zur Verfügung steht. In diesem Fall kann es zu einmaligen, initialen Verzögerungen in der Dokumentanzeige kommen.

public class ExampleFontFactory implements FontFactory {
  final FontManagerFuture fontManagerFuture;

  public ExampleFontFactory() {
    fontManagerFuture = FontManagers.startBuilding("example font manager")
        .asynchronously()
        .withStandard14()
        .finish();
  }

  @Override
  public Font create(FontAttributeSet fontAttributeSet, Map<String, Object> scope) {
    Font resultingFont;
    try {
      final FontManager fontManager = fontManagerFuture.get();
      resultingFont = findTheBestFont(fontManager, fontAttributeSet, scope);
    } catch (InterruptedException | ExecutionException e) {
      resultingFont = new BasicFontFactory().create(fontAttributeSet, scope);
    }
    return resultingFont;
  }

  private Font findTheBestFont(FontManager fontManager, 
      FontAttributeSet fontAttributeSet,
      Map<String, Object> scope) {
    …                                                                          
  }
}

Die AbstractFontFactory bietet Methoden, welche bei der Implementierung einer eigenen FontFactory hilfreich sind. Unter anderem beinhaltet diese Methoden zum Laden einer FontSource basierend auf einem oder mehreren Attribute, oder auch das Laden einer Font

Im Beispiel werden die Methoden der AbstractFontFactory verwendet, um eine Font basierend auf dem PostScript-Name aufzulösen. Falls keine Font aufgelöst werden kann, wird null zurückgegeben um zu signalisieren, dass das Handling von einer anderen FontFactory übernommen werden soll.

public class CalibriFontFactory extends AbstractFontFactory {
  protected CalibriFontFactory(FontManagerFuture fontManagerFuture) {
    super(fontManagerFuture);
  }

  @Override
  public Font create(FontAttributeSet fontAttributeSet, Map<String, Object> scope) {
    if (fontAttributeSet.contains(postScriptName("Calibri"))) {
      return getFontFor(postScriptName("Carlito")).orElse(null);
    } else {
      // let other FontFactories deal with this request
      return null;
    }
  }
}

Die ChainedFontFactory ist ein Hilfsmittel zur Trennung von Zuständigkeiten in FontFactory-Implementationen. Der folgende Quelltext zeigt die Erstellung einer ChainedFontFactory, die im Nachgang für Dokument-Ladevorgänge nutzbar ist.

Die ChainedFontFactory nimmt in ihrem Konstruktor weitere FontFactory-Instanzen entgegen. Sie reagiert auf Font-Anfragen, indem sie diese nacheinander an die übergebenen Instanzen delegiert. Sobald ein Wert ungleich null vorliegt, wird dieser als Ergebnis der ChainedFontFactory zurückgegeben. Die verbleibenden Instanzen werden nicht mehr befragt.

Da die FontFactory, die für einen Ladevorgang registriert ist, zwingend einen validen Font zurückgeben muss, sollte dies durch die übergebenen Instanzen sichergestellt werden. Die ChainedFontFactory selbst nimmt keine Validierung vor. Dies bedeutet, dass die angefragten Instanzen null zurückgeben dürfen um damit zu signalisieren, dass weitere Instanzen befragt werden sollen. Die letzte FontFactory muss jedoch zwingend einen Font zurückgeben damit das Gesamtergebnis nicht null wird. Im Beispiel kommt die BasicFontFactory zum Einsatz, die unabhängig von der Anfrage stets einen Fallback-Font zurückliefert.

FontManagerFuture fontManagerFuture = …;
FontFactory fontFactory = new ChainedFontFactory(
    new FuzzyStandard14FontFactory(fontManagerFuture),
    new FuzzyStyleFontFactory(fontManagerFuture),
    new BasicFontFactory()                                                     
);

Zur Entwicklungszeit und im Fehlerfall ist es hilfreich, Informationen darüber zu erhalten, welche Entscheidungen im Font-Auswahlprozess getroffen werden. Insbesondere wenn eine ChainedFontFactory zum Einsatz kommt, steigt die Gesamtkomplexität durch das Zusammenspiel der verschiedenen Klassen. Das Beispiel zeigt, wie Log-Ausgaben bei Bedarf angefordert werden können. Falls kein Logging aktiviert ist, wird der Logging-Code nie durchlaufen und es entsteht somit kein unnötiger Mehraufwand.

FontFactory fontFactory = …;

Logger logger = LoggerFactory.getLogger(getClass());
if (logger.isDebugEnabled()) {
  fontFactory = new ActivateLoggingFontFactory(fontFactory, logger);           
}

Ähnlich wie im vorhergehenden Beispiel werden auch hier Log-Meldungen generiert. Zusätzlich wird die Möglichkeit genutzt, das Ziel der Log-Strings selbst zu bestimmen. Es muss nicht zwingend ein Logger verwendet werden. Stattdessen kommt hier der Standard Error Stream zum Einsatz. Auch Logging in eine Datenbank oder ein anderes entferntes System wäre möglich. Da der Code während des Ladevorgangs ausgeführt wird, muss dafür gesorgt werden, dass möglichst wenig Zeit investiert wird. Langlaufende Operationen, wie beispielsweise eine Netzwerk-Kommunikation, müssen auf einen anderen Thread ausgelagert werden.

FontFactory fontFactory = …;

LogSink systemErrLogSink = new LogSink() {                                     
  @Override
  public void log(String logMessage) {
    System.err.println(logMessage);
  }
};

String loggingFontFactoryID = "My Logging Font Factory";                       
final ActivateLoggingFontFactory activateLoggingFontFactory = 
    new ActivateLoggingFontFactory(fontFactory, 
        systemErrLogSink, 
        loggingFontFactoryID);

Das Beispiel zeigt, wie eine FontFactory für alle folgenden Lesevorgänge einer Reader-Instanz gesetzt werden kann. Für andere Reader-Instanzen muss die unabhängig davon erneut erfolgen.

FontFactory fontFactory = …;

Reader reader = …;
FontFactoryReaderSettings settings = 
    reader.getSettings(FontFactoryReaderSettings.class);
settings.setFontFactory(fontFactory);

reader.read(…);

Um nicht jede Reader-Instanz einzeln konfigurieren zu müssen, existiert ein allgemeingültiger Konfigurationsweg. Dazu wird ein ComponentConfigurer definiert, der vor der ersten Erzeugung einer Reader-Instanz registriert sein muss. Die Registrierung erfolgt global über die Methoden der Klasse Jadice. Als JUnit Test formuliert zeigt das Beispiel, dass der ComponentConfigurer für jede Instanz von FontFactoryReaderSettings, die über die Methoden der Klasse Jadice erzeugt wird, ausgeführt wird. Da der Reader seine Settings-Objekte auf diesem Weg erzeugt, ist die FontFactory-Instanz für jeden Lesevorgang gesetzt.

@Test
public void testThat_configurer_configuresFontFactoryReaderSettings() {
  final FontFactory fontFactory = new BasicFontFactory();

  ComponentConfigurer<FontFactoryReaderSettings> configurer =
      new ComponentConfigurer<FontFactoryReaderSettings>() {
        @Override
        public void configure(FontFactoryReaderSettings settings) {
          settings.setFontFactory(fontFactory);
        }
      };                                                                       

  Jadice.registerComponentConfigurer(configurer, 
      FontFactoryReaderSettings.class);                                        
  
  FontFactoryReaderSettings settings1 = 
      Jadice.create(FontFactoryReaderSettings.class);
  assertThat(settings1.getFontFactory(), is(sameInstance(fontFactory)));
  
  Reader reader = new Reader();
  FontFactoryReaderSettings settings2 = 
      reader.getSettings(FontFactoryReaderSettings.class);
  assertThat(settings2.getFontFactory(), is(sameInstance(fontFactory)));
}

Eine beispielhafte Komplett-Konfiguration für das Laden von Fonts wird in den Klassen FontEnvironments SwingFontEnvironments bereitgestellt.

Für die Integration des Konfigurationsbeispiels genügt ein Aufruf der Konfiguration zu Beginn der Anwendung:

FontEnvironments.configureFontEnvironment();

Sollten zudem noch GUI-Komponenten verwendet werden kann man die Beispielkonfiguration wie folgt übernehmen:

SwingFontEnvironments.configureFontEnvironment();