Pengenalan Maven, Spring, MySQL, Hibernate dan aplikasi CRUD pertama (part 3)

Selamat siang. Pada artikel ini saya ingin berbagi pengalaman pertama saya dengan hal-hal seperti Maven, Spring, Hibernate, MySQL dan Tomcat dalam proses pembuatan aplikasi CRUD sederhana. Ini adalah bagian ketiga dari 4. Artikel ini ditujukan terutama bagi mereka yang telah menyelesaikan 30-40 level di sini, tetapi belum berani melampaui Java murni dan baru mulai (atau akan memulai) memasuki dunia terbuka dengan semua teknologi, kerangka kerja, dan kata-kata asing lainnya. Ini adalah bagian ketiga dari artikel "Pengantar Maven, Spring, MySQL, Hibernate dan aplikasi CRUD pertama". Bagian sebelumnya dapat dilihat pada tautan berikut:

• Pengenalan Maven, Spring, MySQL, Hibernate dan aplikasi CRUD pertama (part 1)
• Pengenalan Maven, Spring, MySQL, Hibernate dan aplikasi CRUD pertama (part 2)

Isi:

• Membuat dan menghubungkan database
• ORM dan JPA
• Kesatuan
• Properti Hibernasi
• Konfigurasi hibernasi
• Lapisan akses data

Membuat dan menghubungkan database

Nah, sekarang saatnya untuk mulai mengerjakan database. Sebelum menghubungkan Hibernate dan memikirkan cara kerjanya di sana, pertama-tama mari kita lihat database itu sendiri, yaitu. Mari kita buat, sambungkan, buat, dan isi tandanya. Kita akan menggunakan DBMS (Database Management System) MySQL (tentunya harus download dan install terlebih dahulu). SQL (Structured Query Language) adalah bahasa pemrograman deklaratif yang digunakan untuk membuat, memodifikasi, dan memanipulasi data dalam database relasional. Dalam database tersebut, data disimpan dalam bentuk tabel. Bagaimana aplikasi berkomunikasi dengan database (mentransmisikan query SQL ke database dan mengembalikan hasilnya). Untuk ini, Java memiliki sesuatu seperti JDBC (Java DataBase Connectivity) , yang sederhananya, adalah sekumpulan antarmuka dan kelas untuk bekerja dengan database. Untuk berinteraksi dengan database, Anda perlu membuat koneksi; untuk ini, paket java.sqlmemiliki kelas Connection. Ada beberapa cara untuk membuat koneksi, misalnya Anda bisa menggunakan metode getConnectionkelas DriverManager. Namun interaksi dengan database tidak dilakukan secara langsung, karena databasenya banyak dan berbeda-beda. Jadi untuk masing-masingnya ada Driver JDBC-nya sendiri, dengan menggunakan driver ini, koneksi ke database dibuat. Oleh karena itu, pertama-tama, agar tidak terganggu nantinya, mari kita instal driver MySQLnya . Mari tambahkan pom.xmlketergantungan berikut:

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.11</version>
</dependency>

Sekarang mari kita buat databasenya. Lihat -> Alat Windows -> Basis Data - panel basis data akan terbuka. Baru (hijau +) -> Sumber Data -> MySQL - sebuah jendela akan terbuka di mana Anda perlu menentukan nama pengguna dan kata sandi, kami mengaturnya saat menginstal MySQL (misalnya, saya menggunakan root dan root). Port (default untuk MySQL 3306), nama, dll. biarkan apa adanya. Anda dapat menguji koneksi menggunakan tombol " Uji Koneksi ". Klik OK dan sekarang kita terhubung ke server MySQL. Selanjutnya, mari kita buat database. Untuk melakukan ini, Anda dapat menulis skrip di konsol yang terbuka:

CREATE DATABASE test

Klik Execute dan database sudah siap, sekarang Anda bisa menghubungkannya.Untuk melakukannya, kembali ke Data Source Properties dan masukkan nama database (test) di kolom Database, lalu masukkan kembali nama pengguna dan kata sandi dan klik OK. Sekarang kita perlu membuat tabel. Anda dapat menggunakan alat grafis, namun untuk pertama kalinya, mungkin ada baiknya menulis skrip dengan tangan untuk melihat tampilannya:

USE test;

CREATE TABLE films
(
  id int(10) PRIMARY KEY AUTO_INCREMENT,
  title VARCHAR(100) NOT NULL,
  year int(4),
  genre VARCHAR(20),
  watched BIT DEFAULT false  NOT NULL
)
COLLATE='utf8_general_ci';
CREATE UNIQUE INDEX films_title_uindex ON films (title);

INSERT INTO `films` (`title`,`year`,`genre`, watched)
VALUES
  ("Inception", 2010, "sci-fi", 1),
  ("The Lord of the Rings: The Fellowship of the Ring", 2001, "fantasy", 1),
  ("Tag", 2018, "comedy", 0),
  ("Gunfight at the O.K. Corral", 1957, "western", 0),
  ("Die Hard", 1988, "action", 1);

Sebuah tabel dibuat dengan nama filmsdengan kolom id, titledll. Untuk setiap kolom, jenisnya ditunjukkan (ukuran keluaran maksimum dalam tanda kurung).

• PRIMARY KEY- ini adalah kunci utama, digunakan untuk mengidentifikasi secara unik catatan dalam tabel (yang menyiratkan keunikan)
• AUTO_INCREMENT— nilainya akan dihasilkan secara otomatis (tentu saja bukan nol, jadi Anda tidak perlu menentukannya)
• NOT NULL- di sini semuanya juga jelas, tidak boleh kosong
• DEFAULT— menetapkan nilai default
• COLLATE- pengkodean
• CREATE UNIQUE INDEX— menjadikan bidang ini unik
• INSERT INTO— menambahkan catatan ke tabel

Hasilnya adalah tanda seperti ini: Mungkin ada baiknya mencoba menyambungkannya, untuk saat ini, secara terpisah dari aplikasi web kita. Bagaimana jika ada masalah yang muncul dengan hal ini, maka kami akan segera menyelesaikannya. Jika tidak, nanti kita akan menghubungkan Hibernate , melakukan sesuatu, mengkonfigurasi, mengotak-atik, dan jika kita membuat kesalahan di suatu tempat, setidaknya kita akan tahu bahwa masalahnya bukan di sini. Nah, untuk mengecek koneksi, mari kita buat metode mainuntuk sementara. Pada prinsipnya, Anda dapat meletakkannya di mana saja, bahkan di kelas pengontrol, bahkan dalam model atau konfigurasi, tidak masalah, Anda hanya perlu menggunakannya untuk memastikan semuanya baik-baik saja dengan koneksi dan Anda dapat menghapusnya. Namun untuk lebih berhati-hati, mari kita buat kelas tersendiri untuknya Main:

package testgroup.filmography;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class Main {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/test";
        String username = "root";
        String password = "root";
        System.out.println("Connecting...");

        try (Connection connection = DriverManager.getConnection(url, username, password)) {
            System.out.println("Connection successful!");
        } catch (SQLException e) {
            System.out.println("Connection failed!");
            e.printStackTrace();
        }
    }
}

Semuanya sederhana di sini, kami mengatur parameter koneksi ke database kami dan mencoba membuat koneksi. Mari kita luncurkan yang ini maindan lihat. Jadi, saya mendapat pengecualian, beberapa masalah zona waktu, dan beberapa peringatan lainnya tentang SSL. Setelah menelusuri Internet, Anda dapat mengetahui bahwa ini adalah masalah yang cukup umum, dan saat menggunakan versi driver yang berbeda (mysql-connector-java), hasilnya mungkin berbeda. Misalnya, saya menemukan secara eksperimental bahwa ketika menggunakan versi 5.1.47 tidak ada pengecualian karena zona waktu, koneksi dibuat normal, tetapi peringatan SSL masih muncul. Pada beberapa versi lain sepertinya ada pengecualian mengenai SSL, dan bukan hanya peringatan. Oke, bukan itu intinya. Anda dapat mencoba menangani masalah ini secara terpisah, namun kami tidak akan membahasnya sekarang. Solusi untuk ini semua cukup sederhana, Anda perlu menentukan parameter tambahan di url , yaitu serverTimezonejika masalahnya ada pada zona waktu, dan useSSLjika masalahnya ada pada SSL:

String url = "jdbc:mysql://localhost:3306/test?serverTimezone=Europe/Minsk&useSSL=false";

Sekarang kami telah mengatur zona waktu dan menonaktifkan SSL. Kami meluncurkannya lagi maindan voila - Koneksi berhasil! Baiklah, kami menemukan cara membuat koneksi. Kelas Mainpada dasarnya telah menyelesaikan tugasnya, Anda dapat menghapusnya.

ORM dan JPA

Dalam cara yang baik, untuk pemahaman yang lebih baik, lebih baik mulai mengenal database secara berurutan, dari awal, tanpa ada hibernasi dan hal lainnya. Oleh karena itu, merupakan ide bagus untuk menemukan beberapa panduan dan pertama-tama mencoba bekerja dengan kelas JDBC, menulis kueri SQL secara manual, dan seterusnya. Baiklah, mari kita langsung beralih ke model ORM . Apa artinya ini? Tentu saja, sekali lagi disarankan untuk membaca tentang ini secara terpisah, tetapi saya akan mencoba menjelaskannya secara singkat. ORM (Object-Relational Mapping atau pemetaan relasional objek) adalah teknologi untuk memetakan objek ke dalam struktur database relasional, yaitu. untuk mewakili objek Java kita sebagai baris tabel. Berkat ORM, Anda tidak perlu khawatir tentang menulis skrip SQL dan fokus bekerja dengan objek. Bagaimana cara menggunakannya. Java punya keunggulan lainnya, JPA (Java Persistence API), yang mengimplementasikan konsep ORM. JPA adalah suatu spesifikasi; ia menjelaskan persyaratan untuk objek, ia mendefinisikan berbagai antarmuka dan anotasi untuk bekerja dengan database. JPA pada dasarnya adalah deskripsi, standar. Oleh karena itu, ada banyak implementasi spesifik, salah satunya (dan salah satu yang paling populer) adalah Hibernate, yang merupakan inti dari framework ini. Hibernate adalah implementasi spesifikasi JPA yang dirancang untuk memecahkan masalah pemetaan relasional objek (ORM). Kita perlu menghubungkan semua ini dengan proyek kita. Selain itu, agar Spring kita tidak berdiam diri dan juga berpartisipasi dalam semua gerakan dengan database ini, kita perlu menghubungkan beberapa modul lagi, karena semua yang kami dapatkan dari ketergantungan spring-webmvc tidak lagi cukup untuk ini. Kita juga memerlukan spring-jdbc untuk bekerja dengan database, spring-tx untuk mendukung transaksi, dan spring-orm untuk bekerja dengan Hibernate. Mari tambahkan dependensi ke pom.xml:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
    <version>5.1.1.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>5.3.7.Final</version>
</dependency>

Kedua ketergantungan ini sudah cukup. javax.persistence-apiakan tiba bersama dengan hibernate-core , dan spring-jdbc dan spring-tx bersama dengan spring-orm .

Kesatuan

Jadi kita ingin objek kelas Filmbisa disimpan di database. Untuk melakukan ini, kelas harus memenuhi sejumlah kondisi. Di JPA ada yang namanya Entitas untuk ini . Kelas entitas adalah kelas POJO biasa , dengan bidang pribadi serta pengambil dan penyetelnya. Itu harus memiliki konstruktor non-pribadi tanpa parameter (atau konstruktor default), dan harus memiliki kunci utama, yaitu. sesuatu yang secara unik akan mengidentifikasi setiap catatan kelas ini dalam database. Anda juga dapat membaca tentang semua persyaratan untuk kelas tersebut secara terpisah. Mari kita jadikan kelas kita Filmsebuah entitas menggunakan anotasi JPA:

