Complemento Minifier 25.11

Abrir en ChatGPT

El complemento Minifier de webforJ minifica y optimiza automáticamente los recursos CSS y JavaScript durante el proceso de compilación. El complemento detecta los recursos a los que se hace referencia mediante las anotaciones de recursos de webforJ y los minifica en el resultado de la compilación, lo que reduce el tamaño de los archivos y mejora los tiempos de carga sin modificar los archivos de origen.

La minificación está integrada en el empaquetador

El empaquetador de frontend minifica CSS y JavaScript como parte de su compilación de producción, por lo que los proyectos que utilizan el empaquetador no necesitan este complemento. El complemento sigue disponible y cuenta con soporte para los proyectos que cargan recursos mediante las anotaciones de recursos sin usar el empaquetador. Las configuraciones existentes siguen funcionando como antes, sin necesidad de hacer cambios.

Configuración

Para configurarlo, el minificador requiere dos elementos: un procesador de anotaciones para detectar recursos durante la compilación y un complemento que realice la minificación.

Maven

Añade lo siguiente a tu pom.xml:

<build>
  <plugins>
    <!-- Annotation Processor Configuration -->
    <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>

    <!-- Minifier Plugin Configuration -->
    <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 minification -->
        <dependency>
          <groupId>com.webforj</groupId>
          <artifactId>webforj-minify-phcss-css</artifactId>
          <version>${webforj.version}</version>
        </dependency>
        <!-- JavaScript minification -->
        <dependency>
          <groupId>com.webforj</groupId>
          <artifactId>webforj-minify-closure-js</artifactId>
          <version>${webforj.version}</version>
        </dependency>
      </dependencies>
    </plugin>
  </plugins>
</build>

Gradle

Añade lo siguiente a tu build.gradle:

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

plugins {
  id 'java'
}

apply plugin: 'com.webforj.minify'

