👈🏾 🎢 ✊🏻 सबसे छोटे और न केवल के लिए हाइबरनेट करें 🛍️ 🧛🏻 👂🏼

सभी को शुभ दिन! जब एक प्रोग्राम लिखना होगा जो किसी तरह डेटाबेस के साथ बातचीत करेगा, तो वे विभिन्न साधनों का उपयोग करते हैं। यह अच्छा पुराना jdbc है , जिसका उपयोग भी किया जाता है: EclipseLink , TopLink , iBatis (पहले से ही MyBatis ), स्प्रिंग फ्रेमवर्क और निश्चित रूप से हमारे लेख के नायक - हाइबरनेट । बेशक, मैंने यहां डेटाबेस के साथ काम करने के लिए सभी उपकरणों को सूचीबद्ध नहीं किया है, लेकिन मैंने सबसे आम लोगों को इंगित करने की कोशिश की है। यह आलेख दिखाएगा कि संग्रहीत प्रक्रियाओं को कॉल करने के लिए हाइबरनेट का उपयोग कैसे करें, दोनों तालिकाओं और वर्ग प्रश्नों को मैप करें। प्रायोगिक डेटाबेस के रूप में, ओरेकल लें।
हम प्रयोगों के लिए आवश्यक सब कुछ तैयार करेंगे। डेटाबेस से शुरू करते हैं। शुरू करने के लिए, हम 3 टैबलेट बनाएंगे, जिस पर हम अभ्यास करेंगे।

CREATE TABLE book ( id NUMBER NOT NULL, name VARCHAR2 (100 BYTE) NOT NULL, description VARCHAR2 (1000 BYTE) NOT NULL, CONSTRAINT pk$book_id PRIMARY KEY (id) ) CREATE TABLE student ( id NUMBER NOT NULL, name VARCHAR2 (100 BYTE) NOT NULL, CONSTRAINT pk$student_id PRIMARY KEY (id) ) CREATE TABLE catalog ( id_student NUMBER NOT NULL, id_book NUMBER NOT NULL )

अब एक फंक्शन बनाएं। जो अपनी आईडी द्वारा पुस्तक का शीर्षक लौटाएगा, उदाहरण बेवकूफ है, लेकिन यह एक इनपुट न्यूमेरिक पैरामीटर और आउटपुट स्ट्रिंग के साथ फ़ंक्शन को कॉल करने का सिद्धांत दिखाएगा।

 CREATE OR REPLACE FUNCTION get_book_name_by_id (p_id IN NUMBER) RETURN VARCHAR2 IS v_name VARCHAR2 (100); BEGIN SELECT name INTO v_name FROM book WHERE id = p_id; RETURN v_name; EXCEPTION WHEN NO_DATA_FOUND THEN RETURN '   !!'; END;

और यह भी, एक प्रयोग के रूप में, हम डेटाबेस में एक सरल बचत प्रक्रिया बनाएंगे, जिसमें इनपुट और आउटपुट दोनों पैरामीटर होंगे।

 CREATE OR REPLACE PROCEDURE save_book (p_id IN OUT NUMBER, p_name IN VARCHAR2, p_descr IN VARCHAR2) IS BEGIN IF p_id > 0 THEN UPDATE book SET name = p_name, description = p_descr WHERE id = p_id; ELSE SELECT catalog_seq.NEXTVAL INTO p_id FROM DUAL; INSERT INTO book VALUES (p_id, p_name, p_descr); END IF; END;

अब जावा में कक्षाओं पर चलते हैं।
हम कक्षाओं में अपने 3 डेटाबेस टेबल निम्नानुसार प्रदर्शित करते हैं:

 @Entity @Table public class Student implements Serializable { private static final long serialVersionUID = -5170875020617735653L; @Id @GeneratedValue(strategy = GenerationType.AUTO, generator = "my_entity_seq_gen") @SequenceGenerator(name = "my_entity_seq_gen", sequenceName = "catalog_seq") private long id; @Column private String name; @OneToMany(mappedBy = "student", fetch = FetchType.LAZY) private Set<Book> bookList; //     getter, setter, hashCode(), equals(), toString() }

कोड पर थोड़ा स्पष्टीकरण:

यदि आपकी कक्षा का नाम तालिका के नाम से मेल नहीं खाता है, तो उदाहरण के लिए हम इस तरह लिखते हैं: तालिका (नाम = "छात्र");
फ्रेमवर्क की आवश्यकताओं में से एक यह है कि प्रत्येक तालिका में एक आईडी होनी चाहिए, अगर तालिका के आईडी फ़ील्ड का नाम और हमारे चर का नाम मेल नहीं खाते हैं, तो एनोटेशन इस तरह दिखेगा: आईडी @Column (नाम = डेटाबेस में "टेबल आईडी");
@GeneratedValue और @SequenceGenerator का उपयोग करते हुए, हम एक विशिष्ट पहचानकर्ता बनाने के लिए रणनीति निर्धारित करते हैं, इस मामले में हम कहते हैं कि जब डेटाबेस को जानकारी की बचत होती है, तो हम उस नाम "अनुक्रम_सेक" नाम के अनुक्रम से एक नंबर लेते हैं;
चूँकि हमारे पास एक छात्र के पास कई किताबें हो सकती हैं, इसलिए हम इसे इस @OneToMany (mappedBy = "student", fetch = FetchType.LAZY) जैसे एनोटेशन का उपयोग करके प्रदर्शित करेंगे, जहाँ mpedBy = "student" पुस्तक वर्ग में फ़ील्ड का नाम है (देखें) नीचे), और FetchType.LAZY - हमें बताता है कि संग्रह
```
 Set<Book> bookList 
```
हम केवल मांग पर डेटा लोड करेंगे।

