Ինչպե՞ս կարելի է դասը կապել տվյալների բազայի հետ Java-ում։

Java- ում դասի կապը տվյալների բազայի հետ սովորաբար իրականացվում է օբյեկտ-ռելյացիոն մոդելավորման (ORM) կամ JDBC տեխնոլոգիաների միջոցով:

JDBC (Java Database Connectivity)

JDBC-ն API է, որը տրամադրում է ստանդարտ միջոց տվյալների ռելյացիոն բազաներին մուտք գործելու համար: Այն թույլ է տալիս կատարել SQL հարցումներ Java կոդից:

Քայլեր:

1. Տվյալների բազայի վարորդի բեռնում
2. Կապ հաստատում (Connection)
3. Statement կամ PreparedStatement օբյեկտի ստեղծում
4. SQL հարցման կատարում
5. Արդյունքների մշակումը (ResultSet)
6. Ռեսուրսների փակումը (Connection, Statement, ResultSet)

Օրինակ տվյալների ստացման համար:

// Օրինակ `users` աղյուսակից տվյալների ստացման
Connection connection = null;
Statement statement = null;
ResultSet resultSet = null;

try {
    // Վարորդի բեռնում (կախված տվյալների բազայից)
    Class.forName("org.postgresql.Driver"); // Օրինակ PostgreSQL-ի համար

    // Կապ հաստատում
    connection = DriverManager.getConnection("jdbc:postgresql://localhost:5432/mydatabase", "user", "password");

    // `Statement` ստեղծում
    statement = connection.createStatement();

    // Հարցում կատարում
    resultSet = statement.executeQuery("SELECT id, name, email FROM users");

    // Արդյունքների մշակումը
    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 {
    // Ռեսուրսների փակումը
    try {
        if (resultSet != null) resultSet.close();
        if (statement != null) statement.close();
        if (connection != null) connection.close();
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

ORM (Օբյեկտ-Ռելյացիոն Մոդելավորում)

ORM-ֆրեյմվորկերը (օրինակ, Hibernate, JPA Hibernate-ի վրա հիմնված) ավտոմատացնում են Java օբյեկտների և տվյալների բազայի աղյուսակների միջև ցուցադրության գործընթացը: Նրանք թույլ են տալիս աշխատել տվյալների հետ որպես Java օբյեկտների, առանց SQL-ի:

Հիմնական հասկացություններ՝

• Entity: սովորական POJO դաս, որը նշված է հատուկ անոտացիաներով և համապատասխանում է բազայի աղյուսակին:
• Annotations: օգտագործվում են կապերի նկարագրության համար դասի և աղյուսակի, դաշտերի և սյունակների միջև, ինչպես նաև հարաբերությունների (մեկ-մեկ, մեկից շատ) համար:
• EntityManager (JPA) / Session (Hibernate): ինտերֆեյսներ, որոնք իրականացնում են գործողություններ entities-ների հետ (պահպանում, թարմացում, ջնջում, որոնում):

Օրինակ entity:

// Օրինակ User entity
import javax.persistence.*;

@Entity // Նշում է, որ սա entity է
@Table(name = "users") // Նշում է համապատասխան աղյուսակի անունը
public class User {

    @Id // Նշում է հիմնական բանալին
    @GeneratedValue(strategy = GenerationType.IDENTITY) // ID սերնդի ռազմավարություն
    private Long id;

    @Column(name = "name") // Նշում է համապատասխան սյունակի անունը
    private String name;

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

    // Գеттерներ, սեթերներ, կոնստրուկտորներ
    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-ի միջոցով entity պահպանելու օրինակ:

// Entity պահպանելու օրինակ
import javax.persistence.*;

EntityManagerFactory emf = Persistence.createEntityManagerFactory("my_persistence_unit"); // my_persistence_unit-ը 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); // Entity պահպանում

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

JDBC և ORM միջև ընտրություն:

Հատկանիշներ	JDBC	ORM (JPA/Hibernate)
Կատարման բարդություն	Ներքին մակարդակ, շատ կոդ։	Բարձր մակարդակ, քիչ կոդ։
Գործունակություն	Լրիվ վերահսկողություն SQL-ի նկատմամբ։	Սահմանափակ գործունակություն SQL-ի ուղղակի աշխատանքի համար։
Արդյունավետություն	Potentiellement բարձր, ձեռքով օպտիմիզացիայով։	Միջնորդային ծախսերի պատճառով կարող է ցածր լինել։
Ամենօրյա աշխատանք	Ավելի շատ ժամանակ պահանջում է տվյալների մշակման համար։	Փոքր ժամանակ, ավտոմատացումներ։
Հարաբերությունների աջակցություն	Հեռու իրականացման կարիք ունի։	Ավտոմատացված (մեկ-մեկ, մեկից շատ):

Ընդհանուր առմամբ, ժամանակակից Java հավելվածներում օգտագործվում են ORM-ֆրեյմվորկեր՝ արդյունավետության և պահպանման համար: JDBC օգտագործվում է այն դեպքերում, երբ անհրաժեշտ է լրիվ վերահսկողություն SQL-ի նկատմամբ կամ ORM-ը չի համապատասխանում (օրինակ՝ շատ հատուկ օպտիմիզացիաներ):