आपका पहला हाइबरनेट अनुप्रयोग

इस लेख में, आप जावा के लिए सबसे लोकप्रिय उद्यम रूपरेखाओं में से एक से परिचित होंगे और अपना पहला हाइबरनेट एप्लिकेशन बनाएंगे। हाइबरनेट के बारे में कभी नहीं सुना? या हो सकता है कि आपने इसके बारे में सुना हो, लेकिन इसका इस्तेमाल नहीं किया हो? या शायद आपने इसका इस्तेमाल करने की कोशिश की, लेकिन असफल रहे? तीनों मामलों में - कट के नीचे आपका स्वागत है :) सभी को नमस्कार! इस लेख में, मैं हाइबरनेट फ्रेमवर्क की मुख्य विशेषताओं के बारे में बात करूँगा और आपको अपना पहला मिनी-एप्लिकेशन लिखने में मदद करूँगा। इसके लिए हमें चाहिए:

1. IntelliJ IDEA अल्टीमेट एडिशन
   इसे आधिकारिक वेबसाइट से डाउनलोड करें और 30-दिवसीय परीक्षण संस्करण को सक्रिय करें।
2. PostgreSQL - सबसे लोकप्रिय आधुनिक डेटाबेस प्रबंधन प्रणालियों (DBMS) में से एक
3. मेवेन (पहले से ही आईडीईए तक वायर्ड)
4. थोड़ा धीरज।

बस मामले में, मैंने GitHub (codegym शाखा) पर एप्लिकेशन कोड पोस्ट किया । लेख मुख्य रूप से उन लोगों के लिए लक्षित है जिन्होंने पहले कभी इस तकनीक के साथ काम नहीं किया है, इसलिए मैंने कोड की मात्रा कम कर दी है। आएँ शुरू करें!

हाइबरनेट क्या है?

यह सबसे लोकप्रिय ऑब्जेक्ट-रिलेशनल मैपिंग (ORM) कार्यान्वयनों में से एक है। ऑब्जेक्ट-रिलेशनल मैपिंग सॉफ्टवेयर ऑब्जेक्ट्स और डेटाबेस रिकॉर्ड्स के बीच संबंध को परिभाषित करता है। बेशक, हाइबरनेट की कार्यक्षमता बहुत व्यापक है, लेकिन हम सबसे सरल कार्यों पर ध्यान केंद्रित करेंगे। हमारा लक्ष्य एक CRUD (क्रिएट, रीड, अपडेट, डिलीट) एप्लिकेशन बनाना है जो सक्षम होगा:

1. उपयोगकर्ता (उपयोगकर्ता) बनाएँ, उन्हें डेटाबेस में आईडी द्वारा खोजें, डेटाबेस में उनके डेटा को अपडेट करें और उन्हें डेटाबेस से हटा दें।
2. उपयोगकर्ताओं को कार ऑब्जेक्ट (ऑटो) असाइन करें। डेटाबेस से कार बनाएं, अपडेट करें, ढूंढें और हटाएं।
3. इसके अतिरिक्त, एप्लिकेशन को डेटाबेस से "मालिकहीन" कारों को स्वचालित रूप से हटा देना चाहिए। दूसरे शब्दों में, जब एक उपयोगकर्ता को हटा दिया जाता है, तो उस उपयोगकर्ता की सभी कारों को भी डेटाबेस से हटा दिया जाना चाहिए।

हमारी परियोजना इस तरह संरचित होगी: जैसा कि आप देख सकते हैं, कुछ भी जटिल नहीं है। कॉन्फ़िगरेशन के साथ 6 कक्षाएं + 1 फ़ाइल। सबसे पहले, IntelliJ IDEA में एक नया मावेन प्रोजेक्ट बनाएं। फ़ाइल -> नई परियोजना। प्रस्तावित परियोजना प्रकारों में से मावेन का चयन करें और अगले चरण पर जाएँ। अपाचे मावेन पीओएम फाइलों में उनकी संरचना के विवरण के आधार पर स्वचालित रूप से परियोजनाओं के निर्माण के लिए एक रूपरेखा है। आपके प्रोजेक्ट की पूरी संरचना pom.xml में वर्णित की जाएगी, एक फ़ाइल जिसे IDEA स्वयं आपके प्रोजेक्ट के रूट में बनाएगी। प्रोजेक्ट सेटिंग्स में, आपको निम्नलिखित मावेन सेटिंग्स निर्दिष्ट करने की आवश्यकता है: GroupId और विरूपण साक्ष्य। परियोजनाओं में, GroupId आमतौर पर कंपनी या व्यावसायिक इकाई का विवरण होता है। कंपनी या वेबसाइट का डोमेन नाम यहां जा सकता है। बदले में, artifactId परियोजना का नाम है। GroupdId के लिए, आप दर्ज कर सकते हैं com.yourNickname.codegym। इससे आवेदन पर कोई प्रभाव नहीं पड़ेगा। artifactId के लिए, अपनी पसंद का कोई भी प्रोजेक्ट नाम चुनें। संस्करण अपरिवर्तित छोड़ा जा सकता है। अंतिम स्क्रीन पर, केवल पहले दर्ज किए गए डेटा की पुष्टि करें।इसलिए, हमने प्रोजेक्ट बनाया। अब बस इतना करना बाकी है कि कुछ कोड लिखें और इसे काम में लाएं :) सबसे पहली बात: अगर हम एक ऐसा एप्लिकेशन बनाना चाहते हैं जो डेटाबेस के साथ काम करता है, तो हम निश्चित रूप से डेटाबेस के बिना नहीं कर सकते हैं! यहां से PostgreSQL डाउनलोड करें (मैं संस्करण 9 का उपयोग कर रहा हूं)। PostgreSQL के पास एक डिफ़ॉल्ट उपयोगकर्ता 'पोस्टग्रेज' है - जब आप इंस्टॉल करते हैं तो आपको इसके लिए एक पासवर्ड सोचना होगा। पासवर्ड न भूलें। हमें इसकी आवश्यकता बाद में पड़ेगी! (सामान्य तौर पर, अनुप्रयोगों में डिफ़ॉल्ट डेटाबेस का उपयोग करना बुरा व्यवहार है, लेकिन हम इसे आपके स्वयं के डेटाबेस बनाकर अल्सर के कारणों की संख्या को कम करने के लिए करेंगे)। यदि आप कमांड लाइन और एसक्यूएल प्रश्नों के मित्र नहीं हैं, तो अच्छी खबर है। IntelliJ IDEA डेटाबेस के साथ काम करने के लिए पूरी तरह उपयुक्त यूजर इंटरफेस प्रदान करता है। (आईडीईए के दाएँ फलक, डेटाबेस टैब पर स्थित)। कनेक्शन बनाने के लिए, "+" पर क्लिक करें और हमारे डेटा स्रोत (PostgeSQL) का चयन करें। उपयोगकर्ता और डेटाबेस ("दोनों के लिए पोस्टग्रेज") के लिए फ़ील्ड भरें और पोस्टग्रेएसक्यूएल की स्थापना के दौरान सेट किया गया पासवर्ड दर्ज करें। यदि आवश्यक हो, तो पोस्टग्रेज़ ड्राइवर डाउनलोड करें। आप इसे उसी पेज पर कर सकते हैं। डेटाबेस कनेक्शन स्थापित होने की पुष्टि करने के लिए "टेस्ट कनेक्शन" पर क्लिक करें। यदि आप "सफल" देखते हैं, तो आगे बढ़ें। अब हम वे तालिकाएँ बनाएंगे जिनकी हमें आवश्यकता है। कुल दो होंगे: उपयोगकर्ता और ऑटो। उपयोगकर्ता तालिका के लिए पैरामीटर: ध्यान दें कि आईडी प्राथमिक कुंजी है। यदि आप नहीं जानते कि SQL में प्राथमिक कुंजी क्या है, तो इसे Google करें। यह महत्वपूर्ण है। ऑटो टेबल के लिए सेटिंग्स: ऑटो टेबल के लिए, आपको एक विदेशी कुंजी को कॉन्फ़िगर करने की आवश्यकता है। यह हमारी तालिकाओं को जोड़ने का काम करेगा। मेरा सुझाव है कि आप इसके बारे में और पढ़ें। सीधे शब्दों में कहें, यह हमारे मामले में, उपयोगकर्ताओं के लिए एक बाहरी तालिका का संदर्भ देता है। यदि कोई कार आईडी = 1 वाले उपयोगकर्ता की है, तो ऑटो का user_id फ़ील्ड 1 के बराबर होगा। इस प्रकार हम अपने एप्लिकेशन में उपयोगकर्ताओं को उनकी कारों से जोड़ते हैं। हमारी ऑटो तालिका में, user_id फ़ील्ड विदेशी कुंजी के रूप में कार्य करेगी। यह उपयोगकर्ता तालिका के आईडी फ़ील्ड को संदर्भित करेगा। इसलिए, हमने दो तालिकाओं वाला एक डेटाबेस बनाया है। यह समझना बाकी है कि इसे जावा कोड से कैसे प्रबंधित किया जाए। हम pom.xml फ़ाइल से शुरू करेंगे, जिसमें हमें आवश्यक पुस्तकालयों को शामिल करने की आवश्यकता है (मावेन में उन्हें निर्भरता कहा जाता है)। सभी पुस्तकालयों को केंद्रीय मावेन रिपॉजिटरी में संग्रहीत किया जाता है। आपके द्वारा pom.xml में निर्दिष्ट लाइब्रेरी आपके लिए प्रोजेक्ट में उपयोग करने के लिए उपलब्ध हैं। आपका pom.xml इस तरह दिखना चाहिए: कुछ भी जटिल नहीं है, जैसा कि आप देख सकते हैं। हमने केवल 2 निर्भरताएँ जोड़ीं - PostgreSQL और हाइबरनेट का उपयोग करने के लिए। अब जावा कोड पर चलते हैं। प्रोजेक्ट में सभी आवश्यक पैकेज और कक्षाएं बनाएं। शुरू करने के लिए, हमें एक डेटा मॉडल की आवश्यकता है: 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 है। इसके बारे में विकिपीडिया पर पढ़ें और यह सब कंठस्थ करें। यह नींव की नींव है। यह एनोटेशन आपकी जावा क्लास की वस्तुओं को डेटाबेस में मैप करने देता है। एक वर्ग को एक इकाई होने के लिए, उसे निम्नलिखित आवश्यकताओं को पूरा करना चाहिए:

• publicइसमें एक खाली कंस्ट्रक्टर ( या protected) होना चाहिए
• इसे नेस्टेड नहीं किया जा सकता, एक इंटरफ़ेस या एकenum
• यह फ़ील्ड/गुण नहीं हो सकता है finalऔर न ही हो सकता हैfinal
• इसमें कम से कम एक @Id फ़ील्ड होना चाहिए।

अपनी इकाई कक्षाओं की जाँच करें: वे पैर में खुद को गोली मारने के लिए बहुत लोकप्रिय स्थान हैं। कुछ भूलना बहुत आसान है। इसके अलावा, एक इकाई निम्नलिखित कार्य कर सकती है:

• इसमें खाली कंस्ट्रक्टर हो सकते हैं
• यह विरासत में मिल सकता है और विरासत में मिल सकता है
• इसमें अन्य तरीके हो सकते हैं और इंटरफेस लागू कर सकते हैं।

जैसा कि आप देख सकते हैं, Userकक्षा उपयोगकर्ता तालिका के समान ही है। इसमें id, name, और हैageखेत। उनके ऊपर स्थित एनोटेशन को किसी विशेष स्पष्टीकरण की आवश्यकता नहीं है: यह स्पष्ट है कि @Id इंगित करता है कि फ़ील्ड इस वर्ग की वस्तुओं का पहचानकर्ता है। वर्ग के ऊपर @Table एनोटेशन उस तालिका के नाम को इंगित करता है जहां ऑब्जेक्ट लिखे गए हैं। आयु क्षेत्र के ऊपर की टिप्पणी पर ध्यान दें: यदि कक्षा में फ़ील्ड का नाम तालिका के नाम के समान है, तो आप @ कॉलम एनोटेशन को छोड़ सकते हैं और यह काम करेगा। जैसा कि ब्रेसिज़ में इंगित भाग के लिए ("रणनीति = जेनरेशनटाइप। पहचान"): आईडी बनाने के लिए कई रणनीतियाँ हैं। आप उन्हें गूगल कर सकते हैं, लेकिन हमारे आवेदन के लिए परेशान होने की जरूरत नहीं है। मुख्य बात यह है कि हमारी वस्तुओं के लिए आईडी का मान स्वतः उत्पन्न हो जाएगा। तदनुसार, आईडी के लिए कोई सेटर नहीं है, और हम इसे कंस्ट्रक्टर में भी सेट नहीं करते हैं। हालाँकि,Userवर्ग बाहर खड़ा है। इसमें कारों की एक सूची है! @OneToMany एनोटेशन सूची के ऊपर लटका हुआ है। इसका अर्थ है कि कई कारें उपयोगकर्ता वर्ग की एक ही वस्तु के अनुरूप हो सकती हैं। Auto"मैप्डबी" तत्व वर्ग के उपयोगकर्ता क्षेत्र को संदर्भित करता है । इस प्रकार, कार और उपयोगकर्ता संबंधित हैं। ऑर्फनरिमूवल एलिमेंट इंगित करता है कि क्या रिमूव ऑपरेशन को उन संस्थाओं पर लागू करना है जिनका अब कोई संबंध नहीं है। यदि हम किसी उपयोगकर्ता को डेटाबेस से हटाते हैं, तो उससे जुड़ी सभी कारें भी हटा दी जाएंगी। बदले में, में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 पैरामीटर शामिल हैं। यह आवश्यक है ताकि हाइबरनेट द्वारा निष्पादित सभी एसक्यूएल प्रश्नों को कंसोल पर प्रदर्शित किया जा सके। इस तरह आप देखेंगे कि हाइबरनेट किसी भी समय क्या कर रहा है, "जादू" की किसी भी भावना को खत्म कर रहा है। आगे हमें चाहिएUserDAOकक्षा। सबसे अच्छा अभ्यास इंटरफेस के माध्यम से प्रोग्राम करना है - एक अलग UserDAOइंटरफ़ेस और UserDAOImplकार्यान्वयन बनाएं, लेकिन कोड की मात्रा कम करने के लिए मैं इसे छोड़ दूंगा। असली परियोजनाओं में ऐसा मत करो! 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 नहीं बनाएंगे और इसके तरीकों को अपने 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और इसके तरीकों में डीएओ विधियों को कॉल करता है। ऐसा लग सकता है कि हम यहां कार्यों को डुप्लिकेट कर रहे हैं (क्यों न केवल डीएओ ऑब्जेक्ट से विधियों को कॉल करें?), लेकिन बहुत सारी वस्तुओं और जटिल तर्क के साथ, एप्लिकेशन को लेयर करना बहुत बड़ा लाभ प्रदान करता है (ऐसा करना अच्छा अभ्यास है - इसे भविष्य में याद रखें और "एप्लिकेशन लेयर्स" के बारे में पढ़ें)। हमारी सेवा में सरल तर्क है, लेकिन वास्तविक दुनिया की परियोजनाओं में सेवा विधियों में कोड की एक से अधिक पंक्तियाँ होती हैं :) अब हमारे पास वह सब कुछ है जो आपको एप्लिकेशन चलाने के लिए चाहिए! विधि में 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()उपयोगकर्ता को डेटाबेस से लाने और कंसोल पर अपनी कारों की सूची प्रदर्शित करने की विधि। बेशक, हमने हाइबरनेट की कार्यक्षमता का केवल एक छोटा सा हिस्सा देखा है। इसकी क्षमताएं बहुत व्यापक हैं, और यह लंबे समय से जावा विकास के लिए एक मानक उद्योग उपकरण रहा है। यदि आप इसका विस्तार से अध्ययन करना चाहते हैं, तो मैं "जावा पर्सिस्टेंस एपीआई और हाइबरनेट" पुस्तक की सिफारिश कर सकता हूं। मैंने पिछले लेख में समीक्षा की थी। मुझे उम्मीद है कि यह लेख पाठकों के लिए मददगार रहा होगा। यदि आपके कोई प्रश्न हैं, तो उन्हें टिप्पणियों में पूछें। मुझे जवाब देने में खुशी होगी :) इसके अलावा, "लाइक" पोस्ट करके प्रतियोगिता में लेखक का समर्थन करना न भूलें। या बेहतर अभी तक - "इसे प्यार करो" :) आपकी पढ़ाई में शुभकामनाएँ!