Compilando y ejecutando Java sin un IDE

En un momento en reddit.com , en el tema Compilación y ejecución de Java sin un IDE , se hizo la pregunta: ¿Existe un comando que compila un grupo de archivos Java que están dentro de un paquete en una carpeta separada (llamémoslo bin )? ¿Y cómo haría para iniciar nuevos archivos de clase? " El autor del tema, kylolink , explica: "Cuando comencé a usar Java, confié en Eclipse para hacer toda la compilación por mí y solo me preocupaba escribir el código". He visto esta pregunta muchas veces y, de hecho, esta es lo que me impulsó a publicar en el blog Sistemas GPS e IDE: ¿buenos o malos? Me encantan los IDE de Java modernos y potentes y me hacen la vida más fácil a diario, pero también tiene ventajas saber cómo crear y ejecutar ejemplos sencillos de Java sin ellos. Esta publicación trata sobre cómo hacer precisamente eso. En mi blog sobre cómo aprender Java con pruebas simples, escribí sobre cómo a veces me gusta usar un editor de texto simple y herramientas de línea de comandos para escribir, construir y ejecutar aplicaciones simples. Ahora tengo una idea bastante clara de cuánto "gastos generales" requieren mis IDE de Java favoritos y tomar una decisión temprana sobre si los beneficios logrados al usar el marco son suficientes para justificar los "gastos generales". En la mayoría de las aplicaciones reales, no hay duda de que VL IDE vale mucho. Sin embargo, para las aplicaciones de ejemplo más simples, este no es siempre el caso. El resto de esta publicación muestra cómo compilar y ejecutar código Java sin un IDE para estas situaciones.

Escribir y ejecutar código Java

Para que el ejemplo sea más claro, usaré algunas clases Java muy simples que están relacionadas entre sí mediante composición o herencia y están en el mismo paquete llamado Dustin.examples . A dos clases les falta una función main; la tercera clase, Main.java, tiene una función mainque le permite demostrar cómo ejecutar la clase sin un IDE. A continuación se muestra el código para estas tres clases: Parent.java

package dustin.examples;

public class Parent
{
   @Override
   public String toString()
   {
      return "I'm the Parent.";
   }
}

niño.java

package dustin.examples;

public class Child extends Parent
{
   @Override
   public String toString()
   {
      return "I'm the Child.";
   }
}

principal.java

package dustin.examples;

import static java.lang.System.out;

public class Main
{
   private final Parent parent = new Parent();
   private final Child child = new Child();

   public static void main(final String[] arguments)
   {
      final Main instance = new Main();
      out.println(instance.parent);
      out.println(instance.child);
   }
}

La siguiente captura de pantalla muestra la estructura de directorios con estas clases .java . La captura de pantalla muestra que los archivos fuente están en la jerarquía de directorios que representan el nombre del paquete ( dustin/examples , porque la información del paquete es Dustin.examples ) y que este paquete refleja el directorio. La jerarquía se encuentra en el subdirectorio SRC. También creé un subdirectorio de clases (que actualmente está vacío) para albergar los archivos .class compilados para que Javac no cree este directorio cuando no exista.

Construyendo con JAVAC y ejecutando con Java

No importa qué enfoque se utilice para crear código Java (Ant, Maven, Gradle o IDE), en última instancia, todo se reduce a JAVAC. Las opciones estándar en la herramienta de línea de comandos JAVAC proporcionada por Oracle/Sun se pueden ver ejecutando JAVAC -help y se pueden ver opciones de extensión adicionales ejecutando JAVAC -help -X. Puede encontrar más información sobre cómo utilizar estas opciones en la documentación de la herramienta JAVAC para Windows o Unix/Linux. Como dice la documentación de Javac, la opción -sourcepath se puede utilizar para expresar el directorio en el que existen los archivos fuente. En la estructura de mi directorio que se muestra en la captura de pantalla anterior, esto significa que, suponiendo que estoy ejecutando el comando JAVAC desde el directorio C:\Java\examples\javacAndJava\ , tendría que tener algo como esto en mi comando: Javac -sourcepath src SRC\Dustin\ejemplos\*. Java . La siguiente captura de pantalla muestra los resultados de esto. Debido a que no especificamos un directorio para los archivos .class , se colocaron de forma predeterminada en el mismo directorio que los archivos .java de origen a partir de los cuales fueron compuestos. Podemos utilizar la opción -dpara solucionar esta situación. Nuestro comando se puede ejecutar ahora, por ejemplo, como Javac -sourcepath src -d clases src\Dustin\examples\*. Yo tú . Como se señaló anteriormente, la carpeta seleccionada (clases) ya debe existir. Cuando esto sucede, el comando colocará los archivos .class en la carpeta especificada como se muestra en la siguiente captura de pantalla. Con los archivos fuente de Java compilados en los archivos .class correspondientes en el directorio especificado, podemos iniciar la aplicación usando el menú de inicio rápido del Herramienta de línea de comandos de Java. Esto simplemente se hace siguiendo las instrucciones proporcionadas en las páginas de ayuda de Java o de herramientas de Java y especificando la ubicación de los archivos .class con la opción -classpath( o -cp). En la siguiente captura de pantalla se demuestra el uso de ambos enfoques para especificar el directorio de clases donde buscar archivos .class . El último argumento es el nombre completo (paquete Java completo) de la clase que tiene la función principal a ejecutar. Los comandos que se muestran en la siguiente captura de pantalla son clases de Java -cp Dustin.examples.Main y clases de Java -classpath Dustin.examples.Main.

