Minifier-Plugin 25.11

In ChatGPT öffnen

Das webforJ Minifier-Plugin minimiert automatisch Minifizierung und optimiert CSS- und JavaScript-Ressourcen während des Build-Prozesses. Das Plugin entdeckt Ressourcen, die über webforJ Asset-Annotationen referenziert werden, und minimiert sie im Build-Ausgang, wodurch die Dateigrößen reduziert und die Ladezeiten verbessert werden, ohne die ursprünglichen Quelldateien zu verändern.

Einrichtung

Wenn Sie Ihr Projekt mit startforJ oder einem webforJ Archetyp erstellt haben, ist das Minifier-Plugin bereits konfiguriert und wird automatisch ausgeführt, wenn Sie mit dem prod-Profil mit mvn package -Pprod bauen.

Für eine manuelle Einrichtung benötigt der Minifier zwei Konfigurationen: einen Annotation Processor, um Ressourcen während der Kompilierung zu entdecken, und ein Plugin, um die Minifizierung durchzuführen.

Maven
Gradle

Fügen Sie Folgendes zu Ihrer pom.xml hinzu:

<build>
  <plugins>
    <!-- Konfiguration des Annotation Processors -->
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <configuration>
        <annotationProcessorPaths>
          <path>
            <groupId>com.webforj</groupId>
            <artifactId>webforj-minify-foundation</artifactId>
            <version>${webforj.version}</version>
          </path>
        </annotationProcessorPaths>
      </configuration>
    </plugin>

    <!-- Konfiguration des Minifier-Plugins -->
    <plugin>
      <groupId>com.webforj</groupId>
      <artifactId>webforj-minify-maven-plugin</artifactId>
      <version>${webforj.version}</version>
      <executions>
        <execution>
          <goals>
            <goal>minify</goal>
          </goals>
        </execution>
      </executions>
      <dependencies>
        <!-- CSS-Minifizierung -->
        <dependency>
          <groupId>com.webforj</groupId>
          <artifactId>webforj-minify-phcss-css</artifactId>
          <version>${webforj.version}</version>
        </dependency>
        <!-- JavaScript-Minifizierung -->
        <dependency>
          <groupId>com.webforj</groupId>
          <artifactId>webforj-minify-closure-js</artifactId>
          <version>${webforj.version}</version>
        </dependency>
      </dependencies>
    </plugin>
  </plugins>
</build>

Fügen Sie Folgendes zu Ihrer build.gradle hinzu:

buildscript {
  repositories {
    mavenCentral()
  }
  dependencies {
    classpath "com.webforj:webforj-minify-gradle-plugin:${webforjVersion}"
  }
}

plugins {
  id 'java'
}

apply plugin: 'com.webforj.minify'

dependencies {
  // Annotation Processor zum Entdecken von Ressourcen während der Kompilierung
  annotationProcessor "com.webforj:webforj-minify-foundation:${webforjVersion}"

  // Minifier-Implementierungen
  add "webforjMinifier", "com.webforj:webforj-minify-phcss-css:${webforjVersion}"
  add "webforjMinifier", "com.webforj:webforj-minify-closure-js:${webforjVersion}"
}

Die minify-Aufgabe wird automatisch vor den jar- oder war-Aufgaben ausgeführt. Sie können sie auch manuell mit ./gradlew minify ausführen.

Verwendung des Plugins

Sobald es konfiguriert ist, funktioniert das Plugin automatisch. Verwenden Sie einfach die webforJ-Asset-Annotationen in Ihrem Code:

package com.example;

import com.webforj.annotation.StyleSheet;
import com.webforj.annotation.JavaScript;

@StyleSheet("ws://css/app.css")
@JavaScript("ws://js/app.js")
public class MyApp extends App {
  // Ihr Anwendungs-Code
}

Wenn Sie Ihr Projekt bauen, führt das Plugin automatisch die folgenden Schritte aus:

Entdeckt Ressourcen, die in Annotationen während der Kompilierung referenziert werden
Minifiziert die entdeckten CSS- und JavaScript-Dateien
Berichtet über die Größenreduzierung und die Verarbeitungszeit

URL-Protokollauflösung

Das Plugin versteht die webforJ URL-Protokolle und löst sie in Dateisystempfade auf:

Protokoll	Löst auf	Beispiel
`ws://`	`src/main/resources/static/`	`ws://css/app.css` → `static/css/app.css`
`context://`	`src/main/resources/`	`context://styles/app.css` → `styles/app.css`

URLs ohne Protokoll werden vom Minifier nicht unterstützt und werden übersprungen.

Eingebaute Minifier

webforJ enthält zwei produktionsbereite Minifier für CSS und JavaScript.

