توهان جي پهرين Hibernate ايپليڪيشن

هن آرٽيڪل ۾، توهان جاوا لاءِ سڀ کان مشهور انٽرپرائز فريم ورڪ مان هڪ کان واقف ٿي ويندا ۽ توهان جي پهرين Hibernate ايپليڪيشن ٺاهيندا. Hibernate بابت ڪڏهن به نه ٻڌو آهي؟ يا شايد توهان ان جي باري ۾ ٻڌو آهي، پر ان کي استعمال نه ڪيو آهي؟ يا ٿي سگهي ٿو ته توهان ان کي استعمال ڪرڻ جي ڪوشش ڪئي، پر ناڪام؟ سڀني ٽن ڪيسن ۾ - ڀلي ڪري آيا کٽ جي هيٺان :) هيلو، هرڪو! هن آرٽيڪل ۾، مان ڳالهائيندس Hibernate فريم ورڪ جي بنيادي خصوصيتن جي باري ۾ ۽ توهان جي پهرين مني-ايپليڪيشن لکڻ ۾ مدد ڪندي. هن لاء، اسان کي ضرورت آهي:

1. IntelliJ IDEA الٽيميٽ ايڊيشن
   ان کي سرڪاري ويب سائيٽ تان ڊائون لوڊ ڪريو ۽ 30 ڏينهن جي آزمائشي ورزن کي چالو ڪريو.
2. PostgreSQL - هڪ تمام مشهور جديد ڊيٽابيس مينيجمينٽ سسٽم (DBMS)
3. Maven (اڳ ۾ ئي IDEA تائين وائرڊ)
4. ٿورو صبر.

بس صورت ۾، مون GitHub تي ايپليڪيشن ڪوڊ پوسٽ ڪيو . آرٽيڪل بنيادي طور تي انهن جو مقصد آهي جن ڪڏهن به هن ٽيڪنالاجي سان ڪم نه ڪيو آهي، تنهن ڪري مون ڪوڊ جي مقدار کي گهٽايو آهي. اچو ته شروع ڪريون!

Hibernate ڇا آهي؟

اهو سڀ کان وڌيڪ مشهور اعتراض-رابطي واري نقشي سازي (ORM) عملن مان هڪ آهي. هڪ اعتراض-رابطي وارو نقشو وضاحت ڪري ٿو سافٽ ويئر شين ۽ ڊيٽابيس جي رڪارڊ جي وچ ۾ تعلق. يقينن، Hibernate ۾ تمام وسيع ڪارڪردگي آهي، پر اسان آسان ترين ڪمن تي ڌيان ڏينداسين. اسان جو مقصد هڪ CRUD ٺاهڻ آهي (ٺاهي، پڙهو، تازه ڪاري، حذف) ايپليڪيشن جيڪا قابل ٿي ويندي:

1. صارفين (يوزر) ٺاهيو، انهن کي ڊيٽابيس ۾ ID ذريعي ڳولهيو، انهن جي ڊيٽا کي ڊيٽابيس ۾ تازه ڪاري ڪريو، ۽ انهن کي ڊيٽابيس مان حذف ڪريو.
2. استعمال ڪندڙن کي ڪار شيون (آٽو) لڳايو. ڊيٽابيس مان ڪارٽون ٺاهيو، تازه ڪاري ڪريو، ڳولھيو ۽ حذف ڪريو.
3. اضافي طور تي، ايپليڪيشن کي خودڪار طور تي ڊيٽابيس مان "مالڪ بيڪار" ڪارين کي هٽائڻ گهرجي. ٻين لفظن ۾، جڏهن هڪ صارف کي ختم ڪيو ويندو آهي، انهي صارف سان لاڳاپيل سڀئي ڪارٽون پڻ ڊيٽابيس مان خارج ٿيڻ گهرجن.

اسان جو منصوبو هن طرح ٺهيل هوندو: جيئن توهان ڏسي سگهو ٿا، ڪجھ به پيچيده ناهي. 6 ڪلاس + 1 فائل ترتيب سان. پهريون، IntelliJ IDEA ۾ هڪ نئون Maven منصوبو ٺاهيو. فائل -> نئون پروجيڪٽ. تجويز ڪيل پروجيڪٽ جي قسمن مان Maven چونڊيو ۽ ايندڙ قدم ڏانهن وڃو. Apache Maven POM فائلن ۾ انهن جي جوڙجڪ جي وضاحت جي بنياد تي خودڪار تعميراتي منصوبن لاء هڪ فريم ورڪ آهي. توهان جي پروجيڪٽ جي پوري ڍانچي کي pom.xml ۾ بيان ڪيو ويندو، هڪ فائل جيڪا IDEA پاڻ توهان جي پروجيڪٽ جي روٽ ۾ ٺاهي ويندي. پروجيڪٽ جي سيٽنگن ۾، توھان کي ھيٺ ڏنل Maven سيٽنگون بيان ڪرڻ جي ضرورت آھي: groupId ۽ artifactId. منصوبن ۾، گروپ آئي ڊي عام طور تي ڪمپني يا ڪاروباري يونٽ جي وضاحت آهي. ڪمپني يا ويب سائيٽ جو ڊومين نالو هتي وڃي سگهي ٿو. موڙ ۾، artifactId منصوبي جو نالو آهي. GroupdId لاءِ، توھان داخل ڪري سگھو ٿا com.yourNickname.codegym. هن اپليڪيشن تي ڪو به اثر نه ٿيندو. artifactId لاءِ، ڪنھن به منصوبي جو نالو چونڊيو جيڪو توھان پسند ڪريو. نسخي کي بغير تبديل ڪري سگھجي ٿو. آخري اسڪرين تي، صرف اڳ ۾ داخل ٿيل ڊيٽا جي تصديق ڪريو. تنهن ڪري، اسان منصوبو ٺاهيو. ھاڻي بس اھو ڪرڻو آھي ته ڪجھ ڪوڊ لکڻو ۽ ان کي ڪم ڪرڻ ڏيو :) پھريون شيون پھريون: جيڪڏھن اسان ھڪڙي ايپليڪيشن ٺاهڻ چاھيون ٿا جيڪا ڊيٽابيس سان ڪم ڪري، اسان يقينن ڊيٽابيس کانسواءِ نٿا ڪري سگھون! ڊائون لوڊ ڪريو PostgreSQL هتان کان (مان ورجن 9 استعمال ڪري رهيو آهيان). PostgreSQL وٽ ڊفالٽ يوزر آهي 'postgres' — توهان کي ان لاءِ پاسورڊ سوچڻو پوندو جڏهن توهان انسٽال ڪندا. پاسورڊ نه وساريو. اسان کي بعد ۾ ضرورت پوندي! (عام طور تي، ايپليڪيشنن ۾ ڊفالٽ ڊيٽابيس کي استعمال ڪرڻ خراب عمل آهي، پر اسان اهو ڪنداسين ته جيئن توهان جو پنهنجو ڊيٽابيس ٺاهي السر جي سببن جي تعداد کي گهٽايو). جيڪڏهن توهان ڪمانڊ لائن ۽ SQL سوالن سان دوست نه آهيو، اتي سٺي خبر آهي. IntelliJ IDEA ڊيٽابيس سان ڪم ڪرڻ لاءِ مڪمل طور تي مناسب يوزر انٽرفيس مهيا ڪري ٿي. اهو هن طرح ڏسڻ ۾ اچي ٿو: (IDEA جي ساڄي پين تي واقع آهي، ڊيٽابيس ٽيب). ڪنيڪشن ٺاهڻ لاءِ، "+" تي ڪلڪ ڪريو ۽ اسان جو ڊيٽا جو ذريعو چونڊيو (PostgeSQL). استعمال ڪندڙ ۽ ڊيٽابيس لاءِ فيلڊ ۾ ڀريو ("پوسٽ گريس" ٻنهي لاءِ) ۽ پاسورڊ داخل ڪريو جيڪو پوسٽ گري ايس ايس ايل جي انسٽاليشن دوران مقرر ڪيو ويو هو. جيڪڏهن ضروري هجي ته، پوسٽ گريس ڊرائيور ڊائون لوڊ ڪريو. توهان هن ساڳئي صفحي تي ڪري سگهو ٿا. "ٽيسٽ ڪنيڪشن" تي ڪلڪ ڪريو تصديق ڪرڻ لاءِ ته ڊيٽابيس ڪنيڪشن قائم ٿيل آهي. جيڪڏھن توھان ڏسو "ڪامياب"، پوء اڳتي وڌو. ھاڻي اسان ٽيبل ٺاھينداسين جيڪي اسان کي گھربل آھن. مجموعي طور تي ٻه هوندا: استعمال ڪندڙ ۽ خودڪار. استعمال ڪندڙن جي ٽيبل لاءِ پيرا ميٽرز: نوٽ ڪريو ته id بنيادي ڪيچي آھي. جيڪڏهن توهان کي خبر ناهي ته SQL ۾ پرائمري ڪيچ ڇا آهي، گوگل ان کي. هي اهم آهي. خودڪار ٽيبل لاء سيٽنگون: خودڪار ٽيبل لاء، توهان کي هڪ غير ملڪي چيڪ ترتيب ڏيڻ جي ضرورت آهي. اهو اسان جي جدولن کي ڳنڍڻ جي خدمت ڪندو. مان سفارش ڪريان ٿو ته توهان ان بابت وڌيڪ پڙهو. سادو رکو، اهو هڪ خارجي ٽيبل جو حوالو ڏئي ٿو، اسان جي صورت ۾، صارفين. جيڪڏهن هڪ ڪار id = 1 سان استعمال ڪندڙ سان تعلق رکي ٿي، ته پوءِ autos جي user_id فيلڊ 1 جي برابر هوندي. اهڙي طرح اسان پنهنجي ايپليڪيشن ۾ صارفين کي انهن جي ڪارن سان ڳنڍيندا آهيون. اسان جي آٽو ٽيبل ۾، user_id فيلڊ غير ملڪي ڪي جي طور تي ڪم ڪندو. اهو حوالو ڏيندو id فيلڊ جي استعمال ڪندڙن جي ٽيبل. تنهن ڪري، اسان هڪ ڊيٽابيس ٺاهي ڇڏيو آهي ٻن جدولن سان. باقي رهي ٿو سمجھي ته ان کي ڪيئن منظم ڪجي جاوا ڪوڊ مان. اسان pom.xml فائل سان شروع ڪنداسين، جنهن ۾ اسان کي لازمي لائبريريون شامل ڪرڻ جي ضرورت آهي (Maven ۾ انهن کي انحصار سڏيو ويندو آهي). سڀئي لائبريريون مرڪزي Maven مخزن ۾ محفوظ ٿيل آهن. لائبريريون جيڪي توهان pom.xml ۾ بيان ڪيون آهن اهي توهان جي پروجيڪٽ ۾ استعمال ڪرڻ لاءِ موجود آهن. توهان جي pom.xml هن طرح ڏسڻ گهرجي: ڪجھ به پيچيده ناهي، جيئن توهان ڏسي سگهو ٿا. اسان صرف 2 انحصار شامل ڪيو - PostgreSQL ۽ Hibernate استعمال ڪرڻ لاءِ. ھاڻي اچو ته جاوا ڪوڊ ڏانھن وڃو. پروجيڪٽ ۾ سڀ ضروري پيڪيجز ۽ ڪلاس ٺاهيو. شروع ڪرڻ لاء، اسان کي ڊيٽا ماڊل جي ضرورت آهي: 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)
• اهو nested نه ٿو ڪري سگهجي، هڪ انٽرفيس يا هڪenum
• اهو نه ٿي سگهي ٿو final۽ نه ٿي سگهي ٿو finalفيلڊ/پراپرٽيز
• ان کي گهٽ ۾ گهٽ هڪ @Id فيلڊ هجڻ گهرجي.

