Kegigihan Java dengan JPA dan Hibernate: Tutorial Lengkap

JPA adalah singkatan API Kegigihan Java, spesifikasi standard untuk pemetaan objek Java ke jadual pangkalan data, dan Hibernate adalah salah satu pelaksanaannya yang paling popular, menyediakan keupayaan pemetaan objek-relasi (ORM) yang memudahkan operasi pangkalan data. 1. JPA mentakrifkan piawaian untuk pemetaan entiti dan operasi CRUD, yang membolehkan pemaju mengendalikan pangkalan data dengan cara yang berorientasikan objek, mengelakkan menulis sejumlah besar kod JDBC. 2. Hibernate, sebagai pelaksanaan JPA, bukan sahaja menyokong spesifikasi JPA, tetapi juga menyediakan ciri -ciri canggih seperti caching, pemuatan malas, dan pengurusan transaksi. 3. Gunakan Maven untuk menambah pemacu hibernate-core dan pangkalan data (seperti H2), dan konfigurasikan sambungan pangkalan data dan sifat hibernat dalam Src/Main/Sumber/Meta-Inf/Kegigihan.xml, seperti HBM2DDL.Auto untuk mengawal strategi penjanaan struktur jadual. 4. Tentukan hubungan pemetaan antara kelas entiti dan jadual pangkalan data melalui @Entity, @table, @id, @GeneratedValue, @column dan anotasi lain. 5. Gunakan EntityManager untuk melaksanakan operasi CRUD. Semua operasi perlu dilakukan dalam transaksi. Berterusan () menjimatkan entiti baru, menggabungkan () mengemas kini entiti yang sedia ada, mencari () pertanyaan mengikut kunci utama, keluarkan () memadam entiti. 6. Sokongan pemetaan hubungan antara entiti, seperti @onetomany dan @manytoOne untuk melaksanakan persatuan satu-ke-banyak, dan mengkonfigurasi operasi cascade melalui Cascade untuk memastikan data yang berkaitan disimpan atau dipadamkan secara serentak. 7. Amalan terbaik termasuk: tepat pada masanya mematikan EntityManager dan EntityManagerFactory untuk mengelakkan kebocoran memori, menulis semula sama () dan hashcode () kaedah, mengutamakan fetchType.lazy untuk mengelakkan masalah prestasi, menggunakan DTO dan bukannya kelas entiti untuk mendedahkan API, dan mengelakkan lazyinitializationexception. 8. Dalam Projek Boot Spring, adalah disyorkan untuk menggunakan data Spring JPA, yang secara automatik memperoleh fungsi CRUD dengan mewarisi antara muka JParepository, dan diuruskan oleh konfigurasi pengurusan musim bunga, urus niaga dan suntikan ketergantungan. 9. Anda boleh memuatkan data yang berkaitan melalui pertanyaan jpql seperti pilih u dari pengguna yang ditinggalkan sertai u.posts untuk mengelakkan pengecualian memuatkan malas. 10. Dalam perkembangan sebenar, kita harus bermula dengan fungsi kecil, secara beransur -ansur meningkatkan entiti, hubungan dan pertanyaan, dan menggabungkan amalan untuk memahami dengan mendalam penggunaan JPA dan Hibernate. Anda kini telah menguasai pengetahuan teras JPA dan Hibernate dan dapat membina aplikasi Java yang berterusan.

Kegigihan Java dengan JPA dan Hibernate adalah kombinasi untuk menguruskan data relasi dalam aplikasi Java. Sama ada anda membina aplikasi Boot Spring atau projek Java yang berdiri sendiri, memahami bagaimana untuk meneruskan data dengan berkesan adalah penting. Tutorial ini membimbing anda melalui asas -asas JPA (Java Constence API) dan Hibernate - salah satu pelaksanaannya yang paling popular - dengan contoh praktikal dan amalan terbaik.

Apa itu JPA dan mengapa menggunakan Hibernate?

JPA (API Kegigihan Java) adalah spesifikasi, bukan pelaksanaan konkrit. Ia mentakrifkan bagaimana objek Java boleh dipetakan ke jadual pangkalan data, dan bagaimana untuk melaksanakan operasi CRUD (membuat, membaca, mengemas kini, memadam) menggunakan sintaks berorientasikan objek dan bukannya SQL mentah.

Hibernate adalah rangka kerja ORM (Object-Relational Mapping) yang lengkap, terbuka yang melaksanakan spesifikasi JPA. Ia menambah ciri -ciri tambahan di luar JPA dan mengendalikan pengangkat berat menterjemahkan objek Java ke rekod pangkalan data dan sebaliknya.

✅ Mengapa menggunakannya bersama?

• Tulis kod JDBC yang kurang boilerplate
• Bekerjasama dengan objek Java dan bukannya pertanyaan SQL
• Leverage anotasi untuk pemetaan mudah
• Sokongan untuk ciri canggih seperti caching, pemuatan malas, dan urus niaga

Menyiapkan JPA dengan Hibernate

Untuk memulakan, anda memerlukan kebergantungan yang betul. Inilah cara untuk menetapkannya dalam projek Maven:

 <dependencies>
    <geterlihat>
        <groupId> org.hibernate </groupId>
        <stifactid> Hibernate-core </artifactid>
        <versi> 6.4.4.final </versi>
    </ketergantungan>
    <geterlihat>
        <groupId> com.h2database </groupId>
        <ctiFactId> H2 </artifactid>
        <versi> 2.2.224 </versi>
    </ketergantungan>
</dependencies>

Kami menggunakan H2 sebagai pangkalan data dalam memori untuk kesederhanaan, tetapi Hibernate menyokong MySQL, PostgreSQL, Oracle, dan banyak lagi.

Seterusnya, buat fail persistence.xml dalam src/main/resources/META-INF/ :

 <? xml version = "1.0" encoding = "utf-8"?>
<Constence xmlns = "http://xmlns.jcp.org/xml/ns/persistence" version = "3.0">
    <ketekunan-unit name = "my-persistence-unit">
        <creatties>
            <property name = "javax.persistence.jdbc.driver" value = "org.h2.driver"/>
            <property name = "javax.persistence.jdbc.url" value = "jdbc: h2: mem: testdb"/>
            <property name = "javax.persistence.jdbc.user" value = "sa"/>
            <property name = "javax.persistence.jdbc.password" value = ""/>
            <property name = "hibernate.dialect" value = "org.hibernate.dialect.h2dialect"/>
            <property name = "hibernate.hbm2ddl.auto" value = "update"/>
            <property name = "hibernate.show_sql" value = "true"/>
        </hartanah>
    </ketekunan-unit>
</ketekunan>

Harta Utama:

• hibernate.hbm2ddl.auto : update secara automatik mencipta atau mengemas kini jadual berdasarkan kelas entiti anda. Gunakan none , validate , atau create-drop dalam pengeluaran seperti yang diperlukan.

Membuat entiti pertama anda

Entiti adalah kelas Java yang dipetakan ke jadual pangkalan data. Gunakan anotasi JPA untuk menentukan pemetaan.

 import jakarta.persistence.*;

@Entity
@Table (name = "pengguna")
pengguna kelas awam {

    @Id
    @GeneratedValue (Strategi = GenerasiType.identity)
    ID panjang peribadi;

    @Column (nullable = false)
    nama rentetan peribadi;

    @Column (unik = benar)
    e -mel rentetan peribadi;

    // pembina
    pengguna awam () {}

    pengguna awam (nama rentetan, e -mel rentetan) {
        this.name = name;
        this.email = e -mel;
    }

    // getters dan setters
    public long getId () {return id; }
    public void setID (id panjang) {this.id = id; }

    rentetan awam getName () {return name; }
    public void setName (Nama String) {this.name = name; }

    public string getEmail () {return e -mel; }
    public void setemail (string e -mel) {this.email = email; }

    @Override
    rentetan awam toString () {
        kembali "Pengguna {"  
                "id =" id  
                ", Nama = '" Nama' \ ''  
                ", e -mel = '" e -mel' \ ''  
                '}';
    }
}

Anotasi dijelaskan:

• @Entity : Tandakan kelas sebagai entiti JPA.
• @Table : Pilihan; menyesuaikan nama jadual.
• @Id : Menentukan kunci utama.
• @GeneratedValue : Beritahu Hibernate untuk menjana ID secara automatik.
• @Column : Sesuaikan definisi lajur (kebolehpercayaan, keunikan, dan lain -lain).

Melaksanakan operasi CRUD

Gunakan EntityManager untuk berinteraksi dengan konteks kegigihan.

 import jakarta.persistence.entityManager;
import jakarta.persistence.entityManagerFactory;
import jakarta.persistence.persistence;

Utama kelas awam {
    public static void main (string [] args) {
        EntityManagerFactory emf = constence.createEntityManagerFactory ("my-persistence-unit");
        EntityManager EM = EMF.CreateEntityManager ();

        // buat
        em.getTransaction (). Begin ();
        Pengguna Pengguna = Pengguna Baru ("Alice", "Alice@example.com");
        em.persist (pengguna);
        em.getTransaction (). komit ();

        // Baca
        Pengguna dijumpai = em.find (user.class, 1L);
        System.out.println ("dijumpai:" dijumpai);

        // kemas kini
        em.getTransaction (). Begin ();
        found.setName ("Alicia");
        em.merge (dijumpai);
        em.getTransaction (). komit ();

        // Padam
        em.getTransaction (). Begin ();
        em.remove (dijumpai);
        em.getTransaction (). komit ();

        em.close ();
        EMF.CLOSE ();
    }
}

? Catatan:

• Sentiasa membungkus operasi pangkalan data dalam urus niaga.
• persist() menjimatkan entiti baru; merge() mengemas kini yang terpisah.
• find() mengambil semula entiti dengan id.

Hubungan: Contoh satu-ke-banyak

Kebanyakan aplikasi dunia nyata melibatkan hubungan. Mari tambahkan entiti Post yang dikaitkan dengan User .

 @Entity
Pos Kelas Awam {
    @Id
    @GeneratedValue (Strategi = GenerasiType.identity)
    ID panjang peribadi;

    tajuk rentetan peribadi;

    @Manytoone
    @Joincolumn (name = "user_id")
    pengguna pengguna peribadi;

    // pembina, getters, setters ...
}

Sekarang, User boleh mempunyai beberapa jawatan:

 @Onetomany (mappedBy = "user", cascade = cascadetype.all, orphanRemoval = true)
Senarai Persendirian <Sost> Posts = New ArrayList <> ();

Apabila anda menyimpan pengguna dengan jawatan (dan Cascade diaktifkan), Hibernate menyimpan jawatan secara automatik.

 Pengguna pengguna = pengguna baru ("bob", "bob@example.com");
Post Post1 = Post Baru ("Pos Pertama");
Post Post2 = Post Baru ("Pos Kedua");

pos1.setUser (pengguna);
pos2.setUser (pengguna);
user.getPosts (). Tambah (post1);
user.getPosts (). Tambah (Post2);

em.getTransaction (). Begin ();
em.persist (pengguna);
em.getTransaction (). komit ();

Ini mewujudkan pengguna dan kedua -dua jawatan dalam satu transaksi.

Amalan terbaik dan perangkap biasa

Berikut adalah petua utama untuk mengelakkan masalah biasa:

• Sentiasa tutup EntityManager dan EntityManagerFactory untuk mengelakkan kebocoran memori.
• Gunakan equals() dan hashCode() dalam entiti - terutamanya apabila menggunakan koleksi.
• Elakkan fetchtype.eager secara lalai; lebih suka FetchType.LAZY untuk mengelakkan memuatkan data yang tidak perlu.
• Jangan mendedahkan entiti secara langsung dalam API - Gunakan DTOS (objek pemindahan data) sebaliknya.
• Berhati -hati dengan cascade = CascadeType.ALL - ia secara tidak sengaja boleh memadam data yang berkaitan.
• Inisialisasi koleksi malas di dalam transaksi (sebelum penutupan EntityManager ), atau gunakan JOIN FETCH dalam pertanyaan.

Contoh pertanyaan JPQL untuk mengambil pengguna dengan siaran:

 String jpql = "Pilih U dari Pengguna u Kiri Sertai u.Posts Where u.id =: id";
Pengguna Pengguna = Em.CreateQuery (JPQL, User.class)
              .setParameter ("ID", 1L)
              .getSingleresult ();

Ini mengelakkan "LazyinitializationException".

Melangkah lebih jauh: Integrasi Boot Spring

Dalam projek sebenar, terutamanya dengan Spring Boot, anda tidak akan menggunakan EntityManagerFactory secara langsung. Sebaliknya:

• Gunakan Spring Data JPA untuk abstraksi repositori
• Anotate kelas utama anda dengan @SpringBootApplication
• Tentukan repositori seperti:

 UserRepository antara muka awam memanjangkan JParePository <user, long> {
}

Spring mengendalikan selebihnya - konfigurasi, urus niaga, dan suntikan pergantungan.

Itu sahaja. Anda kini mempunyai asas yang kukuh di JPA dan Hibernate. Daripada mendefinisikan entiti dan hubungan untuk melaksanakan CRUD dan menguruskan urus niaga, anda sudah bersedia untuk membina aplikasi Java yang didorong oleh data yang mantap. Kuncinya adalah amalan - cuba menambah lebih banyak entiti, pertanyaan, dan kekangan untuk memperdalam pemahaman anda.

Pada asasnya, mulakan kecil, biarkan Hibernate melakukan kerja, dan belajar semasa anda pergi.

Atas ialah kandungan terperinci Kegigihan Java dengan JPA dan Hibernate: Tutorial Lengkap. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!