¿Qué es JBang? La guía completa de scripting en Java

Introducción

Java es un lenguaje muy potente, pero tradicionalmente no ha sido conocido por su rapidez en la creación de scripts o prototipos. La verbosidad y el código boilerplate han sido citados frecuentemente como razones por las que los desarrolladores recurren a Python, JavaScript, Bash u otros lenguajes para tareas de scripting.

JBang es una herramienta que cambia esta percepción, convirtiendo a Java en un ciudadano de primera clase en el mundo de los scripts. Creado por Max Andersen, JBang responde a una pregunta sencilla: ¿por qué escribir una utilidad Java rápida debería requerir más ceremonia que Python o Bash?

En esta guía completa, aprenderás qué es JBang, cómo se compara con las alternativas y cómo aprovechar todo su potencial en tu flujo de desarrollo.

¿Qué es JBang?

JBang es una herramienta de línea de comandos que transforma Java en un lenguaje de scripting, haciéndolo tan accesible como Python o el scripting de Shell. Permite a los desarrolladores crear, editar y ejecutar programas Java autocontenidos con una configuración mínima. No hay necesidad de configuración de proyecto ni archivos de compilación.

Al eliminar la necesidad de herramientas de compilación tradicionales como Maven o Gradle para scripts simples, JBang simplifica el desarrollo en Java, permitiendo la experimentación y la creación rápida de prototipos. Ya estés escribiendo un script rápido o prototipando una idea, JBang te permite trabajar con la sintaxis Java estándar mientras gestiona automáticamente las dependencias e incluso las versiones del JDK.

Con JBang puedes:

• Ejecutar código Java directamente desde archivos .java, URLs o incluso coordenadas Maven
• Gestionar dependencias inline usando directivas de comentarios simples (//DEPS) o anotaciones
• Soportar múltiples lenguajes incluyendo Java, Kotlin, Groovy, JShell y Markdown
• Crear ejecutables nativos usando GraalVM native-image
• Depurar y editar scripts sin problemas en IDEs populares como IntelliJ IDEA, VS Code y Eclipse
• Compartir scripts a través de la JBang App Store y catálogos

Su lema, "Desata el poder de Java", encapsula perfectamente su misión de hacer que Java sea más accesible para la creación de scripts y tareas sencillas.

JBang vs JShell vs Java Single-File

Java ofrece varias opciones para ejecutar código sin una configuración de proyecto completa. Entender las diferencias te ayuda a elegir la herramienta adecuada para tus necesidades.

JShell (Java 9+)

JShell es el REPL (Read-Eval-Print Loop) integrado de Java, introducido en Java 9. Aunque es útil para experimentación rápida, tiene limitaciones significativas para scripting:

• Manejo de errores deficiente: JShell ignora los errores de sintaxis y continúa la ejecución, devolviendo código de salida 0 independientemente de los fallos
• Paso de argumentos difícil: Pasar argumentos de línea de comandos a scripts de JShell requiere soluciones alternativas
• Sin gestión de dependencias: No puedes incluir fácilmente bibliotecas externas sin configuración manual del classpath

Programas Java de un solo archivo (JEP 330, Java 11+)

Java 11 introdujo JEP 330, permitiendo ejecutar archivos .java directamente sin compilación explícita:

java HelloWorld.java

Esto es más robusto que JShell. Los errores de sintaxis y las excepciones devuelven correctamente códigos de salida distintos de cero. Sin embargo, sigue sin tener gestión de dependencias; debes distribuir cualquier JAR requerido por separado.

JBang: La solución completa

JBang combina lo mejor de ambos enfoques mientras añade características poderosas que ninguno puede ofrecer:

Si necesitas gestión de dependencias, JBang es la mejor opción.

¿Por qué usar JBang?

Durante años, los desarrolladores de Java han carecido de una solución de scripting sencilla. JBang llena este vacío con características como:

• Facilidad de uso: Escribe un archivo .java independiente con un método main y ejecútalo inmediatamente
• Gestión automática de dependencias: Resuelve dependencias de Maven Central u otros repositorios con simples comentarios (ej., //DEPS ...)
• Multiplataforma: Funciona en Windows, macOS, Linux y AIX. Verdadero "Escribe una vez, ejecuta en cualquier lugar"
• Arranque del JDK: ¿No tienes Java instalado? JBang puede descargar e instalar el JDK necesario por ti
• Soporte para Java moderno: Usa características en vista previa, últimas versiones de Java y opciones de compilación
• Integración con frameworks: Compatible con Quarkus, Spring Boot, Micronaut y Apache Camel
• Listo para CI/CD: Ejecuta scripts JBang en GitHub Actions, GitLab CI o cualquier pipeline de CI/CD
• Compilación a imagen nativa: Crea ejecutables nativos independientes con GraalVM

Empezando con JBang

Vamos a instalar JBang y ponerlo en marcha en tu sistema.

Instalación

JBang ofrece múltiples métodos de instalación para diferentes plataformas:

Linux/macOS/AIX/WSL (bash):

curl -Ls https://sh.jbang.dev | bash -s - app setup

Windows PowerShell:

iex "& { $(iwr -useb https://ps.jbang.dev) } app setup"

Gestores de paquetes:

sdk install jbang

brew install jbangdev/tap/jbang

choco install jbang

scoop install jbang

Después de la instalación, verifica que JBang está correctamente instalado:

jbang --version

Escribiendo tu primer script

Vamos a crear un simple script "Hello, World!" usando JBang.

1. Inicializar el script

JBang proporciona una forma sencilla de crear un nuevo script:

jbang init HelloWorld.java

Esto crea un archivo llamado HelloWorld.java con una plantilla básica:

///usr/bin/env jbang "$0" "$@" ; exit $?

import static java.lang.System.*;

public class HelloWorld {

    public static void main(String... args) {
        out.println("Hello World");
    }
}

2. Ejecutar el script

Ejecuta el script con:

jbang HelloWorld.java

Deberías ver Hello World en tu terminal.

En sistemas tipo Unix, también puedes hacer el script ejecutable y ejecutarlo directamente:

chmod +x HelloWorld.java
./HelloWorld.java

La línea shebang (///usr/bin/env jbang "$0" "$@" ; exit $?) indica al sistema que use JBang para ejecutar el script.

Directivas de scripts JBang

Los scripts de JBang usan comentarios especiales (directivas) para configurar el comportamiento. Estos deben aparecer al principio del archivo, antes de cualquier código.

Gestión de dependencias

La directiva //DEPS añade dependencias Maven a tu script:

///usr/bin/env jbang "$0" "$@" ; exit $?

//DEPS info.picocli:picocli:4.7.6
//DEPS com.google.code.gson:gson:2.11.0

import picocli.CommandLine;
import com.google.gson.Gson;

public class WithDependencies {
    public static void main(String... args) {
        System.out.println("¡Dependencias cargadas con éxito!");
    }
}

JBang descarga automáticamente las dependencias desde Maven Central y las añade al classpath.

Repositorios personalizados

Usa //REPOS para añadir repositorios Maven personalizados:

//REPOS central,jitpack
//REPOS custom=https://repo.company.com/maven2
//DEPS com.github.user:repo:tag

Versión de Java

Especifica la versión de Java requerida con //JAVA:

//JAVA 21        // Versión exacta
//JAVA 17+       // Versión mínima (17 o superior)

JBang descarga automáticamente la versión del JDK requerida si no está disponible en tu sistema.

Características en vista previa

Habilita las características en vista previa para experimentar con las últimas capacidades de Java:

//JAVA 23+
//PREVIEW

void main() {
    System.out.println("¡Usando main simplificado con características preview!");
}

Referencia completa de directivas

Aquí tienes una tabla completa de todas las directivas JBang disponibles:

Soporte multilenguaje

JBang no está limitado a Java. También soporta múltiples lenguajes JVM.

Kotlin

Crea y ejecuta scripts de Kotlin:

jbang init -t hello.kt HelloKotlin.kt
jbang HelloKotlin.kt

Puedes controlar la versión de Kotlin:

//KOTLIN 2.0.21

fun main() {
    println("¡Hola desde Kotlin!")
}

Groovy

Crea scripts de Groovy:

jbang init -t hello.groovy HelloGroovy.groovy
jbang HelloGroovy.groovy

Especifica la versión de Groovy:

//GROOVY 4.0.24

println "¡Hola desde Groovy!"

Markdown

¡Incluso puedes "ejecutar" archivos Markdown! JBang extrae y ejecuta bloques de código Java o JShell:

jbang init -t readme.md README.md
jbang README.md

Esto es genial para documentación ejecutable y tutoriales.

Imágenes nativas con GraalVM

JBang puede compilar tus scripts a ejecutables nativos usando la herramienta native-image de GraalVM. Los binarios resultantes se inician en milisegundos, tienen menor huella de memoria y funcionan de forma independiente sin necesidad de una instalación de JVM.

Creando una imagen nativa

jbang --native HelloWorld.java

La primera ejecución compila la imagen nativa (lo cual toma más tiempo). Las ejecuciones posteriores usan el binario nativo en caché para un arranque instantáneo.

Personalizando la compilación nativa

Usa la directiva //NATIVE_OPTIONS para ajustes finos:

///usr/bin/env jbang "$0" "$@" ; exit $?

//NATIVE_OPTIONS --no-fallback -O2
//NATIVE_OPTIONS -H:+ReportExceptionStackTraces

public class NativeApp {
    public static void main(String... args) {
        System.out.println("¡Ejecutándose como binario nativo!");
    }
}

Requisitos previos para imágenes nativas

Necesitas GraalVM con native-image instalado:

# Instalar vía SDKMan
sdk install java 21.0.2-graalce
sdk use java 21.0.2-graalce

# O descargar desde graalvm.org e instalar native-image
gu install native-image

Las imágenes nativas son ideales para herramientas CLI, funciones serverless e imágenes de contenedores con tamaño mínimo.

Integración con IDEs

JBang se integra perfectamente con IDEs populares para una experiencia de desarrollo completa.

VS Code

Instala la extensión JBang para VS Code para resaltado de sintaxis, autocompletado de dependencias y soporte de depuración.

IntelliJ IDEA

El plugin JBang para IntelliJ proporciona soporte completo de IDE, incluyendo autocompletado de código para dependencias y configuraciones de ejecución.

Abriendo scripts en el IDE

Usa el comando edit para abrir cualquier script con soporte completo de IDE:

jbang edit HelloWorld.java

JBang crea un proyecto temporal con la configuración de classpath adecuada, dándote autocompletado de código, depuración y capacidades de refactorización.

JBang App Store y catálogos

JBang incluye un potente sistema para compartir y descubrir scripts.

La JBang App Store

La JBang App Store te permite descubrir y ejecutar scripts publicados por la comunidad:

# Ejecutar cowsay
jbang cowsay@jbangdev "¡Hola JBang!"

# Ejecutar JReleaser
jbang jreleaser@jreleaser

# Buscar en Maven Central
jbang gavsearch@jbangdev hibernate

Creando alias

Crea alias locales para scripts que uses frecuentemente:

jbang alias add --name hello https://github.com/jbangdev/jbang-examples/blob/HEAD/examples/helloworld.java
jbang hello

Archivos de catálogo

Comparte colecciones de scripts vía jbang-catalog.json:

{
  "aliases": {
    "hello": {
      "script-ref": "HelloWorld.java",
      "description": "Un simple script hello world"
    },
    "cli": {
      "script-ref": "MyCLI.java",
      "description": "Utilidad de línea de comandos"
    }
  }
}

Aloja este archivo en un repositorio Git, y otros pueden usar tus scripts:

jbang hello@user/repo

Instalando como comandos del sistema

Instala scripts JBang como comandos a nivel de sistema:

jbang app install hello.java
hello  # Ahora disponible como comando

Integración con frameworks

JBang funciona perfectamente con frameworks Java populares.

Quarkus

Crea una API REST de Quarkus en un solo archivo:

///usr/bin/env jbang "$0" "$@" ; exit $?

//DEPS io.quarkus.platform:quarkus-bom:3.17.7@pom
//DEPS io.quarkus:quarkus-rest

//JAVA 17+

//Q:CONFIG quarkus.http.port=8080

import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;

@Path("/hello")
public class QuarkusApp {

    @GET
    public String hello() {
        return "¡Hola desde Quarkus!";
    }
}

Ejecútalo:

jbang QuarkusApp.java
# Visita http://localhost:8080/hello

Apache Camel

Instala Camel JBang y ejecuta rutas de integración:

# Instalar CLI de Camel
jbang app install camel@apache/camel

# Ejecutar una ruta
camel run route.yaml

Ejemplo de ruta YAML:

- from:
    uri: "timer:tick?period=1000"
    steps:
      - set-body:
          constant: "¡Hola Camel!"
      - log: "${body}"

Picocli CLI

Crea aplicaciones de línea de comandos profesionales:

jbang init -t cli MyCLI.java

Esto genera un script con Picocli para análisis de argumentos, generación de ayuda y autocompletado de shell.

Integración con CI/CD

JBang es perfecto para scripts de automatización en pipelines de CI/CD.

GitHub Actions

Usa la JBang GitHub Action oficial:

name: Ejecutar Script JBang
on: [push]

jobs:
  jbang:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6

      - name: Ejecutar script JBang
        uses: jbangdev/jbang-action@v0.135.1
        with:
          script: myscript.java
          scriptargs: "arg1 arg2"

Docker

Ejecuta scripts JBang en contenedores:

docker run -v $(pwd):/scripts jbangdev/jbang-action /scripts/myscript.java

Exportando a Maven o Gradle

Cuando tu script crezca a un proyecto completo, expórtalo a un sistema de compilación tradicional:

Exportar a Gradle

jbang export gradle --group com.example --artifact myapp hello.java

Exportar a Maven

jbang export maven --group com.example --artifact myapp hello.java

JBang convierte tus directivas //DEPS a dependencias apropiadas en pom.xml o build.gradle.

Otros formatos de exportación

# Crear un fat JAR
jbang export fatjar hello.java

# Crear un paquete portable
jbang export portable hello.java

# Crear una imagen de runtime JLink
jbang export jlink hello.java

# Exportar a repositorio Maven
jbang export mavenrepo hello.java

Casos de uso reales

JBang sobresale en escenarios donde la configuración tradicional de Java es excesiva:

Automatización DevOps

Reemplaza scripts de shell complejos con Java type-safe:

///usr/bin/env jbang "$0" "$@" ; exit $?

//DEPS info.picocli:picocli:4.7.6
//DEPS org.zeroturnaround:zt-exec:1.12

import picocli.CommandLine;
import picocli.CommandLine.Command;
import org.zeroturnaround.exec.ProcessExecutor;

@Command(name = "deploy", description = "Desplegar blog")
public class deploy implements Runnable {

    @CommandLine.Option(names = {"-e", "--env"}, required = true)
    String environment;

    public void run() {
        System.out.println("Desplegando blog.marcnuri.com en " + environment);
        // Tu lógica de despliegue aquí
    }

    public static void main(String... args) {
        new CommandLine(new deploy()).execute(args);
    }
}

Prototipado rápido

Prueba bibliotecas sin crear un proyecto:

///usr/bin/env jbang "$0" "$@" ; exit $?

//DEPS com.squareup.okhttp3:okhttp-jvm:5.3.2

import okhttp3.*;

public class TestLibrary {
    public static void main(String... args) throws Exception {
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
            .url("https://blog.marcnuri.com")
            .build();
        try (Response response = client.newCall(request).execute()) {
            System.out.println(response.body().string());
        }
    }
}

Demos educativas

Comparte ejemplos ejecutables vía URLs:

jbang https://github.com/marcnuri-demo/blog-tutorials/blob/main/Demo.java

Los estudiantes pueden ejecutar ejemplos sin ninguna configuración.

Preguntas frecuentes

¿Necesito Java instalado para usar JBang?

¡No! JBang puede descargar y gestionar Java automáticamente por ti. Si Java no está instalado, JBang descarga la versión requerida en la primera ejecución.

¿Puedo usar JBang con mi proyecto Maven/Gradle existente?

JBang está diseñado para scripts independientes, pero puedes:

• Usar jbang export maven|gradle para convertir scripts a proyectos
• Usar los plugins de JBang para Maven/Gradle para ejecutar scripts desde proyectos existentes

¿Cuál es la diferencia entre JBang y JShell?

JBang ofrece gestión de dependencias, soporte multilenguaje, compilación a imagen nativa y manejo adecuado de errores. JShell está integrado pero limitado a exploración interactiva sin dependencias externas.

¿Puedo usar JBang en producción?

¡Absolutamente! JBang se usa en producción para herramientas CLI, scripts de automatización y microservicios. Para despliegues en producción, considera exportar a imágenes nativas o sistemas de compilación tradicionales.

¿Cómo depuro scripts de JBang?

Usa jbang edit para abrir tu script en un IDE con soporte completo de depuración, o ejecuta con jbang --debug script.java y conecta un depurador remoto.

¿Puedo usar repositorios Maven privados?

Sí, usa la directiva //REPOS para añadir repositorios privados:

//REPOS private=https://repo.company.com/maven2

Para autenticación, configura tu ~/.m2/settings.xml como lo harías para Maven.

Conclusión

JBang aporta la comodidad de los lenguajes de scripting a Java sin sacrificar nada de su potencia. Ya estés automatizando tareas DevOps, probando una nueva biblioteca, prototipando una idea o introduciendo Java a principiantes, JBang elimina la sobrecarga de configuración que históricamente ha hecho que Java parezca pesado para tareas rápidas.

Puntos clave:

• Cero configuración: Ejecuta archivos Java directamente sin configuración de proyecto
• Gestión de dependencias: Añade bibliotecas con simples comentarios //DEPS
• Multilenguaje: Soporte para Java, Kotlin, Groovy y más
• Imágenes nativas: Compila a ejecutables independientes con GraalVM
• Soporte de IDE: Experiencia de desarrollo completa en VS Code, IntelliJ y Eclipse
• Listo para CI/CD: GitHub Actions, Docker e integración con pipelines

¡Prueba JBang y descubre cómo puede agilizar tu flujo de desarrollo Java!

Recursos oficiales:

• Sitio web de JBang
• Documentación de JBang
• Repositorio GitHub de JBang
• JBang App Store