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

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

1. Intellij Idea Ultimate Edition؛ سرڪاري ويب سائيٽ
   تان ڊائون لوڊ ڪريو ۽ 30 ڏينهن جي آزمائشي ورزن کي چالو ڪريو.
2. PostgeSQL سڀ کان مشهور جديد ڊيٽابيس مينيجمينٽ سسٽم مان هڪ آهي (DBMS)؛
3. Maven (اڳ ۾ ئي IDEA ۾ ٺهيل)؛
4. ٿورو صبر.

مضمون جو مقصد بنيادي طور تي انھن لاء آھي جن ھن ٽيڪنالاجي سان ڪڏھن به ڪم نه ڪيو آھي، تنھنڪري ڪوڊ جو مقدار گھٽجي ويو آھي جيترو ٿي سگھي. اچو ته شروع ڪريون!

Hibernate ڇا آهي؟

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

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

اسان جي منصوبي جي جوڙجڪ هيٺ ڏنل هوندي: جيئن توهان ڏسي سگهو ٿا، ڪجھ به پيچيده ناهي. 6 ڪلاس + 1 فائل ترتيب سان. پهرين، اچو ته انٽيليج آئيڊيا ۾ هڪ نئون ميون پروجيڪٽ ٺاهيو. فائل -> نئون پروجيڪٽ. تجويز ڪيل پروجيڪٽ جي قسمن مان، چونڊيو Maven ۽ اڳتي وڌو. Apache Maven POM ٻولي ۾ فائلن ۾ انهن جي جوڙجڪ جي وضاحت جي بنياد تي منصوبن جي اسيمبلي کي خودڪار ڪرڻ لاء هڪ فريم ورڪ آهي. توهان جي پروجيڪٽ جو سڄو ڍانچو pom.xml فائل ۾ بيان ڪيو ويندو، جيڪو IDEA پاڻ توهان جي پروجيڪٽ جي روٽ ۾ ٺاهيندو. پروجيڪٽ سيٽنگن ۾ توهان کي وضاحت ڪرڻ جي ضرورت پوندي Maven پيٽرولر - گروپ آئي ڊي ۽ آرٽيفڪٽ آئي ڊي. عام طور تي پروجيڪٽ گروپ آئي ڊي ۾ تنظيم يا ڊويزن جو نالو هوندو آهي، ۽ تنظيم يا پروجيڪٽ سائيٽ جو ڊومين نالو اتي لکيل هوندو آهي. موڙ ۾، artifactId منصوبي جو نالو آهي. GroupdId لاءِ توھان وضاحت ڪري سگھو ٿا com.вашНикнейм.javarush، اھو ڪنھن بہ طرح ايپليڪيشن جي آپريشن کي متاثر نه ڪندو. artifactId لاءِ، ڪنهن به منصوبي جو نالو چونڊيو جيڪو توهان پسند ڪيو. توھان پڻ ڇڏي سگھو ٿا نسخو اڻ تبديل ٿيل. آخري اسڪرين تي، بس توهان جي اڳوڻي داخل ٿيل ڊيٽا جي تصديق ڪريو. تنهن ڪري، اسان پروجيڪٽ ٺاهي ڇڏيو آهي، جيڪو باقي رهي ٿو اهو ڪوڊ لکڻ ۽ ان کي ڪم ڪرڻ آهي :) سڀ کان پهريان، جيڪڏهن اسان هڪ ايپليڪيشن ٺاهڻ چاهيون ٿا جيڪو ڊيٽابيس سان ڪم ڪري، اسان يقينن ڊيٽابيس کان سواء نٿا ڪري سگهون! ڊائون لوڊ ڪريو PostgreSQL هتان کان (مان ورجن 9 استعمال ڪريان ٿو). PostgreSQL هڪ ڊفالٽ صارف آهي 'postgres'، توهان کي انسٽاليشن دوران ان لاءِ پاسورڊ ٺاهڻو پوندو. پنهنجو پاسورڊ نه وساريو، اسان کي بعد ۾ ان جي ضرورت پوندي! (عام طور تي، ايپليڪيشنن ۾ ڊفالٽ ڊيٽابيس استعمال ڪرڻ خراب عمل آهي، پر بواسير جي مقدار کي گهٽائڻ لاءِ، اسان پنهنجو ڊيٽابيس ٺاهڻ سان گڏ ڪنداسين). جيڪڏهن توهان ڪمانڊ لائن ۽ SQL سوالن سان آرام سان نه آهيو، اتي سٺي خبر آهي. Intellij IDEA ڊيٽابيس سان ڪم ڪرڻ لاءِ ڪافي مناسب يوزر انٽرفيس مهيا ڪري ٿي. اهو هن طرح ڏسڻ ۾ اچي ٿو: (IDEA جي ساڄي سائڊبار تي واقع آهي، ڊيٽابيس ٽئب) ڪنيڪشن ٺاهڻ لاءِ، ڪلڪ ڪريو “+”، اسان جو مهيا ڪندڙ چونڊيو (PostgeSQL). استعمال ڪندڙ سان فيلڊ ۾ ڀريو، ڊيٽابيس جو نالو (ٻئي پوسٽ گريس آهن) ۽ پاسورڊ داخل ڪريو جيڪو توهان مقرر ڪيو آهي جڏهن PostgreSQL انسٽال ڪيو. جيڪڏهن ضروري هجي ته، ڊائون لوڊ ڪريو Postgres ڊرائيور، اهو ٿي سگهي ٿو هن ساڳئي صفحي تي. چيڪ ڪرڻ لاء "ٽيسٽ ڪنيڪشن" تي ڪلڪ ڪريو ته ڊيٽابيس سان ڪنيڪشن قائم آهي. جيڪڏهن توهان لکت ڏسو "ڪامياب"، اسان اڳتي وڌون ٿا. ھاڻي اچو ته ٽيبل ٺاھيون جن جي اسان کي ضرورت آھي. انهن مان ٻه هوندا - استعمال ڪندڙ ۽ خودڪار. استعمال ڪندڙن جي جدول لاءِ پيرا ميٽرز: مھرباني ڪري نوٽ ڪريو ته 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 not specify Column name if it matches the name of the column 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 not specify Column name if it matches the name of the column 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، name. ageانهن جي مٿان موجود تشريحن کي وڌيڪ وضاحت جي ضرورت ناهي: اهو اڳ ۾ ئي واضح آهي ته @Id هڪ اشارو آهي ته فيلڊ هن طبقي جي شين جي سڃاڻپ ڪندڙ آهي. ڪلاس جي مٿان @Table تشريح ان ٽيبل جو نالو بيان ڪري ٿي جنهن ۾ شيون لکيل آهن. عمر جي فيلڊ جي مٿي ڏنل تبصري تي ڌيان ڏيو: جيڪڏهن ڪلاس ۽ ٽيبل ۾ فيلڊ جو نالو ساڳيو آهي، توهان کي @ ڪالمن تشريح شامل ڪرڻ جي ضرورت ناهي، اهو ڪم ڪندو. جي حوالي سان ”حڪمت = GenerationType.IDENTITY“ قوس ۾ اشارو ڪيو ويو آهي: اتي ڪيترائي ID پيدا ڪرڻ واريون حڪمت عمليون آهن. توھان ان کي گوگل ڪري سگھو ٿا، پر اسان جي ايپليڪيشن جي فريم ورڪ ۾ توھان کي پريشان ٿيڻ جي ضرورت ناھي. بنيادي شيء اها آهي ته اسان جي شين لاء ids خودڪار طريقي سان ٺاهي ويندي، تنهنڪري id لاء ڪو به سيٽ نه آهي، ۽ اسان ان کي تعمير ڪندڙ ۾ بيان نه ڪندا آهيون. بهرحال، طبقو اڃا تائين ڪجهه طريقن Userسان بيٺو آهي . هن وٽ ڪارن جي فهرست آهي! @OneToMany تشريح فهرست جي مٿان ظاهر ٿئي ٿي. ان جو مطلب آهي ته صارف طبقي جو هڪ اعتراض ڪيترن ئي مشينن سان ملندڙ جلندڙ ٿي سگهي ٿو. "mappedBY" سيٽنگ ڪلاس جي صارف فيلڊ ڏانهن اشارو ڪري ٿي Auto. هن طريقي سان، مشينون ۽ استعمال ڪندڙ هڪ ٻئي سان ڳنڍيل آهن. يتيم هٽائڻ واري سيٽنگ انگريزيءَ مان چڱيءَ طرح ترجمو ڪري ٿي - ”يتيم کي هٽايو“. جيڪڏهن اسان ڊيٽابيس مان هڪ صارف کي حذف ڪريون ٿا، ان سان لاڳاپيل سڀئي ڪارٽون پڻ ختم ٿي وينديون. موڙ ۾، ڪلاس ۾ 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 ڪم ڪري ٿي، خاص فائل hibernate.cfg.xml ۾ بيان ڪيل آهي. Hibernate.cfg.xml هتي پڙهيو ويو آهي: new Configuration().configure(); جيئن توهان ڏسي سگهو ٿا، ان ۾ ڪجهه خاص ناهي - ڊيٽابيس سان ڳنڍڻ لاء پيرا ميٽر، ۽ هڪ خاص پيٽرولر show_sql. اهو ضروري آهي ته اهي سڀئي SQL سوال جيڪي اسان جي ڊيٽابيس جي خلاف هلندا ويندا آهن انهن کي ڪنسول تائين پهچايو ويندو آهي. هن طريقي سان، توهان ڏسندا ته ڇا Hibernate وقت ۾ هر وقت ڪري رهيو آهي ۽ "جادو" اثر کان نجات حاصل ڪريو. اڳتي اسان کي ڪلاس جي ضرورت آهي UserDAO. (سٺي طريقي سان، توهان کي انٽرفيس ذريعي پروگرام ڪرڻ جي ضرورت آهي - هڪ انٽرفيس ٺاهيو UserDAO۽ ان کي الڳ الڳ لاڳو ڪريو UserDAOImpl، پر ڪوڊ جي مقدار کي گهٽائڻ لاءِ آئون هن کي ڇڏي ڏيندس. اهو نه ڪريو حقيقي منصوبن ۾!). DAO (ڊيٽا رسائي اعتراض) سڀ کان وڌيڪ عام ڊيزائن جي نمونن مان هڪ آهي، "ڊيٽا رسائي". ان جو مطلب سادو آهي - ايپليڪيشن ۾ هڪ پرت ٺاهي جيڪا صرف ڊيٽا تائين رسائي جي ذميوار آهي، ۽ ٻيو ڪجهه به ناهي. ڊيٽابيس مان ڊيٽا حاصل ڪريو، ڊيٽا کي اپڊيٽ ڪريو، ڊيٽا کي حذف ڪريو - ۽ اھو آھي. DAOs بابت وڌيڪ پڙهو؛ توهان انهن کي مسلسل پنهنجي ڪم ۾ استعمال ڪندا. اسان جو ڪلاس ڇا ڪري سگھي ٿو 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 طريقن کي سڏي ٿو. اهو لڳي سگهي ٿو توهان کي افعال جي نقل وانگر (ڇو نه صرف ڊاء اعتراض کان طريقن کي ڪال ڪريو)، پر وڏي تعداد ۾ شيون ۽ پيچيده منطق سان، ايپليڪيشن کي پرت ۾ ٽوڙڻ جا وڏا فائدا آهن (اهو سٺو عمل آهي، هن معلومات لاء ياد رکو. مستقبل ۽ "ايپليڪيشن ليئرز" بابت پڙهو). اسان جي خدمت ۾، منطق سادو آهي، پر حقيقي منصوبن ۾، خدمت جي طريقن ۾ ڪوڊ جي هڪ کان وڌيڪ لائن هوندي :) هاڻي اسان وٽ سڀ ڪجهه آهي جيڪو اسان کي اپليڪيشن جي ڪم ڪرڻ جي ضرورت آهي! اچو ته 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("Masha",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("Masha",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("Sasha");
        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("Masha",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("Sasha");
        userService.updateUser(user);
        userService.deleteUser(user);
    }
}

۽ اسان جون ٽيبلون مڪمل طور تي خالي آھن (ڪنسول ڏانھن ڌيان ڏيو، سڀ سوال جيڪي ھائبرنيٽ تي عمل ڪيا ويا آھن اتي ڏيکاريا ويندا). توهان ايپليڪيشن سان گڏ راند ڪري سگهو ٿا ۽ ان جي سڀني خاصيتن کي آزمائي سگهو ٿا. مثال طور، مشينن سان هڪ صارف ٺاهيو، ان کي ڊيٽابيس ۾ محفوظ ڪريو، ڏسو ته ان کي ڪهڙي ID تفويض ڪئي وئي آهي، ۽ طريقو استعمال ڪرڻ جي ڪوشش ڪريو main()استعمال ڪندڙ کي ڊيٽابيس مان هن آئي ڊي ذريعي ۽ هن جي مشينن جي فهرست ڏيکاريو ڪنسول ۾. . يقينن، اسان صرف Hibernate جي ڪارڪردگي جو هڪ ننڍڙو حصو ڏٺو. ان جون صلاحيتون تمام وسيع آهن، ۽ اهو ڊگهي عرصي کان جاوا جي ترقي لاء صنعت جي معيار مان هڪ آهي. جيڪڏھن توھان ان کي تفصيل سان پڙھڻ چاھيو ٿا، مان سفارش ڪري سگھان ٿو ڪتاب ”جاوا پرسسٽنس API ۽ ھائبرنيٽ“، جنھن جو مون پنھنجي پوئين مضمونن مان ھڪڙي ۾ جائزو ورتو . مون کي اميد آهي ته هي مضمون پڙهندڙن لاء مفيد هو. جيڪڏهن توهان وٽ ڪي سوال آهن، انهن کي تبصرن ۾ پڇو، مان جواب ڏيڻ ۾ خوش ٿيندس :) انهي سان گڏ، ليکڪ کي "پسند" طرفان مقابلي ۾ مدد ڪرڻ نه وساريو. يا اڃا بهتر - "مون کي اهو تمام گهڻو پسند آهي" :) توهان جي پڙهائي ۾ سٺي قسمت!