Hoe koppel je een klasse aan een database in Java…

In Java wordt de koppeling tussen een klasse en een database meestal gedaan met behulp van object-relationeel mappen (ORM) technologieën of JDBC.

JDBC (Java Database Connectivity)

JDBC is een API die een standaard manier biedt om toegang te krijgen tot relationele databases. Het stelt je in staat om SQL-query's uit Java-code uit te voeren.

Stappen:

Laad de database driver.
Maak een verbinding (Connection).
Maak een Statement of PreparedStatement object.
Voer de SQL-query uit.
Verwerk de resultaten (ResultSet).
Sluit de resources (Connection, Statement, ResultSet).

Voorbeeld van gegevens ophalen:

// Voorbeeld van gegevens ophalen uit de tabel "users"
Connection connection = null;
Statement statement = null;
ResultSet resultSet = null;

try {
    // Laad de driver (afhankelijk van de database)
    Class.forName("org.postgresql.Driver"); // Voorbeeld voor PostgreSQL

    // Maak de verbinding
    connection = DriverManager.getConnection("jdbc:postgresql://localhost:5432/mydatabase", "user", "password");

    // Maak een Statement
    statement = connection.createStatement();

    // Voer de query uit
    resultSet = statement.executeQuery("SELECT id, name, email FROM users");

    // Verwerk de resultaten
    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 {
    // Resources sluiten
    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)

Frameworks zoals Hibernate en JPA gebaseerd op Hibernate automatiseren het proces van het mappen van Java-objecten naar database-tabellen en vice versa. Ze stellen je in staat om met gegevens te werken als met Java-objecten, zonder SQL te hoeven schrijven.

Belangrijke concepten:

Entity: Een gewone POJO-klasse gemarkeerd met speciale annotaties die overeenkomt met een tabel in de database.
Annotaties: Worden gebruikt om de relaties tussen klasse en tabel, velden en kolommen, en relaties tussen entiteiten (een-op-een, een-op-veel, etc.) te beschrijven.
EntityManager (JPA) / Session (Hibernate): Interfaces voor het uitvoeren van operaties op entiteiten (opslaan, bijwerken, verwijderen, zoeken).

Voorbeeld van een entiteit:

// Voorbeeld van een User-entiteit
import javax.persistence.*;

@Entity // Geeft aan dat dit een entiteit is
@Table(name = "users") // Geeft de naam van de bijbehorende tabel aan
public class User {

    @Id // Geeft de primaire sleutel aan
    @GeneratedValue(strategy = GenerationType.IDENTITY) // Strategie voor ID-generatie
    private Long id;

    @Column(name = "name") // Geeft de naam van de bijbehorende kolom aan
    private String name;

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

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

Voorbeeld van het opslaan van een entiteit met JPA:

// Voorbeeld van het opslaan van een User-entiteit
import javax.persistence.*;

EntityManagerFactory emf = Persistence.createEntityManagerFactory("my_persistence_unit"); // uit 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); // Opslaan van de entiteit

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

Keuze tussen JDBC en ORM:

Kenmerk	JDBC	ORM (JPA/Hibernate)
Complexiteit	Laag niveau van abstractie, meer code.	Hoog niveau van abstractie, minder code.
Flexibiliteit	Volledige controle over SQL.	Beperkte flexibiliteit bij direct werken met SQL.
Prestaties	Potentieel hoger bij handmatige optimalisatie.	Kan lager zijn door ORM overhead.
Ontwikkeltijd	Meer tijd voor handmatige gegevensverwerking.	Minder tijd, automatisering van veel taken.
Relatiebeheer	Vereist handmatige implementatie.	Geautomatiseerd (een-op-een, een-op-veel).

In moderne Java-toepassingen worden meestal ORM-frameworks gebruikt vanwege hun efficiëntie in ontwikkeling en onderhoud. JDBC wordt gebruikt wanneer volledige controle over SQL vereist is of ORM niet geschikt is vanwege bijvoorbeeld zeer specifieke optimalisaties.

Hoe koppel je een klasse aan een database in Java?