package testgroup.filmography.model;

import javax.persistence.*;

@Entity
@Table(name = "films")
public class Film {

    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @Column(name = "title")
    private String title;

    @Column(name = "year")
    private int year;

    @Column(name = "genre")
    private String genre;

    @Column(name = "watched")
    private boolean watched;

    // + getters and setters
}

• @Entity- menunjukkan bahwa kelas ini adalah suatu entitas.
• @Table- menunjuk ke tabel tertentu untuk menampilkan entitas ini.
• @Id— menunjukkan bahwa bidang ini adalah kunci utama, mis. properti ini akan digunakan untuk mengidentifikasi setiap entri unik.
• @Column— menghubungkan bidang ke kolom tabel. Jika nama kolom bidang dan tabel sama, Anda dapat menghilangkannya.
• @GeneratedValue— properti akan dibuat secara otomatis; Anda dapat menentukan caranya dalam tanda kurung. Kami sekarang tidak akan memahami bagaimana sebenarnya berbagai strategi bekerja. Cukup diketahui bahwa dalam hal ini setiap nilai baru akan bertambah 1 dari nilai sebelumnya.

Untuk setiap properti, Anda juga dapat menentukan banyak hal lainnya, misalnya, apa yang harus bukan nol atau unik, menentukan nilai default, ukuran maksimum, dll. Ini akan berguna jika Anda perlu membuat tabel berdasarkan kelas ini; Hibernate memiliki opsi ini. Namun kami telah membuat tabelnya sendiri dan mengonfigurasi semua propertinya, jadi kami dapat melakukannya tanpa tabel tersebut. Catatan kecil.Dokumentasi Hibernate merekomendasikan penggunaan anotasi bukan pada bidang, tetapi pada pengambil. Namun, perbedaan antara pendekatan-pendekatan ini cukup halus dan dalam penerapan sederhana kita hal ini tidak akan berdampak apa pun. Ditambah lagi, kebanyakan orang tetap menaruh anotasi di atas kolom. Maka dari itu, biarkan saja seperti ini agar terlihat lebih rapi.

Properti Hibernasi

Baiklah, mari kita mulai mengatur Hibernate kita. Dan pertama-tama, mari kita masukkan beberapa informasi, seperti nama pengguna dan kata sandi, url, dan lainnya ke dalam file terpisah. Anda tentu saja dapat menentukannya sebagai baris reguler langsung di kelas, seperti yang kita lakukan saat memeriksa koneksi ( String username = "root";dan kemudian meneruskannya ke metode untuk membuat koneksi). Namun masih lebih tepat untuk menyimpan data statis seperti itu di beberapa propertyfile. Dan jika, misalnya, Anda perlu mengubah database, maka Anda tidak perlu menelusuri semua kelas dan mencari di mana database tersebut digunakan; cukup mengubah nilai dalam file ini satu kali saja. Mari kita buat file db.properties di direktori resources :

jdbc.driverClassName=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test?serverTimezone=Europe/Minsk&useSSL=false
jdbc.username=root
jdbc.password=root

hibernate.dialect=org.hibernate.dialect.MySQL8Dialect
hibernate.show_sql=true

