Kaip susieti klasę su duomenų baze Java?

Java dažnai susiejama su duomenų baze naudojant objektų-reliacinio žemėlapio (ORM) technologijas arba JDBC.

JDBC (Java Database Connectivity)

JDBC yra API, suteikianti standartinį būdą prieiti prie reliacinių duomenų bazių. Jis leidžia vykdyti SQL užklausas iš Java kodo.

Žingsniai:

1. Duomenų bazės tvarkyklės įkėlimas
2. Ryšio sukūrimas (Connection)
3. Statement arba PreparedStatement objekto sukūrimas
4. SQL užklausos vykdymas
5. Rezultatų apdorojimas (ResultSet)
6. Išteklių uždarymas (Connection, Statement, ResultSet)

Pavyzdys duomenų gavimui:

// Pavyzdys duomenų iš "users" lentelės gavimui
Connection connection = null;
Statement statement = null;
ResultSet resultSet = null;

try {
    // Tvarkyklės įkėlimas (priklauso nuo DB)
    Class.forName("org.postgresql.Driver"); // PostgreSQL pavyzdys

    // Ryšio sukūrimas
    connection = DriverManager.getConnection("jdbc:postgresql://localhost:5432/mydatabase", "user", "password");

    // Statement kūrimas
    statement = connection.createStatement();

    // Užklausos vykdymas
    resultSet = statement.executeQuery("SELECT id, name, email FROM users");

    // Rezultatų apdorojimas
    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 {
    // Išteklų uždarymas
    try {
        if (resultSet != null) resultSet.close();
        if (statement != null) statement.close();
        if (connection != null) connection.close();
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

ORM (Objektų-Reliacinis Žemėlapis)

ORM karkasai (pvz., Hibernate, JPA, pagrįsta Hibernate) automatizuoja Java objektų ir duomenų bazės lentelių atvaizdavimą. Jie leidžia dirbti su duomenimis kaip su Java objektais, nesinaudojant SQL.

Pagrindinės sąvokos:

• Entity: paprastas POJO klasė, pažymėta specialiomis anotacijomis, atitinka lentelę duomenų bazėje.
• Annotations: naudojamos aprašyti ryšius tarp klasės ir lentelės, laukų ir stulpelių, taip pat ryšius tarp entitetų (vienas su vienu, vienas su daug).
• EntityManager (JPA) / Session (Hibernate): sąsajos, kurios atlieka operacijas su entitetais (saugojimas, atnaujinimas, trinimas, paieška).

Pavyzdys entitetui:

// Pavyzdinis User entitetas
import javax.persistence.*;

@Entity // Nurodo, kad tai entitetas
@Table(name = "users") // Nurodo atitinkančios lentelės pavadinimą
public class User {

    @Id // Pagrindinis raktas
    @GeneratedValue(strategy = GenerationType.IDENTITY) // ID generavimo strategija
    private Long id;

    @Column(name = "name") // Stulpelio pavadinimas
    private String name;

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

    // Geteriai, seteriai, konstruktoriai
    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;
    }
}

JPA naudojant išsaugoti entitetą pavyzdys:

// Entiteto išsaugojimo pavyzdys
import javax.persistence.*;

EntityManagerFactory emf = Persistence.createEntityManagerFactory("my_persistence_unit"); // iš 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); // išsaugojimas

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

Pasirinkimas tarp JDBC ir ORM:

Savybė	JDBC	ORM (JPA/Hibernate)
Sudėtingumas	Žemas lygis, daugiau kodo.	Aukštas lygis, mažiau kodo.
Lankstumas	Pilnas kontrolė SQL.	Ribotas tiesioginis SQL darbo lankstumas.
Veikimo efektyvumas	Potencialiai aukštesnis, rankiniu būdu optimizuojant.	Gali būti žemesnis dėl ORM papildomų išlaidų.
Kūrimo laikas	Daugiau laiko reikalaujantis.	Mažiau laiko, automatizacija.
Ryšių palaikymas	Reikalauja rankinio įgyvendinimo.	Automatizuotas (vienas su vienu, vienas su daug).

Dažniausiai šiuolaikinėse Java programose naudojami ORM karkasai dėl jų efektyvumo kūrimo ir palaikymo. JDBC naudojamas tada, kai reikalinga pilna kontrolė SQL arba ORM netinka dėl tam tikrų priežasčių (pvz., labai specifinės optimizacijos).