Crear un proyecto Maven en NetBeans y Eclipse

Maven hace dos cosas: baja las dependencias y da a todos los proyectos la misma forma. Lo segundo importa tanto como lo primero: cualquiera que se descargue tu proyecto sabe dónde está cada cosa y lo compila con un solo comando.

Crearlo desde la terminal

Es la forma más rápida y la que funciona igual en los tres IDE, porque todos saben abrir después la carpeta resultante.

mvn -B archetype:generate \
  -DarchetypeGroupId=org.apache.maven.archetypes \
  -DarchetypeArtifactId=maven-archetype-quickstart \
  -DarchetypeVersion=1.5 \
  -DgroupId=com.decodigo \
  -DartifactId=mi-app \
  -Dpackage=com.decodigo.app

find mi-app -type fmi-app/pom.xml
mi-app/src/main/java/com/decodigo/app/App.java
mi-app/src/test/java/com/decodigo/app/AppTest.java

El -B es «modo por lotes»: sin él, Maven va preguntando. Y los tres datos que identifican el proyecto para siempre son:

Campo	Qué es	Convención
`groupId`	quién lo hace	tu dominio al revés: `com.decodigo`
`artifactId`	cómo se llama	en minúsculas y con guiones
`version`	en qué versión va	`1.0-SNAPSHOT` mientras se desarrolla

La estructura, que no se discute

salidami-app/
├── pom.xml
└── src/
    ├── main/
    │   ├── java/         ← el código
    │   └── resources/    ← lo que va dentro del jar
    └── test/
        ├── java/         ← las pruebas
        └── resources/

Esto es lo que Maven llama convención sobre configuración: si pones las cosas donde toca, no hay que configurar nada. Mover el código a otra carpeta se puede, pero entonces hay que explicárselo a Maven y se pierde justo la ventaja.

El pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" ...>
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.decodigo</groupId>
  <artifactId>mi-app</artifactId>
  <version>1.0-SNAPSHOT</version>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.release>25</maven.compiler.release>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter</artifactId>
      <version>5.11.0</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

maven.compiler.release, no source y target. La pareja antigua comprueba la sintaxis de la versión que pidas, pero compila contra las clases del JDK que tengas instalado: puedes decir «Java 8» y llamar sin querer a un método que solo existe en el 21, y el programa revienta en producción. release comprueba también la biblioteca. Es una línea y evita una clase entera de errores.

Los comandos que se usan

Comando	Qué hace
`mvn compile`	compila lo de `src/main`
`mvn test`	compila y ejecuta las pruebas
`mvn package`	genera el jar en `target/`
`mvn install`	lo copia a tu repositorio local, para que otros proyectos tuyos lo usen
`mvn clean`	borra `target/`
`mvn dependency:tree`	enseña de dónde sale cada jar

Son acumulativos: package compila y pasa las pruebas antes de empaquetar. Lo normal es escribir mvn clean package.

mvn -B package && java -cp target/mi-app-1.0-SNAPSHOT.jar com.decodigo.app.App

salidaHello World!

Ese -cp hace falta porque el jar del arquetipo no declara una clase principal. Para que se pueda lanzar con java -jar, se configura el maven-jar-plugin con <mainClass>, y si además quieres que lleve dentro las dependencias, el maven-shade-plugin.

Abrirlo en el IDE

Ninguno de los tres necesita que el proyecto se cree desde dentro: todos entienden un pom.xml directamente.

IDE	Cómo
NetBeans	File → Open Project y elegir la carpeta; la reconoce por el pom
Eclipse	File → Import → Maven → Existing Maven Projects
IntelliJ IDEA	Open y señalar el `pom.xml`
VS Code	la extensión Extension Pack for Java lo detecta solo

Y los tres pueden crear el proyecto desde su propio asistente, que no es más que una ventana encima del mismo arquetipo: NetBeans en Java with Maven, Eclipse en Maven Project, IntelliJ eligiendo Maven como sistema de construcción.

Lo que de verdad conviene recordar es que el proyecto es el pom.xml y la carpeta src, no la configuración del IDE. Por eso en el control de versiones se sube pom.xml y src/, y se ignoran target/, .idea/, .classpath y nbproject/: quien clone el repositorio los regenera con su propio IDE.

Esta página tenía diecisiete capturas de los asistentes de NetBeans y Eclipse de 2018. Se han quitado porque ninguno de los dos se parece ya a aquello, y unas capturas que no coinciden con lo que ves en pantalla estorban más de lo que ayudan. Los menús de arriba sí están al día.

Todo el código se compiló y se ejecutó con Java 25 LTS en un contenedor limpio antes de publicar esta página; las salidas están copiadas de esa ejecución.