Cum se poate lega o clasă de o bază de date în Java…

În Java, legătura dintre o clasă și o bază de date se realizează de obicei cu ajutorul tehnologiilor de mapare obiect-relațional (ORM) sau JDBC.

JDBC (Java Database Connectivity)

JDBC este o API care oferă o metodă standard de acces la bazele de date relaționale. Permite executarea interogărilor SQL din codul Java.

Pași:

Încărcarea driver-ului bazei de date.
Stabilirea conexiunii (Connection).
Crearea unui obiect Statement sau PreparedStatement.
Executarea interogării SQL.
Procesarea rezultatelor (ResultSet).
Închiderea resurselor (Connection, Statement, ResultSet).

Exemplu de preluare a datelor:

// Exemplu de preluare a datelor din tabelul "users"
Connection connection = null;
Statement statement = null;
ResultSet resultSet = null;

try {
    // Încărcarea driver-ului (depinde de BD)
    Class.forName("org.postgresql.Driver"); // Exemplu pentru PostgreSQL

    // Stabilirea conexiunii
    connection = DriverManager.getConnection("jdbc:postgresql://localhost:5432/mydatabase", "user", "password");

    // Crearea Statement
    statement = connection.createStatement();

    // Executarea interogării
    resultSet = statement.executeQuery("SELECT id, name, email FROM users");

    // Procesarea rezultatelor
    while (resultSet.next()) {
        int id = resultSet.getInt("id");
        String name = resultSet.getString("name");
        String email = resultSet.getString("email");
        System.out.println("User ID: " + id + ", Name: " + name + ", Email: " + email);
    }
} catch (SQLException | ClassNotFoundException e) {
    e.printStackTrace();
} finally {
    // Închiderea resurselor
    try {
        if (resultSet != null) resultSet.close();
        if (statement != null) statement.close();
        if (connection != null) connection.close();
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

ORM (Mapare Obiect-Relatională)

Framework-uri precum Hibernate și JPA bazată pe Hibernate automatizează procesul de mapare a obiectelor Java pe tabelele bazei de date și invers. Permite lucrul cu datele ca și cu obiecte Java, fără a scrie SQL.

Conceptele principale:

Entity: O clasă POJO obișnuită, marcată cu adnotări speciale, care corespunde unui tabel în bază.
Adnotări: Sunt folosite pentru a descrie relațiile dintre clasă și tabel, câmpurile și coloanele, relațiile între entități (unu la unu, unu la mai mulți etc.).
EntityManager (JPA) / Session (Hibernate): Interfețe pentru efectuarea operațiilor cu entitățile (salvare, actualizare, ștergere, căutare).

Exemplu de entitate:

// Exemplu de entitate User
import javax.persistence.*;

@Entity // Indică faptul că este o entitate
@Table(name = "users") // Numele tabelului corespunzător
public class User {

    @Id // Indică cheia primară
    @GeneratedValue(strategy = GenerationType.IDENTITY) // Strategia de generare a ID-ului
    private Long id;

    @Column(name = "name") // Numele coloanei
    private String name;

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

    // Getters, setters, constructor
    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;
    }
}

Exemplu de salvare a entității cu JPA:

// Exemplu de salvare a entității User
import javax.persistence.*;

EntityManagerFactory emf = Persistence.createEntityManagerFactory("my_persistence_unit"); // din 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); // Salvarea entității

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

Alegerea între JDBC și ORM:

Caracteristică	JDBC	ORM (JPA/Hibernate)
Complexitate	Nivel scăzut de abstractizare, mai mult cod.	Nivel înalt de abstractizare, mai puțin cod.
Flexibilitate	Control total asupra SQL-ului.	Flexibilitate limitată în lucrul direct cu SQL.
Performanță	Potențial mai mare cu optimizări manuale.	Poate fi mai mică din cauza overhead-ului ORM.
Timp de dezvoltare	Mai mult timp pentru procesare manuală a datelor.	Mai puțin timp, automatizare a multor sarcini.
Gestionarea relațiilor	Necesită implementare manuală.	Automatizată (unu la unu, unu la mai mulți).

În aplicațiile Java moderne, de obicei se folosesc framework-uri ORM pentru lucrul cu bazele de date datorită eficienței în dezvoltare și întreținere. JDBC se folosește în cazurile în care este necesar control complet asupra SQL-ului sau ORM nu este potrivit din motive precum optimizări foarte specifice.

Cum se poate lega o clasă de o bază de date în Java?