Minifier-plugin 25.11

Openen in ChatGPT

De webforJ Minifier Plugin minimaliseert automatisch minifies en optimaliseert CSS- en JavaScript-assets tijdens het bouwproces. De plugin ontdekt assets die worden verwezen via webforJ asset-annotaties en minimaliseert ze in de bouwuitvoer, waardoor bestandsformaten worden verkleind en laadtijden worden verbeterd zonder uw oorspronkelijke bronbestanden te wijzigen.

Minificatie is ingebouwd in de bundler

De frontend-bundler minimaliseert CSS en JavaScript als onderdeel van de productie-build, zodat een project dat de bundler gebruikt deze plugin niet nodig heeft. De plugin blijft beschikbaar en ondersteund voor projecten die assets laden via de asset-annotaties zonder de bundler. Bestaande setups blijven werken zoals voorheen, zonder dat er wijzigingen nodig zijn.

Configuratie

Als u uw project hebt gemaakt met startforJ of een webforJ archetype, is de minifier-plugin al geconfigureerd en draait deze automatisch wanneer u bouwt met het prod profiel met mvn package -Pprod.

Voor handmatige configuratie vereist de minifier twee configuraties: een annotatieprocessor om assets tijdens de compilatie te ontdekken, en een plugin om de minificatie uit te voeren.

Maven
Gradle

Voeg het volgende toe aan uw pom.xml:

<build>
  <plugins>
    <!-- Configuratie van de annotatieprocessor -->
    <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>

    <!-- Configuratie van de minifier-plugin -->
    <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-minificatie -->
        <dependency>
          <groupId>com.webforj</groupId>
          <artifactId>webforj-minify-phcss-css</artifactId>
          <version>${webforj.version}</version>
        </dependency>
        <!-- JavaScript-minificatie -->
        <dependency>
          <groupId>com.webforj</groupId>
          <artifactId>webforj-minify-closure-js</artifactId>
          <version>${webforj.version}</version>
        </dependency>
      </dependencies>
    </plugin>
  </plugins>
</build>

Voeg het volgende toe aan uw build.gradle:

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

plugins {
  id 'java'
}

apply plugin: 'com.webforj.minify'

dependencies {
  // Annotatieprocessor voor het ontdekken van assets tijdens de compilatie
  annotationProcessor "com.webforj:webforj-minify-foundation:${webforjVersion}"

  // Implementaties van de minifier
  add "webforjMinifier", "com.webforj:webforj-minify-phcss-css:${webforjVersion}"
  add "webforjMinifier", "com.webforj:webforj-minify-closure-js:${webforjVersion}"
}

De minify taak draait automatisch vóór de jar of war taken. U kunt deze ook handmatig uitvoeren met ./gradlew minify.

De plugin gebruiken

Zodra geconfigureerd, werkt de plugin automatisch. Gebruik eenvoudig webforJ-assetannotaties in uw 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 {
  // Uw applicatiecode
}

Wanneer u uw project bouwt, minimaliseert de plugin automatisch:

Ontdekt assets die in annotaties tijdens de compilatie zijn verwezen
Minimaliseert de ontdekte CSS- en JavaScript-bestanden
Rapporteert de grootte-reductie en verwerkingstijd

URL-protocolresolutie

De plugin begrijpt webforJ URL-protocollen en lost ze op naar bestandspaden:

Protocol	Lost op	Voorbeeld
`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 zonder een protocol worden niet ondersteund door de minifier en worden overgeslagen.

Ingebouwde minifiers

webforJ bevat twee productieklaar minifiers voor CSS en JavaScript.

Minifier	Kenmerken	Overgeslagen
CSS	Verwijdert witruimtes, opmerkingen en optimaliseert eigenschapswaarden	`.min.css`
JavaScript	Hernoemen van variabelen, eliminatie van dode code, syntaxisoptimalisatie	`.min.js`, `.min.mjs`

Configuratie-opties

De plugin biedt opties om minificatie uit te schakelen, JavaScript-optimalisatie aan te passen en aanvullende bestanden te verwerken.

Minificatie uitschakelen

U wilt mogelijk de minificatie uitschakelen tijdens ontwikkeling of voor debugdoeleinden.

Maven
Gradle

Via de opdrachtregel:

mvn package -Dwebforj.minify.skip=true

Via pluginconfiguratie:

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

Via bouwconfiguratie:

webforjMinify {
  skip = true
}

Opties voor JavaScript-minifier

De JavaScript-minifier biedt verschillende configuratieopties om het optimalisatiegedrag te regelen.

Gradle-ondersteuning

Vanaf v25.12 ondersteunt de Gradle-plugin het doorgeven van opties voor de JavaScript-minifier.

Optie	Standaard	Beschrijving
`compilationLevel`	`SIMPLE_OPTIMIZATIONS`	`WHITESPACE_ONLY` - verwijdert alleen witruimtes en opmerkingen `SIMPLE_OPTIMIZATIONS` - hernoemen van variabelen en eliminatie van dode code `ADVANCED_OPTIMIZATIONS` - agressieve optimalisatie met hernoeming van functies/eigenschappen
`languageIn`	`ECMASCRIPT_NEXT`	Ingang JavaScript-versie: `ECMASCRIPT3`, `ECMASCRIPT5`, `ECMASCRIPT_2015` tot `ECMASCRIPT_2021`, `ECMASCRIPT_NEXT`
`languageOut`	`ECMASCRIPT5`	Uitvoer JavaScript-versie: hetzelfde als `languageIn`, plus `NO_TRANSPILE`
`prettyPrint`	`false`	Stel in op `true` om de opmaak voor debuggen te behouden

Configureer deze opties in het configuratiegedeelte:

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  // Stel in op true om minificatie over te slaan
    minifierConfigurations.put("closureJs", [
      compilationLevel: "SIMPLE_OPTIMIZATIONS",
      languageIn: "ECMASCRIPT_NEXT",
      languageOut: "ECMASCRIPT5"
    ])
}

Aanvullende bestanden minificeren

Om bestanden te minimaliseren die niet ontdekt zijn via annotaties, maakt u een configuratiebestand aan dat glob-patronen specificeert:

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

# Uitsluitingspatronen (prefix met !)
!**/*.min.css
!**/*.min.js

Aangepaste minifiers

De plugin ondersteunt aangepaste minifiers via de Java's Service Provider Interface (SPI), waarmee u ondersteuning kunt toevoegen voor aanvullende bestandstypen of alternatieve minificatiebibliotheken.

Een aangepaste minifier maken

Implementeer de AssetMinifier interface om uw eigen minifier te maken. Het volgende voorbeeld toont een JSON-minifier die Gson gebruikt om witruimtes te verwijderen:

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("Ongeldige JSON in " + sourceFile + ", overgeslagen: " + e.getMessage());
      return content;
    } catch (Exception e) {
      throw new MinificationException("Failed to minify JSON file: " + sourceFile, e);
    }
  }

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

  @Override
  public boolean shouldMinify(Path filePath) {
    String filename = filePath.getFileName().toString();
    // Sla configuratiebestanden en al geminimaliseerde bestanden over
    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) {
    // Configuratieopties indien nodig
  }
}

Uw minifier registreren

Maak een configuratiebestand voor de serviceprovider aan:

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

Gebruik uw aangepaste minifier

Verpak uw minifier als een aparte JAR en voeg deze toe als een plugin-afhankelijkheid:

<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>
    <!-- Standaard minifiers (optioneel) -->
    <dependency>
      <groupId>com.webforj</groupId>
      <artifactId>webforj-minify-phcss-css</artifactId>
      <version>${webforj.version}</version>
    </dependency>
  </dependencies>
</plugin>

Veelvoorkomende problemen

Geen minifiers geregistreerd

[WARN] Geen minifiers geregistreerd via SPI. Minificatie wordt overgeslagen.
[WARN] Zorg ervoor dat ph-css en/of closure-compiler op het classpath staan.

Voeg minifier-moduulafhankelijkheden toe aan de pluginconfiguratie. Voor CSS, voeg webforj-minify-phcss-css toe. Voor JavaScript, voeg webforj-minify-closure-js toe.

Geen bestanden verwerkt

Als de plugin rapporteert 0 bestanden verwerkt, controleer dan of:

De annotatieprocessor is geconfigureerd in maven-compiler-plugin met webforj-minify-foundation in annotationProcessorPaths
webforJ-assetannotaties bestaan in uw broncode
target/classes/META-INF/webforj-resources.json bestaat na compilatie

Bestand niet gevonden

[WARN] Bestand niet gevonden: /path/to/static/css/app.css (verwezen als 'ws://css/app.css')

Controleer of het bestand zich op het juiste pad bevindt onder src/main/resources/static en of het URL-protocol overeenkomt met de directorystructuur.

Minificatiefouten

[WARN] Fout bij minificatie van bestand /path/to/app.css: parse-fout op regel 42

De plugin waarschuwt maar gaat door zonder de build te laten falen. De oorspronkelijke inhoud blijft behouden wanneer minificatie faalt. Om syntaxisfouten te verhelpen, valideert u CSS of JavaScript met een linter.

Configuratie​

De plugin gebruiken​

URL-protocolresolutie​

Ingebouwde minifiers​

Configuratie-opties​

Minificatie uitschakelen​

Opties voor JavaScript-minifier​

Aanvullende bestanden minificeren​

Aangepaste minifiers​

Een aangepaste minifier maken​

Uw minifier registreren​

Gebruik uw aangepaste minifier​

Veelvoorkomende problemen​