آرٽيڪل
شروع
سکڻ شروع ڪريو
JavaRush /جاوا بلاگ /Random-SD /JPA ادارا ۽ DB تعلقات
Nikita Koliadin
سطح
Днепр

JPA ادارا ۽ DB تعلقات

گروپ ۾ شايع ٿيل

JPA ادارا ۽ ۽ ڊي بي تعلقات

سٺو ڏينهن، ساٿيو!
JPA ادارا ۽ DB تعلقات - 1
هي مواد انهن لاءِ آهي جن کي اڳ ۾ ئي ڊيٽابيس جي تنظيم جو خيال آهي (هتان کان پوءِ صرف ڊي بي - "ڊيٽا بيس")، گهٽ ۾ گهٽ ڄاڻ آهي ته ڪيئن Object-Relational Mapping ڪم ڪندو آهي (هتان کان پوءِ صرف ORM )، ۽ ان تي عمل درآمد، جهڙوڪ Hibernate / جي پي اي . جيڪڏهن توهان هن سان واقف نه آهيو، مان توهان کي مشورو ڏيان ٿو JDBC سان شروع ڪريو ، ۽ صرف پوء ORM ماڊل ڏانهن وڃو. مون توهان کي ڊيڄاريو، ۽ مان هن مضمون کي پڙهڻ کان پوء توهان جي نفسيات جي ذميواري نه کڻان ٿو مناسب تياري کان سواء! :) اچو ته ترتيب ۾ هر شيء سان ڊيل ڪرڻ شروع ڪريون. سڀ کان پهريان، اسان ٿورڙي نظريي ۾ تفصيل ڪنداسين، ٿورو ٿورو. ٻيو، اسان اهو معلوم ڪنداسين ته اهو ڪم هر ڪنهن جي پسنديده جاوا ۾ ڪيئن ڪجي. اسان توهان سان گڏ هڪ پروجيڪٽ-چيٽ شيٽ پڻ لکنداسين، جيڪا اسان جي موضوع جي سمجھ کي مضبوط ڪندي ۽ هڪ ٽيمپليٽ جي طور تي ڪم ڪندي ته ڪيئن ميپنگ ٿيڻ گهرجي . سو، اچو ته اهو ڪريون!

Entity ڇا آهي؟

هڪ وجود حقيقي زندگي مان هڪ اعتراض آهي (مثال طور، هڪ ڪار) جنهن ۾ خاصيتون آهن (دروازو، WHEELS ، انجڻ). ڊي بي ادارو: هن معاملي ۾، اسان جو ادارو هڪ ڊي بي ۾ ذخيرو ٿيل آهي، هر شيء سادو آهي. ڇو ۽ ڪيئن اسان ڪار کي ڊيٽابيس ۾ رکون ٿا - اسان ان کي بعد ۾ ڏسنداسين.

ڊي بي تعلقات ڇا آهي؟

هڪ ڊگهو وقت اڳ، دور دراز سلطنت ۾ ، هڪ تعلقي ڊي بي ٺاهي وئي هئي . هن ڊي بي ۾، ڊيٽا جدولن جي صورت ۾ پيش ڪئي وئي. پر شرڪ مان گڏهه کي اهو به واضح ٿيو ته انهن جدولن کي پاڻ ۾ ڳنڍڻ لاءِ هڪ ميکانيزم ٺاهڻ ضروري هو. نتيجي طور، 4 ڊي بي تعلقات ظاهر ٿيا :
  1. هڪ کان هڪ
  2. هڪ کان گهڻا
  3. گهڻن کان هڪ
  4. گهڻن کان گهڻا
جيڪڏهن توهان اهو سڀ ڪجهه پهريون ڀيرو ڏسي رهيا آهيو، مان توهان کي ٻيهر ڊيڄاريان ٿو - اهو خراب ٿي ويندو: سير لاء وڃڻ بابت سوچيو. اسان هڪ مثال استعمال ڪندي انهن سڀني رشتن جو تجزيو ڪنداسين، ۽ انهن جي وچ ۾ فرق کي سمجھنداسين.

خوفناڪ مثال

اسان وٽ ھڪڙو پروجيڪٽ ھوندو جنھن ۾ 5 شاخون ھونديون: ماسٽر، جتي ھوندو پروجيڪٽ جو تفصيل، ۽ 1 برانچ ھر DB رشتي لاءِ. هر برانچ ۾ ڊي بي ٺاهڻ ۽ ان کي ٽيسٽ ڊيٽا سان ڀرڻ لاءِ SQL اسڪرپٽ شامل هوندي، ان سان گڏ اينٽيٽي ڪلاس اينوٽيشن ميپنگ سان. هر شاخ لاءِ هڪ Hibernate config فائل پڻ هوندي. مان پروجيڪٽ لاءِ H2 ايمبيڊڊ ڊي بي استعمال ڪندس ته جيئن ڪلائوڊ ڊي بي يا خارجي ڊي بي جي انفرادي پهلوئن کان پريشان نه ٿئي. لنڪ تي عمل ڪندي، پنهنجي ويڪيوم ڪلينر تي H2 DB انسٽال ڪريو. مان هر قدم کي 1 شاخ ۾ بيان ڪندس، باقي صرف اهم نقطا آهن. آخر ۾ اسان اختصار ڪنداسين. وڃ. هي منهنجي منصوبي جي ماسٽر برانچ جي لنڪ آهي.

هڪ ٻئي سان تعلق

هتي شاخ سان ڳنڍيو .

  1. اسان کي اسان جي منصوبي سان H2 DB ڳنڍڻ جي ضرورت آهي. هتي اسان کي زور ڏيڻ جي ضرورت آهي ته اسان کي DB ۽ ٻين شين سان آرام سان ڪم ڪرڻ لاء الٽيميٽ IDEA جي ضرورت آهي. جيڪڏهن توهان وٽ اڳ ۾ ئي آهي، پوء سڌو سنئون ڊي بي ڪنيڪشن ڏانهن وڃو. ڊيٽابيس ٽيب ڏانھن وڃو ۽ اسڪرين شاٽ وانگر ڪريو:

    JPA ادارا ۽ DB تعلقات - 2

    اڳتي هلي اسان ڊي بي سيٽنگون ڏانهن وڃو. توھان پنھنجي ڊيٽا داخل ڪري سگھو ٿا، ۽ حتي توھان جو DBMS؛ مان ورجائي ٿو، مان سادگي لاءِ H2 DB استعمال ڪريان ٿو.

    JPA ادارا ۽ DB تعلقات - 3

    اڳيون، اچو ته سرڪٽ قائم ڪريو. هي قدم اختياري آهي پر سفارش ڪئي وئي آهي جيڪڏهن توهان وٽ ڊي بي ۾ ڪيترائي اسڪيما آهن.

    JPA ادارا ۽ DB تعلقات - 4

    سيٽنگون لاڳو ڪريو، ۽ آخر ۾ اسان کي ڪجھھ حاصل ڪرڻ گھرجي:

    JPA ادارا ۽ DB تعلقات - 5

  2. اسان ڊيٽابيس ٺاھيو ۽ ان کي IDEA کان رسائي ترتيب ڏني. هاڻي توهان کي ان ۾ ٽيبل ٺاهڻ جي ضرورت آهي ۽ ان کي ڪجهه ڊيٽا سان ڀريو. مثال طور، مان ٻه ادارا کڻندس: ليکڪ ۽ ڪتاب. هڪ ڪتاب ۾ هڪ ليکڪ ٿي سگهي ٿو، ٿي سگهي ٿو ڪيترائي ليکڪ هجن، يا شايد هڪ نه هجي. هن مثال ۾ اسان سڀني قسمن جا ڪنيڪشن ٺاهينداسين. پر هن نقطي تي - هڪ کان هڪ تعلق. اچو ته لاڳاپيل اسڪرپٽ ٺاهيون جيڪا ٺاهي ٿي ڊي بي ٽيبل :

    DROP TABLE IF EXISTS PUBLIC.BOOK;

CREATE TABLE PUBLIC.BOOK (
  ID         INTEGER      NOT NULL AUTO_INCREMENT,
  NAME       VARCHAR(255) NOT NULL,
  PRINT_YEAR INTEGER(4)   NOT NULL,
  CONSTRAINT BOOK_PRIMARY_KEY PRIMARY KEY (ID)
);

DROP TABLE IF EXISTS PUBLIC.AUTHOR;

CREATE TABLE PUBLIC.AUTHOR (
  ID          INTEGER      NOT NULL AUTO_INCREMENT,
  FIRST_NAME  VARCHAR(255) NOT NULL,
  SECOND_NAME VARCHAR(255) NOT NULL,
  BOOK_ID     INTEGER      NOT NULL UNIQUE,
  CONSTRAINT AUTHOR_PRIMARY_KEY PRIMARY KEY (ID),
  CONSTRAINT BOOK_FOREIGN_KEY FOREIGN KEY (BOOK_ID) REFERENCES BOOK (ID)
);

    ۽ اچو ته ان تي عمل ڪريون:

    JPA ادارا ۽ DB تعلقات - 6

    ڪنسول ۾ عملدرآمد جو نتيجو:

    JPA ادارا ۽ DB تعلقات - 7

    DB ۾ نتيجا:

    JPA ادارا ۽ DB تعلقات - 8

  3. اچو ته اسان جي جدولن جو هڪ خاڪو ڏسو. هن کي ڪرڻ لاء، اسان جي ڊي بي تي RMB:

    JPA ادارا ۽ DB تعلقات - 9

    نتيجو:

    JPA ادارا ۽ DB تعلقات - 10

    يو ايم ايل ڊاگرام تي اسين سڀ پرائمري ڪي ۽ پرڏيهي ڪيز ڏسي سگھون ٿا، اسان کي اسان جي جدولن جي وچ ۾ ڪنيڪشن پڻ نظر اچي ٿو.

  4. اچو ته هڪ اسڪرپٽ لکون جيڪو اسان جي ڊي بي کي ٽيسٽ ڊيٽا سان ڀري ٿو:

    INSERT INTO PUBLIC.BOOK (NAME, PRINT_YEAR)
VALUES ('First book', 2010),
       ('Second book', 2011),
       ('Third book', 2012);

INSERT INTO PUBLIC.AUTHOR (FIRST_NAME, SECOND_NAME, BOOK_ID)
VALUES ('Pablo', 'Lambado', 1),
       ('Pazo', 'Zopa', 2),
       ('Lika', 'Vika', 3);

    منهنجو مطلب، ڇا ٿيندو؟ ھڪڙي کان ھڪڙي تعلق جي ضرورت آھي جڏھن ھڪڙي جدول جو ادارو ھڪڙي ٻئي جي ھڪڙي اداري سان لاڳاپيل آھي (يا بلڪل لاڳاپيل نه آھي جيڪڏھن NULL BOOK_ID مان هٽايو ويو آھي). اسان جي مثال ۾، ھڪڙي ڪتاب جو ھڪڙو ليکڪ آھي. ٻيو رستو نه.

  5. هاڻي سڀ کان وڌيڪ دلچسپ ڳالهه اها آهي ته جاوا ڪلاس کي ڊي بي ادارن سان ڪيئن ڳنڍجي؟ تمام سادو. اچو ته ٻه طبقا ڪتاب ۽ مصنف ٺاهي. هڪ مثال استعمال ڪندي، مان ڪلاس 1 ۽ اهم ڪميونيڪيشن فيلڊز جو تجزيو ڪندس. اچو ته ليکڪ طبقي کي مثال طور وٺون :

    @Data
@Entity
@DynamicInsert
@DynamicUpdate
@Table(name = "AUTHOR")
public class Author {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "ID", nullable = false)
    private Long id;

    @Column(name = "FIRST_NAME", nullable = false)
    private String firstName;

    @Column(name = "SECOND_NAME", nullable = false)
    private String secondName;

    @OneToOne
    @JoinColumn(name = "BOOK_ID", unique = true, nullable = false)
    private Book book;
}
Java-университет
اچو ته ان کي ترتيب ڏيو:
  1. ڪلاس ۾ سڀئي شعبا ڊي بي ايٽيٽيٽ جي خاصيتن کي ورجائيندا آهن.
  2. @ ڊيٽا ( لومبوڪ کان ) چوي ٿو ته هر فيلڊ لاء هڪ حاصل ڪندڙ ۽ سيٽر ٺاهي ويندي، برابر، هيش ڪوڊ ختم ڪيو ويندو، ۽ هڪ toString طريقو پيدا ڪيو ويندو.
  3. @Entity چوي ٿو ته ڏنل طبقو هڪ ادارو آهي ۽ هڪ DB اداري سان لاڳاپيل آهي.
  4. @DynamicInsert ۽ @DynamicUpdate چون ٿا ته ڊي بي ۾ متحرڪ داخل ۽ تازه ڪاريون ڪيون وينديون. اهي گهڻيون هائيبرنيٽ سيٽنگون آهن جيڪي توهان لاءِ ڪارائتيون هونديون ته جيئن توهان وٽ صحيح بيچنگ هجي.
  5. @ ٽيبل (نالو = "AUTHOR") ڪتاب ڪلاس کي DB AUTHOR ٽيبل سان ڳنڍي ٿو.
  6. @Id چوي ٿو ته هي فيلڊ بنيادي ڪنجي آهي.
  7. @GeneratedValue (حڪومت = GenerationType.IDENTITY) - بنيادي اهم نسل جي حڪمت عملي.
  8. @ ڪالمن (نالو = "ID"، nullable = غلط) ھڪڙي فيلڊ کي ڊي بي خاصيت سان ڳنڍيندو آھي، ۽ اھو پڻ چوي ٿو ته ڏنل ڊي بي فيلڊ نال نه ٿي سگھي. اهو پڻ مفيد آهي جڏهن ادارن مان جدول ٺاهي رهيا آهن. اسان کي هاڻي اسان جي پروجيڪٽ کي ڪيئن ٺاهيو، اهو ريورس پروسيس يونٽ ٽيسٽ لاء ٽيسٽ ڊي بيز ۾ گهربل آهي.
  9. @OneToOne چوي ٿو ته ڏنل فيلڊ ھڪڙي ھڪڙي تعلق واري فيلڊ آھي.
  10. @JoinColumn (نالو = "BOOK_ID"، منفرد = سچ، nullable = غلط) - ھڪڙو BOOK_ID ڪالم ٺاھيو ويندو، جيڪو منفرد آھي ۽ ناھي.
پڄاڻيءَ تي ( ڪتاب ڪلاس ۾ ) اسان کي به ون ٽو ون ڪنيڪشن ٺاهڻو پوندو ۽ انهي فيلڊ کي ظاهر ڪرڻ جي ضرورت آهي جنهن تي نقشي سازي ٿيندي آهي. @OneToOne(mappedBy = "book") - هن مثال ۾، هي ليکڪ طبقي جو ڪتاب فيلڊ آهي. JPA انهن کي پاڻ سان ڳنڍيندو. پهرين نظر ۾، اهو لڳي سگھي ٿو ته تبصرن جي گندگي آهي، پر حقيقت ۾ اهو تمام آسان آهي ۽ تجربي سان توهان انهن کي خودڪار طور تي شامل ڪيو ويندو بغير سوچڻ جي.

  1. ھاڻي ھائيبرنٽ کي ترتيب ڏيو. هن کي ڪرڻ لاء، هڪ hibernate.cfg.xml فائل ٺاهيو:

    <?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
        <property name="hibernate.dialect">org.hibernate.dialect.H2Dialect</property>
        <property name="hibernate.connection.driver_class">org.h2.Driver</property>

        <property name="hibernate.connection.url">jdbc:h2:~/db/onetoone</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password"/>

        <property name="hibernate.hbm2ddl.auto">update</property>

        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>
        <property name="hibernate.use_sql_comments">true</property>

        <property name="hibernate.generate_statistics">true</property>

        <property name="hibernate.jdbc.batch_size">50</property>
        <property name="hibernate.jdbc.fetch_size">50</property>

        <property name="hibernate.order_inserts">true</property>
        <property name="hibernate.order_updates">true</property>
        <property name="hibernate.jdbc.batch_versioned_data">true</property>

        <mapping class="com.qthegamep.forjavarushpublication2.entity.Book"/>
        <mapping class="com.qthegamep.forjavarushpublication2.entity.Author"/>
    </session-factory>
</hibernate-configuration>
ملڪيت جي وضاحت :
  1. hibernate.dialect اها ڊي بي ايم ايس جي ٻولي آهي جنهن کي اسان چونڊيو آهي.
  2. hibernate.connection.driver_class — اسان جي ڊي بي جو ڊرائيور ڪلاس.
  3. hibernate.connection.url - اسان جي ڊي بي جو utl. توهان ان کي پهرين نقطي کان وٺي سگهو ٿا جتي اسان ڊي بي ترتيب ڏني آهي.
  4. hibernate.connection.username - DB صارف جو نالو.
  5. hibernate.connection.password — ڊي بي يوزر پاسورڊ.
  6. hibernate.hbm2ddl.auto - ٽيبل جي نسل کي ترتيب ڏيڻ. جيڪڏهن تازه ڪاري، پوء اهو پيدا نٿو ڪري ته اهو اڳ ۾ ئي ٺاهيو ويو آهي، پر صرف ان کي تازه ڪاري ڪري ٿو.
  7. hibernate.show_sql - ڇا ڊي بي سوالن کي ڏيکارڻ لاء.
  8. hibernate.format_sql - ڇا ڊي بي سوالن کي فارميٽ ڪرڻ لاء. جيڪڏهن نه ته پوءِ اهي سڀ هڪ لڪير تي هوندا. مان ان کي چالو ڪرڻ جي صلاح ڏيان ٿو.
  9. hibernate.use_sql_comments - تبصرا DB سوال. جيڪڏهن هي Insert آهي ته پوءِ گذارش جي مٿان هڪ تبصرو لکيل هوندو ته درخواست Insert قسم جي آهي.
  10. hibernate.generate_statistics - لاگ ٺاهي ٿو. آئون سفارش ڪريان ٿو ۽ وڌ ۾ وڌ لاگنگ کي ترتيب ڏيڻ جي صلاح ڏيو. لاگ پڙهڻ سان ORM سان صحيح ڪم ڪرڻ جا موقعا وڌندا.
  11. hibernate.jdbc.batch_size - وڌ ۾ وڌ بيچ سائيز.
  12. hibernate.jdbc.fetch_size — وڌ ۾ وڌ آڻڻ سائيز.
  13. hibernate.order_inserts - متحرڪ داخل ڪرڻ جي اجازت ڏئي ٿي.
  14. hibernate.order_updates - متحرڪ اپڊيٽ جي اجازت ڏئي ٿي.
  15. hibernate.jdbc.batch_versioned_data - بيچنگ جي اجازت ڏئي ٿي. توهان جي ڊي بي ايم ايس کي ڏسو: هرڪو هن جي حمايت نٿو ڪري.
  16. ميپنگ ڪلاس - ڪلاس جيڪي اسان جا ادارا آهن. هر شي کي درج ڪرڻ جي ضرورت آهي.

  1. هاڻي اسان جي جوهر کي طئي ڪرڻو پوندو. اسان هن کي مسلسل ٽيب ۾ چيڪ ڪري سگهون ٿا:

    JPA ادارا ۽ DB تعلقات - 11

    نتيجو:

    JPA ادارا ۽ DB تعلقات - 12

  2. اسان کي تفويض ڊيٽا کي ترتيب ڏيڻ جي ضرورت آهي:

    JPA ادارا ۽ DB تعلقات - 13 JPA ادارا ۽ DB تعلقات - 14

    نتيجا: اسان ون ٽو ون ميپنگ ڪئي آهي. مواد صرف معلوماتي مقصدن لاء آهي، تفصيل حوالن ۾ آهن.

هڪ کان گهڻا تعلق

هتي شاخ سان ڳنڍيو . مان هاڻي آرٽيڪل ۾ ڪوڊ پوسٽ نه ڪندس، ڇاڪاڻ ته اهو اڳ ۾ ئي ڊگهو آهي. اسان GitHub تي سڀ ڪوڊ ڏسو.

  1. شروعاتي رسم الخط تي عمل ڪرڻ جي نتيجي ۾ ، اسان ھيٺ ڏنل حاصل ڪندا آھيون:

    JPA ادارا ۽ DB تعلقات - 15

    ڇا توهان پوئين ٽيبل سان فرق محسوس ڪيو؟

  2. خاڪو:

    JPA ادارا ۽ DB تعلقات - 16

    هڪ کان گهڻن رشتي - هڪ ليکڪ ڪيترائي ڪتاب رکي سگهي ٿو. کاٻي وجود هڪ يا وڌيڪ ساڄي وارن سان ملندو آهي.

  3. نقشي ۾ فرق تشريح ۽ شعبن ۾ ٿيندو:

    ليکڪ ڪلاس ۾ هڪ فيلڊ ظاهر ٿئي ٿو :

    @OneToMany(fetch = FetchType.LAZY, mappedBy = "author")
private Set<Book> books;

    اهو اڳ ۾ ئي هڪ سيٽ آهي، ڇاڪاڻ ته اسان وٽ ڪيترائي ڪتاب آهن. @OneToMany رويي جي قسم بابت ڳالهائي رهيو آهي. FetchType.Lazy چوي ٿو ته اسان کي ڪتابن جي پوري لسٽ لوڊ ڪرڻ جي ضرورت ناهي جيڪڏهن اها درخواست ۾ بيان نه ڪئي وئي آهي. اهو پڻ چوڻ گهرجي ته هي فيلڊ toString ۾ شامل نه ٿي ڪري سگھجي، ٻي صورت ۾ اسان هڪ StackOverflowError تماڪ ڪرڻ شروع ڪنداسين. منهنجو محبوب Lombok هن جو خيال رکندو آهي:

    @ToString(exclude = "books")

    ڪتاب جي ڪلاس ۾ اسان ڪيترن ئي کان هڪ راءِ ڏيون ٿا:

    @ManyToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
@JoinColumn(name = "AUTHOR_ID", nullable = false)
private Author author;

    هتي اسان ان نتيجي تي پهتا آهيون ته هڪ کان گھڻائي ڪيترن ئي کان هڪ جي آئيني تصوير آهي ۽ ان جي برعڪس. اهو زور ڀريو وڃي ٿو ته Hibernate ٻه طرفي ڪميونيڪيشن بابت ڪجھ به نه ڄاڻندو آهي. هن لاء، اهي ٻه مختلف ڪنيڪشن آهن: هڪ هڪ طرف ۾، ٻيو مخالف طرف.

  4. hibernate.cfg.xml ۾ گهڻو ڪجهه نه بدليو آهي .

  5. استقامت:

    JPA ادارا ۽ DB تعلقات - 17

گهڻن کان هڪ تعلق

جيئن ته گھڻن کان ھڪڙي ھڪڙي ھڪڙي کان گھڻن جي آئيني تصوير آھي، ان ۾ ڪجھ فرق ھوندا. هتي شاخ سان ڳنڍيو .

  1. شروعاتي رسم الخط تي عمل ڪرڻ جي نتيجي ۾ ، اسان ھيٺ ڏنل نتيجو حاصل ڪندا آھيون:

    JPA ادارا ۽ DB تعلقات - 18

  2. خاڪو:

    JPA ادارا ۽ DB تعلقات - 19

  3. نقشي ۾ فرق تشريح ۽ شعبن ۾ ٿيندو:

    ليکڪ ڪلاس ۾ هاڻي ڪو به سيٽ ناهي ، ڇاڪاڻ ته اهو ڪتاب ڪلاس ۾ منتقل ڪيو ويو آهي.

  4. hibernate.cfg.xml

  5. استقامت:

    JPA ادارا ۽ DB تعلقات - 20

گهڻن کان گهڻا تعلق

اچو ته سڀ کان وڌيڪ دلچسپ تعلق ڏانهن وڃو. هي تعلق، شرافت ۽ بي حيائي جي سڀني قاعدن جي مطابق، هڪ اضافي ٽيبل ذريعي پيدا ڪيو ويو آهي. پر هي ٽيبل هڪ ادارو ناهي. دلچسپ، صحيح؟ اچو ته هن گند تي هڪ نظر وجهون. هتي شاخ سان ڳنڍيو .

  1. شروعاتي اسڪرپٽ کي ڏسو ، هڪ اضافي HAS ٽيبل هتي ظاهر ٿئي ٿو. اسان کي ليکڪ جي ڪتاب وانگر ڪجهه ملي ٿو.

    رسم الخط تي عمل ڪرڻ جي نتيجي ۾، اسان ھيٺ ڏنل جدول حاصل ڪنداسين:

    JPA ادارا ۽ DB تعلقات - 21

  2. خاڪو:

    JPA Entities and DB Relationships - 22

    اسان جي مثال ۾، اهو ظاهر ٿئي ٿو ته هڪ ڪتاب ڪيترن ئي ليکڪن کي ٿي سگهي ٿو، ۽ هڪ ليکڪ ڪيترائي ڪتاب ٿي سگهي ٿو. اهي اوورليپ ٿي سگهن ٿا.

  3. ميپنگ ڪلاس ۾ ڪلاسن اندر سيٽون هونديون. پر جيئن مون چيو، HAS ٽيبل هڪ ادارو ناهي.

    ليکڪ طبقو :

    @ManyToMany
@JoinTable(name = "HAS",
        joinColumns = @JoinColumn(name = "AUTHOR_ID", referencedColumnName = "ID"),
        inverseJoinColumns = @JoinColumn(name = "BOOK_ID", referencedColumnName = "ID")
)
private Set<Book> books;

    @ManyToMany رشتي جو هڪ قسم آهي.

    @JoinTable - اھو اھو آھي جيڪو خاصيت کي اضافي HAS ٽيبل سان ڳنڍيندو. ان ۾ اسان ٻه خاصيتون بيان ڪيون ٿا جيڪي ٻن ادارن جي بنيادي ڪنجي ڏانهن اشارو ڪندا.

    ڪتاب ڪلاس :

    @ManyToMany(fetch = FetchType.LAZY, mappedBy = "books")
private Set<Author> authors;

    هتي اسان اشارو ڪندا آهيون FetchType ۽ فيلڊ جنهن کي اسين نقشي ۾ استعمال ڪنداسين.

  4. اسان جي hibernate.cfg.xml وري به ڪا تبديلي نه رهي (مان ان حقيقت کي نظر ۾ نه ٿو رکان ته اسان هر شاخ لاءِ هڪ نئون ڊي بي ٺاهيو).

  5. استقامت:

    JPA Entities and DB Relationships - 23

بحث ڪرڻ

تنهن ڪري، اسان سطحي طور تي ڊي بي رشتن جي قسمن جي جانچ ڪئي آهي ۽ اهو معلوم ڪيو آهي ته انهن کي ORM ماڊل ۾ ڪيئن لاڳو ڪجي. اسان هڪ آزمائشي پروجيڪٽ لکيو آهي جيڪو سڀني ڪنيڪشن کي ظاهر ڪري ٿو، ۽ اهو معلوم ڪيو ته ڪيئن ترتيب ڏيڻ hibernate / jpa. ڦوهه.

مفيد لنڪس

منهنجا پوئين مضمون: PS متن ۾ نقص ۽ نقص ٿي سگھي ٿو. پي پي ايس ليکڪ هي مضمون لکڻ دوران ڪجهه عجيب تماڪ ڇڪي رهيو هو. توهان جي توجه لاء مهرباني!
تبصرا
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION