S01L01 - Hibernate का अवलोकन

html


हाइबरनेट ORM में महारत हासिल करना: जावा डेवलपर्स के लिए एक व्यापक मार्गदर्शिका
सामग्री की तालिका

परिचय ............................................................. 1
ऑब्जेक्ट-रिलेशनल मैपिंग (ORM) को समझना ........... 3
बड़ा चित्र: जावा ऑब्जेक्ट्स और डेटाबेस ................... 5
हाइबरनेट के उपयोग के लाभ ...................................... 7
हाइबरनेट क्रिया में: एक उदाहरण ............................. 10
निष्कर्ष ............................................................. 15
पूरक जानकारी .................................. 17


परिचय
आपका स्वागत है "हाइबरनेट ORM में महारत हासिल करना: जावा डेवलपर्स के लिए एक व्यापक मार्गदर्शिका" में। जावा प्रोग्रामिंग के निरंतर विकसित हो रहे परिदृश्य में, डेटाबेस इंटरैक्शन्स को कुशलतापूर्वक प्रबंधित करना अत्यंत महत्वपूर्ण है। यह ईबुक हाइबरनेट में गहराई से उतरती है, जो एक शक्तिशाली ऑब्जेक्ट-रिलेशनल मैपिंग (ORM) टूल है जो जावा अनुप्रयोगों में डेटाबेस संचालन को सरल बनाता है।
क्यों हाइबरनेट?
हाइबरनेट ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग और रिलेशनल डेटाबेस के बीच के अंतर को पाटता है। SQL क्वेरी बनाने को स्वचालित करके और डेटाबेस कनेक्शन्स का प्रबंधन करके, हाइबरनेट डेवलपर्स को डेटाबेस की जटिलताओं की चिंता किए बिना बिजनेस लॉजिक लिखने पर ध्यान केंद्रित करने की अनुमति देता है।
फायदे और नुकसान
फायदे:

डेटाबेस स्वतंत्रता: कम कोड परिवर्तनों के साथ विभिन्न डेटाबेस के बीच आसानी से स्विच करें।
स्वचालित SQL हैंडलिंग: हाइबरनेट SQL क्वेरियों का प्रबंधन करता है, जिससे मानवीय त्रुटियों का जोखिम कम होता है।
घटित बोइलरप्लेट कोड: JDBC-संबंधित कोड को न्यूनतम करता है, विकास प्रक्रियाओं को सुव्यवस्थित करता है।

नुकसान:

सीखने की वक्र: हाइबरनेट की जटिलताओं को समझना शुरुआती लोगों के लिए चुनौतीपूर्ण हो सकता है।
प्रदर्शन ओवरहेड: कुछ मामलों में, रॉ SQL की तुलना में हाइबरनेट प्रदर्शन ओवरहेड पेश कर सकता है।
डिबगिंग में जटिलता: अमूर्त स्तर के कारण मुद्दों का निदान अधिक जटिल हो सकता है।

तुलनात्मक अवलोकन


विशेषता
Hibernate ORM
मैनुअल SQL हैंडलिंग


डेटाबेस स्वतंत्रता
उच्च – डेटाबेस आसानी से बदलें
कम – SQL क्वेरियाँ विशिष्ट डेटाबेस से बंधी होती हैं


SQL प्रबंधन
Hibernate द्वारा स्वचालित
डेवलपर को SQL क्वेरियाँ लिखनी और प्रबंधित करनी होती हैं


कोड बोइलरप्लेट
न्यूनतम JDBC कोड
व्यापक JDBC बोइलरप्लेट कोड


रखरखाव प्रयास
कम – बनाए रखने के लिए कम कोड
ज्यादा – प्रबंधित करने के लिए अधिक कोड


प्रदर्शन अनुकूलन
Hibernate अनुकूलन द्वारा संभाला जाता है
मैनुअल अनुकूलन की आवश्यकता होती है



