உங்களின் முதல் ஹைபர்னேட் பயன்பாடு

இந்தக் கட்டுரையில், ஜாவாவிற்கான மிகவும் பிரபலமான நிறுவன கட்டமைப்புகளில் ஒன்றை நீங்கள் நன்கு அறிந்திருப்பீர்கள் மற்றும் உங்கள் முதல் ஹைபர்னேட் பயன்பாட்டை உருவாக்குவீர்கள். Hibernate பற்றி கேள்விப்பட்டதில்லையா? அல்லது நீங்கள் அதைப் பற்றி கேள்விப்பட்டிருக்கலாம், ஆனால் அதைப் பயன்படுத்தவில்லையா? அல்லது நீங்கள் அதைப் பயன்படுத்த முயற்சித்திருக்கலாம், ஆனால் தோல்வியுற்றதா? மூன்று நிகழ்வுகளிலும் - வெட்டுக்கு கீழே வருக :) அனைவருக்கும் வணக்கம்! இந்தக் கட்டுரையில், நான் ஹைபர்னேட் கட்டமைப்பின் முக்கிய அம்சங்களைப் பற்றிப் பேசுவேன், மேலும் உங்களின் முதல் சிறிய விண்ணப்பத்தை எழுத உதவுகிறேன். இதற்கு, நமக்குத் தேவை:

1. IntelliJ IDEA அல்டிமேட் பதிப்பு அதிகாரப்பூர்வ இணையதளத்தில்
   இருந்து பதிவிறக்கம் செய்து 30 நாள் சோதனை பதிப்பை செயல்படுத்தவும்.
2. PostgreSQL - மிகவும் பிரபலமான நவீன தரவுத்தள மேலாண்மை அமைப்புகளில் ஒன்று (DBMS)
3. மேவன் (ஏற்கனவே IDEA வரை இணைக்கப்பட்டுள்ளது)
4. கொஞ்சம் பொறுமை.

ஒரு வேளை, விண்ணப்பக் குறியீட்டை GitHub இல் (codegym கிளை) இடுகையிட்டேன் . கட்டுரை முதன்மையாக இந்த தொழில்நுட்பத்துடன் இதுவரை வேலை செய்யாதவர்களை இலக்காகக் கொண்டது, எனவே குறியீட்டின் அளவைக் குறைத்துள்ளேன். தொடங்குவோம்!

ஹைபர்னேட் என்றால் என்ன?

இது மிகவும் பிரபலமான பொருள்-தொடர்பு மேப்பிங் (ORM) செயலாக்கங்களில் ஒன்றாகும். ஒரு பொருள்-தொடர்பு மேப்பிங் மென்பொருள் பொருள்கள் மற்றும் தரவுத்தள பதிவுகளுக்கு இடையிலான உறவை வரையறுக்கிறது. நிச்சயமாக, ஹைபர்னேட் மிகவும் பரந்த செயல்பாட்டைக் கொண்டுள்ளது, ஆனால் நாங்கள் எளிமையான செயல்பாடுகளில் கவனம் செலுத்துவோம். CRUD (உருவாக்கு, படிக்க, புதுப்பிக்க, நீக்குதல்) பயன்பாட்டை உருவாக்குவதே எங்கள் குறிக்கோள்:

1. பயனர்களை (பயனர்) உருவாக்கவும், ஐடி மூலம் தரவுத்தளத்தில் அவர்களைத் தேடவும், தரவுத்தளத்தில் அவர்களின் தரவைப் புதுப்பிக்கவும் மற்றும் தரவுத்தளத்திலிருந்து அவர்களை நீக்கவும்.
2. கார் பொருட்களை (ஆட்டோ) பயனர்களுக்கு ஒதுக்கவும். தரவுத்தளத்திலிருந்து கார்களை உருவாக்கவும், புதுப்பிக்கவும், கண்டறியவும் மற்றும் நீக்கவும்.
3. கூடுதலாக, பயன்பாடு தானாகவே "உரிமையற்ற" கார்களை தரவுத்தளத்திலிருந்து அகற்ற வேண்டும். வேறு வார்த்தைகளில் கூறுவதானால், ஒரு பயனர் நீக்கப்பட்டால், அந்த பயனருக்கு சொந்தமான அனைத்து கார்களும் தரவுத்தளத்திலிருந்து நீக்கப்பட வேண்டும்.

