Esta guía lo guiará para construir un proyecto Java simple usando Maven.
¿Qué construirías?
Creará una aplicación que proporciona la hora del día y luego usará Maven para compilar.
Que necesitas
1. Aproximadamente 15 minutos
2. Editor de texto favorito o IDE
3. JDK 8 o superior
Cómo completar esta guía
Puede comenzar desde el principio y completar cada paso, o puede omitir los pasos básicos de configuración con los que ya está familiarizado. De cualquier manera, eventualmente puede usar el código de trabajo.
Establecer elementos
Primero, debe configurar un proyecto Java para que Maven lo construya. Para centrarse en Maven, el proyecto ahora se hace lo más simple posible. Cree esta estructura en la carpeta del proyecto que elija.
Crear una estructura de directorio
En el directorio del proyecto que elija, cree la siguiente estructura de subdirectorio; por ejemplo, ** mkdir -p src / main / java / hello en el sistema * nix **:
Construyendo proyectos Java usando Maven
En el directorio src / main / java / hello, puede crear cualquier clase de Java que necesite. Para ser coherente con el resto de esta guía, cree las dos clases siguientes: HelloWorld.java y Greeter.java.
src / main / java / hello / HelloWorld.java
.
paquete hola;
public class HelloWorld {
public static void main (String [] args) {
Greeter greeter = new Greeter ();
System.out.println (greeter.sayHello ());
}
}src / main / java / hello / Greeter.java
paquete hola;
public class Greeter {
public String sayHello () {
return "¡Hola mundo!";
}
}
Ahora que está listo para construir un proyecto usando Maven, el siguiente paso es instalar Maven.
Maven se puede descargar como un archivo zip desde https://maven.apache.org/download.cgi. Solo se requieren archivos binarios, así que busque enlaces a apache-maven- {versión} -bin.zip o apache-maven- {versión} -bin.tar.gz.
Después de descargar el archivo zip, extráigalo a su computadora. Luego agregue la carpeta bin a su ruta.
Para probar la instalación de Maven, ejecute mvn desde la línea de comandos:
mvn -v
Si todo va bien, debería recibir información sobre la instalación de Maven. Tiene un aspecto similar al siguiente (aunque puede ser ligeramente diferente):
Apache Maven 3.3.9 (bb52d8502b132ec0a5a3f4c09453c07478323dc5; 2015-11-10T16: 41: 47 + 00: 00)
Maven home: / home / dsyer / Programs / apache-maven
versión Java: 1.8.0_152, proveedor: Azul Systems, Inc.
Java inicio: /home/dsyer/.sdkman/candidates/java/8u152-zulu/jre Configuración
regional predeterminada: en_GB, codificación de plataforma: UTF-8
Nombre del sistema operativo: "linux", versión: "4.15.0-36-generic", arch : "amd64", familia: "unix"
Felicidades Ahora has instalado Maven.
Información: puede considerar usar [Maven Wrapper] (https://github.com/takari/maven-wrapper) para evitar que los desarrolladores tengan la versión correcta de Maven o la instalen por completo. Los proyectos descargados de [Spring Initializr] (https://start.spring.io/) incluyen envoltorios. Muestra mvnw en el nivel superior del proyecto en forma de script en lugar de mvn.
## Definir una compilación Maven simple
Ahora que Maven está instalado, debe crear una definición de proyecto Maven. El proyecto Maven se define usando un archivo XML llamado pom.xml. Entre otras cosas, el archivo proporciona el nombre del proyecto, la versión y sus dependencias en bibliotecas externas.
Cree un archivo llamado pom.xml en el directorio raíz del proyecto (es decir, colóquelo junto a la carpeta src) y proporcione lo siguiente:
pom.xml
.
<? xml version = "1.0" encoding = "UTF-8"?>
<project xmlns = "http://maven.apache.org/POM/4.0.0" xmlns: xsi = "http: //www.w3 .org / 2001 / XMLSchema-instance "
xsi: schemaLocation =" http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd ">
<modelVersion> 4.0.0 </modelVersion><groupId> org.springframework </groupId>
<artifactId> gs-maven </artifactId>
<packaging> jar </packaging>
<version> 0.1.0 </version><properties>
<maven.compiler.source> 1.8 </maven.compiler.source>
<maven.compiler.target> 1.8 </maven.compiler.target>
</properties><build>
<plugins>
<plugin>
<groupId> org.apache.maven.plugins </groupId>
<artifactId> maven-shade-plugin </artifactId>
<version> 2.1 </version>
<executions>
<execution>
< phase> package </phase>
<goals>
<goal> shade </goal>
</goals>
<configuration>
<transformers>
<transformer
implementación = "org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
<mainClass > hello.HelloWorld </mainClass>
</transformer>
</transformers>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
Además del elemento opcional <packaging>, este es el archivo pom.xml más simple necesario para construir un proyecto Java. Incluye información detallada sobre las siguientes configuraciones de proyecto:
- <modelVersion>. Versión del modelo POM (siempre 4.0.0).
- <groupId>. El grupo u organización a la que pertenece el proyecto. Generalmente se expresa como un nombre de dominio inverso.
- <artifactId>. El nombre del artefacto de la biblioteca que se le dará al proyecto (por ejemplo, el nombre de su archivo JAR o WAR).
- <versión>. La versión del proyecto que se está construyendo.
- <embalaje>. Cómo empaquetar el proyecto. Para el empaquetado de archivos JAR, el valor predeterminado es "jar". Use "war" para el empaquetado de archivos WAR.
En este punto, ha definido un proyecto Maven mínimo pero poderoso
Construyendo código Java
Maven ya está listo para construir el proyecto. Ahora puede usar Maven para realizar varios objetivos de ciclo de vida de compilación, incluido el objetivo de compilar código de proyecto, crear paquetes de biblioteca (como archivos JAR) e instalar la biblioteca en una biblioteca local dependiente de Maven.
Para intentar compilar, emita el siguiente comando en la línea de comando:
mvn compilar
Esto ejecutará Maven y le dirá que ejecute el objetivo de compilación. Cuando termine, debe encontrar el archivo compilado .class en el directorio target / classes.
Dado que es poco probable que desee distribuir o usar directamente archivos .class, es posible que deba ejecutar el destino del paquete:
paquete mvn
El objetivo de empaquetado compilará el código Java, ejecutará cualquier prueba y empaquetará el código a través del archivo JAR interno para completar el directorio de destino. El nombre del archivo JAR se basará en el <artifactId> y <version> del proyecto. Por ejemplo, dado el archivo pom.xml mínimo anterior, el archivo JAR se llamará gs-maven-0.1.0.jar.
Para ejecutar el archivo JAR, ejecute:
java -jar target / gs-maven-0.1.0.jar
Si cambia el valor <packaging> de "jar" a "war", el resultado será el archivo WAR en el directorio de destino en lugar del archivo JAR.
Maven también mantiene un repositorio de dependencias en la computadora local (generalmente en el directorio .m2 / repository en el directorio principal) para acceder rápidamente a las dependencias del proyecto. Si desea instalar el archivo JAR del proyecto en este repositorio local, debe llamar al destino de instalación:
instalar mvn
El objetivo de la instalación compilará, probará y empaquetará el código del proyecto, luego lo copiará a la biblioteca de dependencias local, listo para hacer referencia a él como una dependencia en otro proyecto.
Hablando de dependencias, es hora de declarar dependencias en la compilación Maven.
La declaración del
ejemplo simple Hello World es completamente independiente y no depende de ninguna otra biblioteca. Sin embargo, la mayoría de las aplicaciones dependen de bibliotecas externas para manejar funciones comunes y complejas.
Por ejemplo, suponga que además de decir "¡Hola, mundo!", Desea que la aplicación imprima la fecha y hora actuales. Aunque puede usar las herramientas de fecha y hora en la biblioteca nativa de Java, puede usar la biblioteca Joda Time para hacer las cosas más interesantes.
Primero, cambie HelloWorld.java de la siguiente manera:
src / main / java / hello / HelloWorld.java
.
paquete hola;
importar org.joda.time.LocalTime;
public class HelloWorld {
public static void main (String [] args) {
LocalTime currentTime = new LocalTime ();
System.out.println ("La hora local actual es:" + currentTime);
Greeter greeter = new Greeter ();
System.out.println (greeter.sayHello ());
}
}
Aquí HelloWorld utiliza la clase LocalTime de Joda Time para obtener e imprimir la hora actual.
Si ahora desea ejecutar mvn compile para compilar el proyecto, la compilación fallará porque no ha declarado Joda Time como una dependencia de compilación en la compilación. Puede resolver este problema agregando la siguiente línea a pom.xml (dentro del elemento <project>):
<dependencies>
<dependency>
<groupId> joda-time </groupId>
<artifactId> joda-time </artifactId>
<version> 2.9.2 </version>
</dependency>
</dependencies>
El bloque XML declara la lista de dependencias del proyecto. Específicamente, declara una dependencia para la biblioteca Joda Time. Dentro del elemento <dependency>, las coordenadas de dependencia están definidas por tres elementos secundarios:
- <groupId>: el grupo u organización a la que pertenece la dependencia.
- Biblioteca <artifactId> -required.
- <versión> - La versión específica requerida de la biblioteca.
De forma predeterminada, todas las dependencias se definen como dependencias de compilación. Es decir, deberían estar disponibles en el momento de la compilación (si está creando un archivo WAR, inclúyalo en la carpeta WAR / WEB-INF / libs). Además, puede especificar un elemento <scope> para especificar uno de los siguientes ámbitos:
proporcionado: las dependencias necesarias para compilar el código del proyecto, pero serán proporcionadas por el contenedor que ejecuta el código (como la API de Java Servlet) en tiempo de ejecución.
Las dependencias de prueba se utilizan para compilar y ejecutar pruebas, pero no son necesarias para construir o ejecutar el código de tiempo de ejecución del proyecto.
Ahora, si ejecuta mvn compile o mvn package, Maven debería resolver las dependencias de Joda Time desde el repositorio de Maven Central, y la compilación tendrá éxito
Prueba de escritura
Primero, agregue JUnit como una dependencia de pom.xml en el alcance de la prueba:
<dependency> <groupId> junit </groupId> <artifactId> junit </artifactId> <version> 4.12 </version> <scope>test</scope> </dependency>
Luego cree un caso de prueba de la siguiente manera:
src / test / java / hello / GreeterTest.java.
paquete hola;
importar estática org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert. *;
import org.junit.Test;
GreeterTest de clase pública {
Greeter greeter privado = new Greeter ();@Test
public void greeterSaysHello () {
afirmar que (greeter.sayHello (), contieneString ("Hola"));
}
} Maven usa un complemento llamado "surefire" para ejecutar pruebas unitarias. La configuración predeterminada de este complemento compilará y ejecutará todas las clases * Prueba con src / test / java. Puede ejecutar pruebas en la línea de comando como esta
mvn mano
t o simplemente utilice los pasos que se muestran arriba en mvn install (hay una definición de ciclo de vida donde se incluye "prueba" como una etapa de "instalación").
Este es el archivo pom.xml completo:
<? xml version = "1.0" encoding = "UTF-8"?>
<project xmlns = "http://maven.apache.org/POM/4.0.0" xmlns: xsi = "http: //www.w3 .org / 2001 / XMLSchema-instance "
xsi: schemaLocation =" http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd ">
<modelVersion> 4.0.0 </modelVersion><groupId> org.springframework </groupId>
<artifactId> gs-maven </artifactId>
<packaging> jar </packaging>
<version> 0.1.0 </version><properties>
<maven.compiler.source> 1.8 </maven.compiler.source>
<maven.compiler.target> 1.8 </maven.compiler.target>
</properties><dependencies>
<! - tag :: joda [] ->
<dependency>
<groupId> joda-time </groupId>
<artifactId> joda-time </artifactId>
<version> 2.9.2 </version>
< / dependency>
<! - end :: joda [] ->
<! - tag :: junit [] ->
<dependency>
<groupId> junit </groupId>
<artifactId> junit </artifactId>
<versión > 4.12 </version>
<scope> test </scope>
</dependency>
<! - end :: junit [] ->
</dependencies><build>
<plugins>
<plugin>
<groupId> org.apache.maven.plugins </groupId>
<artifactId> maven-shade-plugin </artifactId>
<version> 2.1 </version>
<executions>
<execution>
< phase> package </phase>
<goals>
<goal> shade </goal>
</goals>
<configuration>
<transformers>
<transformer implementación = "org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
<mainClass > hello.HelloWorld </mainClass>
</transformer>
</transformers>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</ project> El archivo pom.xml completo está utilizando el complemento Maven Shade para hacer que el archivo JAR sea ejecutable. El objetivo de esta guía es comenzar a usar Maven en lugar de usar este complemento específico.
Resumen
¡Felicidades! Ha creado una definición de proyecto Maven simple y efectiva para construir un proyecto Java.
También puede echar un vistazo a las
siguientes guías que también pueden ser útiles:
[Cree un proyecto Java usando Gradle] (https://blog.csdn.net/weixin_46577306/article/details/105515324)