Nah, semuanya jelas dari atas, parameter untuk menghubungkan ke database, mis. nama kelas driver, url, nama pengguna dan kata sandi. hibernate.dialect- properti ini diperlukan untuk menunjukkan ke Hibernate versi bahasa SQL mana yang digunakan. Faktanya adalah bahwa di setiap DBMS, untuk memperluas kemampuan, menambahkan beberapa fungsi atau mengoptimalkan sesuatu, mereka biasanya sedikit memodernisasi bahasanya. Hasilnya, ternyata setiap DBMS memiliki dialek SQL masing-masing. Seperti halnya dalam bahasa Inggris, sepertinya bahasanya sama, tetapi di Australia, Amerika, atau Inggris akan sedikit berbeda, dan beberapa kata mungkin memiliki arti berbeda. Dan untuk menghindari masalah pemahaman, Anda perlu memberi tahu Hibernate secara langsung apa sebenarnya yang harus ditangani. hibernate.show_sql— berkat properti ini, kueri ke database akan ditampilkan di konsol. Ini tidak perlu, tetapi dengan hal ini Anda setidaknya dapat melihat apa yang terjadi, jika tidak, Hibernate mungkin tampak melakukan semacam keajaiban. Yah, tentu saja, itu tidak akan sepenuhnya jelas untuk ditampilkan; lebih baik menggunakan semacam logger untuk ini, tapi itu adalah sesuatu untuk lain waktu, untuk saat ini sudah cukup.

Konfigurasi hibernasi

Mari beralih ke pengaturan konfigurasi. configMari kita buat kelas di paket HibernateConfig:

package testgroup.filmography.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.hibernate5.HibernateTransactionManager;
import org.springframework.orm.hibernate5.LocalSessionFactoryBean;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;
import java.util.Properties;

@Configuration
@ComponentScan(basePackages = " testgroup.filmography")
@EnableTransactionManagement
@PropertySource(value = "classpath:db.properties")
public class HibernateConfig {
    private Environment environment;

    @Autowired
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }

    private Properties hibernateProperties() {
        Properties properties = new Properties();
        properties.put("hibernate.dialect", environment.getRequiredProperty("hibernate.dialect"));
        properties.put("hibernate.show_sql", environment.getRequiredProperty("hibernate.show_sql"));
        return properties;
    }

    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(environment.getRequiredProperty("jdbc.driverClassName"));
        dataSource.setUrl(environment.getRequiredProperty("jdbc.url"));
        dataSource.setUsername(environment.getRequiredProperty("jdbc.username"));
        dataSource.setPassword(environment.getRequiredProperty("jdbc.password"));
        return dataSource;
    }

    @Bean
    public LocalSessionFactoryBean sessionFactory() {
        LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
        sessionFactory.setDataSource(dataSource());
        sessionFactory.setPackagesToScan("testgroup.filmography.model");
        sessionFactory.setHibernateProperties(hibernateProperties());
        return sessionFactory;
    }

    @Bean
    public HibernateTransactionManager transactionManager() {
        HibernateTransactionManager transactionManager = new HibernateTransactionManager();
        transactionManager.setSessionFactory(sessionFactory().getObject());
        return transactionManager;
    }
}

Ada cukup banyak hal baru di sini, jadi sebaiknya cari juga informasi setiap item di sumber yang berbeda. Mari kita bahas secara singkat di sini.

• Kami @Configurationsudah @ComponentScanmengetahuinya saat kami mengikuti kelas WebConfig.
• @EnableTransactionManagement— memungkinkan Anda menggunakannya TransactionManageruntuk mengelola transaksi. Hibernate bekerja dengan database menggunakan transaksi; transaksi tersebut diperlukan agar serangkaian operasi tertentu dapat dilakukan secara keseluruhan, mis. jika metode tersebut bermasalah pada salah satu operasi, maka semua operasi lainnya tidak akan dijalankan, sehingga tidak terjadi seperti pada contoh klasik transfer uang, ketika operasi penarikan uang dari satu rekening telah selesai, tetapi operasi operasi tulis ke yang lain tidak berhasil, alhasil uangnya hilang.
• @PropertySource— menghubungkan file properti yang baru saja kita buat.
• Environment- untuk mendapatkan properti dari propertysuatu file.
• hibernateProperties- metode ini diperlukan untuk merepresentasikan properti Hibernate sebagai objek Properties
• DataSource— digunakan untuk membuat koneksi ke database. Ini merupakan alternatif untuk DriverManager , yang kami gunakan sebelumnya saat membuat file main. Dokumentasi mengatakan bahwa DataSourcelebih baik untuk digunakan. Itu yang akan kita lakukan tentunya dengan tidak lupa membaca di internet apa saja perbedaan dan kelebihannya. Salah satu manfaat khususnya adalah kemampuan untuk membuat Database Connection Pool (DBCP).
• sessionFactory— untuk membuat sesi yang dengannya operasi dengan objek entitas dilakukan. Di sini kita mengatur sumber data, properti Hibernate dan di paket mana kita perlu mencari kelas entitas.
• transactionManager— untuk mengkonfigurasi manajer transaksi.

Sebuah catatan kecil tentang DataSource. Dokumentasi menyebutkan bahwa menggunakan implementasi standar yaitu, DriverManagerDataSourcetidak disarankan, karena ini hanya pengganti pengumpulan koneksi normal dan umumnya hanya cocok untuk pengujian dan semacamnya. Untuk aplikasi normal, lebih baik menggunakan semacam perpustakaan DBCP. Nah, untuk aplikasi kita tentunya yang kita punya sudah cukup, namun untuk melengkapi gambarannya mungkin kita masih akan menggunakan implementasi lain seperti yang disarankan. Mari tambahkan pom.xmlketergantungan berikut:

<dependency>
            <groupId>org.apache.tomcat</groupId>
            <artifactId>tomcat-dbcp</artifactId>
            <version>9.0.10</version>
</dependency>

Dan pada metode dataSourcekelas HibernateConfigkita menggantinya DriverManagerDataSourcedengan BasicDataSourceyang dari paket org.apache.tomcat.dbcp.dbcp2:

BasicDataSource dataSource = new BasicDataSource();

Nah sepertinya semuanya sudah siap, konfigurasi sudah siap, tinggal menambahkannya ke AppInitializer kita :

protected Class<?>[] getRootConfigClasses() {
        return new Class[]{HibernateConfig.class};
    }

Lapisan akses data

Saatnya untuk akhirnya memulai DAO kami. Kami pergi ke kelas FilmDAOImpldan pertama-tama kami menghapus daftar percobaan dari sana, kami tidak lagi membutuhkannya. Mari tambahkan pabrik sesi dan kerjakan.

private SessionFactory sessionFactory;

    @Autowired
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

Pertama, mari buat metode untuk menampilkan halaman dengan daftar film, di dalamnya kita akan menerima sesi dan membuat permintaan ke database (keluarkan semua catatan dan membuat daftar):

public List<Film> allFilms() {
        Session session = sessionFactory.getCurrentSession();
        return session.createQuery("from Film").list();
    }

Ada 2 poin di sini. Pertama, peringatan ditampilkan. Hal ini disebabkan oleh fakta bahwa kita ingin menerima parameterized List<Film>, tetapi metode ini kembali hanya Listkarena pada waktu kompilasi tidak diketahui jenis permintaan apa yang akan dikembalikan. Jadi gagasan ini memperingatkan kita bahwa kita melakukan konversi yang tidak aman, yang mungkin menimbulkan masalah. Ada beberapa cara yang lebih tepat untuk melakukan hal ini agar pertanyaan seperti itu tidak muncul. Anda dapat mencari informasi di Internet. Tapi jangan ambil pusing dengan hal ini sekarang. Faktanya adalah kita tahu persis tipe apa yang akan dikembalikan, jadi tidak akan ada masalah yang muncul di sini, Anda bisa mengabaikan peringatan itu. Tapi, agar mata Anda tidak merusak pemandangan, Anda bisa memberi penjelasan di atas caranya @SupressWarning("unchecked"). Dengan melakukan ini, kami semacam memberi tahu kompiler, terima kasih sobat, atas perhatian Anda, tetapi saya tahu apa yang saya lakukan dan semuanya terkendali, sehingga Anda dapat bersantai dan tidak khawatir tentang metode ini. Kedua, gagasan tersebut digarisbawahi dengan warna merah " from Film". Itu hanya query HQL (Hibernate Query Language) dan idenya tidak memahami apakah semuanya benar atau ada kesalahan. Anda dapat membuka pengaturan ide dan menyesuaikan semuanya secara manual (lihat di Internet jika tertarik). Atau Anda cukup menambahkan dukungan untuk kerangka Hibernate, untuk melakukannya, klik kanan pada proyek, pilih Tambahkan Dukungan Kerangka , centang kotak Hibernate dan klik OK. Setelah ini, kemungkinan besar di kelas entitas ( Film) banyak hal juga akan digarisbawahi dengan warna merah, misalnya, di mana anotasi @Table(name = "films")akan mengeluarkan peringatan Cannot solve table 'films' . Sekali lagi, tidak ada yang salah disini, ini bukan kesalahan desain, semuanya akan dikompilasi dan berfungsi. Idenya ditekankan karena tidak tahu apa-apa tentang markas kita. Untuk memperbaikinya, mari integrasikan ide tersebut dengan database. Lihat -> Alat Windows -> Persistense (sebuah tab akan terbuka) -> tombol kanan mouse, pilih Assign Data Sources -> di Sumber Data, tentukan koneksi ke database dan klik OK . Ketika semua ini sudah diperbaiki, masih ada sesuatu yang tersisa. Ayo naik ke level yang lebih tinggi, ke layanan. Di kelas, FilmServiceImplkami menandai allFilmsmetode pegas dengan anotasi @Transactional, yang akan menunjukkan bahwa metode tersebut harus dijalankan dalam suatu transaksi (tanpa ini, Hibernate akan menolak untuk bekerja):

@Transactional
public List<Film> allFilms() {
    return filmDAO.allFilms();
}

Jadi semuanya sudah siap di sini, Anda tidak perlu menyentuh apa pun di pengontrol. Sepertinya momen kebenaran telah tiba, klik Jalankan dan lihat apa yang terjadi. Dan ini dia tanda kita, dan kali ini didapat bukan dari daftar yang kita buat sendiri langsung di kelas, melainkan dari database. Hebat, semuanya tampak berfungsi. Sekarang kita melakukan semua operasi CRUD lainnya dengan cara yang sama menggunakan metode sesi. Kelas yang dihasilkan terlihat seperti ini:

package testgroup.filmography.dao;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import testgroup.filmography.model.Film;

import java.util.List;

@Repository
public class FilmDAOImpl implements FilmDAO {
    private SessionFactory sessionFactory;

    @Autowired
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    @Override
    @SuppressWarnings("unchecked")
    public List<Film> allFilms() {
        Session session = sessionFactory.getCurrentSession();
        return session.createQuery("from Film").list();
    }

    @Override
    public void add(Film film) {
        Session session = sessionFactory.getCurrentSession();
        session.persist(film);
    }

    @Override
    public void delete(Film film) {
        Session session = sessionFactory.getCurrentSession();
        session.delete(film);
    }

    @Override
    public void edit(Film film) {
        Session session = sessionFactory.getCurrentSession();
        session.update(film);
    }

    @Override
    public Film getById(int id) {
        Session session = sessionFactory.getCurrentSession();
        return session.get(Film.class, id);
    }
}

Sekarang yang tersisa hanyalah jangan lupa pergi ke layanan dan menambahkan anotasi ke metodenya @Transactional. Itu saja, siap. Anda sekarang dapat menjalankan dan memeriksa. Klik tautan dan tombol, coba tambah/hapus/edit entri. Jika semuanya dilakukan dengan benar, itu akan berhasil. Sekarang ini adalah aplikasi CRUD lengkap yang menggunakan Hibernate, Spring, MySQL. Bersambung... Memperkenalkan Maven, Spring, MySQL, Hibernate dan aplikasi CRUD pertama (bagian 1) Memperkenalkan Maven, Spring, MySQL, Hibernate dan aplikasi CRUD pertama (bagian 2) Memperkenalkan Maven, Spring, MySQL, Hibernate dan aplikasi CRUD pertama (part 3) Pengenalan Maven, Spring, MySQL, Hibernate dan aplikasi CRUD pertama (part 4)