Minifier	Funktionen	Überspringt
CSS	Entfernt Whitespace, Kommentare und optimiert Attributwerte	`.min.css`
JavaScript	Umbenennung von Variablen, Eliminierung ungenutzten Codes, Syntaxoptimierung	`.min.js`, `.min.mjs`

Konfigurationsoptionen

Das Plugin bietet Optionen zum Deaktivieren der Minifizierung, Anpassen der JavaScript-Optimierung und Verarbeiten zusätzlicher Dateien.

Deaktivieren der Minifizierung

Möglicherweise möchten Sie die Minifizierung während der Entwicklung oder zu Debugging-Zwecken deaktivieren.

Maven
Gradle

Über die Befehlszeile:

mvn package -Dwebforj.minify.skip=true

Über die Plugin-Konfiguration:

<plugin>
  <groupId>com.webforj</groupId>
  <artifactId>webforj-minify-maven-plugin</artifactId>
  <configuration>
    <skip>true</skip>
  </configuration>
</plugin>

Über die Build-Konfiguration:

webforjMinify {
  skip = true
}

Optionen für den JavaScript-Minifier

Der JavaScript-Minifier bietet mehrere Konfigurationsoptionen, um das Optimierungsverhalten zu steuern.

Gradle Unterstützung

Ab v25.12 unterstützt das Gradle-Plugin das Übergeben von JavaScript-Minifier-Optionen.

Option	Standard	Beschreibung
`compilationLevel`	`SIMPLE_OPTIMIZATIONS`	`WHITESPACE_ONLY` - entfernt nur Whitespace und Kommentare `SIMPLE_OPTIMIZATIONS` - Umbenennung von Variablen und Eliminierung ungenutzten Codes `ADVANCED_OPTIMIZATIONS` - aggressive Optimierung mit Umbenennung von Funktionen/Eigenschaften
`languageIn`	`ECMASCRIPT_NEXT`	Eingangs-JavaScript-Version: `ECMASCRIPT3`, `ECMASCRIPT5`, `ECMASCRIPT_2015` bis `ECMASCRIPT_2021`, `ECMASCRIPT_NEXT`
`languageOut`	`ECMASCRIPT5`	Ausgabedatei-Version von JavaScript: dieselbe wie `languageIn`, plus `NO_TRANSPILE`
`prettyPrint`	`false`	Auf `true` setzen, um das Format für Debugging beizubehalten

Konfigurieren Sie diese Optionen im Konfigurationsbereich:

Maven
Gradle

<plugin>
  <groupId>com.webforj</groupId>
  <artifactId>webforj-minify-maven-plugin</artifactId>
  <version>${webforj.version}</version>
  <configuration>
    <minifierConfigurations>
      <closureJs>
        <compilationLevel>SIMPLE_OPTIMIZATIONS</compilationLevel>
        <languageIn>ECMASCRIPT_2020</languageIn>
        <languageOut>ECMASCRIPT5</languageOut>
        <prettyPrint>false</prettyPrint>
      </closureJs>
    </minifierConfigurations>
  </configuration>
  <executions>
    <execution>
      <goals>
        <goal>minify</goal>
      </goals>
    </execution>
  </executions>
  <dependencies>
    <dependency>
      <groupId>com.webforj</groupId>
      <artifactId>webforj-minify-closure-js</artifactId>
      <version>${webforj.version}</version>
    </dependency>
  </dependencies>
</plugin>

webforjMinify {
    skip = false  // Auf true setzen, um die Minifizierung zu überspringen
    minifierConfigurations.put("closureJs", [
      compilationLevel: "SIMPLE_OPTIMIZATIONS",
      languageIn: "ECMASCRIPT_NEXT",
      languageOut: "ECMASCRIPT5"
    ])
}

Minifizieren zusätzlicher Dateien

Um Dateien, die nicht durch Annotationen entdeckt wurden, zu minifizieren, erstellen Sie eine Konfigurationsdatei, die Glob-Muster angibt:

src/main/resources/META-INF/webforj-minify.txt
# Einschlussmuster
**/*.css
**/*.js

# Ausschlussmuster (mit ! prefix)
!**/*.min.css
!**/*.min.js

Benutzerdefinierte Minifier

Das Plugin unterstützt benutzerdefinierte Minifier über die Java Service Provider Interface (SPI), sodass Sie Unterstützung für zusätzliche Dateitypen oder alternative Minifizierungsbibliotheken hinzufügen können.

Erstellen eines benutzerdefinierten Minifiers

Implementieren Sie das AssetMinifier-Interface, um Ihren eigenen Minifier zu erstellen. Das folgende Beispiel zeigt einen JSON-Minifier, der Gson verwendet, um Whitespace zu entfernen:

src/main/java/com/example/minifier/JsonMinifier.java
package com.example.minifier;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonElement;
import com.google.gson.JsonSyntaxException;
import com.webforj.minify.common.AssetMinifier;
import com.webforj.minify.common.MinificationException;
import java.nio.file.Path;
import java.util.Map;
import java.util.Set;
import java.util.logging.Logger;

public class JsonMinifier implements AssetMinifier {

  private static final Logger logger = Logger.getLogger(JsonMinifier.class.getName());
  private final Gson gson = new GsonBuilder().create();

  @Override
  public String minify(String content, Path sourceFile) throws MinificationException {
    try {
      JsonElement element = gson.fromJson(content, JsonElement.class);
      return gson.toJson(element);
    } catch (JsonSyntaxException e) {
      logger.warning("Fehlerhaftes JSON in " + sourceFile + ", wird übersprungen: " + e.getMessage());
      return content;
    } catch (Exception e) {
      throw new MinificationException("Fehler beim Minifizieren der JSON-Datei: " + sourceFile, e);
    }
  }

  @Override
  public Set<String> getSupportedExtensions() {
    return Set.of("json");
  }

  @Override
  public boolean shouldMinify(Path filePath) {
    String filename = filePath.getFileName().toString();
    // Konfigurationsdateien und bereits minifizierte Dateien überspringen
    if (filename.equals("package.json") || filename.equals("tsconfig.json")) {
      return false;
    }
    if (filename.endsWith("-lock.json") || filename.endsWith(".min.json")) {
      return false;
    }
    return true;
  }

  @Override
  public void configure(Map<String, Object> options) {
    // Konfigurationsoptionen bei Bedarf
  }
}

Registrieren Ihres Minifiers

Erstellen Sie eine Service-Provider-Konfigurationsdatei:

src/main/resources/META-INF/services/com.webforj.minify.common.AssetMinifier
com.example.minifier.JsonMinifier

Verwendung Ihres benutzerdefinierten Minifiers

Verpacken Sie Ihren Minifier als separates JAR und fügen Sie ihn als Plugin-Abhängigkeit hinzu:

<plugin>
  <groupId>com.webforj</groupId>
  <artifactId>webforj-minify-maven-plugin</artifactId>
  <dependencies>
    <dependency>
      <groupId>com.example</groupId>
      <artifactId>json-minifier</artifactId>
      <version>1.0.0</version>
    </dependency>
    <!-- Standard-Minifier (optional) -->
    <dependency>
      <groupId>com.webforj</groupId>
      <artifactId>webforj-minify-phcss-css</artifactId>
      <version>${webforj.version}</version>
    </dependency>
  </dependencies>
</plugin>

Häufige Probleme

Keine Minifier registriert

[WARN] Keine Minifier über SPI registriert. Minifizierung wird übersprungen.
[WARN] Stellen Sie sicher, dass ph-css und/oder closure-compiler im Klassenpfad vorhanden sind.

Fügen Sie den Minifier-Modulabhängigkeiten zur Plugin-Konfiguration hinzu. Für CSS fügen Sie webforj-minify-phcss-css hinzu. Für JavaScript fügen Sie webforj-minify-closure-js hinzu.

Keine Dateien verarbeitet

Wenn das Plugin 0 Dateien verarbeitet meldet, überprüfen Sie, dass:

Der Annotation Processor im maven-compiler-plugin mit webforj-minify-foundation in annotationProcessorPaths konfiguriert ist
WebforJ-Asset-Annotationen in Ihrem Quellcode vorhanden sind
target/classes/META-INF/webforj-resources.json nach der Kompilierung vorhanden ist

Datei nicht gefunden

[WARN] Datei nicht gefunden: /path/to/static/css/app.css (referenziert als 'ws://css/app.css')

Stellen Sie sicher, dass die Datei im richtigen Pfad unter src/main/resources/static existiert und dass das URL-Protokoll mit der Verzeichnisstruktur übereinstimmt.

Minifizierungsfehler

[WARN] Fehler bei der Minifizierung der Datei /path/to/app.css: Analysefehler in Zeile 42

Das Plugin warnt, fährt aber fort, ohne den Build fehlschlagen zu lassen. Der ursprüngliche Inhalt bleibt erhalten, wenn die Minifizierung fehlschlägt. Um Syntaxfehler zu beheben, validieren Sie CSS oder JavaScript mit einem Linter.

Einrichtung​

Verwendung des Plugins​

URL-Protokollauflösung​

Eingebaute Minifier​

Konfigurationsoptionen​

Deaktivieren der Minifizierung​

Optionen für den JavaScript-Minifier​

Minifizieren zusätzlicher Dateien​

Benutzerdefinierte Minifier​

Erstellen eines benutzerdefinierten Minifiers​

Registrieren Ihres Minifiers​

Verwendung Ihres benutzerdefinierten Minifiers​

Häufige Probleme​