எங்கள் திட்டம் இப்படி கட்டமைக்கப்படும்: நீங்கள் பார்க்க முடியும் என, சிக்கலான எதுவும் இல்லை. கட்டமைப்புகளுடன் 6 வகுப்புகள் + 1 கோப்பு. முதலில், IntelliJ IDEA இல் ஒரு புதிய Maven திட்டத்தை உருவாக்கவும். கோப்பு -> புதிய திட்டம். முன்மொழியப்பட்ட திட்ட வகைகளில் இருந்து மேவனைத் தேர்ந்தெடுத்து அடுத்த படிக்குச் செல்லவும். Apache Maven என்பது POM கோப்புகளில் அவற்றின் கட்டமைப்பின் விளக்கத்தின் அடிப்படையில் தானாகவே திட்டங்களை உருவாக்குவதற்கான ஒரு கட்டமைப்பாகும். உங்கள் திட்டப்பணியின் முழு அமைப்பும் pom.xml இல் விவரிக்கப்படும், இது IDEA தானே உங்கள் திட்டத்தின் மூலத்தில் உருவாக்கும். திட்ட அமைப்புகளில், நீங்கள் பின்வரும் மேவன் அமைப்புகளைக் குறிப்பிட வேண்டும்: groupId மற்றும் artifactId. திட்டங்களில், groupId என்பது பொதுவாக நிறுவனம் அல்லது வணிகப் பிரிவின் விளக்கமாகும். நிறுவனம் அல்லது இணையதளத்தின் டொமைன் பெயர் இங்கே செல்லலாம். இதையொட்டி, ஆர்டிஃபாக்ட் ஐடி என்பது திட்டத்தின் பெயர். groupdIdக்கு, நீங்கள் உள்ளிடலாம் com.yourNickname.codegym. இது பயன்பாட்டில் எந்த விளைவையும் ஏற்படுத்தாது. ArtifactIdக்கு, நீங்கள் விரும்பும் எந்த திட்டப் பெயரையும் தேர்வு செய்யவும். பதிப்பை மாற்றாமல் விடலாம். கடைசி திரையில், முன்பு உள்ளிடப்பட்ட தரவை உறுதிப்படுத்தவும்.எனவே, நாங்கள் திட்டத்தை உருவாக்கினோம். இப்போது செய்ய வேண்டியது என்னவென்றால், சில குறியீடுகளை எழுதி அதைச் செயல்பட வைப்பதுதான் :) முதல் விஷயம்: ஒரு தரவுத்தளத்துடன் செயல்படும் பயன்பாட்டை உருவாக்க விரும்பினால், தரவுத்தளம் இல்லாமல் நிச்சயமாக செய்ய முடியாது! PostgreSQL ஐ இங்கிருந்து பதிவிறக்கவும் (நான் பதிப்பு 9 ஐப் பயன்படுத்துகிறேன்). PostgreSQL இல் இயல்புநிலை பயனர் 'postgres' உள்ளது - நீங்கள் நிறுவும் போது அதற்கான கடவுச்சொல்லை நீங்கள் சிந்திக்க வேண்டும். கடவுச்சொல்லை மறந்துவிடாதீர்கள். எங்களுக்கு அது பின்னர் தேவைப்படும்! (பொதுவாக, பயன்பாடுகளில் இயல்புநிலை தரவுத்தளத்தைப் பயன்படுத்துவது தவறான நடைமுறையாகும், ஆனால் உங்கள் சொந்த தரவுத்தளத்தை உருவாக்குவதன் மூலம் புண்களின் எண்ணிக்கையைக் குறைக்க நாங்கள் அதைச் செய்வோம்). கட்டளை வரி மற்றும் SQL வினவல்களுடன் நீங்கள் நண்பர்களாக இல்லாவிட்டால், ஒரு நல்ல செய்தி உள்ளது. IntelliJ IDEA ஆனது தரவுத்தளத்துடன் பணிபுரிய முற்றிலும் பொருத்தமான பயனர் இடைமுகத்தை வழங்குகிறது. (IDEA இன் வலது பலகத்தில், தரவுத்தள தாவலில் அமைந்துள்ளது). இணைப்பை உருவாக்க, "+" என்பதைக் கிளிக் செய்து, எங்கள் தரவு மூலத்தைத் தேர்ந்தெடுக்கவும் (PostgeSQL). பயனர் மற்றும் தரவுத்தளத்திற்கான புலங்களை நிரப்பவும் (இரண்டிற்கும் "postgres") மற்றும் PostgreSQL இன் நிறுவலின் போது அமைக்கப்பட்ட கடவுச்சொல்லை உள்ளிடவும். தேவைப்பட்டால், Postgres இயக்கியைப் பதிவிறக்கவும். இதை ஒரே பக்கத்தில் செய்யலாம். தரவுத்தள இணைப்பு நிறுவப்பட்டுள்ளதா என்பதைச் சரிபார்க்க, "சோதனை இணைப்பு" என்பதைக் கிளிக் செய்யவும். "வெற்றிகரமானது" என்று பார்த்தால், தொடரவும். இப்போது நாம் தேவையான அட்டவணையை உருவாக்குவோம். மொத்தம் இரண்டு இருக்கும்: பயனர்கள் மற்றும் ஆட்டோக்கள். பயனர் அட்டவணைக்கான அளவுருக்கள்: ஐடி முதன்மை விசை என்பதை நினைவில் கொள்ளவும். SQL இல் உள்ள முதன்மை விசை என்னவென்று உங்களுக்குத் தெரியாவிட்டால், அதை கூகிள் செய்யவும். இது முக்கியமானது. ஆட்டோ அட்டவணைக்கான அமைப்புகள்: ஆட்டோஸ் அட்டவணைக்கு, நீங்கள் ஒரு வெளிநாட்டு விசையை உள்ளமைக்க வேண்டும். இது எங்கள் அட்டவணைகளை இணைக்க உதவும். நீங்கள் அதைப் பற்றி மேலும் படிக்க பரிந்துரைக்கிறேன். எளிமையாகச் சொன்னால், இது வெளிப்புற அட்டவணையைக் குறிக்கிறது, எங்கள் விஷயத்தில், பயனர்கள். கார் ஐடி = 1 உள்ள பயனருக்கு சொந்தமானதாக இருந்தால், ஆட்டோக்களின் பயனர்_ஐடி புலம் 1 க்கு சமமாக இருக்கும். எங்கள் பயன்பாட்டில் பயனர்களின் கார்களுடன் நாங்கள் தொடர்புபடுத்துவது இதுதான். எங்கள் autos அட்டவணையில், user_id புலம் வெளிநாட்டு விசையாக செயல்படும். இது பயனர் அட்டவணையின் ஐடி புலத்தைக் குறிக்கும். எனவே, இரண்டு அட்டவணைகள் கொண்ட தரவுத்தளத்தை உருவாக்கியுள்ளோம். ஜாவா குறியீட்டிலிருந்து அதை எவ்வாறு நிர்வகிப்பது என்பதைப் புரிந்துகொள்வது எஞ்சியுள்ளது. நாம் pom.xml கோப்புடன் தொடங்குவோம், அதில் தேவையான நூலகங்களைச் சேர்க்க வேண்டும் (மேவனில் அவை சார்புகள் என்று அழைக்கப்படுகின்றன). அனைத்து நூலகங்களும் மத்திய மேவன் களஞ்சியத்தில் சேமிக்கப்பட்டுள்ளன. நீங்கள் pom.xml இல் குறிப்பிடும் நூலகங்கள் நீங்கள் திட்டத்தில் பயன்படுத்துவதற்குக் கிடைக்கும். உங்கள் pom.xml இப்படி இருக்க வேண்டும்: நீங்கள் பார்ப்பது போல் சிக்கலான எதுவும் இல்லை. PostgreSQL மற்றும் Hibernate ஐப் பயன்படுத்துவதற்கு 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. இதைப் பற்றி விக்கிபீடியாவில் படித்து, முழு மனதுடன் கற்றுக்கொள்ளுங்கள். இது அடித்தளத்தின் அடித்தளம். இந்த சிறுகுறிப்பு உங்கள் ஜாவா வகுப்பின் பொருட்களை ஒரு தரவுத்தளத்தில் வரைபடமாக்க உதவுகிறது. ஒரு வர்க்கம் ஒரு நிறுவனமாக இருக்க, அது பின்வரும் தேவைகளைப் பூர்த்தி செய்ய வேண்டும்:

• அதில் காலியான கன்ஸ்ட்ரக்டர் இருக்க வேண்டும் ( publicஅல்லது protected)
• அதை உள்ளமைக்க முடியாது, ஒரு இடைமுகம் அல்லது ஒருenum
• புலங்கள்/பண்புகள் இருக்க முடியாது finalமற்றும் இருக்க முடியாதுfinal
• அதில் குறைந்தது ஒரு @Id புலமாவது இருக்க வேண்டும்.

உங்கள் நிறுவன வகுப்புகளைச் சரிபார்க்கவும்: அவை உங்களை காலில் சுட மிகவும் பிரபலமான இடங்கள். ஒன்றை மறப்பது மிகவும் எளிது. மேலும், ஒரு நிறுவனம் பின்வருவனவற்றைச் செய்யலாம்:

• இது காலியாக இல்லாத கட்டமைப்பாளர்களைக் கொண்டிருக்கலாம்
• அது மரபுரிமையாகவும், பரம்பரையாகவும் இருக்கலாம்
• இது மற்ற முறைகள் மற்றும் இடைமுகங்களை செயல்படுத்தலாம்.

நீங்கள் பார்க்க முடியும் என, Userவகுப்பு பயனர் அட்டவணைக்கு மிகவும் ஒத்திருக்கிறது. இது உள்ளது id, nameமற்றும்ageவயல்வெளிகள். மேலே அமைந்துள்ள சிறுகுறிப்புகளுக்கு எந்த குறிப்பிட்ட விளக்கமும் தேவையில்லை: புலம் இந்த வகுப்பின் பொருள்களின் அடையாளங்காட்டி என்பதை @Id குறிக்கிறது என்பது தெளிவாகிறது. வகுப்பிற்கு மேலே உள்ள @Table சிறுகுறிப்பு, பொருள்கள் எழுதப்பட்ட அட்டவணையின் பெயரைக் குறிக்கிறது. வயதுப் புலத்திற்கு மேலே உள்ள கருத்தைக் கவனியுங்கள்: வகுப்பில் உள்ள புலத்தின் பெயரும் அட்டவணையின் பெயரும் ஒன்றாக இருந்தால், நீங்கள் @Column சிறுகுறிப்பைத் தவிர்க்கலாம், அது வேலை செய்யும். பிரேஸ்களில் குறிப்பிடப்பட்டுள்ள பகுதியைப் பொறுத்தவரை ("strategy = GenerationType.IDENTITY"): ஐடிகளை உருவாக்குவதற்கு பல உத்திகள் உள்ளன. நீங்கள் அவற்றை Google செய்யலாம், ஆனால் எங்கள் பயன்பாட்டிற்கு, கவலைப்படத் தேவையில்லை. முக்கிய விஷயம் என்னவென்றால், எங்கள் பொருள்களுக்கு ஐடியின் மதிப்பு தானாகவே உருவாக்கப்படும். அதன்படி, ஐடிக்கு செட்டர் இல்லை, அதை நாங்கள் கன்ஸ்ட்ரக்டரிலும் அமைக்கவில்லை. எனினும்,Userவர்க்கம் தனித்து நிற்கிறது. அதில் கார்களின் பட்டியல் உள்ளது! @OneToMany சிறுகுறிப்பு பட்டியலுக்கு மேலே தொங்குகிறது. பல கார்கள் பயனர் வகுப்பின் ஒரே பொருளுக்கு ஒத்திருக்கும் என்று அர்த்தம். "mappedBy" உறுப்பு வகுப்பின் பயனர் புலத்தைக் குறிக்கிறது 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 அளவுருவும் இதில் உள்ளது. Hibernate மூலம் செயல்படுத்தப்படும் அனைத்து 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);
     }
 }
 
 

நீங்கள் பார்க்க முடியும் என, பயனர் அட்டவணை அதன் சொந்த பதிவு உள்ளது, மற்றும் autos அட்டவணை அதன் சொந்த பதிவு உள்ளது. எங்கள் பயனரின் பெயரை மாற்ற முயற்சிப்போம். பயனர் அட்டவணையை அழித்து, குறியீட்டை இயக்கவும்

 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);
     }
 }
 
 

எங்கள் அட்டவணைகள் முற்றிலும் காலியாக உள்ளன (கன்சோலில் கவனம் செலுத்துங்கள் - Hibernate ஆல் செய்யப்படும் அனைத்து கோரிக்கைகளும் அங்கு காட்டப்படும்). நீங்கள் பயன்பாட்டுடன் விளையாடலாம் மற்றும் அதன் அனைத்து செயல்பாடுகளையும் முயற்சி செய்யலாம். எடுத்துக்காட்டாக, கார்களுடன் ஒரு பயனரை உருவாக்கவும், அதை தரவுத்தளத்தில் சேமித்து, பயனருக்கு ஒதுக்கப்பட்ட ஐடியைப் பார்த்து, இந்த ஐடியைப் பயன்படுத்த முயற்சிக்கவும்.main()தரவுத்தளத்திலிருந்து பயனரைப் பெற்று, அதன் கார்களின் பட்டியலை கன்சோலில் காண்பிக்கும் முறை. நிச்சயமாக, Hibernate இன் செயல்பாட்டின் ஒரு சிறிய பகுதியை மட்டுமே நாங்கள் பார்த்தோம். அதன் திறன்கள் மிகவும் பரந்தவை, மேலும் இது ஜாவா மேம்பாட்டிற்கான ஒரு நிலையான தொழில் கருவியாக நீண்ட காலமாக இருந்து வருகிறது. நீங்கள் அதை விரிவாக படிக்க விரும்பினால், "ஜாவா பெர்சிஸ்டன்ஸ் ஏபிஐ மற்றும் ஹைபர்னேட்" புத்தகத்தை பரிந்துரைக்கலாம். முந்தைய கட்டுரையில் மதிப்பாய்வு செய்தேன். இந்த கட்டுரை வாசகர்களுக்கு பயனுள்ளதாக இருக்கும் என்று நம்புகிறேன். உங்களிடம் கேள்விகள் இருந்தால், கருத்துகளில் அவர்களிடம் கேளுங்கள். நான் பதிலளிப்பதில் மகிழ்ச்சி அடைவேன் :) மேலும், "லைக்" போட்டு போட்டியில் ஆசிரியருக்கு ஆதரவளிக்க மறக்காதீர்கள். அல்லது இன்னும் சிறப்பாக — "லவ் இட்" :) உங்கள் படிப்பில் நல்ல அதிர்ஷ்டம்!