ऑब्जेक्ट-रिलेशनल मैपिंग (ORM) को समझना
ORM क्या है?
ऑब्जेक्ट-रिलेशनल मैपिंग (ORM) एक प्रोग्रामिंग तकनीक है जो ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग भाषाओं का उपयोग करते हुए असंगत प्रकार की प्रणालियों के बीच डेटा के रूपांतरण की सुविधा प्रदान करती है। सरल शब्दों में, ORM डेवलपर्स को जावा ऑब्जेक्ट्स का उपयोग करके डेटाबेस के साथ इंटरैक्ट करने की अनुमति देता है, जिससे अंतर्निहित SQL क्वेरियों का अमूर्तिकरण होता है।
ORM का उपयोग क्यों करें?
ORM के बिना, डेवलपर्स को डेटाबेस संचालन जैसे क्रिएट, रीड, अपडेट, और डिलीट (CRUD) करने के लिए मैन्युअल रूप से SQL क्वेरियों लिखनी होती हैं। यह प्रक्रिया थकाऊ, त्रुटिपूर्ण, और विशिष्ट डेटाबेस के साथ कड़ी तरीके से जुड़ी हो सकती है। Hibernate जैसे ORM टूल इस प्रक्रिया को सुव्यवस्थित करते हैं, उत्पादकता और कोड मेंटेनबिलिटी बढ़ाते हैं।
ORM कैसे काम करता है
ORM टूल्स जावा क्लासों को डेटाबेस टेबल्स के साथ मैप करते हैं। जावा क्लास का प्रत्येक इंस्टेंस डेटाबेस टेबल में एक रो के अनुरूप होता है। क्लास की विशेषताएं टेबल में कॉलम्स का प्रतिनिधित्व करती हैं। यह मैपिंग डेवलपर्स को परिचित ऑब्जेक्ट-ओरिएंटेड पैराबिडाइम्स का उपयोग करके डेटाबेस संचालन करने की अनुमति देती है।

बड़ा चित्र: जावा ऑब्जेक्ट्स और डेटाबेस
परंपरागत दृष्टिकोण बिना ORM के
जब हाइबरनेट का उपयोग नहीं करते हैं, तो डेवलपर्स डेटाबेस के साथ इंटरैक्ट करते हैं:

SQL क्वेरियों का निर्माण: CRUD ऑपरेशनों के लिए रॉ SQL क्वेरियों को लिखना।
कनेक्शन्स का प्रबंधन: JDBC कनेक्शन्स को मैन्युअल रूप से संभालना।
परिणामों का मैपिंग: ResultSet डेटा को जावा ऑब्जेक्ट्स में अनुवाद करना।

ORM के बिना उदाहरण:




		
		
			
			
Java
			
			public class UserDAO {
    public User getUser(int userId) {
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        User user = null;
        
        try {
            conn = DriverManager.getConnection(DB_URL, USER, PASS);
            String sql = "SELECT user_id, username, password, first_name, last_name FROM users WHERE user_id=?";
            stmt = conn.prepareStatement(sql);
            stmt.setInt(1, userId);
            rs = stmt.executeQuery();
            
            if(rs.next()){
                user = new User();
                user.setUserId(rs.getInt("user_id"));
                user.setUsername(rs.getString("username"));
                user.setPassword(rs.getString("password"));
                user.setFirstName(rs.getString("first_name"));
                user.setLastName(rs.getString("last_name"));
            }
        } catch(SQLException se){
            se.printStackTrace();
        } finally {
            // संसाधनों को बंद करें
        }
        return user;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
				
						public class UserDAO {
    public User getUser(int userId) {
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        User user = null;
        
        try {
            conn = DriverManager.getConnection(DB_URL, USER, PASS);
            String sql = "SELECT user_id, username, password, first_name, last_name FROM users WHERE user_id=?";
            stmt = conn.prepareStatement(sql);
            stmt.setInt(1, userId);
            rs = stmt.executeQuery();
            
            if(rs.next()){
                user = new User();
                user.setUserId(rs.getInt("user_id"));
                user.setUsername(rs.getString("username"));
                user.setPassword(rs.getString("password"));
                user.setFirstName(rs.getString("first_name"));
                user.setLastName(rs.getString("last_name"));
            }
        } catch(SQLException se){
            se.printStackTrace();
        } finally {
            // संसाधनों को बंद करें
        }
        return user;
    }
}
					
				
			
		


हाइबरनेट के साथ सरल दृष्टिकोण
हाइबरनेट जटिलताओं को अमूर्तिकृत करके डेवलपर्स को सीधे जावा ऑब्जेक्ट्स का उपयोग करके डेटाबेस के साथ इंटरैक्ट करने की अनुमति देता है।
हाइबरनेट के साथ उदाहरण:




		
		
			
			
Java
			
			// User.java
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int userId;
    
    private String username;
    private String password;
    private String firstName;
    private String lastName;
    
    // Getters and Setters
}

// UserDAO.java
public class UserDAO {
    public User getUser(int userId) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        User user = session.get(User.class, userId);
        session.close();
        return user;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
				
						// User.java
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int userId;
    
    private String username;
    private String password;
    private String firstName;
    private String lastName;
    
    // Getters and Setters
}
 
// UserDAO.java
public class UserDAO {
    public User getUser(int userId) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        User user = session.get(User.class, userId);
        session.close();
        return user;
    }
}
					
				
			
		


आरेख: ORM कार्यप्रणाली

चित्र 1: Hibernate ORM कार्यप्रणाली

हाइबरनेट के उपयोग के लाभ
हाइबरनेट कई लाभ प्रदान करता है जो जावा अनुप्रयोगों की दक्षता और मेंटेनबिलिटी को बढ़ाते हैं।
1. डेटाबेस स्वतंत्रता
हाइबरनेट डेटाबेस लेयर को अमूर्तिकृत करता है, जिससे अनुप्रयोगों को बिना महत्वपूर्ण कोड परिवर्तनों के विभिन्न डेटाबेस के बीच स्विच करने की अनुमति मिलती है। यह लचीलापन सुनिश्चित करता है कि अनुप्रयोग किसी विशिष्ट डेटाबेस सिस्टम के साथ कड़ी तरीके से जुड़ा नहीं है।
उदाहरण: MySQL से Oracle में स्विच करना


पहलू
हाइबरनेट के बिना
हाइबरनेट के साथ


SQL क्वेरियाँ
Oracle के लिए क्वेरियों को फिर से लिखना होगा
Hibernate SQL उत्पन्न करता है


कनेक्शन सेटिंग्स
मैन्युअल समायोजन आवश्यक
Hibernate में कॉन्फ़िगरेशन परिवर्तनों


कोड परिवर्तन
व्यापक संशोधनों की आवश्यकता
न्यूनतम या बिना कोड परिवर्तनों


2. स्वचालित SQL हैंडलिंग
हाइबरनेट परिभाषित मैपिंग्स के आधार पर स्वचालित रूप से SQL क्वेरियाँ उत्पन्न करता है, जिससे मैन्युअल क्वेरी निर्माण की आवश्यकता समाप्त हो जाती है। यह स्वचालन त्रुटियों की संभावना को कम करता है और विकास को तेज करता है।
3. घटित JDBC कोड
बोइलरप्लेट JDBC कोड का प्रबंधन करके हाइबरनेट डेटाबेस इंटरैक्शन्स को सरल बनाता है। डेवलपर्स न्यूनतम कोड के साथ CRUD ऑपरेशन्स कर सकते हैं, जिससे उत्पादकता बढ़ती है।
JDBC और Hibernate कोड की तुलना


ऑपरेशन
JDBC कोड उदाहरण
Hibernate कोड उदाहरण


क्रिएट
व्यापक सेटअप और SQL निष्पादन
session.save(user);


रीड
मैन्युअल क्वेरी तैयारी, निष्पादन, और परिणाम मैपिंग
User user = session.get(User.class, id);


अपडेट
मैन्युअल SQL अपडेट स्टेटमेंट्स
session.update(user);


डिलीट
मैन्युअल SQL डिलीट स्टेटमेंट्स
session.delete(user);


4. कैशिंग और प्रदर्शन अनुकूलन
हाइबरनेट विभिन्न कैशिंग मैकेनिज्म्स (फर्स्ट-लेवल और सेकंड-लेवल कैश) का समर्थन करता है जो डेटाबेस एक्सेस के समय को कम करके अनुप्रयोग के प्रदर्शन में सुधार करते हैं।
5. स्कीमा जनरेशन
हाइबरनेट परिभाषित जावा संस्थाओं के आधार पर स्वचालित रूप से डेटाबेस स्कीमाओं को उत्पन्न कर सकता है, सेटअप प्रक्रिया को सरल बनाते हुए।

हाइबरनेट क्रिया में: एक उदाहरण
हाइबरनेट की क्षमताओं को स्पष्ट करने के लिए, आइए एक प्रायोगिक उदाहरण के माध्यम से हाइबरनेट को जावा अनुप्रयोग में एकीकृत करने की प्रक्रिया पर चलते हैं।
चरण 1: हाइबरनेट सेटअप करना

हाइबरनेट डिपेंडेंसीज़ जोड़ें: सुनिश्चित करें कि आपके प्रोजेक्ट में Hibernate और इसकी डिपेंडेंसीज़ (जैसे hibernate-core, hibernate-entitymanager, और आपके डेटाबेस के लिए JDBC ड्राइवर) शामिल हैं।
हाइबरनेट कॉन्फ़िगर करें: डेटाबेस कनेक्शन विवरण और हाइबरनेट प्रॉपर्टीज के साथ एक कॉन्फ़िगरेशन फाइल (hibernate.cfg.xml) बनाएं।

hibernate.cfg.xml




		
		
			
			
Java
			
			&lt;!DOCTYPE hibernate-configuration PUBLIC 
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN" 
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"&gt;
&lt;hibernate-configuration&gt;
    &lt;session-factory&gt;
        &lt;property name="hibernate.connection.driver_class"&gt;com.mysql.cj.jdbc.Driver&lt;/property&gt;
        &lt;property name="hibernate.connection.url"&gt;jdbc:mysql://localhost:3306/mydb&lt;/property&gt;
        &lt;property name="hibernate.connection.username"&gt;root&lt;/property&gt;
        &lt;property name="hibernate.connection.password"&gt;password&lt;/property&gt;
        &lt;property name="hibernate.dialect"&gt;org.hibernate.dialect.MySQLDialect&lt;/property&gt;
        &lt;property name="show_sql"&gt;true&lt;/property&gt;
        
        &lt;!-- Mapping class --&gt;
        &lt;mapping class="com.example.User"/&gt;
    &lt;/session-factory&gt;
&lt;/hibernate-configuration&gt;
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						&lt;!DOCTYPE hibernate-configuration PUBLIC 
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN" 
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"&gt;
&lt;hibernate-configuration&gt;
    &lt;session-factory&gt;
        &lt;property name="hibernate.connection.driver_class"&gt;com.mysql.cj.jdbc.Driver&lt;/property&gt;
        &lt;property name="hibernate.connection.url"&gt;jdbc:mysql://localhost:3306/mydb&lt;/property&gt;
        &lt;property name="hibernate.connection.username"&gt;root&lt;/property&gt;
        &lt;property name="hibernate.connection.password"&gt;password&lt;/property&gt;
        &lt;property name="hibernate.dialect"&gt;org.hibernate.dialect.MySQLDialect&lt;/property&gt;
        &lt;property name="show_sql"&gt;true&lt;/property&gt;
        
        &lt;!-- Mapping class --&gt;
        &lt;mapping class="com.example.User"/&gt;
    &lt;/session-factory&gt;
&lt;/hibernate-configuration&gt;
					
				
			
		


चरण 2: एंटिटी क्लास को परिभाषित करना
डेटाबेस टेबल का प्रतिनिधित्व करने वाली एक जावा क्लास बनाएं। मैपिंग्स को परिभाषित करने के लिए Hibernate एनोटेशन्स का उपयोग करें।
User.java




		
		
			
			
Java
			
			package com.example;

import javax.persistence.*;

@Entity
@Table(name = "users")
public class User {
    
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    @Column(name = "user_id")
    private int userId;
    
    @Column(name = "username", nullable=false, unique=true)
    private String username;
    
    @Column(name = "password", nullable=false)
    private String password;
    
    @Column(name = "first_name")
    private String firstName;
    
    @Column(name = "last_name")
    private String lastName;
    
    // Constructors
    public User() {}
    
    public User(String username, String password, String firstName, String lastName) {
        this.username = username;
        this.password = password;
        this.firstName = firstName;
        this.lastName = lastName;
    }
    
    // Getters and Setters
    // ...
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
				
						package com.example;
 
import javax.persistence.*;
 
@Entity
@Table(name = "users")
public class User {
    
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    @Column(name = "user_id")
    private int userId;
    
    @Column(name = "username", nullable=false, unique=true)
    private String username;
    
    @Column(name = "password", nullable=false)
    private String password;
    
    @Column(name = "first_name")
    private String firstName;
    
    @Column(name = "last_name")
    private String lastName;
    
    // Constructors
    public User() {}
    
    public User(String username, String password, String firstName, String lastName) {
        this.username = username;
        this.password = password;
        this.firstName = firstName;
        this.lastName = lastName;
    }
    
    // Getters and Setters
    // ...
}
					
				
			
		


चरण 3: हाइबरनेट यूटिलिटी क्लास बनाना
यह क्लास Hibernate SessionFactory का प्रबंधन करती है, जो डेटाबेस के साथ इंटरैक्ट करने के लिए आवश्यक है।
HibernateUtil.java




		
		
			
			
Java
			
			package com.example;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
    private static final SessionFactory sessionFactory = buildSessionFactory();
    
    private static SessionFactory buildSessionFactory() {
        try {
            return new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
        } catch(Throwable ex) {
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }
    
    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
    
    public static void shutdown() {
        getSessionFactory().close();
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
				
						package com.example;
 
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
 
public class HibernateUtil {
    private static final SessionFactory sessionFactory = buildSessionFactory();
    
    private static SessionFactory buildSessionFactory() {
        try {
            return new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
        } catch(Throwable ex) {
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }
    
    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
    
    public static void shutdown() {
        getSessionFactory().close();
    }
}
					
				
			
		


चरण 4: CRUD ऑपरेशन्स करना
User बनाना




		
		
			
			
Java
			
			package com.example;

import org.hibernate.Session;
import org.hibernate.Transaction;

public class UserDAO {
    public void addUser(User user) {
        Transaction transaction = null;
        try(Session session = HibernateUtil.getSessionFactory().openSession()) {
            transaction = session.beginTransaction();
            session.save(user);
            transaction.commit();
        } catch(Exception e) {
            if(transaction != null) {
                transaction.rollback();
            }
            e.printStackTrace();
        }
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
				
						package com.example;
 
import org.hibernate.Session;
import org.hibernate.Transaction;
 
public class UserDAO {
    public void addUser(User user) {
        Transaction transaction = null;
        try(Session session = HibernateUtil.getSessionFactory().openSession()) {
            transaction = session.beginTransaction();
            session.save(user);
            transaction.commit();
        } catch(Exception e) {
            if(transaction != null) {
                transaction.rollback();
            }
            e.printStackTrace();
        }
    }
}
					
				
			
		


User प्राप्त करना




		
		
			
			
Java
			
			public User getUser(int userId) {
    try(Session session = HibernateUtil.getSessionFactory().openSession()) {
        User user = session.get(User.class, userId);
        return user;
    } catch(Exception e) {
        e.printStackTrace();
        return null;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						public User getUser(int userId) {
    try(Session session = HibernateUtil.getSessionFactory().openSession()) {
        User user = session.get(User.class, userId);
        return user;
    } catch(Exception e) {
        e.printStackTrace();
        return null;
    }
}
					
				
			
		


User अपडेट करना




		
		
			
			
Java
			
			public void updateUser(User user) {
    Transaction transaction = null;
    try(Session session = HibernateUtil.getSessionFactory().openSession()) {
        transaction = session.beginTransaction();
        session.update(user);
        transaction.commit();
    } catch(Exception e) {
        if(transaction != null) {
            transaction.rollback();
        }
        e.printStackTrace();
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						public void updateUser(User user) {
    Transaction transaction = null;
    try(Session session = HibernateUtil.getSessionFactory().openSession()) {
        transaction = session.beginTransaction();
        session.update(user);
        transaction.commit();
    } catch(Exception e) {
        if(transaction != null) {
            transaction.rollback();
        }
        e.printStackTrace();
    }
}
					
				
			
		


User डिलीट करना




		
		
			
			
Java
			
			public void deleteUser(int userId) {
    Transaction transaction = null;
    try(Session session = HibernateUtil.getSessionFactory().openSession()) {
        transaction = session.beginTransaction();
        User user = session.get(User.class, userId);
        if(user != null) {
            session.delete(user);
            System.out.println("User is deleted");
        }
        transaction.commit();
    } catch(Exception e) {
        if(transaction != null) {
            transaction.rollback();
        }
        e.printStackTrace();
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
				
						public void deleteUser(int userId) {
    Transaction transaction = null;
    try(Session session = HibernateUtil.getSessionFactory().openSession()) {
        transaction = session.beginTransaction();
        User user = session.get(User.class, userId);
        if(user != null) {
            session.delete(user);
            System.out.println("User is deleted");
        }
        transaction.commit();
    } catch(Exception e) {
        if(transaction != null) {
            transaction.rollback();
        }
        e.printStackTrace();
    }
}
					
				
			
		


चरण 5: कार्यान्वयन का परीक्षण करना
Main.java




		
		
			
			
Java
			
			package com.example;

public class Main {
    public static void main(String[] args) {
        UserDAO userDAO = new UserDAO();
        
        // नया यूजर बनाएं
        User newUser = new User("jdoe", "password123", "John", "Doe");
        userDAO.addUser(newUser);
        
        // यूजर प्राप्त करें
        User retrievedUser = userDAO.getUser(newUser.getUserId());
        System.out.println("Retrieved User: " + retrievedUser.getUsername());
        
        // यूजर अपडेट करें
        retrievedUser.setPassword("newpassword456");
        userDAO.updateUser(retrievedUser);
        
        // यूजर डिलीट करें
        userDAO.deleteUser(retrievedUser.getUserId());
        
        // Hibernate बंद करें
        HibernateUtil.shutdown();
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
				
						package com.example;
 
public class Main {
    public static void main(String[] args) {
        UserDAO userDAO = new UserDAO();
        
        // नया यूजर बनाएं
        User newUser = new User("jdoe", "password123", "John", "Doe");
        userDAO.addUser(newUser);
        
        // यूजर प्राप्त करें
        User retrievedUser = userDAO.getUser(newUser.getUserId());
        System.out.println("Retrieved User: " + retrievedUser.getUsername());
        
        // यूजर अपडेट करें
        retrievedUser.setPassword("newpassword456");
        userDAO.updateUser(retrievedUser);
        
        // यूजर डिलीट करें
        userDAO.deleteUser(retrievedUser.getUserId());
        
        // Hibernate बंद करें
        HibernateUtil.shutdown();
    }
}
					
				
			
		


आउटपुट:




		
		
			
			
Java
			
			Hibernate: insert into users (username, password, first_name, last_name) values (?, ?, ?, ?)
Hibernate: select user_id, username, password, first_name, last_name from users where user_id=?
Retrieved User: jdoe
Hibernate: update users set username=?, password=?, first_name=?, last_name=? where user_id=?
Hibernate: select user_id, username, password, first_name, last_name from users where user_id=?
Hibernate: delete from users where user_id=?
User is deleted
			
				
					
				
					1
2
3
4
5
6
7
				
						Hibernate: insert into users (username, password, first_name, last_name) values (?, ?, ?, ?)
Hibernate: select user_id, username, password, first_name, last_name from users where user_id=?
Retrieved User: jdoe
Hibernate: update users set username=?, password=?, first_name=?, last_name=? where user_id=?
Hibernate: select user_id, username, password, first_name, last_name from users where user_id=?
Hibernate: delete from users where user_id=?
User is deleted
					
				
			
		



निष्कर्ष
Hibernate ORM ने जावा डेवलपर्स के रिलेशनल डेटाबेस के साथ इंटरैक्शन के तरीके में क्रांति ला दी है। SQL और JDBC की जटिलताओं को अमूर्तिकृत करके, Hibernate उत्पादकता को बढ़ाता है, डेटाबेस स्वतंत्रता सुनिश्चित करता है, और स्वच्छ, अधिक मेंटेनबिल कोड को बढ़ावा देता है। चाहे आप जावा डेवलपमेंट में नए हों या डेटाबेस संचालन को सुव्यवस्थित करने के लिए एक अनुभवी डेवलपर हों, Hibernate में महारत हासिल करना एक अमूल्य संपत्ति है।
प्रमुख निष्कर्ष

सरल डेटाबेस इंटरैक्शन्स: Hibernate SQL क्वेरी जेनरेशन को स्वचालित करता है और डेटाबेस कनेक्शन्स का कुशलतापूर्वक प्रबंधन करता है।
बढ़ी हुई उत्पादकता: घटित बोइलरप्लेट कोड के साथ, डेवलपर्स बिजनेस लॉजिक पर अधिक ध्यान केंद्रित कर सकते हैं।
डेटाबेस लचीलापन: व्यापक कोड संशोधनों के बिना विभिन्न डेटाबेस के बीच आसानी से स्विच करें।
प्रदर्शन अनुकूलन: Hibernate के कैशिंग मैकेनिज्म्स का उपयोग करने से महत्वपूर्ण प्रदर्शन सुधार हो सकते हैं।

Hibernate ORM को अपनाने से न केवल विकास प्रक्रिया में तेजी आती है बल्कि यह स्केलेबल और मेंटेनबिल जावा अनुप्रयोगों के लिए एक मजबूत नींव भी स्थापित करता है। Hibernate की विशेषताओं में गहराई से उतरें, उन्नत मैपिंग्स का अन्वेषण करें, और इसकी पूरी क्षमता का उपयोग करके अपने जावा विकास यात्रा को ऊंचा उठाएं।
SEO अनुकूलित कीवर्ड्स
Hibernate ORM, Java ORM tool, Object-Relational Mapping, Java database interaction, Hibernate benefits, Hibernate tutorial, Hibernate examples, Java Hibernate integration, Hibernate CRUD operations, ORM vs JDBC, Hibernate configuration, Hibernate annotations, Hibernate SessionFactory, Hibernate utility class, Java database independence, Hibernate caching mechanisms

पूरक जानकारी
हाइबरनेट कॉन्फ़िगरेशन प्रॉपर्टीज


प्रॉपर्टी
विवरण
उदाहरण मूल्य


hibernate.connection.driver_class
JDBC ड्राइवर क्लास
com.mysql.cj.jdbc.Driver


hibernate.connection.url
डेटाबेस कनेक्शन URL
jdbc:mysql://localhost:3306/mydb


hibernate.connection.username
डेटाबेस यूजरनेम
root


hibernate.connection.password
डेटाबेस पासवर्ड
password


hibernate.dialect
डेटाबेस के लिए SQL डायलैक्ट
org.hibernate.dialect.MySQLDialect


hibernate.show_sql
कंसोल में SQL क्वेरियों को दिखाना है या नहीं
true


hibernate.hbm2ddl.auto
स्कीमा जनरेशन रणनीति (validate, update, create, create-drop)
update


सामान्य Hibernate एनोटेशन्स


एनोटेशन
उद्देश्य


@Entity
क्लास को एक एंटिटी होने का निर्दिष्ट करता है जो डेटाबेस टेबल के साथ मैप की जाती है


@Table
डेटाबेस टेबल का नाम निर्दिष्ट करता है जिस पर एंटिटी मैप की जाती है


@Id
एंटिटी की प्राथमिक कुंजी को चिह्नित करता है


@GeneratedValue
प्राथमिक कुंजी जनरेशन के लिए रणनीति निर्दिष्ट करता है


@Column
क्लास फील्ड को डेटाबेस कॉलम के साथ मैप करता है और कॉलम विशेषताएं निर्दिष्ट करता है


@OneToMany
दो एंटिटीज़ के बीच एक-से-कई संबंध को परिभाषित करता है


@ManyToOne
दो एंटिटीज़ के बीच कई-से-एक संबंध को परिभाषित करता है


@JoinColumn
दो टेबल्स को जोड़ने के लिए उपयोग किए गए विदेशी कुंजी कॉलम को निर्दिष्ट करता है


@Transient
दर्शाता है कि एक फील्ड डेटाबेस में स्थायी नहीं होना चाहिए


Hibernate प्रदर्शन टिप्स

सेकंड-लेवल कैश सक्षम करें: डेटाबेस लोड को कम करने के लिए Hibernate के कैशिंग मैकेनिज्म्स का उपयोग करें।
लेज़ी लोडिंग: अनावश्यक डेटा पुनःप्राप्ति को कम करने के लिए संबंधित एंटिटीज़ को केवल आवश्यक होने पर ही प्राप्त करें।
बैच प्रोसेसिंग: बैचों में एंटिटीज़ को प्रोसेस करके बल्क ऑपरेशन्स को अनुकूलित करें।
क्वेरी अनुकूलन: कुशल क्वेरियों को बनाने के लिए Hibernate की क्राइटेरिया API या HQL का उपयोग करें।
कनेक्शन पूलिंग: बेहतर संसाधन प्रबंधन के लिए C3P0 या HikariCP जैसी कनेक्शन पूलिंग लाइब्रेरियों के साथ एकीकृत करें।

अतिरिक्त संसाधन

आधिकारिक Hibernate दस्तावेज़: https://hibernate.org/documentation/
Hibernate GitHub रिपॉजिटरी: https://github.com/hibernate/hibernate-orm
Baeldung द्वारा Hibernate ट्यूटोरियल्स: https://www.baeldung.com/hibernate-5-spring
Java Persistence API (JPA) गाइड: https://www.oracle.com/technical-resources/articles/java/java-ee-jpa.html

इन संसाधनों का लाभ उठाकर और इस ईबुक में चर्चा किए गए अवधारणाओं को लागू करके, आप Hibernate ORM की पूरी क्षमता का उपयोग करके मजबूत और स्केलेबल जावा अनुप्रयोग बना सकते हैं।
नोट: यह लेख AI द्वारा उत्पन्न किया गया है।

ऑपरेशन	JDBC कोड उदाहरण	Hibernate कोड उदाहरण
क्रिएट	व्यापक सेटअप और SQL निष्पादन	`session.save(user);`
रीड	मैन्युअल क्वेरी तैयारी, निष्पादन, और परिणाम मैपिंग	`User user = session.get(User.class, id);`
अपडेट	मैन्युअल SQL अपडेट स्टेटमेंट्स	`session.update(user);`
डिलीट	मैन्युअल SQL डिलीट स्टेटमेंट्स	`session.delete(user);`

प्रॉपर्टी	विवरण	उदाहरण मूल्य
`hibernate.connection.driver_class`	JDBC ड्राइवर क्लास	`com.mysql.cj.jdbc.Driver`
`hibernate.connection.url`	डेटाबेस कनेक्शन URL	`jdbc:mysql://localhost:3306/mydb`
`hibernate.connection.username`	डेटाबेस यूजरनेम	`root`
`hibernate.connection.password`	डेटाबेस पासवर्ड	`password`
`hibernate.dialect`	डेटाबेस के लिए SQL डायलैक्ट	`org.hibernate.dialect.MySQLDialect`
`hibernate.show_sql`	कंसोल में SQL क्वेरियों को दिखाना है या नहीं	`true`
`hibernate.hbm2ddl.auto`	स्कीमा जनरेशन रणनीति (`validate`, `update`, `create`, `create-drop`)	`update`

विशेषता	Hibernate ORM	मैनुअल SQL हैंडलिंग
डेटाबेस स्वतंत्रता	उच्च – डेटाबेस आसानी से बदलें	कम – SQL क्वेरियाँ विशिष्ट डेटाबेस से बंधी होती हैं
SQL प्रबंधन	Hibernate द्वारा स्वचालित	डेवलपर को SQL क्वेरियाँ लिखनी और प्रबंधित करनी होती हैं
कोड बोइलरप्लेट	न्यूनतम JDBC कोड	व्यापक JDBC बोइलरप्लेट कोड
रखरखाव प्रयास	कम – बनाए रखने के लिए कम कोड	ज्यादा – प्रबंधित करने के लिए अधिक कोड
प्रदर्शन अनुकूलन	Hibernate अनुकूलन द्वारा संभाला जाता है	मैनुअल अनुकूलन की आवश्यकता होती है

पहलू	हाइबरनेट के बिना	हाइबरनेट के साथ
SQL क्वेरियाँ	Oracle के लिए क्वेरियों को फिर से लिखना होगा	Hibernate SQL उत्पन्न करता है
कनेक्शन सेटिंग्स	मैन्युअल समायोजन आवश्यक	Hibernate में कॉन्फ़िगरेशन परिवर्तनों
कोड परिवर्तन	व्यापक संशोधनों की आवश्यकता	न्यूनतम या बिना कोड परिवर्तनों

एनोटेशन	उद्देश्य
`@Entity`	क्लास को एक एंटिटी होने का निर्दिष्ट करता है जो डेटाबेस टेबल के साथ मैप की जाती है
`@Table`	डेटाबेस टेबल का नाम निर्दिष्ट करता है जिस पर एंटिटी मैप की जाती है
`@Id`	एंटिटी की प्राथमिक कुंजी को चिह्नित करता है
`@GeneratedValue`	प्राथमिक कुंजी जनरेशन के लिए रणनीति निर्दिष्ट करता है
`@Column`	क्लास फील्ड को डेटाबेस कॉलम के साथ मैप करता है और कॉलम विशेषताएं निर्दिष्ट करता है
`@OneToMany`	दो एंटिटीज़ के बीच एक-से-कई संबंध को परिभाषित करता है
`@ManyToOne`	दो एंटिटीज़ के बीच कई-से-एक संबंध को परिभाषित करता है
`@JoinColumn`	दो टेबल्स को जोड़ने के लिए उपयोग किए गए विदेशी कुंजी कॉलम को निर्दिष्ट करता है
`@Transient`	दर्शाता है कि एक फील्ड डेटाबेस में स्थायी नहीं होना चाहिए