तुमचा पहिला हायबरनेट अॅप्लिकेशन

या लेखात, तुम्ही Java साठी सर्वात लोकप्रिय एंटरप्राइझ फ्रेमवर्कशी परिचित व्हाल आणि तुमचा पहिला हायबरनेट अनुप्रयोग तयार कराल. हायबरनेट बद्दल कधीही ऐकले नाही? किंवा कदाचित आपण ते ऐकले असेल, परंतु ते वापरले नाही? किंवा कदाचित आपण ते वापरण्याचा प्रयत्न केला, परंतु अयशस्वी झाला? सर्व तीन प्रकरणांमध्ये - कटच्या खाली आपले स्वागत आहे :) नमस्कार, प्रत्येकजण! या लेखात, मी हायबरनेट फ्रेमवर्कच्या मुख्य वैशिष्ट्यांबद्दल बोलेन आणि तुम्हाला तुमचा पहिला मिनी-अॅप्लिकेशन लिहिण्यात मदत करेन. यासाठी, आम्हाला आवश्यक आहे:

1. IntelliJ IDEA Ultimate Edition अधिकृत वेबसाइटवरून
   डाउनलोड करा आणि 30-दिवसांची चाचणी आवृत्ती सक्रिय करा.
2. PostgreSQL - सर्वात लोकप्रिय आधुनिक डेटाबेस व्यवस्थापन प्रणालींपैकी एक (DBMS)
3. मावेन (आधीपासूनच IDEA पर्यंत वायर्ड)
4. थोडा संयम.

फक्त बाबतीत, मी GitHub (codegym शाखा) वर अनुप्रयोग कोड पोस्ट केला आहे. लेख मुख्यतः त्यांच्यासाठी आहे ज्यांनी या तंत्रज्ञानासह यापूर्वी कधीही काम केले नाही, म्हणून मी कोडचे प्रमाण कमी केले आहे. चला सुरू करुया!

हायबरनेट म्हणजे काय?

हे सर्वात लोकप्रिय ऑब्जेक्ट-रिलेशनल मॅपिंग (ORM) अंमलबजावणींपैकी एक आहे. ऑब्जेक्ट-रिलेशनल मॅपिंग सॉफ्टवेअर ऑब्जेक्ट्स आणि डेटाबेस रेकॉर्डमधील संबंध परिभाषित करते. अर्थात, हायबरनेटमध्ये खूप विस्तृत कार्यक्षमता आहे, परंतु आम्ही सर्वात सोप्या कार्यांवर लक्ष केंद्रित करू. आमचे ध्येय CRUD (तयार करा, वाचा, अद्यतनित करा, हटवा) अनुप्रयोग तयार करणे आहे जे सक्षम असेल:

1. वापरकर्ते (वापरकर्ता) तयार करा, त्यांना डेटाबेसमध्ये ID द्वारे शोधा, डेटाबेसमध्ये त्यांचा डेटा अद्यतनित करा आणि त्यांना डेटाबेसमधून हटवा.
2. वापरकर्त्यांना कार वस्तू (ऑटो) नियुक्त करा. डेटाबेसमधून कार तयार करा, अपडेट करा, शोधा आणि हटवा.
3. याव्यतिरिक्त, अनुप्रयोगाने डेटाबेसमधून "मालकविरहित" कार स्वयंचलितपणे काढल्या पाहिजेत. दुसऱ्या शब्दांत, जेव्हा एखादा वापरकर्ता हटविला जातो, तेव्हा त्या वापरकर्त्याच्या मालकीच्या सर्व कार देखील डेटाबेसमधून हटविल्या पाहिजेत.