Construyendo y ejecutando con Ant

Para las aplicaciones Java más simples, es bastante fácil usar JAVAC y Java para crear y ejecutar la aplicación, respectivamente, como se acaba de demostrar. A medida que las aplicaciones se vuelven un poco más complejas (por ejemplo, código existente en más de un paquete/directorio o clases de dependencia más complejas en bibliotecas y marcos de terceros), este enfoque puede volverse difícil de manejar. Apache Ant es la más antigua de las "tres grandes" herramientas de compilación de Java y se ha utilizado en miles de aplicaciones e implementaciones. Como dije en una publicación de blog anterior, un archivo de compilación Ant muy simple es fácil de crear, especialmente si comienza con una plantilla como la que describí en esta publicación. La siguiente lista de códigos es para el archivo build.xml de Ant , que se puede usar para componer archivos .java en archivos .class y luego ejecutar la clase Dustin.examples.Main como se hizo anteriormente con JAVAC y Java. construir.xml

<?xml version="1.0" encoding="UTF-8"?>
<project name="BuildingSansIDE" default="run" basedir=".">
   <description>Building Simple Java Applications Without An IDE</description>

   <target name="compile"
           description="Compile the Java code.">
      <javac srcdir="src"
             destdir="classes"
             debug="true"
      includeantruntime="false" />
   </target>

   <target name="run" depends="compile"
           description="Run the Java application.">
      <java classname="dustin.examples.Main" fork="true">
         <classpath>
           <pathelement path="classes"/>
         </classpath>
      </java>
   </target>
</project>

No utilicé las propiedades Ant y no incluí los objetivos comunes que normalmente incluyo (como "puro" y "Javadoc") para mantener este ejemplo lo más simple posible y mantenerlo cerca del ejemplo anterior usando JAVAC y Java. . Tenga en cuenta también que he habilitado la "depuración" establecida en "verdadero" para la tarea JAVAC Ant porque esto no es cierto en caso de falla de Ant, pero sí lo es con el valor predeterminado de JAVAC. No es sorprendente que la tarea Javac y la tarea Java Ant se parezcan a las herramientas de comando JAVAC y Java. Porque utilicé el nombre predeterminado Ant espera un archivo de compilación cuando no se especifica explícitamente (build.xml) y porque proporcioné el objetivo "Ejecutar" como el "predeterminado" para esta compilación y porque incluí "compilar" como una ejecución de dependencia. el objetivo "Ejecutar" y debido a que Ant estaba en la ruta de mi entorno, todo lo que tenía que hacer en la línea de comando era hacer que Ant compilara y ejecutara el ejemplo de ant en el directorio con el archivo build.xml . Esto se muestra en la siguiente captura de pantalla. Aunque he demostrado cómo compilar y ejecutar una aplicación Java simple con Ant, tiendo a compilar solo con Ant y ejecutar con Java (o un script que llama a Java si el classpath es pesado).

Construyendo y ejecutando con Maven

Aunque Ant fue la primera herramienta central de compilación de Java, Apache Maven finalmente ganó su fama en gran parte debido a su adopción de configuración basada en convenciones y soporte para repositorios de bibliotecas compartidas. Maven es fácil de usar cuando el código y los objetos generados siguen su diseño de directorio estándar. Desafortunadamente, mi ejemplo no sigue esta estructura de directorios, pero Maven nos permite anular la estructura de directorios predeterminada esperada. La siguiente lista es el código para un archivo POM de Maven que se usa en lugar de los directorios de origen y de destino y proporciona los otros elementos mínimos requeridos para una compilación de Maven usando Maven 3.2.1. pom.xml

<project>
   <modelVersion>4.0.0</modelVersion>
   <groupId>dustin.examples</groupId>
   <artifactId>CompilingAndRunningWithoutIDE</artifactId>
   <version>1</version>

   <build>
      <defaultGoal>compile</defaultGoal>
      <sourceDirectory>src</sourceDirectory>
      <outputDirectory>classes</outputDirectory>
      <finalName>${project.artifactId}-${project.version}</finalName>
   </build>
</project>

Dado que el archivo pom.xml anterior define el "objetivo predeterminado" de "compilar" y porque los archivos pom.xml son el POM personalizado predeterminado que busca el ejecutable de Maven (MVN) y porque el directorio bin de instalación de Maven está en mi ruta, solo Necesito ejecutar "MVN" para compilar archivos .class como se menciona en la siguiente captura de pantalla. También puedo ejecutar la aplicación compilada desde Maven usando el comando Mvn Exec: Java -Dexec.mainClass = Dustin.examples.Main , que se observa en la siguiente captura de pantalla. Al igual que con Ant, tiendo a no usar Maven para ejecutar mi aplicación Java simple, sino que uso Java en código compilado (o uso un script que llama a Java directamente en clases largas).

Construyendo y ejecutando con Gradle

Gradle es la más nueva, moderna y elegante de las tres principales herramientas de compilación de Java. A veces soy escéptico sobre la esencia de lo que está de moda, pero he encontrado muchas cosas que me gustan de Gradle (escrito en Groovy en lugar de XML, soporte Ant integrado, soporte Ivy integrado, configuración por convención que es fácil). para reconfigurar, soporte del repositorio Maven, etc.). El siguiente ejemplo muestra una compilación de Gradle que se puede usar para compilar y ejecutar una aplicación simple, que es el código de muestra principal de esta publicación. Presenté este ejemplo adaptado en el blog Personalización simple del complemento Java de Gradle. construir.gradle

apply plugin: 'java'
apply plugin: 'application'

// Redefine where Gradle should expect Java source files (*.java)
sourceSets {
    main {
        java {
            srcDirs 'src'
        }
    }
}

// Redefine where .class files are written
sourceSets.main.output.classesDir = file("classes")

// Specify main class to be executed
mainClassName = "dustin.examples.Main"

defaultTasks 'compileJava', 'run'

Las primeras dos líneas del archivo build.gradle indican el uso del complemento Java y el complemento de la aplicación, lo que da como resultado que se incorpore automáticamente una gran cantidad de funciones a esta compilación. La definición de "sourceSets" y "sourceSets.main.output.classesDir" le permite anular los directorios Java predeterminados del complemento Gradle para el código fuente Java y las clases binarias compiladas, respectivamente. "MainClassName" le permite especificar explícitamente qué clase debe ejecutarse dentro del Complemento de aplicación. La línea "defaultTasks" define las tareas que se ejecutarán simplemente escribiendo "Gradle" en la línea de comando: 'compileJava' es la tarea predeterminada proporcionada por el complemento de Java y 'Ejecutar' es la tarea predeterminada proporcionada por el complemento de aplicación. Debido a que nombré a los ensamblados build.gradle y es por eso que especifiqué las tareas predeterminadas como 'compileJava' y 'Ejecutar' y debido a que tengo el directorio bin de instalación de Gradle en mi ruta, todo lo que tuve que hacer para compilar y ejecutar los ejemplos fue escribir 'Gradle' y esto se demuestra en la siguiente captura de pantalla. Incluso el más escéptico debe admitir que las compilaciones de Gradle son muy resbaladizas para este simple ejemplo. Combina la concisión de confiar en ciertas convenciones y suposiciones con un mecanismo muy sencillo para anular los incumplimientos cuando sea necesario. ¡El hecho de que esté en Groovy en lugar de XML también es muy atractivo! Al igual que con Ant y Maven, tiendo a compilar solo con estas herramientas y tiendo a ejecutar archivos .class compilados directamente desde Java o un script que llama a Java. Por cierto, también tiendo a archivar estas clases .class en un jar para su lanzamiento, pero eso está más allá del alcance de este artículo.

Conclusión

Un IDE a menudo no es necesario para crear aplicaciones y ejemplos simples y puede ser incluso más costoso que crear ejemplos simples. En tal caso, es bastante fácil utilizar JAVAC y Java para crear y ejecutar directamente los ejemplos. Como ejemplos de cómo involucrarse más, una herramienta de construcción como Ant, Maven o Gradle se vuelve más atractiva. El hecho de que muchos entornos de desarrollo admitan estas utilidades de compilación significa que un desarrollador puede migrar al IDE utilizando una herramienta integrada creada anteriormente en el proceso si se determina que se necesita soporte IDE a medida que una aplicación simple se convierte en un proyecto completo. .