dependencies {
  // Annotation processor for discovering assets during compilation
  annotationProcessor "com.webforj:webforj-minify-foundation:${webforjVersion}"

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

La tarea minify se ejecuta automáticamente antes de las tareas jar o war. También puedes ejecutarla manualmente con ./gradlew minify.

Uso del complemento

Una vez configurado, el complemento funciona automáticamente. Solo tienes que usar las anotaciones de recursos de webforJ en tu código:

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 {
  // Your application code
}

Al compilar el proyecto, el complemento automáticamente:

1. Detecta los recursos a los que se hace referencia en las anotaciones durante la compilación
2. Minifica los archivos CSS y JavaScript detectados
3. Informa de la reducción de tamaño y del tiempo de procesamiento

Resolución de protocolos de URL

El complemento reconoce los protocolos de URL de webforJ y los resuelve a rutas del sistema de archivos:

Protocolo	Se resuelve en	Ejemplo
ws://	src/main/resources/static/	ws://css/app.css → static/css/app.css
context://	src/main/resources/	context://styles/app.css → styles/app.css

El minificador no admite las URL sin protocolo y las omitirá.

Minificadores integrados

webforJ incluye dos minificadores listos para producción: uno para CSS y otro para JavaScript.

Minificador	Características	Omite
CSS	Elimina espacios en blanco y comentarios, y optimiza los valores de las propiedades	.min.css
JavaScript	Renombra variables, elimina código muerto y optimiza la sintaxis	.min.js, .min.mjs

Opciones de configuración

El complemento ofrece opciones para desactivar la minificación, personalizar la optimización de JavaScript y procesar archivos adicionales.

Desactivar la minificación

Quizá quieras desactivar la minificación durante el desarrollo o para depurar.

Maven

Mediante la línea de comandos:

mvn package -Dwebforj.minify.skip=true

Mediante la configuración del complemento:

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

Gradle

Mediante la configuración de compilación:

webforjMinify {
  skip = true
}

Opciones del minificador de JavaScript

El minificador de JavaScript ofrece varias opciones de configuración para controlar el comportamiento de optimización.

Compatibilidad con Gradle

A partir de v25.12, el complemento de Gradle permite pasar opciones al minificador de JavaScript.

Opción	Valor predeterminado	Descripción
compilationLevel	SIMPLE_OPTIMIZATIONS	WHITESPACE_ONLY - elimina solo los espacios en blanco y los comentarios SIMPLE_OPTIMIZATIONS - renombra variables y elimina código muerto ADVANCED_OPTIMIZATIONS - optimización intensiva con renombrado de funciones y propiedades
languageIn	ECMASCRIPT_NEXT	Versión de JavaScript de entrada: ECMASCRIPT3, ECMASCRIPT5, ECMASCRIPT_2015 hasta ECMASCRIPT_2021, ECMASCRIPT_NEXT
languageOut	ECMASCRIPT5	Versión de JavaScript de salida: las mismas que languageIn, más NO_TRANSPILE
prettyPrint	false	Establécelo en true para conservar el formato y facilitar la depuración

Configura estas opciones en la sección de configuración:

Maven

<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>

Gradle

webforjMinify {
    skip = false  // Set to true to skip minification
    minifierConfigurations.put("closureJs", [
      compilationLevel: "SIMPLE_OPTIMIZATIONS",
      languageIn: "ECMASCRIPT_NEXT",
      languageOut: "ECMASCRIPT5"
    ])
}

Minificar archivos adicionales

Para minificar archivos que no se detecten mediante anotaciones, crea un archivo de configuración con patrones glob:

src/main/resources/META-INF/webforj-minify.txt

# Include patterns
**/*.css
**/*.js

# Exclusion patterns (prefix with !)
!**/*.min.css
!**/*.min.js

Minificadores personalizados

El complemento admite minificadores personalizados mediante la interfaz SPI (Service Provider Interface) de Java, lo que te permite añadir compatibilidad con otros tipos de archivo o bibliotecas de minificación alternativas.

Crear un minificador personalizado

Implementa la interfaz AssetMinifier para crear tu propio minificador. El siguiente ejemplo muestra un minificador de JSON que usa Gson para eliminar los espacios en blanco:

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("Malformed JSON in " + sourceFile + ", skipping: " + 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();
    // Skip config files and already minified files
    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) {
    // Configuration options if needed
  }
}

Registrar el minificador

Crea un archivo de configuración del proveedor de servicios:

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

com.example.minifier.JsonMinifier

Usar tu minificador personalizado

Empaqueta el minificador en un JAR independiente y añádelo como dependencia del complemento:

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

Problemas comunes

No hay minificadores registrados

[WARN] No minifiers registered via SPI. Skipping minification.
[WARN] Ensure ph-css and/or closure-compiler are on the classpath.

Añade dependencias de los módulos de minificación a la configuración del complemento. Para CSS, añade webforj-minify-phcss-css. Para JavaScript, añade webforj-minify-closure-js.

No se procesaron archivos

Si el complemento informa Processed 0 files, verifica que:

1. El procesador de anotaciones esté configurado en maven-compiler-plugin con webforj-minify-foundation en annotationProcessorPaths
2. Haya anotaciones de recursos de webforJ en el código fuente
3. Exista target/classes/META-INF/webforj-resources.json después de la compilación

No se encontró el archivo

[WARN] File not found: /path/to/static/css/app.css (referenced as 'ws://css/app.css')

Verifica que el archivo exista en la ruta correcta dentro de src/main/resources/static y que el protocolo de URL coincida con la estructura de directorios.

Errores de minificación

[WARN] Error minifying file /path/to/app.css: parse error at line 42

El complemento muestra una advertencia, pero continúa sin interrumpir la compilación. Si la minificación falla, se conserva el contenido original. Para corregir errores de sintaxis, valida el CSS o JavaScript con un linter.

Sigue aprendiendo

ArtículoProduction build for a Java web app: smaller, cacheable assets