आमच्या प्रकल्पाची रचना याप्रमाणे केली जाईल: जसे आपण पाहू शकता, काहीही क्लिष्ट नाही. कॉन्फिगसह 6 वर्ग + 1 फाइल. प्रथम, IntelliJ IDEA मध्ये एक नवीन Maven प्रकल्प तयार करा. फाइल -> नवीन प्रकल्प. प्रस्तावित प्रकल्प प्रकारांपैकी Maven निवडा आणि पुढील चरणावर जा. Apache Maven POM फाइल्समधील त्यांच्या संरचनेच्या वर्णनावर आधारित प्रकल्प स्वयंचलितपणे तयार करण्यासाठी एक फ्रेमवर्क आहे. तुमच्या प्रकल्पाच्या संपूर्ण संरचनेचे वर्णन pom.xml मध्ये केले जाईल, एक फाइल जी IDEA स्वतः तुमच्या प्रोजेक्टच्या रूटमध्ये तयार करेल. प्रोजेक्ट सेटिंग्जमध्ये, तुम्हाला खालील मॅवेन सेटिंग्ज निर्दिष्ट करण्याची आवश्यकता आहे: ग्रुपआयडी आणि आर्टिफॅक्टआयडी. प्रकल्पांमध्ये, ग्रुपआयडी हे सहसा कंपनी किंवा व्यवसाय युनिटचे वर्णन असते. कंपनीचे डोमेन नाव किंवा वेबसाइट येथे जाऊ शकते. त्या बदल्यात, artifactId हे प्रकल्पाचे नाव आहे. GroupdId साठी, तुम्ही एंटर करू शकता com.yourNickname.codegym. याचा अनुप्रयोगावर कोणताही परिणाम होणार नाही. आर्टिफॅक्टआयडीसाठी, तुम्हाला आवडणारे कोणतेही प्रकल्प नाव निवडा. आवृत्ती अपरिवर्तित सोडली जाऊ शकते. शेवटच्या स्क्रीनवर, पूर्वी प्रविष्ट केलेल्या डेटाची फक्त पुष्टी करा.म्हणून, आम्ही प्रकल्प तयार केला. आता फक्त काही कोड लिहिणे आणि ते कार्य करणे बाकी आहे :) प्रथम गोष्टी: जर आम्हाला डेटाबेससह कार्य करणारा अनुप्रयोग तयार करायचा असेल तर आम्ही डेटाबेसशिवाय करू शकत नाही! येथून PostgreSQL डाउनलोड करा (मी आवृत्ती 9 वापरत आहे). PostgreSQL मध्ये डीफॉल्ट वापरकर्ता 'postgres' आहे — तुम्ही जेव्हा इन्स्टॉल करता तेव्हा तुम्हाला त्यासाठी पासवर्ड विचार करावा लागेल. पासवर्ड विसरू नका. आम्हाला ते नंतर लागेल! (सर्वसाधारणपणे, ऍप्लिकेशन्समध्ये डीफॉल्ट डेटाबेस वापरणे ही वाईट पद्धत आहे, परंतु आम्ही आपला स्वतःचा डेटाबेस तयार करून अल्सरच्या कारणांची संख्या कमी करण्यासाठी ते करू). तुम्ही कमांड लाइन आणि SQL क्वेरीचे मित्र नसल्यास, चांगली बातमी आहे. IntelliJ IDEA डेटाबेससह कार्य करण्यासाठी पूर्णपणे योग्य वापरकर्ता इंटरफेस प्रदान करते. (IDEA च्या उजव्या उपखंडावर, डेटाबेस टॅबवर स्थित आहे). कनेक्शन तयार करण्यासाठी, "+" क्लिक करा आणि आमचा डेटा स्रोत (PostgeSQL) निवडा. वापरकर्ता आणि डेटाबेस (दोन्हींसाठी "पोस्टग्रेस") फील्ड भरा आणि पोस्टग्रेएसक्यूएलच्या स्थापनेदरम्यान सेट केलेला पासवर्ड प्रविष्ट करा. आवश्यक असल्यास, पोस्टग्रेस ड्राइव्हर डाउनलोड करा. आपण हे त्याच पृष्ठावर करू शकता. डेटाबेस कनेक्शन स्थापित झाले आहे हे सत्यापित करण्यासाठी "कनेक्शन चाचणी" वर क्लिक करा. जर तुम्हाला "यशस्वी" दिसत असेल तर पुढे जा. आता आपण आवश्यक टेबल तयार करू. एकूण दोन असतील: वापरकर्ते आणि ऑटो. वापरकर्त्यांच्या सारणीसाठी पॅरामीटर्स: लक्षात घ्या की आयडी ही प्राथमिक की आहे. एसक्यूएलमध्ये प्राथमिक की काय आहे हे तुम्हाला माहिती नसल्यास, ते Google करा. हे महत्वाचे आहे. ऑटो टेबलसाठी सेटिंग्ज: ऑटो टेबलसाठी, तुम्हाला परदेशी की कॉन्फिगर करणे आवश्यक आहे. हे आमच्या टेबलांना जोडण्यासाठी काम करेल. मी शिफारस करतो की आपण याबद्दल अधिक वाचा. सोप्या भाषेत सांगायचे तर ते बाह्य सारणीचा संदर्भ देते, आमच्या बाबतीत, वापरकर्ते. जर एखादी कार आयडी = 1 असलेल्या वापरकर्त्याची असेल, तर ऑटोचे user_id फील्ड 1 च्या बरोबरीचे असेल. आम्ही आमच्या ऍप्लिकेशनमध्ये अशा प्रकारे वापरकर्त्यांना त्यांच्या कारशी जोडतो. आमच्या ऑटो टेबलमध्ये, user_id फील्ड परदेशी की म्हणून काम करेल. ते वापरकर्त्यांच्या टेबलच्या आयडी फील्डचा संदर्भ देईल. तर, आम्ही दोन टेबलांसह डेटाबेस तयार केला आहे. जावा कोडमधून ते कसे व्यवस्थापित करावे हे समजून घेणे बाकी आहे. आम्ही pom.xml फाईलसह प्रारंभ करू, ज्यामध्ये आम्हाला आवश्यक लायब्ररी समाविष्ट करणे आवश्यक आहे (Maven मध्ये त्यांना अवलंबन म्हणतात). सर्व लायब्ररी मध्यवर्ती मावेन भांडारात संग्रहित आहेत. तुम्ही pom.xml मध्ये निर्दिष्ट केलेल्या लायब्ररी तुमच्या प्रकल्पात वापरण्यासाठी उपलब्ध आहेत. तुमचे pom.xml असे दिसले पाहिजे: काहीही क्लिष्ट नाही, जसे तुम्ही पाहू शकता. PostgreSQL आणि हायबरनेट वापरण्यासाठी आम्ही फक्त 2 अवलंबित्व जोडले. आता जावा कोडकडे वळू. प्रकल्पातील सर्व आवश्यक पॅकेजेस आणि वर्ग तयार करा. प्रारंभ करण्यासाठी, आम्हाला डेटा मॉडेलची आवश्यकता आहे: Userआणि Autoवर्ग.

package models;

import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;

@Entity
@Table (name = "users")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    @Column(name = "name")
    private String name;
    // You can omit the Column attribute if the name property matches the column name in the table
    private int age;

    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Auto> autos;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
        autos = new ArrayList<>();
    }

    public void addAuto(Auto auto) {
        auto.setUser(this);
        autos.add(auto);
    }

    public void removeAuto(Auto auto) {
        autos.remove(auto);
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public List<Auto> getAutos() {
        return autos;
    }

    public void setAutos(List<Auto> autos) {
        this.autos = autos;
    }

    @Override
    public String toString() {
        return "models.User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package models;

import javax.persistence.*;

@Entity
@Table(name = "autos")
public class Auto {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @Column (name = "model")
    private String model;

    // You can omit the Column attribute if the name property matches the column name in the table
    private String color;


    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "user_id")
    private User user;

    public Auto() {
    }

    public Auto(String model, String color) {
        this.model = model;
        this.color = color;
    }

    public int getId() {
        return id;
    }

    public String getModel() {
        return model;
    }

    public void setModel(String model) {
        this.model = model;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    @Override
    public String toString() {
        return color + " " + model;
    }
}

जसे तुम्ही बघू शकता, वर्गांमध्ये अनेक अस्पष्ट भाष्ये आहेत. चला त्यांच्यामध्ये खोदणे सुरू करूया. आमच्यासाठी, मुख्य भाष्य @Entity आहे. त्याबद्दल विकिपीडियावर वाचा आणि मनापासून जाणून घ्या. हा पायाचा पाया आहे. हे भाष्य तुमच्या Java वर्गातील वस्तू डेटाबेसमध्ये मॅप करू देते. वर्ग एक घटक होण्यासाठी, त्याने खालील आवश्यकता पूर्ण केल्या पाहिजेत:

• त्यात रिक्त कन्स्ट्रक्टर ( publicकिंवा protected) असणे आवश्यक आहे
• हे नेस्टेड केले जाऊ शकत नाही, इंटरफेस किंवा एenum
• हे फील्ड/गुणधर्म असू शकत नाही finalआणि असू शकत नाहीfinal
• त्यात किमान एक @Id फील्ड असणे आवश्यक आहे.

तुमचे घटक वर्ग तपासा: स्वतःला पायात गोळ्या घालण्यासाठी ती खूप लोकप्रिय ठिकाणे आहेत. काहीतरी विसरणे खूप सोपे आहे. शिवाय, एखादी संस्था पुढील गोष्टी करू शकते:

• यात रिक्त नसलेले कन्स्ट्रक्टर असू शकतात
• तो वारसा आणि वारसा मिळू शकतो
• यात इतर पद्धती असू शकतात आणि इंटरफेस लागू करू शकतात.

जसे आपण पाहू शकता, Userवर्ग वापरकर्त्यांच्या सारणीसारखेच आहे. त्यात id, name, आणि आहेageफील्ड त्यांच्या वर असलेल्या भाष्यांना कोणत्याही विशिष्ट स्पष्टीकरणाची आवश्यकता नाही: हे स्पष्ट आहे की @Id हे फील्ड या वर्गातील ऑब्जेक्ट्सचे अभिज्ञापक असल्याचे सूचित करते. वर्गाच्या वरील @Table भाष्य हे सारणीचे नाव दर्शवते जेथे वस्तू लिहिल्या जातात. वय फील्डवरील टिप्पणी लक्षात घ्या: जर वर्गातील फील्डचे नाव टेबलच्या नावाप्रमाणेच असेल, तर तुम्ही @Column भाष्य वगळू शकता आणि ते कार्य करेल. ब्रेसेसमध्ये दर्शविलेल्या भागासाठी ("strategy = GenerationType.IDENTITY"): आयडी तयार करण्यासाठी अनेक धोरणे आहेत. तुम्ही त्यांना Google करू शकता, परंतु आमच्या अनुप्रयोगासाठी, त्रास देण्याची गरज नाही. मुख्य म्हणजे आमच्या ऑब्जेक्ट्ससाठी id चे मूल्य आपोआप तयार होईल. त्यानुसार, आयडीसाठी कोणतेही सेटर नाही आणि आम्ही ते कन्स्ट्रक्टरमध्ये देखील सेट करत नाही. तथापि,Userवर्ग वेगळे आहे. त्यात गाड्यांची यादी आहे! @OneToMany भाष्य सूचीच्या वर लटकलेले आहे. याचा अर्थ असा की अनेक कार वापरकर्ता वर्गाच्या समान ऑब्जेक्टशी संबंधित असू शकतात. "mappedBy" घटक वर्गाच्या वापरकर्ता फील्डचा संदर्भ देतो Auto. अशा प्रकारे, कार आणि वापरकर्ते संबंधित आहेत. orphanRemoval घटक यापुढे संबंध नसलेल्या घटकांना काढण्याची क्रिया लागू करायची की नाही हे सूचित करते. आम्ही डेटाबेसमधून वापरकर्ता हटविल्यास, त्याच्याशी संबंधित सर्व कार देखील हटविल्या जातील. यामधून, मध्येAutoवर्गात, तुम्हाला @ManyToOne भाष्य (एक वापरकर्ता अनेक ऑटोशी संबंधित असू शकतो) आणि @JoinColumn भाष्यासह वापरकर्ता फील्ड दिसेल. हे सूचित करते की ऑटो टेबलमधील कोणता स्तंभ वापरकर्त्यांच्या सारणीचा संदर्भ देण्यासाठी वापरला जातो (म्हणजेच परदेशी की ज्याबद्दल आपण आधी बोललो होतो). डेटा मॉडेल तयार केल्यानंतर, आमच्या प्रोग्रामला डेटाबेसमधील डेटासह ऑपरेशन्स करण्यास शिकवण्याची वेळ आली आहे. चला HibernateSessionFactoryUtil युटिलिटी क्लासपासून सुरुवात करूया. त्याचे फक्त एकच काम आहे - डेटाबेससह कार्य करण्यासाठी आमच्या अनुप्रयोगासाठी सत्र कारखाना तयार करणे (फॅक्टरी डिझाइन पॅटर्नला नमस्कार म्हणा!). बाकी काही कसं करायचं ते कळत नाही.

package utils;

import models.Auto;
import models.User;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;

public class HibernateSessionFactoryUtil {
    private static SessionFactory sessionFactory;

    private HibernateSessionFactoryUtil() {}

    public static SessionFactory getSessionFactory() {
        if (sessionFactory == null) {
            try {
                Configuration configuration = new Configuration().configure();
                configuration.addAnnotatedClass(User.class);
                configuration.addAnnotatedClass(Auto.class);
                StandardServiceRegistryBuilder builder = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties());
                sessionFactory = configuration.buildSessionFactory(builder.build());

            } catch (Exception e) {
                System.out.println("Исключение!" + e);
            }
        }
        return sessionFactory;
    }
}

या वर्गात, आम्ही एक नवीन कॉन्फिगरेशन ऑब्जेक्ट तयार करतो, आणि त्यास घटक म्हणून हाताळले पाहिजे असे वर्ग पास करतो: Userआणि Auto. पद्धतीकडे लक्ष द्या configuration.getProperties(). इतर कोणते गुणधर्म आहेत? ते कोठून आले आहेत? गुणधर्म ही विशेष hibernate.cfg.xml फाइलमध्ये दर्शविलेली हायबरनेट सेटिंग्ज आहेत. Hibernate.cfg.xml येथे वाचले आहे: new Configuration().configure(); जसे तुम्ही पाहत आहात, त्यात काही विशेष नाही: त्यात डेटाबेसशी कनेक्ट करण्यासाठी पॅरामीटर्स, तसेच show_sql पॅरामीटर आहेत. हे आवश्यक आहे जेणेकरून हायबरनेटद्वारे कार्यान्वित केलेल्या सर्व sql क्वेरी कन्सोलवर प्रदर्शित केल्या जातील. अशा प्रकारे तुम्हाला हायबरनेट कोणत्याही क्षणी नेमके काय करत आहे हे दिसेल, "जादू" ची कोणतीही भावना काढून टाकते. पुढे आम्हाला आवश्यक आहेUserDAOवर्ग इंटरफेसद्वारे प्रोग्राम करणे ही सर्वोत्तम सराव आहे - एक स्वतंत्र UserDAOइंटरफेस आणि UserDAOImplअंमलबजावणी तयार करा, परंतु कोडचे प्रमाण कमी करण्यासाठी मी हे वगळेन. वास्तविक प्रकल्पांमध्ये हे करू नका! DAO (डेटा ऍक्सेस ऑब्जेक्ट) डिझाइन पॅटर्न सर्वात सामान्य आहे. कल्पना अगदी सोपी आहे — फक्त डेटा ऍक्सेस करण्यासाठी जबाबदार ऍप्लिकेशन स्तर तयार करा, आणखी काही नाही. डेटाबेसमधून डेटा मिळवा, डेटा अद्यतनित करा, डेटा हटवा - इतकेच. DAO बद्दल अधिक अभ्यास करा. तुम्ही तुमच्या कामात डेटा ऍक्सेस ऑब्जेक्ट्सचा सतत वापर कराल. आमचा UserDaoवर्ग काय करू शकतो? बरं, सर्व DAO प्रमाणे, ते केवळ डेटासह कार्य करू शकते. आयडीद्वारे वापरकर्ता शोधा, त्याचा डेटा अद्यतनित करा, तो हटवा, डेटाबेसमधून सर्व वापरकर्त्यांची यादी मिळवा किंवा डेटाबेसमध्ये नवीन वापरकर्ता जतन करा - हीच त्याची संपूर्ण कार्यक्षमता आहे.

package dao;

import models.Auto;
import models.User;
import org.hibernate.Session;
import org.hibernate.Transaction;
import utils.HibernateSessionFactoryUtil;
import java.util.List;

public class UserDao {

    public User findById(int id) {
        return HibernateSessionFactoryUtil.getSessionFactory().openSession().get(User.class, id);
    }

    public void save(User user) {
        Session session = HibernateSessionFactoryUtil.getSessionFactory().openSession();
        Transaction tx1 = session.beginTransaction();
        session.save(user);
        tx1.commit();
        session.close();
    }

    public void update(User user) {
        Session session = HibernateSessionFactoryUtil.getSessionFactory().openSession();
        Transaction tx1 = session.beginTransaction();
        session.update(user);
        tx1.commit();
        session.close();
    }

    public void delete(User user) {
        Session session = HibernateSessionFactoryUtil.getSessionFactory().openSession();
        Transaction tx1 = session.beginTransaction();
        session.delete(user);
        tx1.commit();
        session.close();
    }

    public Auto findAutoById(int id) {
        return HibernateSessionFactoryUtil.getSessionFactory().openSession().get(Auto.class, id);
    }

    public List<User> findAll() {
        List<User> users = (List<User>) HibernateSessionFactoryUtil.getSessionFactory().openSession().createQuery("From User").list();
        return users;
    }
}

UserDaoच्या पद्धती एकमेकांसारख्या आहेत. त्यापैकी बहुतेकांमध्ये, आम्हाला आमच्या सत्र फॅक्टरी वापरून एक सत्र ऑब्जेक्ट (डेटाबेस कनेक्शन सत्र) मिळतो, या सत्रात एकच व्यवहार तयार करतो, आवश्यक डेटा हाताळणी करतो, डेटाबेसमध्ये व्यवहाराचा निकाल जतन करतो आणि नंतर सत्र बंद करतो . पद्धती स्वतःच, जसे आपण पाहू शकता, अगदी सोप्या आहेत. DAO हे आमच्या अर्जाचे "हृदय" आहे. तथापि, आम्ही थेट DAO तयार करणार नाही आणि आमच्या पद्धतीत त्याच्या पद्धती कॉल करणार नाही main(). सर्व तर्कशास्त्र वर्गात हलवले जाईल UserService.

package services;

import dao.UserDao;
import models.Auto;
import models.User;

import java.util.List;

public class UserService {

    private UserDao usersDao = new UserDao();

    public UserService() {
    }

    public User findUser(int id) {
        return usersDao.findById(id);
    }

    public void saveUser(User user) {
        usersDao.save(user);
    }

    public void deleteUser(User user) {
        usersDao.delete(user);
    }

    public void updateUser(User user) {
        usersDao.update(user);
    }

    public List<User> findAllUsers() {
        return usersDao.findAll();
    }

    public Auto findAutoById(int id) {
        return usersDao.findAutoById(id);
    }


}

सेवा हा एक अनुप्रयोग डेटा स्तर आहे जो व्यवसाय तर्क कार्यान्वित करण्यासाठी जबाबदार असतो. तुमच्या प्रोग्रामला काही प्रकारचे व्यावसायिक तर्क कार्यान्वित करायचे असल्यास, ते सेवांद्वारे तसे करते. सेवेमध्ये UserDaoत्याच्या पद्धतींमध्ये DAO पद्धतींचा समावेश असतो आणि कॉल करतो. असे दिसते की आम्ही येथे फंक्शन्सची डुप्लिकेट करत आहोत (फक्त DAO ऑब्जेक्टवरून पद्धती का कॉल करू नये?), परंतु बरेच ऑब्जेक्ट्स आणि जटिल लॉजिकसह, ऍप्लिकेशनला लेयर करणे खूप फायदे देते (असे करणे चांगले सराव आहे — भविष्यात हे लक्षात ठेवा आणि "अनुप्रयोग स्तर" बद्दल वाचा). आमच्या सेवेमध्ये साधे तर्कशास्त्र आहे, परंतु वास्तविक-जगातील प्रकल्पांमधील सेवा पद्धतींमध्ये कोडच्या एकापेक्षा जास्त ओळींचा समावेश आहे :) आता आपल्याकडे अनुप्रयोग चालविण्यासाठी आवश्यक असलेले सर्वकाही आहे! पद्धतीमध्ये main(), वापरकर्ता आणि त्याची कार तयार करू, एकाला दुसऱ्याशी जोडू आणि डेटाबेसमध्ये सेव्ह करू.

import models.Auto;
import models.User;
import services.UserService;

import java.sql.SQLException;

public class Main {
    public static void main(String[] args) throws SQLException {

        UserService userService = new UserService();
        User user = new User ("Jenny", 26);
        userService.saveUser(user);
        Auto ferrari = new Auto("Ferrari", "red");
        ferrari.setUser(user);
        user.addAuto(ferrari);
        Auto ford = new Auto("Ford", "black");
        ford.setUser(user);
        user.addAuto(ford);
        userService.updateUser(user);
    }
}

जसे आपण पाहू शकता, वापरकर्त्यांच्या टेबलचे स्वतःचे रेकॉर्ड आहे आणि ऑटो टेबलचे स्वतःचे रेकॉर्ड आहे. चला आमच्या वापरकर्त्याचे नाव बदलण्याचा प्रयत्न करूया. वापरकर्ते टेबल साफ करा आणि कोड कार्यान्वित करा

import models.Auto;
import models.User;
import services.UserService;

import java.sql.SQLException;

public class Main {
    public static void main(String[] args) throws SQLException {

        UserService userService = new UserService();
        User user = new User ("Jenny", 26);
        userService.saveUser(user);
        Auto ferrari = new Auto("Ferrari", "red");
        user.addAuto(ferrari);
        Auto ford = new Auto("Ford", "black");
        ford.setUser(user);
        user.addAuto(ford);
        userService.updateUser(user);
        user.setName ("Benny");
        userService.updateUser(user);
    }
}

ते कार्य करते! जर तुम्ही वापरकर्ता हटवला तर? वापरकर्ते टेबल साफ करा (ऑटो स्वतःच साफ होतील) आणि कोड कार्यान्वित करा

import models.Auto;
import models.User;
import services.UserService;

import java.sql.SQLException;

public class Main {
    public static void main(String[] args) throws SQLException {

        UserService userService = new UserService();
        User user = new User ("Jenny", 26);
        userService.saveUser(user);
        Auto ferrari = new Auto("Ferrari", "red");
        user.addAuto(ferrari);
        Auto ford = new Auto("Ford", "black");
        ford.setUser(user);
        user.addAuto(ford);
        userService.updateUser(user);
        user.setName ("Benny");
        userService.updateUser(user);
        userService.deleteUser(user);
    }
}

आणि आमची टेबल्स पूर्णपणे रिकामी आहेत (कन्सोलकडे लक्ष द्या — हायबरनेटद्वारे केलेल्या सर्व विनंत्या तेथे प्रदर्शित केल्या जातील). आपण अनुप्रयोगासह खेळू शकता आणि त्याची सर्व कार्ये वापरून पाहू शकता. उदाहरणार्थ, कारसह वापरकर्ता तयार करा, डेटाबेसमध्ये सेव्ह करा, वापरकर्त्याला नियुक्त केलेला आयडी पहा आणि हा आयडी वापरण्याचा प्रयत्न कराmain()वापरकर्त्याला डेटाबेसमधून आणण्यासाठी आणि कन्सोलवर त्याच्या कारची सूची प्रदर्शित करण्याची पद्धत. अर्थात, आम्ही हायबरनेटच्या कार्यक्षमतेचा फक्त एक छोटासा भाग पाहिला आहे. त्याची क्षमता खूप विस्तृत आहे आणि जावा विकासासाठी हे एक मानक उद्योग साधन आहे. जर तुम्हाला त्याचा तपशीलवार अभ्यास करायचा असेल तर मी "Java Persistence API आणि Hibernate" या पुस्तकाची शिफारस करू शकतो. मी मागील लेखात पुनरावलोकन केले. मला आशा आहे की हा लेख वाचकांसाठी उपयुक्त ठरला आहे. आपल्याकडे प्रश्न असल्यास, त्यांना टिप्पण्यांमध्ये विचारा. मला उत्तर देण्यास आनंद होईल :) तसेच, "लाइक" पोस्ट करून लेखकास स्पर्धेत समर्थन करण्यास विसरू नका. किंवा अजून चांगले — "प्रेम करा" :) तुमच्या अभ्यासात शुभेच्छा!