پنھنجي اداري جي طبقن کي چيڪ ڪريو: اھي ڏاڍا مقبول جڳھ آھن پنھنجي پاڻ کي پيرن ۾ مارڻ لاءِ. ڪنهن شيءِ کي وسارڻ تمام آسان آهي. ان کان علاوه، ھڪڙو ادارو ھيٺيون ڪم ڪري سگھي ٿو:

• اهو ٿي سگهي ٿو غير خالي تعمير ڪندڙ
• اهو وارث ٿي سگهي ٿو ۽ وارث ٿي سگهي ٿو
• ان ۾ ٻيا طريقا ٿي سگھن ٿا ۽ انٽرفيس لاڳو ڪري سگھن ٿا.

جئين توهان ڏسي سگهو ٿا، Userڪلاس استعمال ڪندڙن جي ٽيبل سان بلڪل ملندڙ جلندڙ آهي. ان ۾ id,,, nameand agefields آهن. انهن جي مٿان موجود تشريحن کي ڪنهن خاص وضاحت جي ضرورت ناهي: اهو واضح آهي ته @Id اشارو ڪري ٿو ته فيلڊ هن طبقي جي شين جي سڃاڻپ ڪندڙ آهي. ڪلاس جي مٿان @Table تشريح ٽيبل جي نالي کي ظاهر ڪري ٿي جتي شيون لکيل آهن. عمر جي فيلڊ جي مٿان تبصرو نوٽ ڪريو: جيڪڏهن ڪلاس ۾ فيلڊ جو نالو ٽيبل جي نالي وانگر آهي، توهان @Column تشريح کي ختم ڪري سگهو ٿا ۽ اهو ڪم ڪندو. جيئن ته برائنس ۾ ڏيکاريل حصو لاءِ ("strategy = GenerationType.IDENTITY"): آئي ڊي ٺاهڻ لاءِ ڪيتريون ئي حڪمت عمليون آهن. توھان انھن کي گوگل ڪري سگھو ٿا، پر اسان جي ايپليڪيشن لاء، پريشان ٿيڻ جي ڪا ضرورت ناهي. بنيادي شيء اها آهي ته اسان جي شين لاء id جي قيمت خودڪار طريقي سان ٺاهي ويندي. ان جي مطابق، id لاء ڪو به سيٽر ناهي، ۽ اسان ان کي تعمير ڪندڙ ۾ مقرر نه ڪندا آهيون. تنهن هوندي، اتي ڪجھ طريقا آھن جيڪي Userطبقو نڪرندو آھي. اهو ڪارن جي هڪ فهرست آهي! @OneToMany تشريح لسٽ جي مٿان لٽڪيل آهي. هن جو مطلب آهي ته ڪيترن ئي ڪارن صارف طبقي جي هڪ ئي اعتراض سان ملندڙ جلندڙ ڪري سگهو ٿا. "mappedBy" عنصر ڪلاس جي استعمال ڪندڙ فيلڊ ڏانهن اشارو ڪري ٿو Auto. اهڙيء طرح، ڪار ۽ استعمال ڪندڙ لاڳاپيل آهن. orphanRemoval عنصر ظاهر ڪري ٿو ته ڇا هٽائڻ واري عمل کي انهن ادارن تي لاڳو ڪيو وڃي جن جو هاڻي ڪو تعلق ناهي. جيڪڏهن اسان ڊيٽابيس مان هڪ صارف کي حذف ڪريون ٿا، ته ان سان لاڳاپيل سڀئي ڪارٽون پڻ ختم ٿي وينديون. موڙ ۾، Autoڪلاس ۾، توھان ڏسندا يوزر فيلڊ سان @ManyToOne تشريح (ھڪڙو صارف ڪيترن ئي آٽوز سان ملندو) ۽ @JoinColumn تشريح سان. اهو ظاهر ڪري ٿو ته آٽوس ٽيبل ۾ ڪهڙو ڪالم استعمال ڪيو ويو آهي استعمال ڪندڙن جي ٽيبل جي حوالي ڪرڻ لاءِ (يعني پرڏيهي ڪيئي جنهن بابت اسان اڳ ۾ ڳالهايو آهي). ڊيٽا ماڊل ٺاهڻ کان پوء، اهو اسان جي پروگرام کي سيکارڻ جو وقت آهي ڊيٽابيس ۾ ڊيٽا سان آپريشن ڪرڻ لاء. اچو ته شروع ڪريون HibernateSessionFactoryUtil utility class سان. ان ۾ صرف هڪ نوڪري آهي - ڊيٽابيس سان ڪم ڪرڻ لاءِ اسان جي ايپليڪيشن لاءِ هڪ سيشن فيڪٽري ٺاهڻ (فيڪٽري ڊيزائن جي نموني کي هيلو چئو!). اها خبر ناهي ته ٻيو ڪجهه ڪيئن ڪجي.

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("Exception!" + e);
            }
        }
        return sessionFactory;
    }
}

هن ڪلاس ۾، اسان هڪ نئين ڪنفيگريشن شئي ٺاهي، ۽ ان کي ڪلاس پاس ڪريون ٿا ته ان کي ادارن جي حيثيت سان علاج ڪرڻ گهرجي: User۽ Auto. طريقي تي ڌيان ڏيو configuration.getProperties(). ٻيون ڪهڙيون خاصيتون آهن؟ اهي ڪٿان اچن ٿا؟ خاصيتون خاص hibernate.cfg.xml فائل ۾ ظاهر ڪيل hibernate سيٽنگون آهن. Hibernate.cfg.xml هتي پڙهيو ويو آهي: new Configuration().configure(); جيئن توهان ڏسندا آهيو، ان بابت ڪجهه خاص ناهي: ان ۾ ڊيٽابيس سان ڳنڍڻ جا پيرا ميٽر شامل آهن، انهي سان گڏ show_sql پيٽرولر. اهو ضروري آهي ته جيئن سڀني sql سوالن تي عمل ڪيو وڃي Hibernate پاران ڪنسول تي ڏيکاريو وڃي. هن طريقي سان توهان ڏسندا ته هيبرنيٽ ڪنهن به وقت ڇا ڪري رهيو آهي، "جادو" جي ڪنهن به احساس کي ختم ڪندي. اڳتي اسان کي UserDAOڪلاس جي ضرورت آهي. بهترين عمل اهو آهي ته انٽرفيس ذريعي پروگرام ڪجي - هڪ الڳ UserDAOانٽرفيس ٺاهيو ۽ UserDAOImplان تي عمل ڪيو وڃي، پر مان ان کي ڇڏي ڏيندس ڪوڊ جي مقدار کي گهٽائڻ لاءِ. اهو نه ڪريو حقيقي منصوبن ۾! DAO (ڊيٽا رسائي اعتراض) ڊيزائن جو نمونو ھڪڙو عام آھي. خيال سادو آهي - هڪ ايپليڪيشن پرت ٺاهيو جيڪو صرف ڊيٽا تائين رسائي لاءِ ذميوار آهي، وڌيڪ ڪجهه به نه. ڊيٽابيس مان ڊيٽا حاصل ڪريو، ڊيٽا کي اپڊيٽ ڪريو، ڊيٽا کي حذف ڪريو - اھو اھو آھي. DAO بابت وڌيڪ مطالعو ڪريو. توھان پنھنجي ڪم ۾ مسلسل ڊيٽا تائين رسائي واريون شيون استعمال ڪندا. اسان جو طبقو ڇا UserDaoڪري سگهي ٿو؟ خير، سڀني DAOs وانگر، اهو صرف ڊيٽا سان ڪم ڪري سگهي ٿو. id ذريعي هڪ صارف ڳولھيو، ان جي ڊيٽا کي اپڊيٽ ڪريو، ان کي حذف ڪريو، ڊيٽابيس مان سڀني استعمال ڪندڙن جي لسٽ حاصل ڪريو، يا ڊيٽابيس ۾ ھڪڙو نئون استعمال ڪندڙ محفوظ ڪريو - اھو آھي ان جي مڪمل ڪارڪردگي.

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۽ ان جي طريقن ۾ 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()ڊيٽابيس مان آڻڻ ۽ ڪنسول تي ان جي ڪارن جي فهرست ڊسپلي ڪرڻ جي طريقي ۾ استعمال ڪرڻ جي ڪوشش ڪريو. . يقينا، اسان ڏٺو آهي صرف هڪ ننڍڙو حصو Hibernate جي ڪارڪردگي جو. ان جون صلاحيتون تمام وسيع آھن، ۽ اھو ڊگھي عرصي کان جاوا ڊولپمينٽ لاءِ معياري صنعت جو اوزار آھي. جيڪڏھن توھان ان کي تفصيل سان پڙھڻ چاھيو ٿا، مان سفارش ڪري سگھان ٿو ڪتاب ”جاوا پرسسٽنس API ۽ ھائبرنيٽ“. مون اڳئين مضمون ۾ جائزو ورتو. مون کي اميد آهي ته هي مضمون پڙهندڙن لاء مددگار ثابت ٿيو آهي. جيڪڏھن توھان وٽ سوال آھن، انھن کان پڇو تبصرن ۾. مان جواب ڏيڻ ۾ خوش ٿيندس :) پڻ، "پسند" پوسٽ ڪندي مقابلي ۾ ليکڪ جي حمايت ڪرڻ نه وساريو. يا اڃا بهتر - "ان سان پيار ڪريو" :) توهان جي پڙهائي ۾ سٺي قسمت!