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

Selamat petang. Dalam artikel ini saya ingin berkongsi pertemuan pertama saya dengan perkara seperti Maven, Spring, Hibernate, MySQL dan Tomcat dalam proses mencipta aplikasi CRUD yang mudah. Ini adalah bahagian ketiga daripada 4. Artikel ini ditujukan terutamanya untuk mereka yang telah menyelesaikan 30-40 peringkat di sini, tetapi belum menerokai Java tulen dan baru bermula (atau akan bermula) untuk memasuki dunia terbuka dengan semua teknologi, rangka kerja dan perkataan asing yang lain ini. Ini adalah bahagian ketiga artikel "Pengenalan kepada Maven, Spring, MySQL, Hibernate dan aplikasi CRUD pertama." Bahagian sebelumnya boleh dilihat dengan mengikuti pautan:

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

Kandungan:

• Mencipta dan menyambung pangkalan data
• ORM dan JPA
• Entiti
• Sifat Hibernate
• Konfigurasi hibernate
• Lapisan akses data

Mencipta dan menyambung pangkalan data

Nah, sudah tiba masanya untuk mula bekerja pada pangkalan data. Sebelum menyambungkan Hibernate dan memikirkan bagaimana ia harus berfungsi di sana, mula-mula mari kita lihat pangkalan data itu sendiri, i.e. Mari menciptanya, menyambungkannya, membuatnya dan mengisi tanda itu. Kami akan menggunakan DBMS (Sistem Pengurusan Pangkalan Data) MySQL (sudah tentu, anda mesti memuat turun dan memasang dahulu). SQL (Bahasa Pertanyaan Berstruktur) ialah bahasa pengaturcaraan deklaratif yang digunakan untuk mencipta, mengubah suai dan memanipulasi data dalam pangkalan data hubungan. Dalam pangkalan data sedemikian, data disimpan dalam bentuk jadual. Bagaimanakah aplikasi berkomunikasi dengan pangkalan data (menghantar pertanyaan SQL ke pangkalan data dan mengembalikan hasil). Untuk ini, Java mempunyai perkara seperti JDBC (Java DataBase Connectivity) , yang, secara ringkasnya, adalah satu set antara muka dan kelas untuk bekerja dengan pangkalan data. Untuk berinteraksi dengan pangkalan data, anda perlu membuat sambungan; untuk ini, pakej java.sqlmempunyai kelas Connection. Terdapat beberapa cara untuk mewujudkan sambungan, contohnya anda boleh menggunakan kaedah getConnectionkelas DriverManager. Walau bagaimanapun, interaksi dengan pangkalan data tidak dijalankan secara langsung, kerana terdapat banyak pangkalan data, dan ia berbeza. Jadi bagi setiap daripada mereka terdapat Pemacu JDBC sendiri. Menggunakan pemacu ini, sambungan ke pangkalan data diwujudkan. Oleh itu, pertama sekali, supaya tidak terganggu oleh perkara ini kemudian, mari pasang pemacu MySQL . Mari tambahkan pom.xmlkebergantungan berikut:

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

Sekarang mari kita buat pangkalan data. View -> Tool Windows -> Database - panel pangkalan data akan dibuka. Baharu (hijau +) -> Sumber Data -> MySQL - tetingkap akan dibuka di mana anda perlu menentukan nama pengguna dan kata laluan, kami menetapkannya semasa memasang MySQL (sebagai contoh, saya menggunakan root dan root). Port (lalai untuk MySQL 3306), nama, dsb. biarkan sahaja. Anda boleh menguji sambungan menggunakan butang " Sambungan Ujian ". Klik OK dan kini kami disambungkan ke pelayan MySQL. Seterusnya, mari buat pangkalan data. Untuk melakukan ini, anda boleh menulis skrip dalam konsol yang terbuka:

CREATE DATABASE test

Klik Laksanakan dan pangkalan data sudah sedia, kini anda boleh menyambungkannya. Untuk melakukan ini, kembali ke Data Source Properties dan masukkan nama pangkalan data (ujian) dalam medan Pangkalan Data, kemudian masukkan nama pengguna dan kata laluan sekali lagi dan klik OK. Sekarang kita perlu membuat jadual. Anda boleh menggunakan alatan grafik, tetapi buat kali pertama, anda mungkin perlu menulis skrip dengan tangan untuk melihat rupanya:

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

Jadual dibuat dengan nama filmsdengan lajur id, titledsb. Untuk setiap lajur, jenis ditunjukkan (saiz output maksimum dalam kurungan).

• PRIMARY KEY- ini ialah kunci utama, digunakan untuk mengenal pasti rekod dalam jadual secara unik (yang membayangkan keunikan)
• AUTO_INCREMENT— nilai akan dijana secara automatik (sudah tentu ia akan menjadi bukan sifar, jadi anda tidak perlu menentukan ini)
• NOT NULL- di sini semuanya juga jelas, ia tidak boleh kosong
• DEFAULT— tetapkan nilai lalai
• COLLATE- pengekodan
• CREATE UNIQUE INDEX— jadikan bidang itu unik
• INSERT INTO— tambah rekod pada jadual

Hasilnya ialah tanda seperti ini: Mungkin patut dicuba untuk menyambung kepadanya, buat masa ini, secara berasingan daripada aplikasi web kami. Bagaimana jika beberapa masalah timbul dengan ini, maka kami akan menyelesaikannya dengan segera. Jika tidak, kemudian kita akan menyambung Hibernate , melakukan sesuatu, mengkonfigurasi, bermain-main, dan jika kita kacau di suatu tempat, maka sekurang-kurangnya kita akan tahu bahawa masalahnya tiada di sini. Nah, untuk menyemak sambungan, mari buat kaedah main, buat sementara waktu. Pada dasarnya, anda boleh meletakkannya di mana-mana, walaupun dalam kelas pengawal, walaupun dalam model atau konfigurasi, tidak mengapa, anda hanya perlu menggunakannya untuk memastikan semuanya baik-baik saja dengan sambungan dan anda boleh memadamkannya. Tetapi untuk lebih berhati-hati, mari buat kelas berasingan 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();
        }
    }
}

Segala-galanya mudah di sini, kami menetapkan parameter sambungan ke pangkalan data kami dan cuba membuat sambungan. Mari kita lancarkan yang ini maindan lihat. Jadi, saya mendapat pengecualian, beberapa masalah zon waktu dan beberapa amaran lain tentang SSL. Selepas menyemak imbas Internet, anda boleh mengetahui bahawa ini adalah masalah yang agak biasa, dan apabila menggunakan versi pemacu yang berbeza (mysql-connector-java), ia boleh bersumpah secara berbeza. Sebagai contoh, saya mendapati secara eksperimen bahawa apabila menggunakan versi 5.1.47 tidak ada pengecualian kerana zon waktu, sambungan dibuat seperti biasa, tetapi amaran SSL masih muncul. Dengan beberapa versi lain nampaknya terdapat pengecualian mengenai SSL, dan bukan sekadar amaran. Okay, bukan itu maksudnya. Anda boleh cuba menangani isu ini secara berasingan, tetapi kami tidak akan membincangkannya sekarang. Penyelesaian untuk ini semuanya agak mudah, anda perlu menentukan parameter tambahan dalam url , iaitu serverTimezone, jika masalahnya adalah dengan zon waktu, dan useSSLjika masalahnya adalah dengan SSL:

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

Kini kami telah menetapkan zon waktu dan melumpuhkan SSL. Kami melancarkannya sekali lagi maindan voila - Sambungan berjaya! Baiklah, kami telah mengetahui cara membuat sambungan. Kelas Mainpada dasarnya telah menyelesaikan tugasnya, anda boleh memadamkannya.

ORM dan JPA

Dengan cara yang baik, untuk pemahaman yang lebih baik, adalah lebih baik untuk mula membiasakan diri dengan pangkalan data secara teratur, dari awal lagi, tanpa sebarang hibernate dan perkara lain. Oleh itu, adalah idea yang baik untuk mencari beberapa panduan dan mula-mula cuba bekerja dengan kelas JDBC, menulis pertanyaan SQL secara manual dan sebagainya. Baiklah, mari beralih kepada model ORM dengan segera. Apakah maksud ini? Sudah tentu, sekali lagi dinasihatkan untuk membaca tentang perkara ini secara berasingan, tetapi saya akan cuba menerangkannya secara ringkas. ORM (Pemetaan Perkaitan Objek atau pemetaan perhubungan objek) ialah teknologi untuk memetakan objek ke dalam struktur pangkalan data perhubungan, i.e. untuk mewakili objek Java kami sebagai baris jadual. Terima kasih kepada ORM, anda tidak perlu risau tentang menulis skrip SQL dan fokus pada bekerja dengan objek. Bagaimana untuk menggunakannya. Java mempunyai satu lagi perkara yang hebat, JPA (Java Persistence API), yang melaksanakan konsep ORM. JPA ialah spesifikasi sedemikian; ia menerangkan keperluan untuk objek, ia mentakrifkan pelbagai antara muka dan anotasi untuk bekerja dengan pangkalan data. JPA pada asasnya adalah penerangan, piawaian. Oleh itu, terdapat banyak pelaksanaan khusus, salah satunya (dan salah satu yang paling popular) ialah Hibernate, yang merupakan intipati rangka kerja ini. Hibernate ialah pelaksanaan spesifikasi JPA yang direka untuk menyelesaikan masalah pemetaan hubungan objek (ORM). Kami perlu menghubungkan semua perkara ini dengan projek kami. Di samping itu, agar Spring kami tidak berdiri di luar dan turut mengambil bahagian dalam semua pergerakan ini dengan pangkalan data, kami perlu menyambung beberapa modul lagi, kerana semua yang kami dapat daripada pergantungan spring-webmvc tidak lagi mencukupi untuk ini. Kami juga memerlukan spring-jdbc untuk bekerja dengan pangkalan data, spring-tx untuk menyokong transaksi, dan spring-orm untuk bekerja dengan Hibernate. Mari tambah kebergantungan kepada 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>

Dua kebergantungan ini sudah memadai. javax.persistence-apiakan tiba bersama-sama dengan hibernate-core , dan spring-jdbc dan spring-tx bersama dengan spring-orm .

Entiti

Jadi kami mahu objek kelas Filmboleh disimpan dalam pangkalan data. Untuk melakukan ini, kelas mesti memenuhi beberapa syarat. Dalam JPA terdapat perkara seperti Entiti untuk ini . Kelas entiti ialah kelas POJO biasa , dengan medan peribadi dan pengambil dan penetap untuknya. Ia mesti mempunyai pembina bukan persendirian tanpa parameter (atau pembina lalai), dan ia mesti mempunyai kunci utama, i.e. sesuatu yang unik akan mengenal pasti setiap rekod kelas ini dalam pangkalan data. Anda juga boleh membaca tentang semua keperluan untuk kelas sedemikian secara berasingan. Mari jadikan kelas kita Filmsebagai entiti 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 bahawa kelas ini ialah entiti.
• @Table- menunjuk ke jadual tertentu untuk memaparkan entiti ini.
• @Id— menunjukkan bahawa medan ini ialah kunci utama, i.e. sifat ini akan digunakan untuk mengenal pasti setiap entri unik.
• @Column— menghubungkan medan ke lajur jadual. Jika nama medan dan lajur jadual adalah sama, anda boleh meninggalkannya.
• @GeneratedValue— harta akan dijana secara automatik; anda boleh menentukan cara dalam kurungan. Sekarang kita tidak akan memahami bagaimana strategi yang berbeza berfungsi. Adalah cukup untuk mengetahui bahawa dalam kes ini setiap nilai baru akan meningkat sebanyak 1 daripada yang sebelumnya.

Untuk setiap harta, anda juga boleh menentukan banyak perkara lain, contohnya, perkara yang sepatutnya bukan sifar atau unik, nyatakan nilai lalai, saiz maksimum, dsb. Ini berguna jika anda perlu menjana jadual berdasarkan kelas ini; Hibernate mempunyai pilihan ini. Tetapi kami telah mencipta jadual sendiri dan mengkonfigurasi semua sifat, jadi kami boleh melakukannya tanpanya. Nota kecil.Dokumentasi Hibernate mengesyorkan menggunakan anotasi bukan pada medan, tetapi pada getter. Walau bagaimanapun, perbezaan antara pendekatan ini agak halus dan dalam aplikasi mudah kami ini tidak akan memberi sebarang kesan. Selain itu, kebanyakan orang meletakkan anotasi di atas medan. Oleh itu, biarlah begini, nampak lebih kemas.

Sifat Hibernate

Baiklah, mari mula menyediakan Hibernate kami. Dan pertama sekali, mari letakkan beberapa maklumat, seperti nama pengguna dan kata laluan, url dan sesuatu yang lain ke dalam fail yang berasingan. Anda boleh, tentu saja, menentukannya sebagai baris biasa terus dalam kelas, seperti yang kami lakukan semasa kami menyemak sambungan ( String username = "root";dan kemudian menyerahkannya kepada kaedah untuk membuat sambungan). Tetapi masih lebih tepat untuk menyimpan data statik sedemikian dalam beberapa propertyfail. Dan jika, sebagai contoh, anda perlu menukar pangkalan data, maka anda tidak perlu melalui semua kelas dan mencari di mana ia digunakan; ia akan mencukupi untuk menukar nilai dalam fail ini sekali. Mari buat fail db.properties dalam direktori sumber :

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 menyambung ke pangkalan data, i.e. nama kelas pemandu, url, nama pengguna dan kata laluan. hibernate.dialect- sifat ini diperlukan untuk menunjukkan kepada Hibernate versi tertentu bahasa SQL yang digunakan. Hakikatnya ialah dalam setiap DBMS, untuk mengembangkan keupayaan, menambah beberapa fungsi atau mengoptimumkan sesuatu, mereka biasanya memodenkan sedikit bahasa. Hasilnya, ternyata setiap DBMS mempunyai dialek SQL sendiri. Ia seperti bahasa Inggeris, nampaknya bahasanya sama, tetapi di Australia, Amerika Syarikat atau Britain ia akan berbeza sedikit, dan sesetengah perkataan mungkin mempunyai makna yang berbeza. Dan untuk mengelakkan sebarang masalah dengan pemahaman, anda perlu memberitahu Hibernate secara langsung apa sebenarnya yang perlu ditangani. hibernate.show_sql— terima kasih kepada harta ini, pertanyaan kepada pangkalan data akan dipaparkan dalam konsol. Ini tidak perlu, tetapi dengan perkara ini anda sekurang-kurangnya boleh melihat apa yang berlaku, jika tidak, nampaknya Hibernate sedang melakukan sejenis sihir. Sudah tentu, ia tidak akan sepenuhnya jelas untuk dipaparkan; lebih baik menggunakan beberapa jenis pembalak untuk ini, tetapi itu sesuatu untuk masa yang lain, buat masa ini ia akan berjaya.

Konfigurasi hibernate

Mari kita teruskan untuk menyediakan konfigurasi. configMari buat kelas dalam pakej 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;
    }
}

Terdapat banyak perkara baharu di sini, jadi sebaiknya cari maklumat tambahan tentang setiap item dalam sumber yang berbeza. Mari kita bincangkannya secara ringkas di sini.

• Kami @Configurationsudah @ComponentScantahu apabila kami membuat kelas WebConfig.
• @EnableTransactionManagement— membolehkan anda menggunakannya TransactionManageruntuk menguruskan urus niaga. Hibernate berfungsi dengan pangkalan data menggunakan urus niaga; ia diperlukan untuk set operasi tertentu untuk dilakukan secara keseluruhan, i.e. jika kaedah itu mempunyai masalah dengan mana-mana satu operasi, maka semua yang lain tidak akan dilaksanakan, supaya ia tidak berlaku seperti dalam contoh klasik dengan pemindahan wang, apabila operasi pengeluaran wang dari satu akaun telah selesai, tetapi operasi menulis kepada orang lain tidak berfungsi, akibatnya wang itu hilang.
• @PropertySource— menyambungkan fail sifat yang kami buat baru-baru ini.
• Environment- untuk mendapatkan sifat daripada propertyfail.
• hibernateProperties- kaedah ini diperlukan untuk mewakili sifat Hibernate sebagai objek Properties
• DataSource— digunakan untuk membuat sambungan ke pangkalan data. Ini adalah alternatif kepada DriverManager , yang kami gunakan sebelum ini apabila kami mencipta fail main. Dokumentasi mengatakan bahawa DataSourceia adalah lebih baik untuk digunakan. Itulah yang akan kami lakukan, sudah tentu, tidak lupa membaca di Internet apakah perbezaan dan kelebihannya. Satu faedah khususnya ialah keupayaan untuk mencipta Kolam Sambungan Pangkalan Data (DBCP).
• sessionFactory— untuk mencipta sesi dengan bantuan operasi dengan objek entiti dijalankan. Di sini kami menetapkan sumber data, sifat Hibernate dan dalam pakej mana kami perlu mencari kelas entiti.
• transactionManager— untuk mengkonfigurasi pengurus transaksi.

Nota kecil tentang DataSource. Dokumentasi mengatakan bahawa menggunakan pelaksanaan standard, iaitu DriverManagerDataSource, tidak disyorkan, kerana ia hanya pengganti untuk pengumpulan sambungan biasa dan secara amnya hanya sesuai untuk ujian dan sebagainya. Untuk aplikasi biasa, adalah lebih baik untuk menggunakan beberapa jenis perpustakaan DBCP. Nah, untuk aplikasi kami, sudah tentu, apa yang kami ada sudah cukup, tetapi untuk melengkapkan gambar, mungkin kami masih akan menggunakan pelaksanaan lain seperti yang dinasihatkan. Mari tambahkan pom.xmlkebergantungan berikut:

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

Dan dalam kaedah dataSourcekelas HibernateConfigkami menggantikannya DriverManagerDataSourcedengan BasicDataSourcesatu daripada pakej org.apache.tomcat.dbcp.dbcp2:

BasicDataSource dataSource = new BasicDataSource();

Nah, semuanya nampaknya sudah sedia, konfigurasi sudah sedia, yang tinggal hanyalah menambahnya pada AppInitializer kami :

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

Lapisan akses data

Sudah tiba masanya untuk memulakan DAO kami. Kami pergi ke kelas FilmDAOImpldan pertama sekali kami memadam senarai percubaan dari sana, kami tidak lagi memerlukannya. Mari tambah kilang sesi dan selesaikannya.

private SessionFactory sessionFactory;

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

Sebagai permulaan, kami akan membuat kaedah untuk memaparkan halaman dengan senarai filem, di dalamnya kami akan menerima sesi dan membuat permintaan kepada pangkalan data (menarik semua rekod dan membentuk senarai):

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

Terdapat 2 mata di sini. Pertama, amaran telah dipaparkan. Ini disebabkan oleh fakta bahawa kami ingin menerima parameterized List<Film>, tetapi kaedah itu kembali hanya Listkerana pada masa penyusunan tidak diketahui jenis permintaan yang akan dikembalikan. Jadi idea itu memberi amaran kepada kita bahawa kita sedang melakukan penukaran yang tidak selamat, yang boleh mengakibatkan masalah. Terdapat beberapa lagi cara yang betul untuk melakukan ini supaya persoalan sedemikian tidak timbul. Anda boleh mencari maklumat di Internet. Tetapi mari kita tidak peduli dengan ini sekarang. Hakikatnya ialah kami tahu dengan tepat jenis yang akan dikembalikan, jadi tiada masalah akan timbul di sini, anda boleh mengabaikan amaran itu. Tetapi, supaya mata anda tidak menyakitkan mata, anda boleh menggantung anotasi di atas kaedah @SupressWarning("unchecked"). Dengan melakukan ini, kami memberitahu pengkompil, terima kasih, kawan, atas keprihatinan anda, tetapi saya tahu apa yang saya lakukan dan semuanya terkawal, jadi anda boleh berehat dan tidak bimbang tentang kaedah ini. Kedua, idea digariskan dengan warna merah " from Film". Ia hanya pertanyaan HQL (Hibernate Query Language) dan idea itu tidak memahami sama ada semuanya betul atau terdapat ralat. Anda boleh pergi ke tetapan idea dan melaraskan semuanya secara manual (lihat di Internet jika berminat). Atau anda hanya boleh menambah sokongan untuk rangka kerja Hibernate, untuk melakukan ini, klik kanan pada projek, pilih Tambah Sokongan Rangka Kerja , tandakan kotak untuk Hibernate dan klik OK. Selepas ini, kemungkinan besar dalam kelas entiti ( Film) banyak perkara juga akan digariskan dengan warna merah, sebagai contoh, di mana anotasi @Table(name = "films")akan mengeluarkan amaran Tidak dapat menyelesaikan jadual 'filem' . Sekali lagi, tidak ada yang salah di sini, ini bukan ralat reka bentuk, semuanya akan disusun dan berfungsi. Idea ini ditekankan kerana ia tidak tahu apa-apa tentang asas kami. Untuk membetulkannya, mari kita integrasikan idea dengan pangkalan data. Lihat -> Windows Alat -> Persistense (tab akan dibuka) -> butang kanan tetikus, pilih Berikan Sumber Data -> dalam Sumber Data, nyatakan sambungan ke pangkalan data dan klik OK . Apabila semua ini diperbaiki, masih ada yang tinggal. Mari kita pergi ke peringkat yang lebih tinggi, untuk perkhidmatan. Dalam kelas, FilmServiceImplkami menandakan allFilmskaedah spring dengan anotasi @Transactional, yang akan menunjukkan bahawa kaedah itu harus dilaksanakan dalam transaksi (tanpa ini, Hibernate akan enggan berfungsi):

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

Jadi, semuanya sudah sedia di sini, anda tidak perlu menyentuh apa-apa dalam pengawal. Nah, nampaknya saat kebenaran telah tiba, klik Jalankan dan lihat apa yang berlaku. Dan inilah tanda kami, dan kali ini ia diperoleh bukan dari senarai yang kami sendiri buat betul-betul di dalam kelas, tetapi dari pangkalan data. Hebat, semuanya nampaknya berfungsi. Sekarang kami melakukan semua operasi CRUD lain dengan cara yang sama menggunakan kaedah sesi. Kelas yang terhasil kelihatan 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);
    }
}

Kini semua yang tinggal ialah jangan lupa pergi ke perkhidmatan dan menambah anotasi pada kaedah @Transactional. Itu sahaja, siap. Anda kini boleh menjalankan dan menyemak. Klik pautan dan butang, cuba tambah/padam/edit entri. Sekiranya semuanya dilakukan dengan betul, ia sepatutnya berfungsi. Sekarang ini adalah aplikasi CRUD sepenuhnya menggunakan Hibernate, Spring, MySQL. Bersambung... Memperkenalkan Maven, Spring, MySQL, Hibernate dan aplikasi CRUD pertama (bahagian 1) Memperkenalkan Maven, Spring, MySQL, Hibernate dan aplikasi CRUD pertama (bahagian 2) Memperkenalkan Maven, Spring, MySQL, Hibernate dan aplikasi CRUD pertama (bahagian 3) Pengenalan kepada Maven, Spring, MySQL, Hibernate dan aplikasi CRUD pertama (bahagian 4)