Spring Framework – Parte 2

Introduzione

Nell’articolo precedente, abbiamo introdotto le basi di Spring Boot, creato un progetto base e sviluppato una semplice API. In questa seconda parte, collegheremo il progetto a un database, utilizzando PostgreSQL per la persistenza e la gestione dei dati.

PostgreSQL

PostgreSQL, nato nel 1985 come “post-ingres” grazie a Michael Stonebraker, è un’alternativa potente a database relazionali come MySQL. Una sua caratteristica unica è la possibilità di definire nuovi tipi di dati e utilizzare l’ereditarietà tra tipi. Maggiori dettagli sono disponibili sul sito ufficiale di PostgreSQL.

Configurazione di PostgreSQL in Spring Boot

Installazione del Database

Prima di proseguire, è necessario installare PostgreSQL. Questa guida offre istruzioni dettagliate per l’installazione.

Aggiungere le Dipendenze

Aggiungiamo al file pom.xml le dipendenze necessarie:

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>42.6.0</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

Queste dipendenze forniscono gli strumenti per interagire con il database e gestire le entità. Se usi IntelliJ, ricorda di aggiornare il progetto per applicare le modifiche al pom.xml.

Configurare i Parametri di Connessione

Nel file application.properties, configuriamo i parametri per collegare Spring Boot a PostgreSQL:

spring.datasource.url=jdbc:postgresql://localhost:5432/NOME_DB
spring.datasource.username=USERNAME
spring.datasource.password=PASSWORD
spring.datasource.driver-class-name=org.postgresql.Driver

L’opzione spring.datasource.driver-class-name può variare in base alla versione di PostgreSQL. Aggiungiamo anche:

spring.jpa.hibernate.ddl-auto=update

per permettere a Spring Boot di generare automaticamente lo schema delle entità di dominio.

Creazione delle Entità di Dominio

Creiamo un’entità di dominio rappresentante un utente.

In un nuovo package chiamato domain, creiamo il file User.java:

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

    public User() {}

    public User(String username) {
        this.username = username;
    }
    // Getter e Setter
}

• @Entity definisce questa classe come entità. Il nome “users” è specificato perché “user” è una parola riservata in PostgreSQL.
• @Id identifica la chiave primaria.
• @GeneratedValue permette a PostgreSQL di generare automaticamente un ID univoco.

Repository

I repository offrono i metodi necessari per le operazioni CRUD. Creiamo un’interfaccia UserRepository.java in un nuovo package chiamato repository:

@Repository
public interface UserRepository extends JpaRepository<User, Long> {}

L’interfaccia estende JpaRepository, ereditando metodi per le operazioni CRUD.

Controller

Creiamo ora il controller per gestire le operazioni sugli utenti. In UserController.java scriviamo:

@RestController
@RequestMapping("/user")
public class UserController {
    private final UserRepository userRepository;

    public UserController(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

Definire le CRUD

Aggiungiamo i metodi per le CRUD:

@PostMapping(value = "/register")
public ResponseEntity<User> register(@RequestBody String username) {
    User newUser = new User(username);
    userRepository.save(newUser);
    return ResponseEntity.ok(newUser);
}

@GetMapping(value = "")
public ResponseEntity<List<User>> getAll() {
    return ResponseEntity.ok(userRepository.findAll());
}

@GetMapping(value = "/{userId}")
public ResponseEntity<User> getById(@PathVariable Long userId) {
    return userRepository.findById(userId)
           .map(ResponseEntity::ok)
           .orElse(ResponseEntity.notFound().build());
}

@PutMapping(value = "/{userId}")
public ResponseEntity<User> updateById(@PathVariable Long userId, @RequestBody String username) {
    return userRepository.findById(userId).map(user -> {
        user.setUsername(username);
        userRepository.save(user);
        return ResponseEntity.ok(user);
    }).orElse(ResponseEntity.notFound().build());
}

@DeleteMapping(value = "/{userId}")
public ResponseEntity<Void> deleteById(@PathVariable Long userId) {
    return userRepository.findById(userId).map(user -> {
        userRepository.delete(user);
        return ResponseEntity.ok().build();
    }).orElse(ResponseEntity.notFound().build());
}

Questi metodi consentono di registrare nuovi utenti, recuperare utenti per ID o tutti gli utenti, aggiornare e cancellare utenti.

Test delle API

1. Recupero della Lista Utenti

• Metodo: GET
• URL: localhost:8080/user
• Risposta: [] se il DB è vuoto.

2. Creazione Nuovo Utente

• Metodo: POST
• URL: localhost:8080/user/register
• Body: {“username”: “user1”}
• Risposta: {“id”: 1, “username”: “user1”}

3. Recupero Utente per ID

• Metodo: GET
• URL: localhost:8080/user/1
• Risposta: {“id”: 1, “username”: “user1”} se l’ID esiste, altrimenti 404 Not Found.

4. Modifica Utente

• Metodo: PUT
• URL: localhost:8080/user/1
• Body: {“username”: “user2”}
• Risposta: {“id”: 1, “username”: “user2”}

5. Cancellazione Utente

• Metodo: DELETE
• URL: localhost:8080/user/1
• Risposta: 200 OK

Conclusione

In questa seconda parte, abbiamo esplorato come collegare un’applicazione Spring Boot a PostgreSQL e persistere i dati. Nella prossima parte, esamineremo come implementare un sistema di autenticazione con JWT Token e Spring Security.

Il codice completo di questo esempio è disponibile a questo link.