निम्न 2 डेटाबेस तालिकाओं की मैपिंग इस तरह दिखाई देगी:

 @Entity @Table public class Book implements Serializable { private static final long serialVersionUID = 1L; @Id @Column(name="ID") @GeneratedValue(strategy = GenerationType.AUTO, generator = "my_entity_seq_gen") @SequenceGenerator(name = "my_entity_seq_gen", sequenceName = "catalog_seq") private long id; @Column(name="NAME",unique = true, nullable = false, length = 100) private String name; @Column(name="DESCRIPTION",unique = true, nullable = false, length = 100) private String description; @ManyToOne(fetch = FetchType.LAZY,optional=true) @JoinTable(name = "CATALOG", joinColumns = @JoinColumn(name = "ID_BOOK"), inverseJoinColumns = @JoinColumn(name = "ID_STUDENT")) private Student student; //     getter, setter, hashCode(), equals(), toString() }

फ़ील्ड प्रतिबंध को सीधे एनोटेशन में सेट किया जा सकता है, यह अगली पंक्ति @ कॉलम (नाम = "नाम", अद्वितीय = सत्य, अशक्त = गलत, लंबाई = 100) द्वारा किया जाता है। एनोटेशन @ManyToOne और @JoinTable (नाम = "CATALOG") के साथ हम कहते हैं कि बुक टेबल और स्टूडेंट टेबल के कैटलॉग टेबल के माध्यम से कई-से-कई संबंध हैं, इसलिए बुक और स्टूडेंट के लिए सभी परिवर्तन अपने आप लागू हो जाएंगे। कैटलॉग टेबल।
खैर, हम मैपिंग टेबल के साथ किए जाते हैं, और अब हम डेटाबेस के साथ सीधे काम करने के लिए आगे बढ़ेंगे।
संग्रह को भरते समय डेटा निष्कर्षण विभिन्न तरीकों से किया जा सकता है:

HQL (हाइबरनेट क्वेरी भाषा) क्वेरीज़ का उपयोग करना
```
  List<Book> book = (List<Book>)session.createQuery("from Book order by name").list(); 
```

SQL प्रश्नों का उपयोग करना

  List<Book> book = (List<Book>)session.createSQLQuery("select ID, DESCRIPTION, NAME from book order by NAME") .addScalar("id",Hibernate.LONG).addScalar("name").addScalar("description") .setResultTransformer(Transformers.aliasToBean(Book.class)).list();

मानदंड के साथ

  List<Book> book=(List<Book>)session.createCriteria(Book.class).createAlias("student", "st").add(Restrictions.eq("st.name", "Maxim")).list();

चलो संग्रहीत प्रक्रियाओं के साथ काम करने के लिए आगे बढ़ते हैं। किसी फ़ंक्शन को आईडी द्वारा पुस्तक का शीर्षक लौटाने के लिए, हम निम्नलिखित चरणों का पालन करते हैं:

 String bookName = (String)session.createSQLQuery("{? = call get_book_name_by_id (:id)}").setLong("id",1).uniqueResult();

मान लें कि हमारे पास छात्र नामक सर्वर पर एक तालिका नहीं है, लेकिन केवल एक फ़ंक्शन है जो एक कर्सर लौटाता है:

 FUNCTION get_all_students RETURN SYS_REFCURSOR IS l_cur SYS_REFCURSOR; BEGIN OPEN l_cur FOR SELECT * FROM student ORDER BY 1; RETURN l_cur; END;

उसके बाद मैपिंग इस प्रकार की जाएगी, इसके बजाय @Table(name="STUDENT") की व्याख्या करते @Table(name="STUDENT") हम लिखेंगे

 @NamedNativeQuery(name="getAllStudent",query="{? = call get_all_students}", callable=true, resultClass=Student.class)

और इस समारोह के लिए कॉल इस प्रकार होगा:

  List<Student> student = (List<Student>) session.getNamedQuery("entity").list();

खैर, हमारे save_book प्रक्रिया को कॉल करने के लिए, हम निम्नलिखित जोड़तोड़ करेंगे:

 CallableStatement st = session.connection().prepareCall("{call save_book(?,?,?)}"); st.setLong(1,0); st.setString(2, " ,   "); st.setString(3,"-   "); st.registerOutParameter(1, java.sql.Types.NUMERIC); st.execute(); System.out.println(st.getLong(1));

जैसा कि आपने शायद देखा, जब डेटाबेस को एक्सेस करने और संग्रह को पॉप्युलेट करने के लिए कमांड लिखते हैं, तो शब्द सत्र का उपयोग किया जाता था। हमारे मामले में, यह शब्द हमारे जावा एप्लिकेशन और हाइबरनेट ढांचे, यानी org.hibernate.Session सत्र के बीच मुख्य इंटरफ़ेस को इंगित करता है। लेकिन पहले, हमें एक और मौलिक और महत्वपूर्ण इंटरफ़ेस का उपयोग करने की आवश्यकता है - सेशनफैक्टरी। SessionFactory एक विशिष्ट डेटाबेस के लिए जिम्मेदार वैश्विक कारखाना है। इस कारखाने को प्राप्त करने के लिए हमें org.hibernate.cfg.Configuration क्लास का एक उदाहरण प्राप्त करना होगा। यह इस तरह किया जाता है:

  SessionFactory sessions = new Configuration().configure().buildSessionFactory();

जहां कॉन्फ़िगरेशन ()। कॉन्फ़िगर करें ()। BuildSessionFactory () hibernate.cfg.xml नामक एक फ़ाइल को पार्स करता है, जो प्रोग्राम के बगल में बुलाया जा रहा है, निश्चित रूप से यदि पथ निर्दिष्ट नहीं है। यहां कॉन्फ़िगरेशन फ़ाइल है, जो डेटाबेस से कनेक्शन का कॉन्फ़िगरेशन और हमारी तालिकाओं का प्रदर्शन दिखाता है:

  <?xml version="1.0" encoding="utf-8"?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property> <property name="hibernate.connection.url">jdbc:oracle:thin:@localhost:port:baseName</property> <property name="hibernate.connection.username">username</property> <property name="hibernate.connection.password">password</property> <property name="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</property> <property name="show_sql">true</property> <mapping class="com.sample.javaHibernate.data.Book" /> <mapping class="com.sample.javaHibernate.data.Student" /> </session-factory> </hibernate-configuration>

और अब, जब हमारे पास एक कारखाना है जिसमें सभी आवश्यक विन्यास हैं (पूल के माध्यम से डेटाबेस से संबंध, तालिकाओं की मैपिंग / प्रदर्शन, आदि) हम सत्र के साथ काम कर सकते हैं

 Session session = sessions.openSession();

आप इस तरह लेनदेन के साथ काम कर सकते हैं: session.beginTransaction(); और तदनुसार session.getTransaction().commit();
लगता तो सब है। बेशक, मैं सब कुछ कवर नहीं कर सका, लेकिन मुझे लगता है कि यह एक त्वरित शुरुआत के लिए पर्याप्त है।

सबसे छोटे और न केवल के लिए हाइबरनेट करें

More articles: