Apèndix D — Maven i Gradle

Objectius

  • Entendre què és una eina de construcció (build tool) i quins problemes resol.
  • Saber què són Maven i Gradle i en què s’assemblen i es diferencien.
  • Comparar les dues eines i entendre’n avantatges i inconvenients.
  • Decidir quina usar segons el tipus de projecte: Spring, Android/Kotlin, etc.

Quan els projectes creixen, compilar-los “a mà” amb javac es fa impracticable: hi ha desenes de fitxers, llibreries externes de les quals depens, proves que cal executar, i un resultat final (un .jar) que cal empaquetar. Per automatitzar tot això existeixen les eines de construcció. Les dues més usades al món Java són Maven i Gradle.

D.1 Què és una eina de construcció?

Una eina de construcció (build tool) és un programa que automatitza totes les tasques repetitives de convertir el teu codi font en una aplicació que funciona:

  • Compilar tot el codi font en l’ordre correcte.
  • Descarregar i gestionar les dependències (llibreries externes de què depèn el projecte).
  • Executar les proves automàticament.
  • Empaquetar el resultat en un .jar o .war distribuïble.
ConsellAnalogia: la recepta i el robot de cuina

Compilar a mà és cuinar un plat complex tallant, pesant i barrejant tu tot, cada cop.

Una eina de construcció és un robot de cuina amb recepta programada: li dius què vols i ell descarrega els ingredients (dependències), els combina en l’ordre correcte i et serveix el plat acabat.

Tu et centres en la recepta, no en la feina mecànica.

El concepte més potent és la gestió de dependències. Si el teu projecte necessita, per exemple, una llibreria per llegir fitxers Excel, no la baixes tu manualment: declares que la vols i l’eina la descarrega (i descarrega també el que aquella llibreria necessiti a la vegada) des d’un repositori central a Internet.

D.2 Maven

Maven és l’eina de construcció més veterana i estesa al món Java. Es configura amb un fitxer XML anomenat pom.xml (Project Object Model), on declares les dades del projecte i les seves dependències.

<project>
    <groupId>cat.institut</groupId>
    <artifactId>biblioteca</artifactId>
    <version>1.0.0</version>

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

Ordres habituals des del terminal:

mvn compile      # Compila el codi
mvn test         # Executa les proves
mvn package      # Genera el .jar

La filosofia de Maven és “convenció sobre configuració”: si col·loques els fitxers on Maven espera (src/main/java, src/test/java), tot funciona sense configurar gairebé res. Això fa que tots els projectes Maven s’assemblin, cosa molt còmoda quan canvies d’un projecte a un altre.

NotaOn brilla Maven

Maven és predictible i estable. Com que és XML pur i molt estructurat, qualsevol projecte Maven és fàcil de llegir encara que no l’hagis fet tu.

És l’estàndard de facto a l’empresa i el que fa servir per defecte l’ecosistema Spring.

D.3 Gradle

Gradle és una eina més moderna i flexible.

En comptes d’XML, es configura amb scripts (en Groovy o Kotlin), en un fitxer anomenat build.gradle o build.gradle.kts. Això el fa més curt i programable.

plugins {
    id 'java'
}

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter:5.10.0'
}

Ordres habituals:

gradle build     # compila, prova i empaqueta
gradle test      # executa les proves

Fixa’t com la mateixa dependència ocupa una línia en Gradle davant de les set de Maven.

A més, Gradle és més ràpid en projectes grans perquè només reconstrueix el que ha canviat (compilació incremental) i guarda resultats en memòria cau.

NotaOn brilla Gradle

Gradle és ràpid i flexible. En ser un script, hi pots posar lògica pròpia. És l’eina oficial d’Android i molt habitual en projectes Kotlin.

El preu d’aquesta potència és una corba d’aprenentatge una mica més pronunciada.

D.4 Comparativa de Maven i Gradle

Aspecte Maven Gradle
Fitxer de configuració pom.xml build.gradle / .kts
Llenguatge de configuració XML (declaratiu) Groovy o Kotlin (script)
Verbositat més llarg més curt
Velocitat en projectes grans bona millor (incremental + cau)
Flexibilitat limitada (per convenció) molt alta (programable)
Corba d’aprenentatge suau més pronunciada
Predictibilitat / llegibilitat molt alta depèn de l’script
Ecosistema on domina Spring, empresa Android, Kotlin
Maduresa molt madur modern, molt actiu
ConsellAnalogia: cotxe automàtic vs. manual

Maven és com un cotxe automàtic: menys control fi, però fàcil i tothom el sap conduir igual.

Gradle és com un cotxe manual: més control i potència si el domines, a canvi d’una mica més d’aprenentatge.

Cap dels dos és millor; depèn del que necessitis.

D.5 Quina eina escollir?

No hi ha una resposta única; depèn del projecte i de l’ecosistema on treballis:

flowchart TD
    A{"Quin tipus<br/>de projecte?"} -->|"App Android<br/>o Kotlin"| B["Gradle<br/>(és l'estàndard)"]
    A -->|"Spring / Spring Boot"| C["Maven<br/>(opció per defecte)"]
    A -->|"Projecte gran<br/>on la velocitat importa"| D["Gradle"]
    A -->|"Aprens o vols<br/>simplicitat"| E["Maven"]

  • Spring i Spring Boot → Maven. És l’opció que Spring genera per defecte i la més documentada per a aquest ecosistema.
  • Android i Kotlin → Gradle. És l’eina oficial; Android Studio només treballa amb Gradle.
  • Projectes grans amb builds lents → Gradle, per la seva compilació incremental i memòria cau.
  • Aprenent o projectes petits on vols simplicitat i predictibilitat → Maven.
ImportantRecomanació per a aquest curs

En aquest curs farem servir Maven. És més senzill de llegir, més predictible i el fitxer pom.xml en XML és fàcil d’entendre quan comences.

Dominats els conceptes de construcció amb Maven, passar a Gradle és fàcil, perquè les idees (dependències, fases, empaquetat) són les mateixes; només canvia la sintaxi.

AlertaError típic: pensar que has de triar-ne una per sempre

Les eines de construcció no són una religió. Molts professionals coneixen totes dues i usen la que demana cada projecte. El que has d’aprendre bé són els conceptes (què és una dependència, què és empaquetar, quines fases hi ha); la sintaxi concreta l’aprens en minuts quan la necessites.

D.6 Resum

  • Una eina de construcció automatitza compilar, gestionar dependències, provar i empaquetar un projecte.
  • La gestió de dependències és la clau: declares les llibreries que vols i l’eina les descarrega automàticament.
  • Maven usa pom.xml (XML), és estable, predictible i fàcil d’aprendre; domina a Spring i a l’empresa.
  • Gradle usa build.gradle (script), és més curt, ràpid i flexible; és l’estàndard a Android i Kotlin.
  • Tria segons l’ecosistema: Spring → Maven, Android/Kotlin → Gradle. Per a projectes grans on la velocitat importa, Gradle.
  • En aquest curs fem servir Maven per la seva simplicitat; els conceptes es transfereixen després a Gradle sense esforç.

D.7 Per practicar

  1. Llegeix un pom.xml. Obre el pom.xml del projecte model del curs i identifica el groupId, l’artifactId i les dependències.
  2. Afegeix una dependència. Cerca una llibreria a mvnrepository.com i afegeix-la al pom.xml; després executa mvn compile.
  3. Compara mides. Escriu com declararies la mateixa dependència en Maven (XML) i en Gradle (una línia) i compara la longitud.
  4. Investiga Android. Busca per què Android Studio només accepta Gradle i quin fitxer de configuració fa servir.
  5. Fases de Maven. Investiga què fan mvn clean, mvn compile, mvn test i mvn package, i en quin ordre s’executen.