Pràctica Guiada: Crear una Aplicació "Hola Món" amb Spring Boot¶

Objectius¶

En aquesta pràctica guiada crearàs una senzilla aplicació web amb Spring Boot que respondrà a peticions HTTP amb un missatge "Hola Món". Aprendràs els passos fonamentals per a:

Configurar un projecte Spring Boot
Crear un controlador REST
Executar l'aplicació
Verificar que funciona correctament

Requisits Previs¶

Assegura't de tenir instal·lat:

Java Development Kit (JDK) 17 o superior. Verifica la versió amb: java -version
Maven 3.9 o superior (si prefers Maven) o Gradle 8.0 o superior (si prefers Gradle). Verifica amb: mvn -v o gradle -v
Un editor de text o IDE: VS Code, IntelliJ IDEA, Eclipse o qualsevol altre

Opcionalment, pots tenir curl o Postman per provar els endpoints.

Pas 1: Crear el Projecte amb Spring Initializr¶

Opció A: Via Spring Initializr Web¶

Obri la pàgina web: https://start.spring.io
Omple els camps de la següent manera:

Camp	Valor
Project	Maven Project (o Gradle si ho prefers)
Language	Java
Spring Boot	3.4.3 (o la versió estable més recent)
Project Metadata - Group	com.example
Project Metadata - Artifact	hola-mon
Project Metadata - Name	Hola Mon
Project Metadata - Description	Aplicació Hola Món amb Spring Boot
Packaging	JAR
Java	17 (o superior)

En la secció Dependencies, fes clic a ADD DEPENDENCIES i afegeix: - Spring Web
Fes clic a GENERATE per descarregar el fitxer ZIP del projecte.
Descomprimeix el fitxer ZIP a la carpeta on vulguis guardar el projecte.

Opció B: Via VS Code Extension¶

Si uses VS Code:

Instal·la l'extensió Spring Initializr des de la vista d'extensions (Ctrl+Shift+X).
Obri la Paleta de Comandaments (Ctrl+Shift+P) i escriu Spring Initializr.
Segueix el mateix procés que descrit més amunt.

Pas 2: Explorar l'Estructura del Projecte¶

Navega a la carpeta descargada i observa l'estructura:

hola-mon/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/
│   │   │       └── hola_mon/
│   │   │           └── HolaMonApplication.java
│   │   └── resources/
│   │       └── application.properties
│   └── test/
│       └── java/
│           └── com/example/hola_mon/
├── pom.xml (si uses Maven)
├── build.gradle (si uses Gradle)
└── README.md

Descripció dels Fitxers Importants¶

pom.xml / build.gradle: Fitxers de configuració que defineixen les dependències i la configuració de construcció.
HolaMonApplication.java: La classe principal de l'aplicació on es troba el mètode main().
application.properties: Fitxer de configuració per a propietats de l'aplicació (com el port del servidor).

Pas 3: Obrir el Projecte a l'IDE¶

Si uses Maven:¶

Obre l'IDE (per exemple, IntelliJ IDEA o VS Code).
Obri el fitxer pom.xml com a projecte.

Si uses Gradle:¶

Obre el fitxer build.gradle com a projecte.

L'IDE descarregarà automàticament totes les dependències necessàries.

Pas 4: Inspecionar la Classe Principal¶

Obri el fitxer src/main/java/com/example/hola_mon/HolaMonApplication.java:

package com.example.hola_mon;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class HolaMonApplication {

    public static void main(String[] args) {
        SpringApplication.run(HolaMonApplication.class, args);
    }

}

Explicació:

@SpringBootApplication: Aquesta anotació combina tres anotacions importants: @Configuration, @EnableAutoConfiguration i @ComponentScan. Indica a Spring que aquesta és l'aplicació principal.
main(): El punt d'entrada de l'aplicació. SpringApplication.run() inicia l'aplicació Spring Boot.

Pas 5: Crear un Controlador REST¶

Ara crearem una classe controladora que respondrà a les peticions HTTP.

Crea un nou fitxer a: src/main/java/com/example/hola_mon/HelloWorldController.java
Afegeix el següent codi:

package com.example.hola_mon;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloWorldController {

    @GetMapping("/hola")
    public String hola() {
        return "Hola Món!";
    }

    @GetMapping("/hola-personalitzat")
    public String holaPersonalitzat(@RequestParam(value = "nom", defaultValue = "Visitant") String nom) {
        return "Hola, " + nom + "!";
    }

}

Explicació del Codi:

@RestController: Marca aquesta classe com un controlador REST. Els mètodes retornaran directament el contingut (sense necessitat de templates).
@GetMapping("/hola"): Mapeja les peticions GET a la ruta /hola a aquest mètode.
hola(): Mètode que retorna el missatge "Hola Món!".
@GetMapping("/hola-personalitzat"): Mapeja peticions GET a la ruta /hola-personalitzat.
@RequestParam: Indica que el paràmetre nom pot passar-se com a paràmetre de consulta (query parameter). El valor per defecte és "Visitant".

Pas 6: Verificar les Dependències¶

Obri el fitxer pom.xml (Maven) o build.gradle (Gradle) i verifica que tinguis la dependència de Spring Web:

Maven (pom.xml):¶

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Gradle (build.gradle):¶

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
}

Si no la tens, afegeix-la. Alguns IDEs oferiran una opció per recarregar les dependències automàticament.

Pas 7: Configurar el Port (Opcional)¶

Per defecte, Spring Boot s'executa al port 8080. Si vols canviar-lo:

Obri src/main/resources/application.properties
Afegeix la línia següent:

server.port=8082

Guarda el fitxer. Ara l'aplicació s'executarà al port 8082.

Pas 8: Construir i Executar l'Aplicació¶

Opció A: Executar des de la Línia de Comandaments¶

Amb Maven:¶

cd hola-mon
./mvnw spring-boot:run

O si tens Maven instal·lat globalment:

mvn spring-boot:run

Amb Gradle:¶

cd hola-mon
./gradlew bootRun

O si tens Gradle instal·lat globalment:

gradle bootRun

Opció B: Executar des de l'IDE¶

Si uses IntelliJ IDEA:

Busca la classe HolaMonApplication.java
Fes clic amb el botó dret i selecciona Run 'HolaMonApplication.main()'

Si uses VS Code:

Obri la Paleta de Comandaments (Ctrl+Shift+P)
Escriu "Spring Boot Dashboard" i obri l'extensió
Fes clic al botó de reproducció al costat del projecte

Output Esperat¶

Hauries de veure algo similar a:

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v3.4.3)

2025-11-13 10:05:22.123  INFO 12345 --- [  main] c.e.h.HolaMonApplication                 : Starting HolaMonApplication v0.0.1-SNAPSHOT using Java 17.0.1 on MacBook.local with PID 12345
...
2025-11-13 10:05:23.456  INFO 12345 --- [  main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2025-11-13 10:05:23.789  INFO 12345 --- [  main] c.e.h.HolaMonApplication                 : Started HolaMonApplication in 2.123 seconds (JVM running for 2.456)

Això indica que l'aplicació s'està executant correctament al port 8080.

Pas 9: Provar l'Aplicació¶

Opció A: Usar un Navegador Web¶

Obri el navegador i accedeix a: - http://localhost:8080/hola → Veurà: Hola Món! - http://localhost:8080/hola-personalitzat → Veurà: Hola, Visitant! - http://localhost:8080/hola-personalitzat?nom=Anna → Veurà: Hola, Anna!

Opció B: Usar curl¶

Obri una terminal i executa:

curl http://localhost:8080/hola

Resultat:

Hola Món!

Per provar amb paràmetre:

curl "http://localhost:8080/hola-personalitzat?nom=Anna"

Resultat:

Hola, Anna!

Opció C: Usar Postman¶

Obri Postman
Crea una nova sol·licitud GET
Entra l'URL: http://localhost:8080/hola
Fes clic a "Send"
Veurà la resposta: Hola Món!

Pas 10: Construir un JAR Executable¶

Per empaquetar l'aplicació com a fitxer JAR executable:

Amb Maven:¶

./mvnw clean package

El fitxer JAR es crearà a: target/hola-mon-0.0.1-SNAPSHOT.jar

Amb Gradle:¶

./gradlew bootJar

El fitxer JAR es crearà a: build/libs/hola-mon-0.0.1-SNAPSHOT.jar

Executar el JAR:¶

java -jar target/hola-mon-0.0.1-SNAPSHOT.jar

O amb Gradle:

java -jar build/libs/hola-mon-0.0.1-SNAPSHOT.jar

Pas 11: Detenir l'Aplicació¶

Per aturar l'aplicació, prem:

Ctrl + C

Resum de Comandes Ràpides¶

Tasca	Maven	Gradle
Executar l'app	`./mvnw spring-boot:run`	`./gradlew bootRun`
Construir JAR	`./mvnw clean package`	`./gradlew bootJar`
Executar JAR	`java -jar target/hola-mon-0.0.1-SNAPSHOT.jar`	`java -jar build/libs/hola-mon-0.0.1-SNAPSHOT.jar`
Verificar estructura	`tree src/` o `dir src\`	Igual que Maven

Problemes Comuns i Solucions¶

Error: "Port 8080 already in use"¶

Solució: Canvia el port a application.properties:

server.port=8082

Error: "Java version 17 or later not found"¶

Solució: Verifica que tens Java 17 instal·lat:

java -version

Si no la tens, descarrega-la des de OpenJDK o Oracle JDK.

Error: "Maven/Gradle command not found"¶

Solució: Usa els wrappers locals que venen amb el projecte: - Maven: ./mvnw en lloc de mvn - Gradle: ./gradlew en lloc de gradle

Ampliacions de la Pràctica¶

Un cop tinguis el "Hola Món" funcionant, pots experimentar amb:

Afegir més endpoints: Crea nous mètodes amb altres rutes (/, /bienvenida, etc.)
Acceptar dades POST: Crea un endpoint que accepti dades POST amb @PostMapping
Retornar JSON: Usa objectes POJO i Spring Boot els convertirà automàticament a JSON
Afegir validacions: Usa anotacions com @NotNull, @Length, etc.
Crear tests unitaris: Afegeix tests amb @SpringBootTest

Recursos Addicionals¶

Preguntes de Reflexió¶

Per consolidar el teu aprenentatge:

Per a què serveix l'anotació @RestController?
Quina és la diferència entre @GetMapping i @PostMapping?
Com funciona el @RequestParam amb el valor per defecte?
Quin és el rol del fitxer application.properties?
Per a què serveix el mètode SpringApplication.run()?

Conclusió¶

Has completat la pràctica bàsica de crear una aplicació "Hola Món" amb Spring Boot. Ara entens els fonaments de crear aplicacions web amb Spring Boot, incloent:

Crear un projecte amb Spring Initializr
Estructurar l'aplicació amb controladors REST
Executar i provar l'aplicació
Empaquetar l'aplicació com a JAR executable

Felicitats! 🎉