JavaRush /Blog Jawa /Random-JV /JPA: Introducing the Technology

tingkat

28 February 2021
41 views
0 comments

JPA: Introducing the Technology

Donya pangembangan modern kebak macem-macem spesifikasi sing dirancang kanggo nggawe urip luwih gampang. Ngerti alat, sampeyan bisa milih sing bener. Tanpa ngerti, sampeyan bisa nggawe urip luwih angel. Tinjauan iki bakal mbukak tutup rahasia babagan konsep JPA - Java Persistence API. Muga-muga sawise maca sampeyan pengin nyilem luwih jero menyang jagad misterius iki.

Pambuka

Kaya sing wis dingerteni, salah sawijining tugas utama program yaiku nyimpen lan ngolah data. Ing jaman biyen, wong mung nyimpen data ing file. Nanging sanalika akses maca lan suntingan simultan dibutuhake, nalika ana beban (yaiku, sawetara panjaluk teka bebarengan), nyimpen data mung ing file dadi masalah. Kanggo informasi luwih lengkap babagan masalah apa sing diatasi database lan kepiye carane, aku menehi saran supaya maca artikel " Carane database disusun ." Iki tegese kita mutusake kanggo nyimpen data ing basis data. Kanggo wektu sing suwe, Jawa bisa nggarap basis data nggunakake API JDBC (The Java Database Connectivity). Sampeyan bisa maca liyane babagan JDBC kene: " JDBC utawa ngendi iku kabeh diwiwiti ." Nanging wektu liwati lan pangembang saben-saben kudu nulis jinis sing padha lan kode "pangopènan" sing ora perlu (sing diarani kode Boilerplate) kanggo operasi sing ora pati penting kanggo nyimpen obyek Jawa ing basis data lan kosok balene, nggawe obyek Jawa nggunakake data saka database. Banjur, kanggo ngatasi masalah kasebut, konsep kayata ORM lair. ORM - Pemetaan Obyek-Relasional utawa diterjemahake menyang pemetaan obyek-relasional Rusia. Iku teknologi pemrograman sing ngubungake database karo konsep basa pemrograman berorientasi obyek. Kanggo nyederhanakake, ORM iku sambungan antarane obyek Jawa lan cathetan ing database: JPA: Pengantar Teknologi - 2

ORM ateges konsep sing obyek Jawa bisa dituduhake minangka data ing database (lan kosok balene). Iki diwujudake ing wangun spesifikasi JPA - Java Persistence API. Spesifikasi kasebut wis dadi katrangan babagan API Java sing nyatakake konsep iki. Spesifikasi kasebut ngandhani alat apa sing kudu diwenehake (yaiku, antarmuka apa sing bisa ditindakake) supaya bisa digunakake miturut konsep ORM. Lan carane nggunakake dana kasebut. Spesifikasi kasebut ora nggambarake implementasine alat kasebut. Iki ndadekake iku bisa kanggo nggunakake implementasine beda kanggo siji specification. Sampeyan bisa nyederhanakake lan ujar manawa spesifikasi minangka gambaran saka API. Teks spesifikasi JPA bisa ditemokake ing situs web Oracle: " JSR 338: JavaTM Persistence API ". Mula, kanggo nggunakake JPA, kita butuh sawetara implementasine sing bakal digunakake teknologi kasebut. Implementasi JPA uga disebut Penyedia JPA. Salah sawijining implementasi JPA sing paling misuwur yaiku Hibernate . Mulane, aku propose kanggo nimbang iku.

Nggawe Proyek

Amarga JPA babagan Jawa, kita butuh proyek Jawa. Kita bisa nggawe struktur direktori kanthi manual lan nambah perpustakaan sing dibutuhake dhewe. Nanging luwih trep lan bener nggunakake sistem kanggo ngotomatisasi perakitan proyek (yaiku, intine, iki mung program sing bakal ngatur pangumpulan proyek kanggo kita. Nggawe direktori, nambah perpustakaan sing dibutuhake menyang classpath, lsp. .). Salah sawijining sistem kasebut yaiku Gradle. Sampeyan bisa maca liyane babagan Gradle kene: " A Brief Pambuka kanggo Gradle ". Kaya sing wis dingerteni, fungsionalitas Gradle (yaiku perkara sing bisa ditindakake) ditindakake nggunakake macem-macem Plugin Gradle. Ayo nggunakake Gradle lan plugin " Gradle Build Init Plugin ". Ayo mbukak printah:


gradle init --type java-application

Gradle bakal nindakake struktur direktori sing dibutuhake kanggo kita lan nggawe deskripsi deklaratif dhasar proyek kasebut ing skrip mbangun build.gradle. Dadi, kita duwe aplikasi. Kita kudu mikir babagan apa sing arep digambarake utawa model karo aplikasi kita. Ayo nggunakake sawetara alat pemodelan, contone: app.quickdatabasediagrams.com JPA: Pengantar Teknologi - 4

Ing kene kudu dikandhakake manawa sing wis diterangake yaiku "model domain". Domain minangka "area subyek". Umumé, domain minangka "kepemilikan" ing basa Latin. Ing Abad Pertengahan, iki minangka jeneng sing diwènèhaké marang wilayah sing diduweni raja utawa panguwasa feodal. Lan ing basa Prancis dadi tembung "domaine", sing mung nerjemahake minangka "wilayah". Mangkono kita nerangake "model domain" = "model subyek". Saben unsur model iki sawetara jenis "esensi", soko saka urip nyata. Ing kasus kita, iki minangka entitas: Kategori ( Category), Subjek ( Topic). Ayo nggawe paket kapisah kanggo entitas, contone karo model jeneng. Lan ayo nambah kelas Jawa ana sing nggambarake entitas. Ing kode Jawa, entitas kasebut minangka POJO biasa , sing bisa katon kaya iki:

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

    public String getTitle() {
        return title;
    }

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

Ayo nyalin isi kelas lan nggawe kelas kanthi analogi Topic. Dheweke bakal beda-beda mung babagan apa sing dingerteni babagan kategori sing diduweni. Mula, ayo nambah Topiclapangan kategori lan cara kanggo nggarap kelas kasebut:

private Category category;

public Category getCategory() {
	return category;
}

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

Saiki kita duwe aplikasi Java sing duwe model domain dhewe. Saiki wektune miwiti nyambung menyang proyek JPA.

Tambah JPA

Dadi, kaya sing kita eling, JPA tegese kita bakal nyimpen soko ing database. Mulane, kita butuh database. Kanggo nggunakake sambungan database ing project kita, kita kudu nambah perpustakaan dependensi kanggo nyambung menyang database. Nalika kita ngelingi, kita nggunakake Gradle, sing nggawe skrip mbangun kanggo kita build.gradle. Ing kono kita bakal nerangake dependensi sing dibutuhake proyek kita. Dependensi yaiku perpustakaan sing tanpa kode ora bisa digunakake. Ayo dadi miwiti karo gambaran saka katergantungan ing nyambungake menyang database. Kita nindakake iki kanthi cara sing padha yen kita mung nggarap JDBC:


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

Saiki kita duwe database. Saiki kita bisa nambah lapisan kanggo aplikasi kita sing tanggung jawab kanggo pemetaan obyek Jawa menyang konsep database (saka Jawa kanggo SQL). Nalika kita ngelingi, kita bakal nggunakake implementasi spesifikasi JPA sing diarani Hibernate kanggo iki:


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

Saiki kita kudu ngatur JPA. Yen kita maca spesifikasi lan bagean "8.1 Unit Ketekunan", kita bakal ngerti yen Unit Kegigihan minangka kombinasi konfigurasi, metadata lan entitas. Lan supaya JPA bisa digunakake, sampeyan kudu njlèntrèhaké paling ora siji Unit Ketekunan ing file konfigurasi, sing diarani persistence.xml. Lokasi kasebut diterangake ing bab spesifikasi "8.2 Kemasan Unit Kegigihan". Miturut bagean iki, yen kita duwe lingkungan Java SE, mula kudu dilebokake ing root direktori META-INF.

Ayo nyalin konten saka conto sing diwenehake ing spesifikasi JPA ing " 8.2.1 persistence.xml file" bab:

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

Nanging iki ora cukup. Kita kudu ngandhani sapa Panyedhiya JPA kita, yaiku. sing ngetrapake spesifikasi JPA:

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

Saiki ayo nambah setelan ( properties). Sawetara iku (wiwit karo javax.persistence) iku konfigurasi JPA standar lan diterangake ing specification JPA ing bagean "8.2.1.9 property". Sawetara konfigurasi khusus panyedhiya (ing kasus kita, bakal mengaruhi Hibernate minangka Panyedhiya Jpa. Blok setelan kita bakal katon kaya iki:

<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>

Saiki kita duwe konfigurasi sing cocog karo JPA persistence.xml, ana panyedhiya JPA Hibernate lan ana database H2, lan uga ana 2 kelas sing dadi model domain kita. Ayo pungkasane nggawe kabeh iki. Ing katalog /test/java, Gradle kita kanthi apik nggawe cithakan kanggo tes Unit lan diarani AppTest. Ayo nganggo. Kaya sing kasebut ing "7.1 Konteks Ketekunan" ing spesifikasi JPA, entitas ing jagad JPA manggon ing papan sing disebut Konteks Ketekunan. Nanging kita ora bisa langsung karo Konteks Ketekunan. Kanggo iki kita nggunakake Entity Managerutawa "manajer entitas". Dheweke sing ngerti babagan konteks lan entitas apa sing manggon ing kana. Kita sesambungan karo Entity Managerom. Banjur kabeh sing isih ana yaiku ngerti saka ngendi kita bisa entuk iki Entity Manager? Miturut bab "7.2.2 Entuk Manajer Entitas sing dikelola Aplikasi" saka spesifikasi JPA, kita kudu nggunakake EntityManagerFactory. Mula, ayo nyengkuyung spesifikasi JPA lan njupuk conto saka bab "7.3.2 Entuk Pabrik Manager Entitas ing Lingkungan Java SE" lan format ing bentuk tes Unit sing prasaja:

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

Tes iki bakal nuduhake kesalahan "Unrecognized JPA persistence.xml versi XSD". Alasane yaiku persistence.xmlsampeyan kudu nemtokake skema kanthi bener, kaya sing kasebut ing spesifikasi JPA ing bagean "8.3 persistence.xml Schema":

<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">

Kajaba iku, urutan unsur penting. Mulane, providerkudu ditemtokake sadurunge dhaptar kelas. Sawise iki, tes bakal sukses. Kita wis ngrampungake sambungan JPA langsung. Sadurunge nerusake, ayo mikir babagan tes sing isih ana. Saben tes kita mbutuhake EntityManager. Priksa manawa saben tes duwe dhewe EntityManagering wiwitan eksekusi. Kajaba iku, kita pengin database dadi anyar saben wektu. Amarga kasunyatan sing kita nggunakake inmemorypilihan, iku cukup kanggo nutup EntityManagerFactory. Penciptaan Factoryminangka operasi sing larang. Nanging kanggo tes iku sabdho. JUnit ngidini sampeyan nemtokake cara sing bakal ditindakake sadurunge (Sadurunge) lan sawise (Sawise) eksekusi saben tes:

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

Saiki, sadurunge nglakokake tes apa wae, sing anyar bakal digawe EntityManagerFactory, sing bakal nggawe database anyar, amarga hibernate.hbm2ddl.autonduweni teges create. Lan saka pabrik anyar kita bakal entuk sing anyar EntityManager.

Entitas

Minangka kita elinga, kita sadurunge nggawe kelas sing nggambarake model domain kita. Kita wis ujar manawa iki minangka "esensi" kita. Iki Entitas sing bakal kita atur nggunakake EntityManager. Ayo nulis tes prasaja kanggo nyimpen inti saka kategori:

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

Nanging tes iki ora bisa langsung, amarga ... kita bakal nampa macem-macem kesalahan sing bakal mbantu kita ngerti apa entitas:

Unknown entity: hibernate.model.Category
Napa Hibernate ora ngerti apa Categoryiki entity? Sing penting yaiku entitas kudu diterangake miturut standar JPA.
Kelas entitas kudu dianotasi karo anotasi @Entity, kaya sing kasebut ing bab "2.1 Kelas Entitas" saka spesifikasi JPA.
No identifier specified for entity: hibernate.model.Category
Entitas kudu duwe pengenal unik sing bisa digunakake kanggo mbedakake rekaman siji saka liyane.
Miturut bab "2.4 Kunci Utama lan Identitas Entitas" saka spesifikasi JPA, "Saben entitas kudu duwe kunci utama", i.e. Saben entitas kudu duwe "kunci utama". Kunci utama kuwi kudu ditemtokake dening anotasi@Id
ids for this class must be manually assigned before calling save()
ID kudu teka saka ngendi wae. Bisa ditemtokake kanthi manual, utawa bisa dipikolehi kanthi otomatis.
Mulane, kaya sing dituduhake ing bab "11.2.3.3 GeneratedValue" lan "11.1.20 GeneratedValue Annotation", kita bisa nemtokake anotasi @GeneratedValue.

Dadi supaya kelas kategori dadi entitas, kita kudu nggawe owah-owahan ing ngisor iki:

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

Kajaba iku, anotasi @Idnuduhake endi sing bakal digunakake Access Type. Sampeyan bisa maca liyane babagan jinis akses ing spesifikasi JPA, ing bagean "2.3 Tipe Akses". Cepet banget, amarga ... kita kasebut @Iding ndhuwur lapangan ( field), banjur jinis akses bakal standar field-based, ora property-based. Mula, panyedhiya JPA bakal maca lan nyimpen nilai langsung saka lapangan. Yen kita diselehake @Iding ndhuwur getter, banjur property-basedakses bakal digunakake, i.e. liwat getter lan setter. Nalika nglakokake tes, kita uga ndeleng panjaluk apa sing dikirim menyang database (thanks kanggo pilihan hibernate.show_sql). Nanging nalika nyimpen, kita ora weruh apa insert-apa. Pranyata kita bener ora nyimpen apa-apa? JPA ngidini sampeyan nyinkronake konteks kegigihan lan database nggunakake metode flush:

entityManager.flush();

Nanging yen kita nglakokake saiki, kita bakal entuk kesalahan: ora ana transaksi sing lagi ditindakake . Lan saiki wektune sinau babagan carane JPA nggunakake transaksi.

Transaksi JPA

Kaya sing kita eling, JPA adhedhasar konsep konteks kegigihan. Iki panggonan entitas manggon. Lan kita ngatur entitas liwat EntityManager. Nalika kita nglakokake perintah kasebut persist, kita nyelehake entitas kasebut ing konteks. Luwih tepate, kita ngandhani EntityManageryen iki kudu ditindakake. Nanging konteks iki mung sawetara area panyimpenan. Malah kadhangkala disebut "cache tingkat pisanan". Nanging kudu disambungake menyang database. Printah flush, sing sadurunge gagal karo kesalahan, nyinkronake data saka konteks kegigihan karo database. Nanging iki mbutuhake transportasi lan transportasi iki minangka transaksi. Transaksi ing JPA diterangake ing bagean "7.5 Ngontrol Transaksi" ing spesifikasi. Ana API khusus kanggo nggunakake transaksi ing JPA:

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

Kita kudu nambah manajemen transaksi menyang kode kita, sing ditindakake sadurunge lan sawise tes:

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

Sawise nambah, kita bakal weruh ing insert log ekspresi ing SQL sing durung ana sadurunge:

Owah-owahan sing diklumpukake ing EntityManagertransaksi ditindakake (dikonfirmasi lan disimpen) ing basis data. Ayo saiki nyoba golek esensi kita. Ayo nggawe tes kanggo nggoleki entitas kanthi ID:

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

Ing kasus iki, kita bakal nampa entitas sing sadurunge disimpen, nanging kita ora bakal weruh pitakon PILIH ing log. Lan kabeh adhedhasar apa sing kita ucapake: "Manajer Entitas, goleki aku entitas Kategori kanthi ID=1." Lan manager entitas pisanan katon ing konteks (nggunakake jenis cache), lan mung yen ora ketemu, iku dadi kanggo dipikir ing database. Iku worth ngganti ID kanggo 2 (ora ana bab kuwi, kita disimpen mung 1 Kayata), lan kita bakal weruh sing SELECTrequest katon. Amarga ora ana entitas sing ditemokake ing konteks lan EntityManagerdatabase nyoba nemokake entitas. Ana macem-macem perintah sing bisa digunakake kanggo ngontrol kahanan entitas ing konteks kasebut. Transisi entitas saka siji negara menyang liyane diarani siklus urip entitas - lifecycle.

Siklus Urip Entitas

Siklus urip entitas diterangake ing spesifikasi JPA ing bab "3.2 Siklus Urip Instance Entitas". Amarga entitas manggon ing konteks lan kontrol dening EntityManager, banjur padha ngomong sing entitas kontrol, i.e. ngatur. Ayo ndeleng tahapan urip entitas:

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

Lan ing ngisor iki diagram kanggo nggabungake:

pemetaan

Ing JPA kita bisa njlèntrèhaké hubungan entitas antarane siji liyane. Elinga yen kita wis ndeleng hubungane entitas ing antarane siji lan sijine nalika kita ngurusi model domain kita. Banjur kita nggunakake sumber daya quickdatabasediagrams.com :

Nggawe sambungan antarane entitas diarani pemetaan utawa asosiasi (Association Mappings). Jinis asosiasi sing bisa digawe nggunakake JPA ditampilake ing ngisor iki:

Ayo goleki entitas Topicsing nggambarake topik. Apa sing bisa kita ucapake babagan Topicsikap Category? Akeh Topicbakal kalebu siji kategori. Mulane, kita butuh asosiasi ManyToOne. Ayo ungkapake hubungan iki ing JPA:

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

Kanggo ngelingi anotasi sing kudu dilebokake, sampeyan bisa ngelingi manawa bagean pungkasan tanggung jawab kanggo lapangan ing ndhuwur sing dituduhake anotasi kasebut. ToOne- conto tartamtu. ToMany- koleksi. Saiki sambungan kita dadi siji arah. Ayo dadi komunikasi loro arah. Ayo nambah Categorykawruh babagan kabeh wong Topicsing kalebu ing kategori iki. Iku kudu mungkasi karo ToMany, amarga kita duwe dhaftar Topic. Sing, sikap "Kanggo akeh" topik. Pitakonan tetep - OneToManyutawa ManyToMany:

Jawaban sing apik babagan topik sing padha bisa diwaca ing kene: " Nerangake ORM oneToMany, manyToMany hubungan kaya aku lima ". Yen kategori nduweni sesambungan karo ToManytopik, saben topik kasebut mung bisa nduweni siji kategori, banjur dadi One, yen ora Many. Dadi Categorydhaptar kabeh topik bakal katon kaya iki:

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

Lan aja lali Categorynulis getter kanggo entuk dhaptar kabeh topik:

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

Hubungan bidirectional minangka perkara sing angel banget kanggo dilacak kanthi otomatis. Mulane, JPA ngalih tanggung jawab iki kanggo pangembang. Apa tegese kanggo kita yaiku nalika kita nggawe Topichubungan entitas karo Category, kita kudu mesthekake konsistensi data dhewe. Iki ditindakake kanthi prasaja:

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

Ayo nulis tes prasaja kanggo mriksa:

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

Pemetaan minangka topik sing kapisah. Tujuwane panliten iki yaiku kanggo mangerteni sarana kang bisa ditindakake. Sampeyan bisa maca liyane babagan pemetaan ing kene:

JPQL

JPA ngenalake alat sing menarik - pitakon ing Basa Jawa Persistence Query. Basa iki padha karo SQL, nanging nggunakake model obyek Jawa tinimbang tabel SQL. Ayo ndeleng conto:

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

Minangka kita bisa ndeleng, ing pitakonan kita nggunakake referensi kanggo entitas Categorylan dudu tabel. Lan uga ing lapangan entitas iki title. JPQL nyedhiyakake akeh fitur migunani lan pantes artikel dhewe. Rincian liyane bisa ditemokake ing review:

" Pandhuan Ultimate kanggo Kueri JPQL karo JPA lan Hibernate "

Kriteria API

Lan pungkasane, aku pengin ndemek API Kriteria. JPA ngenalake alat mbangun pitakon dinamis. Conto nggunakake API Kriteria:

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

Conto iki padha karo nglakokaké panjalukan " SELECT c FROM Category c". API Kriteria minangka alat sing kuat. Sampeyan bisa maca liyane babagan kene:

Kesimpulan

Kaya sing kita deleng, JPA nyedhiyakake akeh fitur lan alat. Saben wong mbutuhake pengalaman lan kawruh. Malah ing framework saka review JPA, iku ora bisa kanggo sebutno kabeh, ora kanggo sebutno nyilem rinci. Nanging muga-muga sawise maca, dadi luwih jelas apa ORM lan JPA, cara kerjane lan apa sing bisa ditindakake. Nah, kanggo cemilan aku nyedhiyakake macem-macem bahan:

#Viacheslav

Komentar

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION