Aplikasi Hibernasi pertama Anda

Pada artikel ini, Anda akan mengenal salah satu kerangka kerja perusahaan terpopuler untuk Java dan membuat aplikasi pertama Anda menggunakan Hibernate. Belum pernah mendengar tentang Hibernasi? Mungkin Anda pernah mendengarnya, tapi belum menggunakannya? Atau mencoba memulai, tetapi tidak berhasil? Dalam ketiga kasus tersebut, selamat datang di pemotongan :) Halo semuanya! Pada artikel ini, saya akan berbicara tentang fitur-fitur utama kerangka Hibernate dan membantu Anda menulis aplikasi mini pertama Anda. Untuk ini kita membutuhkan:

1. Intellij Idea Edisi Ultimate;
   Unduh dari situs resminya dan aktifkan versi uji coba 30 hari.
2. PostgeSQL adalah salah satu sistem manajemen basis data modern (DBMS) yang paling populer;
3. Maven (sudah ada di dalam IDEA);
4. Sedikit kesabaran.

Artikel ini ditujukan terutama bagi mereka yang belum pernah bekerja dengan teknologi ini, sehingga jumlah kode telah dikurangi sebanyak mungkin. Mari kita mulai!

Apa itu Hibernasi?

Ini adalah salah satu implementasi model ORM yang paling populer. Model objek-relasional menggambarkan hubungan antara objek perangkat lunak dan catatan dalam database. Tentu saja fungsi Hibernate sangat luas, tetapi kami akan fokus pada fungsi yang paling sederhana. Tujuan kami: membuat aplikasi CRUD (Buat, Baca, Perbarui, Hapus) yang mampu:

1. Membuat pengguna (User), serta mencarinya di database berdasarkan ID, memperbarui datanya di database, dan juga menghapusnya dari database.
2. Tetapkan objek kendaraan (Otomatis) kepada pengguna. Membuat, mengedit, mencari dan menghapus mobil dari database.
3. Selain itu, aplikasi akan secara otomatis menghapus mobil “yatim piatu” dari database. Itu. Ketika seorang pengguna dihapus, semua mobil miliknya juga harus dihapus dari database.

Struktur proyek kami adalah sebagai berikut: Seperti yang Anda lihat, tidak ada yang rumit. 6 kelas + 1 file dengan konfigurasi. Pertama, mari buat proyek pakar baru di Intellij Idea. File -> Proyek Baru. Dari jenis proyek yang diusulkan, pilih Maven dan lanjutkan. Apache Maven adalah kerangka kerja untuk mengotomatiskan perakitan proyek berdasarkan deskripsi strukturnya dalam file dalam bahasa POM. Seluruh struktur proyek Anda akan dijelaskan dalam file pom.xml, yang akan dibuat oleh IDEA sendiri di root proyek Anda. Dalam pengaturan proyek Anda perlu menentukan parameter Maven - groupId dan artefakId. Biasanya dalam proyek, groupId adalah nama organisasi atau divisi, dan nama domain organisasi atau situs proyek ditulis di sana. Pada gilirannya, artifakId adalah nama proyek. Untuk groupdId Anda dapat menentukan com.вашНикнейм.javarush, ini tidak akan mempengaruhi pengoperasian aplikasi dengan cara apa pun. Untuk artifakId, pilih nama proyek apa pun yang Anda suka. Anda juga dapat membiarkan Versi tidak berubah. Di layar terakhir, cukup konfirmasikan data yang Anda masukkan sebelumnya. Jadi, kita sudah membuat proyeknya, yang tersisa hanyalah menulis kode dan membuatnya berfungsi :) Pertama-tama, jika kita ingin membuat aplikasi yang bekerja dengan database, kita pasti tidak bisa melakukannya tanpa database! Unduh PostgreSQL dari sini (saya menggunakan versi 9). PostgreSQL memiliki pengguna default 'postgres', Anda perlu membuat kata sandi untuk itu selama instalasi. Jangan lupa kata sandi Anda, kami akan membutuhkannya nanti! (Secara umum, menggunakan database default dalam aplikasi adalah praktik yang buruk, namun untuk mengurangi jumlah wasir, kita akan puas dengan membuat database kita sendiri). Jika Anda merasa tidak nyaman dengan baris perintah dan kueri SQL, ada kabar baik. Intellij IDEA menyediakan antarmuka pengguna yang cukup cocok untuk bekerja dengan database. Tampilannya seperti ini: (terletak di sidebar kanan IDEA, tab Database) Untuk membuat koneksi, klik “+”, pilih penyedia kami (PostgeSQL). Isi kolom dengan pengguna, nama database (keduanya postgres) dan masukkan kata sandi yang Anda tetapkan saat menginstal PostgreSQL. Jika perlu, unduh driver Postgres, ini dapat dilakukan di halaman yang sama. Klik "Uji Koneksi" untuk memeriksa apakah koneksi ke database telah dibuat. Jika Anda melihat tulisan “Sukses”, kita lanjutkan. Sekarang mari kita buat tabel yang kita butuhkan. Akan ada dua di antaranya - pengguna dan mobil. Parameter untuk tabel pengguna: Harap dicatat bahwa id adalah kunci utama. Jika Anda tidak tahu apa itu kunci utama dalam SQL, cari di Google, ini penting. Pengaturan untuk tabel autos: Untuk autos Anda perlu mengkonfigurasi Kunci Asing - kunci asing. Ini akan menghubungkan tabel kita. Saya menyarankan Anda untuk membaca lebih banyak tentang dia; Sederhananya, ini mengacu pada tabel eksternal, dalam kasus kami, pengguna. Jika mobil milik pengguna dengan id=1, maka di kolom user_id pada tabel autos akan ada 1. Ini adalah cara kami menghubungkan pengguna dengan mobil mereka di aplikasi kami. Di tabel autos kita, field user_id akan berfungsi sebagai kunci asing. Ini akan merujuk ke bidang id pada tabel pengguna. Jadi, kami telah membuat database dengan dua tabel. Masih memahami cara mengelolanya dari kode Java. Kita akan mulai dengan file pom.xml, di mana kita perlu menyertakan perpustakaan yang diperlukan (dalam bahasa Maven disebut dependensi). Semua perpustakaan disimpan di repositori Maven pusat. Yang Anda tentukan di pom.xml, dapat Anda gunakan dalam proyek. Pom.xml Anda akan terlihat seperti ini: Tidak ada yang rumit seperti yang Anda lihat. Kami hanya menambahkan 2 dependensi - untuk menggunakan PostgreSQL dan Hibernate. Sekarang mari kita beralih ke kode Java. Buat semua paket dan kelas yang diperlukan untuk proyek tersebut. Untuk memulainya, kita memerlukan model data - kelas Userdan 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;
    }
}

Seperti yang Anda lihat, kelas-kelas tersebut dilengkapi dengan banyak anotasi yang masih belum jelas. Mari kita mulai menangani mereka. Anotasi utama bagi kami adalah @Entity. Baca tentang itu di Wikipedia dan ingat semuanya, ini adalah dasar dari dasar-dasarnya. Anotasi ini memungkinkan objek Java di kelas Anda dikaitkan dengan database. Agar suatu kelas menjadi suatu entitas, kelas tersebut harus memenuhi persyaratan berikut:

• Harus memiliki konstruktor kosong ( publicatau protected);
• Tidak dapat disarangkan, antarmuka atau enum;
• Tidak boleh finaldan tidak boleh berisi final-fields/properties;
• Harus berisi setidaknya satu bidang @Id.

Periksa kelas entitas Anda, ini adalah tempat yang sangat populer untuk menembak diri sendiri. Sangat mudah untuk melupakan sesuatu. Dalam hal ini, entitas dapat:

• Berisi konstruktor yang tidak kosong;
• Untuk diwarisi dan diwariskan;
• Berisi metode lain dan mengimplementasikan antarmuka.

Seperti yang Anda lihat, kelasnya Usersangat mirip dengan tabel pengguna. Ada bidang id, name, age. Anotasi yang terletak di atasnya tidak memerlukan banyak penjelasan: sudah jelas bahwa @Id merupakan indikasi bahwa bidang tersebut merupakan pengidentifikasi objek kelas ini. Anotasi @Table di atas kelas menentukan nama tabel tempat objek ditulis. Perhatikan komentar di atas field age: jika nama field di kelas dan tabel sama, tidak perlu menambahkan anotasi @Column, akan berfungsi seperti itu. Mengenai “strategi = GenerationType.IDENTITY” yang ditunjukkan dalam tanda kurung: ada beberapa strategi pembuatan ID. Anda bisa mencarinya di Google, tetapi dalam kerangka aplikasi kami Anda tidak perlu repot. Hal utama adalah bahwa id untuk objek kita akan dihasilkan secara otomatis, jadi tidak ada penyetel untuk id, dan kita juga tidak menentukannya di konstruktor. UserNamun, kelasnya masih menonjol dalam beberapa hal . Dia punya daftar mobil! Anotasi @OneToMany muncul di atas daftar. Artinya satu objek kelas pengguna dapat berhubungan dengan beberapa mesin. Pengaturan "mappedBY" menunjuk ke bidang pengguna kelas Auto. Dengan cara ini, mesin dan pengguna terhubung satu sama lain. Pengaturan OrphanRemoval diterjemahkan dengan cukup baik dari bahasa Inggris - “remove Orphans”. Jika kami menghapus pengguna dari database, semua mobil yang terkait dengannya juga akan dihapus. Pada gilirannya, di kelas AutoAnda akan melihat bidang pengguna dengan anotasi @ManyToOne (banyak Autos dapat berhubungan dengan satu Pengguna) dan anotasi @JoinColumn. Ini menunjukkan melalui kolom mana dalam tabel autos koneksi dengan tabel pengguna terjadi (kunci asing yang sama yang kita bicarakan sebelumnya). Setelah membuat model data, saatnya mengajarkan program kita untuk melakukan operasi pada data ini di database. Mari kita mulai dengan kelas utilitas HibernateSessionFactoryUtil. Tugasnya hanya satu - membuat pabrik sesi agar aplikasi kita dapat bekerja dengan database (halo, pola "Pabrik!"). Dia tidak bisa melakukan hal lain.

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

Di kelas ini, kami membuat objek konfigurasi baru, Konfigurasi, dan meneruskan ke kelas tersebut yang seharusnya dianggap sebagai entitas - Userdan Auto. Perhatikan caranya configuration.getProperties(). Properti apa lagi? Di mana? Properti adalah parameter cara kerja hibernasi, yang ditentukan dalam file khusus hibernate.cfg.xml. Hibernate.cfg.xml dibaca di sini: new Configuration().configure(); Seperti yang Anda lihat, tidak ada yang istimewa di dalamnya - parameter untuk menghubungkan ke database, dan parameter khusus show_sql. Hal ini diperlukan agar semua kueri SQL yang hibernasi akan dijalankan terhadap database kita dikeluarkan ke konsol. Dengan cara ini, Anda akan melihat dengan tepat apa yang dilakukan Hibernate setiap saat dan menghilangkan efek "ajaib". Selanjutnya kita membutuhkan kelas UserDAO. (Dalam cara yang baik, Anda perlu memprogram melalui antarmuka - membuat antarmuka UserDAOdan mengimplementasikannya secara terpisah UserDAOImpl, tetapi untuk mengurangi jumlah kode, saya akan menghilangkan ini. Jangan lakukan ini di proyek nyata!). DAO (objek akses data) adalah salah satu pola desain yang paling umum, “Akses Data”. Artinya sederhana - untuk membuat lapisan dalam aplikasi yang hanya bertanggung jawab untuk mengakses data, dan tidak lebih. Dapatkan data dari database, perbarui data, hapus data - dan selesai. Baca lebih lanjut tentang DAO; Anda akan menggunakannya terus-menerus dalam pekerjaan Anda. Apa yang bisa dilakukan kelas kita UserDao? Sebenarnya, seperti semua DAO, DAO hanya dapat bekerja dengan data. Temukan pengguna berdasarkan id, perbarui datanya, hapus dia, tarik daftar semua pengguna dari database atau simpan pengguna baru di database - itu saja fungsinya.

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

Metodenya UserDaomirip satu sama lain. Di sebagian besar dari mereka, kami menerima objek Sesi (sesi yang menghubungkan ke database kami) menggunakan Pabrik Sesi kami, membuat satu transaksi dalam sesi ini, melakukan transformasi data yang diperlukan, menyimpan hasil transaksi dalam database dan menutup sesi. Metodenya sendiri, seperti yang Anda lihat, cukup sederhana. DAO adalah “jantung” aplikasi kita. Namun, kami tidak akan membuat DAO secara langsung dan memanggil metodenya di file main(). Semua logika akan dipindahkan ke 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);
    }


}

Layanan adalah lapisan data dalam aplikasi yang bertanggung jawab untuk menjalankan logika bisnis. Jika program Anda perlu menjalankan logika bisnis tertentu, program Anda melakukannya melalui layanan. Layanan berisi dirinya sendiri UserDaodan memanggil metode DAO dalam metodenya. Ini mungkin tampak seperti duplikasi fungsi bagi Anda (mengapa tidak memanggil metode dari objek dao saja), tetapi dengan sejumlah besar objek dan logika yang kompleks, memecah aplikasi menjadi beberapa lapisan memiliki manfaat yang sangat besar (ini adalah praktik yang baik, ingat informasi ini untuk masa depan dan baca tentang “lapisan aplikasi” "). Dalam layanan kami, logikanya sederhana, tetapi dalam proyek nyata, metode layanan akan berisi lebih dari satu baris kode :) Sekarang kami memiliki semua yang kami butuhkan agar aplikasi dapat berfungsi! Mari kita buat main()pengguna dan mesin untuknya dalam metode ini, hubungkan mereka satu sama lain dan simpan dalam database.

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

Seperti yang Anda lihat, tabel pengguna memiliki entrinya sendiri, dan tabel autos memiliki entrinya sendiri. Mari kita coba mengganti nama pengguna kita. Mari kita bersihkan tabel pengguna dan jalankan kodenya

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

Berhasil! Bagaimana jika Anda menghapus pengguna? Mari kita bersihkan tabel pengguna (autos akan menghapus sendiri) dan jalankan kodenya

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

Dan tabel kami benar-benar kosong (perhatikan konsol, semua kueri yang dijalankan Hibernate akan ditampilkan di sana). Anda dapat bermain-main dengan aplikasi ini dan mencoba semua fiturnya. Misalnya, buat pengguna dengan mesin, simpan ke database, lihat ID apa yang diberikan padanya, dan coba gunakan metode main()untuk "menarik" pengguna dari database dengan id ini dan menampilkan daftar mesinnya di konsol . Tentu saja, kami hanya melihat sebagian kecil dari fungsi Hibernate. Kemampuannya sangat luas, dan telah lama menjadi salah satu standar industri untuk pengembangan Java. Jika Anda ingin mempelajarinya secara detail, saya dapat merekomendasikan buku “Java Persistence API and Hibernate” yang telah saya ulas di salah satu artikel saya sebelumnya. Saya harap artikel ini bermanfaat bagi pembaca. Jika Anda memiliki pertanyaan, tanyakan di komentar, saya akan dengan senang hati menjawabnya :) Selain itu, jangan lupa untuk mendukung penulis dalam kompetisi dengan "Sukai" dia. Atau lebih baik lagi - “Saya sangat menyukainya” :) Semoga sukses dalam studi Anda!