JPA: ٽيڪنالاجي متعارف ڪرائڻ

جديد ترقي واري دنيا زندگي کي آسان بڻائڻ لاءِ ٺهيل مختلف وضاحتن سان ڀريل آهي. اوزار ڄاڻڻ، توهان صحيح چونڊي سگهو ٿا. ڄاڻڻ کان سواء، توهان پنهنجي زندگي کي وڌيڪ ڏکيو بڻائي سگهو ٿا. اهو جائزو JPA - Java Persistence API جي تصور تي رازداري جو پردو کڻندو. مون کي اميد آهي ته پڙهڻ کان پوءِ توهان هن پراسرار دنيا ۾ اڃا به وڌيڪ اونهائي ڪرڻ چاهيندا.

• تعارف
• پروجيڪٽ ٺاهڻ
• JPA شامل ڪرڻ
• ادارا
• ميلاپ
• JPQL
• معيار API
• نتيجو

تعارف

جيئن ته اسان ڄاڻون ٿا، پروگرامن جي مکيه ڪمن مان هڪ آهي اسٽوريج ۽ پروسيسنگ ڊيٽا. سٺن پراڻن ڏينهن ۾، ماڻهو صرف فائلن ۾ ڊيٽا محفوظ ڪندا هئا. پر جيئن ئي هڪ ئي وقت پڙهڻ ۽ ايڊٽ ڪرڻ جي پهچ جي ضرورت هوندي آهي، جڏهن هڪ لوڊ هوندو آهي (يعني هڪ ئي وقت ڪيتريون ئي درخواستون اينديون آهن)، ڊيٽا کي صرف فائلن ۾ محفوظ ڪرڻ هڪ مسئلو بڻجي ويندو آهي. وڌيڪ معلومات لاءِ ته ڪهڙن مسئلن کي ڊيٽابيس حل ڪري ٿو ۽ ڪيئن، مان توهان کي مشورو ڏيان ٿو ته مضمون پڙهو ” ڪيئن ڊيٽابيسس ترتيب ڏنل آهن “. ان جو مطلب اهو آهي ته اسان فيصلو ڪيو ته اسان جي ڊيٽا کي ڊيٽابيس ۾ ذخيرو ڪرڻ لاء. هڪ ڊگهي وقت تائين، جاوا JDBC API (جاوا ڊيٽابيس ڪنيڪشن) استعمال ڪندي ڊيٽابيس سان ڪم ڪرڻ جي قابل ٿي چڪو آهي. توهان JDBC بابت وڌيڪ پڙهي سگهو ٿا هتي: " JDBC يا جتي اهو سڀ شروع ٿئي ٿو ." پر وقت گذرندو ويو ۽ ڊولپرز کي هر دفعي ساڳئي قسم جي لکڻ جي ضرورت کي منهن ڏيڻو پيو ۽ غير ضروري ”بحالي“ ڪوڊ (جنهن کي نام نهاد بوائلر پليٽ ڪوڊ) ڊيٽابيس ۾ جاوا آبجڪس کي محفوظ ڪرڻ جي معمولي عملن لاءِ ۽ ان جي برعڪس، جاوا آبجیکٹ ٺاهڻ جي ڊيٽا استعمال ڪندي. ڊيٽابيس. ۽ پوء، انهن مسئلن کي حل ڪرڻ لاء، ORM وانگر هڪ تصور پيدا ٿيو. ORM - Object-Relational Mapping يا ترجمو ڪيو ويو روسي اعتراض-رابطي واري نقشي ۾. اها هڪ پروگرامنگ ٽيڪنالاجي آهي جيڪا ڊيٽابيس کي ڳنڍي ٿي اعتراض تي مبني پروگرامنگ ٻولين جي تصورن سان. آسان ڪرڻ لاء، ORM هڪ ڊيٽابيس ۾ جاوا اعتراض ۽ رڪارڊ جي وچ ۾ ڪنيڪشن آهي: ORM بنيادي طور تي اهو تصور آهي ته جاوا اعتراض کي ڊيٽابيس ۾ ڊيٽا جي طور تي نمائندگي ڪري سگهجي ٿو (۽ ان جي برعڪس). اهو JPA وضاحت جي صورت ۾ ٺهيل هو - Java Persistence API. وضاحت اڳ ۾ ئي جاوا API جي وضاحت آهي جيڪا هن تصور کي ظاهر ڪري ٿي. وضاحت اسان کي ٻڌائي ٿي ته اسان کي ڪهڙن اوزارن سان مهيا ڪيو وڃي (يعني اسان ڪهڙن انٽرفيس ذريعي ڪم ڪري سگهون ٿا) ORM تصور جي مطابق ڪم ڪرڻ لاءِ. ۽ انهن پئسن کي ڪيئن استعمال ڪجي. تفصيلات اوزار جي عمل درآمد کي بيان نٿو ڪري. اهو هڪ وضاحت لاءِ مختلف عملن کي استعمال ڪرڻ ممڪن بڻائي ٿو. توهان ان کي آسان بڻائي سگهو ٿا ۽ چئو ته هڪ وضاحت API جي وضاحت آهي. JPA جي وضاحت جو متن Oracle ويب سائيٽ تي ڳولهي سگھجي ٿو: " JSR 338: JavaTM Persistence API ". تنهن ڪري، JPA استعمال ڪرڻ لاء، اسان کي ڪجهه عمل جي ضرورت آهي جنهن سان اسين ٽيڪنالاجي استعمال ڪنداسين. JPA لاڳو ڪندڙ پڻ سڏيو ويندو آهي JPA فراهم ڪندڙ. سڀ کان وڌيڪ قابل ذڪر JPA عملن مان هڪ آهي Hibernate . تنهن ڪري، مان ان تي غور ڪرڻ جي صلاح ڏيان ٿو.

پروجيڪٽ ٺاهڻ

جيئن ته JPA جاوا بابت آهي، اسان کي جاوا پروجيڪٽ جي ضرورت پوندي. اسان دستي طور تي ڊاريڪٽري جو ڍانچو پاڻ ٺاهي سگھون ٿا ۽ پاڻ کي ضروري لائبريريون شامل ڪري سگھون ٿا. پر پراجيڪٽ جي اسيمبليءَ کي خودڪار ڪرڻ لاءِ سسٽم استعمال ڪرڻ تمام گهڻو آسان ۽ صحيح آهي (يعني اصل ۾، هي صرف هڪ پروگرام آهي، جيڪو اسان لاءِ پروجيڪٽ جي اسيمبليءَ کي منظم ڪندو، ڊائريڪٽري ٺاهي، ڪلاس پاٿ ۾ ضروري لائبريريون شامل ڪري، وغيره. .) ھڪڙو نظام آھي Gradle. توهان هتي Gradle بابت وڌيڪ پڙهي سگهو ٿا: " گريڊل جو مختصر تعارف ". جيئن اسان ڄاڻون ٿا، Gradle ڪارڪردگي (يعني اهي شيون جيڪي ڪري سگهن ٿيون) مختلف Gradle پلگ ان استعمال ڪندي لاڳو ٿينديون آهن. اچو ته استعمال ڪريون Gradle ۽ " Gradle Build Init Plugin " پلگ ان. اچو ته حڪم هلون:

gradle init --type java-application

Gradle اسان لاءِ ضروري ڊاريڪٽري جي جوڙجڪ ڪندو ۽ تعمير اسڪرپٽ ۾ منصوبي جي بنيادي تشريح واري وضاحت ٺاھيندو build.gradle. تنهن ڪري، اسان وٽ هڪ درخواست آهي. اسان کي سوچڻ جي ضرورت آهي ته اسان ڇا بيان ڪرڻ چاهيون ٿا يا اسان جي ايپليڪيشن سان ماڊل. اچو ته ڪجھ ماڊلنگ ٽول استعمال ڪريون، مثال طور: app.quickdatabasediagrams.com هتي اهو چوڻ لائق آهي ته جيڪو اسان بيان ڪيو آهي اهو اسان جو ”ڊومين ماڊل“ آهي. هڪ ڊومين هڪ "موضوع علائقو" آهي. عام طور تي، ڊومين لاطيني ۾ "قبضي" آهي. وچين دور ۾، اهو نالو بادشاهن يا جاگيردارن جي ملڪيت وارن علائقن کي ڏنو ويو هو. ۽ فرانسيسي ۾ اهو لفظ بڻجي ويو "domaine"، جيڪو صرف ترجمو ڪري ٿو "علائقو". اهڙيء طرح اسان اسان جي "ڊومين ماڊل" = "موضوع ماڊل" بيان ڪيو آهي. هن نموني جو هر عنصر ڪجهه قسم جي "جوهر" آهي، حقيقي زندگي مان ڪجهه. اسان جي صورت ۾، اهي ادارا آهن: زمرو ( Category)، مضمون ( Topic). اچو ته ادارن لاءِ الڳ پيڪيج ٺاهيون، مثال طور نالي ماڊل سان. ۽ اچو ته اتي جاوا ڪلاس شامل ڪريون جيڪي بيان ڪن ٿيون. جاوا ڪوڊ ۾، اهڙيون ادارا هڪ باقاعده POJO آهن ، جيڪي هن طرح نظر اچن ٿا:

public class Category {
    private Long id;
    private String title;

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }
}

اچو ته ڪلاس جي مواد کي نقل ڪريون ۽ قياس ذريعي هڪ ڪلاس ٺاهيو Topic. هو صرف ان ۾ اختلاف ڪندو ته هو ڄاڻي ٿو ته هو ڪهڙي درجي سان تعلق رکي ٿو. تنهن ڪري، اچو ته Topicهڪ زمرو فيلڊ شامل ڪريو ۽ ان سان گڏ ڪم ڪرڻ جا طريقا ڪلاس ۾:

private Category category;

public Category getCategory() {
	return category;
}

public void setCategory(Category category) {
	this.category = category;
}

ھاڻي اسان وٽ ھڪڙو جاوا ايپليڪيشن آھي جنھن جو پنھنجو ڊومين ماڊل آھي. هاڻي اهو وقت آهي JPA منصوبي سان ڳنڍڻ شروع ڪرڻ.

JPA شامل ڪرڻ

تنهن ڪري، جيئن اسان کي ياد آهي، JPA جو مطلب آهي ته اسان ڊيٽابيس ۾ ڪجهه محفوظ ڪنداسين. تنهن ڪري، اسان کي هڪ ڊيٽابيس جي ضرورت آهي. اسان جي منصوبي ۾ ڊيٽابيس ڪنيڪشن کي استعمال ڪرڻ لاء، اسان کي ڊيٽابيس سان ڳنڍڻ لاء هڪ انحصار لائبريري شامل ڪرڻ جي ضرورت آهي. جيئن اسان کي ياد آهي، اسان استعمال ڪيو Gradle، جيڪو اسان لاء هڪ تعمير اسڪرپٽ ٺاهي build.gradle. ان ۾ اسان بيان ڪنداسين انحصار جيڪي اسان جي منصوبي جي ضرورت آهي. انحصار اهي لائبريريون آهن جن جي بغير اسان جو ڪوڊ ڪم نٿو ڪري سگهي. اچو ته ڊيٽابيس سان ڳنڍڻ تي انحصار جي وضاحت سان شروع ڪريون. اسان اهو ساڳيو طريقي سان ڪندا آهيون اسان اهو ڪنداسين جيڪڏهن اسان صرف JDBC سان ڪم ڪري رهيا آهيون:

dependencies {
	implementation 'com.h2database:h2:1.4.199'

هاڻي اسان وٽ ڊيٽابيس آهي. اسان ھاڻي پنھنجي ايپليڪيشن ۾ ھڪڙو پرت شامل ڪري سگھون ٿا جيڪو اسان جي جاوا شين کي ڊيٽابيس جي تصورن ۾ نقشي ڪرڻ جي ذميوار آھي (جاوا کان SQL تائين). جيئن ته اسان کي ياد آهي، اسان استعمال ڪرڻ وارا آهيون JPA وضاحت جي عمل کي هن لاءِ Hibernate سڏيو ويندو آهي:

dependencies {
	implementation 'com.h2database:h2:1.4.199'
	implementation 'org.hibernate:hibernate-core:5.4.2.Final'

هاڻي اسان کي JPA ترتيب ڏيڻ جي ضرورت آهي. جيڪڏهن اسان وضاحت ۽ سيڪشن "8.1 Persistence Unit" پڙهون ٿا، اسان کي معلوم ٿيندو ته هڪ Persistence Unit ڪنهن قسم جي ٺاهه، ميٽا ڊيٽا ۽ ادارن جو ميلاپ آهي. ۽ JPA ڪم ڪرڻ لاءِ، توهان کي تشريح واري فائيل ۾ گهٽ ۾ گهٽ هڪ Persistence Unit بيان ڪرڻ جي ضرورت آهي، جنهن کي سڏيو ويندو آهي persistence.xml. ان جو مقام وضاحت جي باب ۾ بيان ڪيو ويو آهي "8.2 Persistence Unit Packaging". هن حصي جي مطابق، جيڪڏهن اسان وٽ جاوا SE ماحول آهي، ته اسان کي ان کي META-INF ڊاريڪٽري جي روٽ ۾ رکڻ گهرجي. اچو ته مواد کي نقل ڪريون مثال مان ڏنل مثال مان JPA وضاحت ۾ " 8.2.1 persistence.xml file" باب ۾:

<persistence>
	<persistence-unit name="JavaRush">
        <description>Persistence Unit For test</description>
        <class>hibernate.model.Category</class>
        <class>hibernate.model.Topic</class>
    </persistence-unit>
</persistence>

پر اهو ڪافي ناهي. اسان کي ٻڌائڻ جي ضرورت آهي ته اسان جو JPA فراهم ڪندڙ ڪير آهي، يعني. جيڪو JPA وضاحتن کي لاڳو ڪري ٿو:

<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>

هاڻي اچو ته سيٽنگون شامل ڪيون ( properties). انهن مان ڪجهه (شروع ٿيندڙ javax.persistence) معياري JPA ترتيب آهن ۽ سيڪشن "8.2.1.9 ملڪيت" ۾ JPA وضاحتن ۾ بيان ڪيل آهن. ڪجهه ترتيبون مهيا ڪندڙ لاءِ مخصوص هونديون آهن (اسان جي صورت ۾، اهي Hibernate کي Jpa فراهم ڪندڙ طور متاثر ڪن ٿيون. اسان جو سيٽنگون بلاڪ هن طرح نظر ايندو:

<properties>
    <property name="javax.persistence.jdbc.driver" value="org.h2.Driver" />
    <property name="javax.persistence.jdbc.url" value="jdbc:h2:mem:db1;DB_CLOSE_DELAY=-1;MVCC=TRUE" />
    <property name="javax.persistence.jdbc.user" value="sa" />
    <property name="javax.persistence.jdbc.password" value="" />
    <property name="hibernate.show_sql" value="true" />
    <property name="hibernate.hbm2ddl.auto" value="create" />
</properties>

ھاڻي اسان وٽ ھڪڙو JPA-compatible config آھي persistence.xml، ھڪڙو JPA مهيا ڪندڙ ھائبرنيٽ آھي ۽ ھڪڙو H2 ڊيٽابيس آھي، ۽ اتي پڻ 2 ڪلاس آھن جيڪي اسان جي ڊومين ماڊل آھن. اچو ته آخرڪار اهو سڀ ڪم ڪريون. فهرست ۾ /test/java، اسان جي Gradle مھرباني ڪري يونٽ ٽيسٽ لاءِ ٽيمپليٽ ٺاھيو ۽ ان کي سڏيو ويو AppTest. اچو ته ان کي استعمال ڪريون. جيئن JPA وضاحت جي "7.1 Persistence Contexts" باب ۾ بيان ڪيو ويو آهي، JPA دنيا ۾ ادارا هڪ خلا ۾ رهن ٿا، جنهن کي Persistence Context سڏيو ويندو آهي. پر اسان سڌو سنئون تسلسل سان ڪم نه ڪندا آهيون. ان لاءِ اسين استعمال ڪندا آهيون Entity Managerيا ”اداري مينيجر“. اھو اھو آھي جيڪو ڄاڻندو آھي ته ان حوالي سان ۽ ڪھڙا ادارا اتي رھندا آھن. اسان Entity Manager'اوم' سان رابطو ڪندا آهيون. پوءِ اهو سڀ ڪجهه سمجهڻو آهي ته اسان اهو ڪٿان حاصل ڪري سگهون ٿا Entity Manager؟ جي پي اي وضاحتن جي باب "7.2.2 ايپليڪيشن-منظم اداري مئنيجر حاصل ڪرڻ" جي مطابق، اسان کي استعمال ڪرڻ گهرجي EntityManagerFactory. تنهن ڪري، اچو ته پاڻ کي JPA وضاحت سان هٿ ڪريون ۽ باب مان هڪ مثال وٺون “7.3.2 جاوا ايس اي ماحول ۾ هڪ ادارو مئنيجر فيڪٽري حاصل ڪرڻ” ۽ ان کي فارميٽ ڪريو هڪ سادي يونٽ ٽيسٽ جي صورت ۾:

@Test
public void shouldStartHibernate() {
	EntityManagerFactory emf = Persistence.createEntityManagerFactory( "JavaRush" );
	EntityManager entityManager = emf.createEntityManager();
}

هي امتحان اڳ ۾ ئي غلطي ڏيکاريندو "اڻ ڄاتل JPA persistence.xml XSD ورزن". ان جو سبب اهو آهي ته persistence.xmlتوهان کي استعمال ڪرڻ لاءِ اسڪيما کي صحيح نموني بيان ڪرڻ جي ضرورت آهي، جيئن سيڪشن "8.3 persistence.xml Schema" ۾ JPA وضاحت ۾ بيان ڪيو ويو آهي:

<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
             http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd"
             version="2.2">

ان کان سواء، عناصر جي ترتيب اهم آهي. تنهن ڪري، providerطبقن کي لسٽ ڪرڻ کان پهريان اهو بيان ڪيو وڃي. ان کان پوء، امتحان ڪاميابي سان هلندو. اسان سڌو JPA ڪنيڪشن مڪمل ڪيو آهي. اسان اڳتي وڌڻ کان اڳ، اچو ته باقي ٽيسٽ بابت سوچيو. اسان جي هر ٽيسٽ جي ضرورت پوندي EntityManager. اچو ته پڪ ڪريو ته هر امتحان جي EntityManagerعمل جي شروعات ۾ ان جي پنهنجي آهي. ان کان علاوه، اسان چاهيون ٿا ته ڊيٽابيس هر وقت نئين هجي. انهي حقيقت جي ڪري ته اسان inmemoryاختيار استعمال ڪندا آهيون، اهو ڪافي آهي بند ڪرڻ لاء EntityManagerFactory. تخليق Factoryهڪ قيمتي آپريشن آهي. پر ٽيسٽن لاءِ اهو جائز آهي. JUnit توهان کي طريقن جي وضاحت ڪرڻ جي اجازت ڏئي ٿو جيڪي هر ٽيسٽ جي عمل کان اڳ (اڳ) ۽ بعد ۾ (بعد ۾) عمل ڪيا ويندا:

public class AppTest {
    private EntityManager em;

    @Before
    public void init() {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory( "JavaRush" );
        em = emf.createEntityManager();
    }

    @After
    public void close() {
        em.getEntityManagerFactory().close();
        em.close();
    }

هاڻي، ڪنهن به امتحان تي عمل ڪرڻ کان اڳ، هڪ نئون ٺاهيو ويندو EntityManagerFactory، جيڪو هڪ نئون ڊيٽابيس ٺاهڻ ۾ شامل هوندو، ڇاڪاڻ ته hibernate.hbm2ddl.autoمعنيٰ رکي ٿو create. ۽ نئين ڪارخاني مان اسان هڪ نئون حاصل ڪنداسين EntityManager.

ادارا

جيئن اسان کي ياد آهي، اسان اڳ ۾ ڪلاس ٺاهيا آهن جيڪي اسان جي ڊومين ماڊل کي بيان ڪن ٿا. اسان اڳ ۾ ئي چيو آهي ته اهي اسان جا "جوهر" آهن. هي ادارو آهي جنهن کي اسين استعمال ڪندي منظم ڪنداسين EntityManager. اچو ته هڪ سادي ٽيسٽ لکون هڪ درجي جي جوهر کي بچائڻ لاءِ:

@Test
public void shouldPersistCategory() {
	Category cat = new Category();
	cat.setTitle("new category");
	// JUnit обеспечит тест свежим EntityManager'ом
	em.persist(cat);
}

پر اهو امتحان فوري طور تي ڪم نه ڪندو، ڇاڪاڻ ته ... اسان کي مختلف غلطيون ملنديون جيڪي اسان کي سمجهڻ ۾ مدد ڪنديون ته ڪهڙا ادارا آهن:

• Unknown entity: hibernate.model.Category
  Hibernate ڇو نٿو سمجهي ته Categoryهي ڇا آهي entity؟ شيء اها آهي ته ادارن کي JPA معيار جي مطابق بيان ڪيو وڃي.
  اينٽيٽي ڪلاس کي لازمي طور تي تشريح سان بيان ڪيو وڃي @Entity، جيئن JPA وضاحت جي باب "2.1 The Entity Class" ۾ بيان ڪيو ويو آهي.

• No identifier specified for entity: hibernate.model.Category
  ادارن کي هڪ منفرد سڃاڻپ ڪندڙ هجڻ گهرجي جيڪو هڪ رڪارڊ کي ٻئي کان ڌار ڪرڻ لاءِ استعمال ڪري سگهجي ٿو.
  جي پي اي وضاحتن جي باب ”2.4 پرائمري ڪيز ۽ وجود جي سڃاڻپ“ جي مطابق، ”هر اداري کي هڪ پرائمري ڪنجي هجڻ گهرجي“، يعني. هر اداري کي "پرائمري ڪيئي" هجڻ گهرجي. اهڙي پرائمري ڪيچي کي تشريح ذريعي بيان ڪيو وڃي@Id

• ids for this class must be manually assigned before calling save()
  ID ڪنهن هنڌ کان اچڻو آهي. اهو دستي طور بيان ڪري سگهجي ٿو، يا اهو خودڪار طريقي سان حاصل ڪري سگهجي ٿو.
  تنهن ڪري، جيئن بابن ۾ ظاهر ڪيو ويو آهي "11.2.3.3 GeneratedValue" ۽ "11.1.20 GeneratedValue Annotation"، اسان تشريح جي وضاحت ڪري سگهون ٿا @GeneratedValue.

تنهن ڪري درجي جي طبقي لاءِ هڪ ادارو بڻجڻ لاءِ اسان کي هيٺيون تبديليون ڪرڻ گهرجن:

@Entity
public class Category {
    @Id
    @GeneratedValue
    private Long id;

ان کان علاوه، تشريح @Idظاهر ڪري ٿي ته ڪهڙو استعمال ڪجي Access Type. توھان وڌيڪ پڙھي سگھوٿا رسائي جي قسم بابت JPA وضاحت ۾، سيڪشن "2.3 رسائي جو قسم" ۾. ان کي مختصر طور بيان ڪرڻ لاء، ڇاڪاڻ ته ... اسان @Idمٿي ڏنل فيلڊ ( field) کي بيان ڪيو، پوء رسائي جو قسم ڊفالٽ ٿيندو field-based، نه property-based. تنهن ڪري، JPA فراهم ڪندڙ سڌو سنئون فيلڊ مان قدر پڙهي ۽ ذخيرو ڪندو. جيڪڏهن اسان @Idگٽر جي مٿان رکيا، پوء property-basedرسائي استعمال ڪئي ويندي، يعني. گيٽر ۽ سيٽر ذريعي. جڏهن ٽيسٽ هلائي رهيا آهيون، اسان اهو پڻ ڏسون ٿا ته ڪهڙيون درخواستون ڊيٽابيس ڏانهن موڪليون ويون آهن (اختيار جي مهرباني hibernate.show_sql). پر جڏهن بچايو وڃي، اسان کي ڪو به نظر نٿو اچي insert. اهو ظاهر ٿيو ته اسان اصل ۾ ڪجهه به نه بچايو آهي؟ JPA توهان کي اجازت ڏئي ٿو ته تسلسل جي حوالي سان ۽ ڊيٽابيس کي هم وقت سازي جو طريقو استعمال ڪندي flush:

entityManager.flush();

پر جيڪڏهن اسان ان تي عمل ڪريون ٿا، اسان کي هڪ غلطي ملندي: ڪابه ٽرانزيڪشن جاري ناهي . ۽ هاڻي اهو وقت آهي سکڻ جو ته ڪيئن JPA ٽرانزيڪشن کي استعمال ڪري ٿو.

JPA ٽرانزيڪشن

جيئن ته اسان کي ياد آهي، JPA تسلسل جي مفهوم تي ٻڌل آهي. هي اهو هنڌ آهي جتي ادارا رهن ٿا. ۽ اسان ادارن جي ذريعي انتظام ڪريون ٿا EntityManager. جڏهن اسان حڪم تي عمل ڪريون ٿا persist، اسان اداري کي حوالي سان رکون ٿا. وڌيڪ واضح طور تي، اسان ٻڌايو EntityManagerته اهو ٿيڻ جي ضرورت آهي. پر هي حوالو صرف ڪجهه اسٽوريج علائقو آهي. اهو ڪڏهن ڪڏهن سڏيو ويندو آهي "پهريون سطح ڪيش". پر ان کي ڊيٽابيس سان ڳنڍڻ جي ضرورت آهي. حڪم flush، جيڪو اڳ ۾ هڪ غلطي سان ناڪام ٿيو، ڊيٽا کي هم وقت سازي جي حوالي سان ڊيٽابيس سان گڏ. پر ان لاءِ ٽرانسپورٽ جي ضرورت آهي ۽ هي ٽرانسپورٽ هڪ ٽرانزيڪشن آهي. JPA ۾ ٽرانزيڪشن وضاحت جي "7.5 ڪنٽرولنگ ٽرانزيڪشن" سيڪشن ۾ بيان ڪيا ويا آهن. JPA ۾ ٽرانزيڪشن استعمال ڪرڻ لاءِ هڪ خاص API آهي:

entityManager.getTransaction().begin();
entityManager.getTransaction().commit();

اسان کي اسان جي ڪوڊ ۾ ٽرانزيڪشن مينيجمينٽ شامل ڪرڻ جي ضرورت آهي، جيڪو ٽيسٽ کان اڳ ۽ بعد ۾ هلندو آهي:

@Before
public void init() {
	EntityManagerFactory emf = Persistence.createEntityManagerFactory( "JavaRush" );
	em = emf.createEntityManager();
	em.getTransaction().begin();
}
@After
public void close() {
	if (em.getTransaction().isActive()) {
		em.getTransaction().commit();
        }
	em.getEntityManagerFactory().close();
	em.close();
}

شامل ڪرڻ کان پوء، اسان ڏسو داخل لاگ ان ۾ SQL ۾ ھڪڙو اظهار جيڪو اڳ ۾ موجود نه ھو. EntityManagerٽرانزيڪشن ۾ جمع ٿيل تبديليون ڊيٽابيس ۾ انجام ڏنيون ويون (تصديق ٿيل ۽ محفوظ ٿيل). اچو ته هاڻي اسان جي ذات کي ڳولڻ جي ڪوشش ڪريون. اچو ته ھڪ ٽيسٽ ٺاھيون ان جي سڃاڻپ ذريعي ھڪڙي اداري کي ڳولڻ لاءِ:

@Test
public void shouldFindCategory() {
	Category cat = new Category();
	cat.setTitle("test");
	em.persist(cat);
	Category result = em.find(Category.class, 1L);
	assertNotNull(result);
}

انهي صورت ۾، اسان حاصل ڪنداسين اهو ادارو جيڪو اسان اڳ ۾ محفوظ ڪيو هو، پر اسان لاگ ان ۾ SELECT سوالن کي نه ڏسندا. ۽ سڀ ڪجھ ان تي ٻڌل آھي جيڪو اسان چئون ٿا: ”اسٽٽي مئنيجر، مھرباني ڪري مون کي ID=1 سان ڪيٽيگري ادارو ڳولھيو. ۽ ادارو مئنيجر پهريون ڀيرو ان جي حوالي سان ڏسڻ ۾ اچي ٿو (هڪ قسم جي ڪيش استعمال ڪري ٿو)، ۽ صرف جيڪڏهن اهو نه ڳولي، اهو ڊيٽابيس ۾ ڏسڻ ۾ اچي ٿو. اهو ID کي 2 ۾ تبديل ڪرڻ جي قابل آهي (اهڙي ڪا به شيء ناهي، اسان صرف 1 مثال بچايو آهي)، ۽ اسان ڏسنداسين ته SELECTدرخواست ظاهر ٿئي ٿي. ڇاڪاڻ ته ان حوالي سان ڪو به ادارو نه ملي سگهيو آهي ۽ EntityManagerڊيٽابيس هڪ ادارو ڳولڻ جي ڪوشش ڪري رهيو آهي. مختلف حڪم آهن جيڪي اسان استعمال ڪري سگهون ٿا هڪ اداري جي حالت کي ڪنٽرول ڪرڻ لاءِ. هڪ وجود جي هڪ رياست کان ٻي حالت ۾ منتقلي کي اداري جي زندگي جي چڪر سڏيو ويندو آهي lifecycle.

اداري لائف سائيڪل

ادارن جي زندگيءَ جي چڪر کي JPA وضاحتن ۾ باب ”3.2 اينٽيٽي انسٽنس جي لائف سائيڪل“ ۾ بيان ڪيو ويو آهي. ڇاڪاڻ ته ادارا هڪ تناظر ۾ رهن ٿا ۽ ڪنٽرول ٿيل آهن EntityManager، پوءِ چون ٿا ته ادارا ڪنٽرول ٿيل آهن، يعني. منظم. اچو ته هڪ اداري جي زندگيءَ جي مرحلن تي نظر وجهون:

// 1. New or Transient (временный)
Category cat = new Category();
cat.setTitle("new category");
// 2. Managed or Persistent
entityManager.persist(cat);
// 3. Транзакция завершена, все сущности в контексте detached
entityManager.getTransaction().begin();
entityManager.getTransaction().commit();
// 4. Сущность изымаем из контекста, она становится detached
entityManager.detach(cat);
// 5. Сущность из detached можно снова сделать managed
Category managed = entityManager.merge(cat);
// 6. И можно сделать Removed. Интересно, что cat всё равно detached
entityManager.remove(managed);

۽ هتي ان کي مضبوط ڪرڻ لاء هڪ خاڪو آهي:

ميلاپ

JPA ۾ اسان هڪ ٻئي جي وچ ۾ ادارن جي رشتن کي بيان ڪري سگهون ٿا. اچو ته ياد رکون ته اسان اڳ ۾ ئي هڪ ٻئي جي وچ ۾ ادارن جي رشتي کي ڏٺو جڏهن اسان اسان جي ڊومين ماڊل سان معاملو ڪيو. پوء اسان استعمال ڪيو quickdatabasediagrams.com وسيلو : ادارن جي وچ ۾ رابطا قائم ڪرڻ کي ميپنگ يا انجمن (ايسوسيئيشن ميپنگ) چئبو آهي. انجمن جا قسم جيڪي JPA استعمال ڪندي قائم ڪري سگھجن ٿا ھيٺ ڏنل پيش ڪيا ويا آھن: اچو ته هڪ اداري کي ڏسو Topicجيڪو هڪ موضوع کي بيان ڪري ٿو. Topicاسان جي رويي جي باري ۾ ڇا چئي سگهون ٿا Category؟ گھڻن جو Topicتعلق ھڪڙي درجي سان ھوندو. تنهن ڪري، اسان کي هڪ اتحاد جي ضرورت آهي ManyToOne. اچو ته هن تعلق کي JPA ۾ بيان ڪريون:

@ManyToOne
@JoinColumn(name = "category_id")
private Category category;

ياد رکڻ لاءِ ڪهڙن تشريحن کي رکڻ لاءِ، توھان ياد ڪري سگھوٿا ته آخري حصو انھيءَ فيلڊ لاءِ ذميوار آھي جنھن مٿان تشريح ڏيکاريل آھي. ToOne- خاص مثال. ToMany- مجموعو. هاڻي اسان جو ڪنيڪشن هڪ طرفو آهي. اچو ته ان کي ٻه طرفي ڪميونيڪيشن بڻايون. اچو ته Categoryهر ڪنهن جي ڄاڻ ۾ اضافو ڪريون Topicجيڪي هن درجي ۾ شامل آهن. اهو ختم ٿيڻ گهرجي ToMany، ڇو ته اسان وٽ هڪ فهرست آهي Topic. اهو آهي، رويو "ڪيترن ئي" عنوانن ڏانهن. سوال رهي ٿو - OneToManyيا ManyToMany: ساڳئي موضوع تي سٺو جواب هتي پڙهي سگهجي ٿو: " ORM oneToMany، manyToMany تعلق جي وضاحت ڪريو جيئن مان پنج آهيان ". جيڪڏهن هڪ زمري جو ToManyعنوانن سان ڪو واسطو آهي، ته پوءِ انهن مان هر هڪ موضوع ۾ صرف هڪ قسم ٿي سگهي ٿو، پوءِ اهو ٿيندو One، ٻي صورت ۾ Many. ان ڪري، Categoryسڀني عنوانن جي فهرست هن طرح نظر ايندي:

@OneToMany(cascade = CascadeType.ALL)
@JoinColumn(name = "topic_id")
private Set<Topic> topics = new HashSet<>();

۽ اچو ته نه وساريون ته لازمي طور تي Categoryسڀني عنوانن جي فهرست حاصل ڪرڻ لاءِ هڪ گيٽر لکڻ:

public Set<Topic> getTopics() {
	return this.topics;
}

ٻه طرفي رشتا خودڪار طريقي سان ٽريڪ ڪرڻ لاء هڪ تمام ڏکيو شيء آهي. تنهن ڪري، JPA هن ذميواري کي ڊولپر ڏانهن منتقل ڪري ٿو. اسان جي لاءِ ان جو مطلب اهو آهي ته جڏهن اسان هڪ اداري Topicسان تعلق قائم ڪريون ٿا Category، اسان کي لازمي طور تي ڊيٽا جي تسلسل کي يقيني بڻائڻ گهرجي. اهو صرف ڪيو ويندو آهي:

public void setCategory(Category category) {
	category.getTopics().add(this);
	this.category = category;
}

اچو ته چيڪ ڪرڻ لاءِ هڪ سادي ٽيسٽ لکون:

@Test
public void shouldPersistCategoryAndTopics() {
	Category cat = new Category();
	cat.setTitle("test");
	Topic topic = new Topic();
	topic.setTitle("topic");
	topic.setCategory(cat);
 	em.persist(cat);
}

ميپنگ هڪ مڪمل الڳ موضوع آهي. هن جائزي جو مقصد اهو آهي ته انهن ذريعن کي سمجهڻ جنهن جي ذريعي هي حاصل ڪيو وڃي. توهان هتي نقشي سازي بابت وڌيڪ پڙهي سگهو ٿا:

• " الٽيميٽ گائيڊ - ايسوسيئيشن ميپنگس سان JPA ۽ هائبرنيٽ ".
• " JPA ۽ شين جي وچ ۾ لاڳاپا "
• " هائبرنيٽ ۾ لاڳاپيل ادارا "

JPQL

JPA هڪ دلچسپ اوزار متعارف ڪرايو آهي - جاوا Persistence Query Language ۾ سوال. هي ٻولي SQL سان ملندڙ جلندڙ آهي، پر SQL جدولن جي بجاءِ جاوا آبجیکٹ ماڊل استعمال ڪري ٿي. اچو ته هڪ مثال ڏسو:

@Test
public void shouldPerformQuery() {
	Category cat = new Category();
	cat.setTitle("query");
	em.persist(cat);
	Query query = em.createQuery("SELECT c from Category c WHERE c.title = 'query'");
 	assertNotNull(query.getSingleResult());
}

جيئن اسان ڏسي سگهون ٿا، سوال ۾ اسان هڪ اداري جو حوالو استعمال ڪيو Category۽ نه ٽيبل. ۽ پڻ هن اداري جي ميدان تي title. JPQL ڪيترائي مفيد خاصيتون مهيا ڪري ٿو ۽ ان جي پنهنجي مضمون جو مستحق آهي. وڌيڪ تفصيل جائزو ۾ ڳولهي سگهجن ٿا:

• JPA ۽ Hibernate سان JPQL سوالن لاءِ حتمي گائيڊ

معيار API

۽ آخر ۾، مان ٽچ ڪرڻ چاهيندس معيار API. JPA هڪ متحرڪ سوال تعمير ڪرڻ وارو اوزار متعارف ڪرايو. معيار API استعمال ڪرڻ جو مثال:

@Test
public void shouldFindWithCriteriaAPI() {
	Category cat = new Category();
	em.persist(cat);
	CriteriaBuilder cb = em.getCriteriaBuilder();
	CriteriaQuery<Category> query = cb.createQuery(Category.class);
	Root<Category> c = query.from(Category.class);
	query.select(c);
	List<Category> resultList = em.createQuery(query).getResultList();
	assertEquals(1, resultList.size());
}

هي مثال درخواست تي عمل ڪرڻ جي برابر آهي " SELECT c FROM Category c". Criteria API هڪ طاقتور اوزار آهي. توھان ان بابت وڌيڪ پڙھي سگھوٿا هتي:

• JPA Criteria API سوال
• JPA معيار
• JPA 2.0 ۾ متحرڪ قسم-محفوظ سوال

نتيجو

جيئن اسان ڏسي سگهون ٿا، JPA مهيا ڪري ٿو وڏي تعداد ۾ خاصيتون ۽ اوزار. انهن مان هر هڪ تجربو ۽ علم جي ضرورت آهي. جيتوڻيڪ JPA جائزو جي فريم ورڪ جي اندر، اهو ممڪن نه هو ته هر شيء جو ذڪر ڪرڻ، تفصيلي ڊيوٽي جو ذڪر نه ڪرڻ. پر مون کي اميد آهي ته ان کي پڙهڻ کان پوء، اهو واضح ٿي ويو ته ORM ۽ JPA ڇا آهن، اهي ڪيئن ڪم ڪن ٿا ۽ ان سان ڇا ڪري سگهجي ٿو. خير، ماني لاءِ مان مختلف مواد پيش ڪريان ٿو:

• JPA - تعارف
• جاوا تي سوچون - Hibernate Beginner
• جاوا تي سوچون - Hibernate ٽوٽڪا
• ترقي يافته JPA موضوع

#وياچسلاو