Come collegare una classe a un database in Java?

In Java, la connessione di una classe a un database viene generalmente effettuata utilizzando tecnologie di mapping object-relational (ORM) o JDBC.

JDBC (Java Database Connectivity)

JDBC è un'API che fornisce un modo standard per accedere ai database relazionali. Permette di eseguire query SQL dal codice Java.

Passaggi:

1. Caricare il driver del database.
2. Stabilire la connessione (Connection).
3. Creare un oggetto Statement o PreparedStatement.
4. Eseguire la query SQL.
5. Elaborare i risultati (ResultSet).
6. Chiudere le risorse (Connection, Statement, ResultSet).

Esempio di recupero dati:

// Esempio di recupero dati dalla tabella "users"
Connection connection = null;
Statement statement = null;
ResultSet resultSet = null;

try {
    // Caricare il driver (dipende dal DB)
    Class.forName("org.postgresql.Driver"); // Esempio per PostgreSQL

    // Stabilire la connessione
    connection = DriverManager.getConnection("jdbc:postgresql://localhost:5432/mydatabase", "user", "password");

    // Creare lo Statement
    statement = connection.createStatement();

    // Eseguire la query
    resultSet = statement.executeQuery("SELECT id, name, email FROM users");

    // Elaborare i risultati
    while (resultSet.next()) {
        int id = resultSet.getInt("id");
        String name = resultSet.getString("name");
        String email = resultSet.getString("email");
        System.out.println("ID utente: " + id + ", Nome: " + name + ", Email: " + email);
    }
} catch (SQLException | ClassNotFoundException e) {
    e.printStackTrace();
} finally {
    // Chiudere le risorse
    try {
        if (resultSet != null) resultSet.close();
        if (statement != null) statement.close();
        if (connection != null) connection.close();
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

ORM (Object-Relational Mapping)

Framework come Hibernate, JPA basato su Hibernate, automatizzano il processo di mapping tra oggetti Java e tabelle del database. Permettono di lavorare con i dati come oggetti Java, astratti dal SQL.

Concetti principali:

• Entity: Classe POJO normale, contrassegnata con annotazioni speciali, che corrisponde a una tabella nel DB.
• Annotations: Sono usate per descrivere le relazioni tra la classe e la tabella, i campi e le colonne, le relazioni tra entità (uno a uno, uno a molti, ecc.).
• EntityManager (JPA) / Session (Hibernate): Interfacce per eseguire operazioni con le entità (salvataggio, aggiornamento, eliminazione, ricerca).

Esempio di entità:

// Esempio di entità User
import javax.persistence.*;

@Entity // Indica che è un'entità
@Table(name = "users") // Indica il nome della tabella
public class User {

    @Id // Chiave primaria
    @GeneratedValue(strategy = GenerationType.IDENTITY) // Strategia di generazione ID
    private Long id;

    @Column(name = "name") // Nome della colonna
    private String name;

    @Column(name = "email", unique = true)
    private String email;

    // Getter, Setter, costruttori
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

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

Esempio di salvataggio di un'entità con JPA:

// Esempio di salvataggio di un'entità User
import javax.persistence.*;

EntityManagerFactory emf = Persistence.createEntityManagerFactory("my_persistence_unit"); // dal persistence.xml
EntityManager em = emf.createEntityManager();
EntityTransaction transaction = em.getTransaction();

try {
    transaction.begin();

    User newUser = new User();
    newUser.setName("John Doe");
    newUser.setEmail("john.doe@example.com");

    em.persist(newUser); // Salvataggio dell'entità

    transaction.commit();
} catch (Exception e) {
    if (transaction != null && transaction.isActive()) {
        transaction.rollback();
    }
    e.printStackTrace();
} finally {
    em.close();
    emf.close();
}

Scelta tra JDBC e ORM:

Caratteristica	JDBC	ORM (JPA/Hibernate)
Complessità	Basso livello di astrazione, più codice.	Alto livello di astrazione, meno codice.
Flessibilità	Controllo totale sul SQL.	Flessibilità limitata nel lavorare direttamente con SQL.
Prestazioni	Potenzialmente superiore con ottimizzazioni manuali.	Potrebbe essere inferiore a causa dell'overhead dell'ORM.
Tempo di sviluppo	Più tempo per l'elaborazione manuale dei dati.	Meno tempo, automazione di molte attività.
Gestione delle relazioni	Richiede implementazione manuale.	Automatizzato (uno a uno, uno a molti).

Nelle applicazioni Java moderne, si usano generalmente framework ORM per l'efficienza nello sviluppo e nella manutenzione. JDBC viene usato quando è richiesto un controllo completo sul SQL o quando l'ORM non è adatto per qualche motivo (ad esempio, ottimizzazioni molto specifiche).