Tutorial d'Introducció a Spring Boot

Índex

1. Què és Spring Boot?
2. Configuració de l'entorn
3. La primera aplicació Spring Boot
4. Conceptes clau
5. Estructura del projecte
6. Creat de la teva primera REST API
7. Accés a bases de dades

---

Què és Spring Boot?

Spring Boot és un framework que simplifica el desenvolupament d'aplicacions Java basades en Spring. Les seves principals característiques són:

• Auto-configuració: Configura automàticament la majoria de components Spring en funció de les dependències del projecte
• Embedded servers: Inclou servidors web integrats (Tomcat, Jetty)
• Dependències gestades: Agrupa les dependències compatibles
• No-XML: Elimina la necessitat de fitxers XML de configuració
• Monitorització: Ofereix endpoints per monitoritzar l'aplicació

---

Configuració de l'entorn

Requisits previs

• Java 11 o superior (Java 17 o 21 recomanat)
• Maven 3.6+ o Gradle 7+
• IDE: IntelliJ IDEA, Eclipse, VS Code amb extensions Java

Verificar la instal·lació

java -version
javac -version
mvn -version

Crear un projecte Spring Boot amb Maven

Opció 1: Usar Spring Initializr (web) 1. Accedeix a https://start.spring.io 2. Configura: - Project: Maven - Language: Java - Spring Boot: 3.2.x (última versió stable) - Group: com.example - Artifact: demo - Name: Spring Boot Demo - Java: 17 o 21 3. Afegeix dependències: Spring Web, Spring Data JPA, MySQL Driver 4. Clica "Generate" i descarrega el projecte

Opció 2: Usar Spring Boot CLI

spring boot new --from=web my-first-app

---

La primera aplicació Spring Boot

Estructura del fitxer 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 
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>Spring Boot Demo</name>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.0</version>
        <relativePath/>
    </parent>

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

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

Classe principal de l'aplicació

package com.example.demo;

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

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

Executar l'aplicació

mvn spring-boot:run

L'aplicació s'executarà per defecte a http://localhost:8080

---

Conceptes clau

@SpringBootApplication

Aquesta anotació combina tres anotacions: - @Configuration: Permet definir beans - @EnableAutoConfiguration: Activa la auto-configuració - @ComponentScan: Escaneja els components de l'aplicació

Beans i Dependency Injection

@Service
public class UserService {
    public String getWelcomeMessage() {
        return "Benvingut a Spring Boot!";
    }
}

@RestController
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/welcome")
    public String welcome() {
        return userService.getWelcomeMessage();
    }
}

application.properties

Fitxer de configuració principal:

# Port del servidor
server.port=8080

# Database
spring.datasource.url=jdbc:mysql://localhost:3306/mibasedades
spring.datasource.username=root
spring.datasource.password=password
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

---

Estructura del projecte

src/
├── main/
│   ├── java/
│   │   └── com/example/demo/
│   │       ├── DemoApplication.java
│   │       ├── controller/
│   │       │   └── UserController.java
│   │       ├── service/
│   │       │   └── UserService.java
│   │       ├── repository/
│   │       │   └── UserRepository.java
│   │       └── entity/
│   │           └── User.java
│   └── resources/
│       └── application.properties
└── test/
    └── java/
        └── com/example/demo/
            └── DemoApplicationTests.java

---

Creat de la teva primera REST API

1. Definir l'entitat

package com.example.demo.entity;

import jakarta.persistence.*;

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String nom;

    @Column(nullable = false)
    private String email;

    // Getters i Setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }

    public String getNom() { return nom; }
    public void setNom(String nom) { this.nom = nom; }

    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

2. Crear el repository

package com.example.demo.repository;

import com.example.demo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    User findByEmail(String email);
}

3. Crear el service

package com.example.demo.service;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Optional;

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    public Optional<User> getUserById(Long id) {
        return userRepository.findById(id);
    }

    public User createUser(User user) {
        return userRepository.save(user);
    }

    public User updateUser(Long id, User userDetails) {
        Optional<User> user = userRepository.findById(id);
        if (user.isPresent()) {
            User existingUser = user.get();
            existingUser.setNom(userDetails.getNom());
            existingUser.setEmail(userDetails.getEmail());
            return userRepository.save(existingUser);
        }
        return null;
    }

    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}

4. Crear el controller REST

package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Optional;

@RestController
@RequestMapping("/api/users")
public class UserController {
    @Autowired
    private UserService userService;

    // GET: Obtenir tots els usuaris
    @GetMapping
    public ResponseEntity<List<User>> getAllUsers() {
        return ResponseEntity.ok(userService.getAllUsers());
    }

    // GET: Obtenir un usuari per ID
    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        Optional<User> user = userService.getUserById(id);
        return user.map(ResponseEntity::ok)
                   .orElseGet(() -> ResponseEntity.notFound().build());
    }

    // POST: Crear un nou usuari
    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        User createdUser = userService.createUser(user);
        return ResponseEntity.status(HttpStatus.CREATED).body(createdUser);
    }

    // PUT: Actualitzar un usuari
    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User userDetails) {
        User updatedUser = userService.updateUser(id, userDetails);
        if (updatedUser != null) {
            return ResponseEntity.ok(updatedUser);
        }
        return ResponseEntity.notFound().build();
    }

    // DELETE: Eliminar un usuari
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
        return ResponseEntity.noContent().build();
    }
}

5. Configurar la base de dades

Actualitza application.properties:

# Configuració del servidor
server.port=8080

# Configuració de la base de dades
spring.datasource.url=jdbc:mysql://localhost:3306/userdb
spring.datasource.username=root
spring.datasource.password=your_password
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# Configuració de JPA/Hibernate
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect
spring.jpa.properties.hibernate.format_sql=true

6. Afegir la dependència de MySQL

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.33</version>
</dependency>

---

Accés a bases de dades

Spring Data JPA

Spring Data JPA proporciona una manera senzilla d'accedir a les dades sense escriure SQL.

Anotacions més comunes

Anotació	Ús
@Entity	Marcar una classe com a entitat
@Table	Especificar el nom de la taula
@Id	Marcar el camp com a clau primària
@GeneratedValue	Auto-generar el valor
@Column	Definir propietats de la columna
@Repository	Marcar una interfície com a repository
@Service	Marcar una classe com a servei
@RestController	Marcar una classe com a controller REST
@GetMapping, @PostMapping, etc.	Mappejar mètodes a endpoints HTTP

Queries personalitzades

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    User findByEmail(String email);
    List<User> findByNomContaining(String nom);

    @Query("SELECT u FROM User u WHERE u.email = ?1")
    User findUserByEmail(String email);
}

---

Recursos addicionals

• Documentació oficial de Spring Boot
• Spring Data JPA Reference
• REST API Best Practices
• Spring Boot Tutorials

---

Properes passes

Després de completar aquest tutorial, pots explorar: - Spring Security per a autenticació i autorització - Spring Data REST per a APIs CRUD automàtiques - Documentació amb Swagger/OpenAPI - Testing amb JUnit i Mockito - Containerització amb Docker