JavaRush /Java Blog /Random-TL /Panimula sa Maven, Spring, MySQL, Hibernate at ang unang ...

Antas

28 February 2021
37 views
0 comments

Panimula sa Maven, Spring, MySQL, Hibernate at ang unang CRUD application (bahagi 3)

Magandang hapon. Sa artikulong ito nais kong ibahagi ang aking unang pagkikita sa mga bagay tulad ng Maven, Spring, Hibernate, MySQL at Tomcat sa proseso ng paglikha ng isang simpleng CRUD application. Ito ang ikatlong bahagi ng 4. Ang artikulo ay pangunahing inilaan para sa mga nakatapos na ng 30-40 na antas dito, ngunit hindi pa nakipagsapalaran sa kabila ng purong Java at nagsisimula pa lamang (o malapit nang magsimula) upang makapasok sa bukas na mundo na may lahat ng mga teknolohiyang ito, mga balangkas at iba pang hindi pamilyar na mga salita.

Panimula sa Maven, Spring, MySQL, Hibernate at ang unang CRUD application (part 3) - 1

Ito ang ikatlong bahagi ng artikulong "Introduction to Maven, Spring, MySQL, Hibernate at ang unang CRUD application." Ang mga nakaraang bahagi ay makikita sa pamamagitan ng pagsunod sa mga link:

Nilalaman:

Paglikha at pagkonekta ng isang database

Well, oras na para magsimulang magtrabaho sa database. Bago kumonekta sa Hibernate at pag-isipan kung paano dapat gumana ang lahat doon, tingnan muna natin ang database mismo, i.e. Gawin natin ito, ikonekta, gawin at punan ang sign. Gagamitin namin ang DBMS (Database Management System) MySQL (siyempre, kailangan mo munang mag-download at mag-install). Ang SQL (Structured Query Language) ay isang declarative programming language na ginagamit upang lumikha, baguhin, at manipulahin ang data sa isang relational database. Sa ganitong mga database, ang data ay nakaimbak sa anyo ng mga talahanayan. Paano nakikipag-ugnayan ang application sa database (nagpapadala ng mga query sa SQL sa database at nagbabalik ng mga resulta). Para dito, ang Java ay mayroong isang bagay tulad ng JDBC (Java DataBase Connectivity) , na, sa madaling salita, ay isang hanay ng mga interface at mga klase para sa pagtatrabaho sa mga database. Upang makipag-ugnayan sa database, kailangan mong lumikha ng isang koneksyon; para dito, ang package java.sqlay may isang klase Connection. Mayroong ilang mga paraan upang magtatag ng isang koneksyon, halimbawa maaari mong gamitin ang getConnectionclass method DriverManager. Gayunpaman, ang pakikipag-ugnayan sa database ay hindi direktang isinasagawa, dahil maraming mga database, at iba ang mga ito. Kaya para sa bawat isa sa kanila ay mayroong sariling JDBC Driver. Gamit ang driver na ito, ang isang koneksyon sa database ay naitatag. Samakatuwid, una sa lahat, upang hindi makagambala dito sa ibang pagkakataon, i-install natin ang MySQL driver . Idagdag natin ang pom.xmlsumusunod na dependency:

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

Ngayon gawin natin ang database. View -> Tool Windows -> Database - magbubukas ang database panel. Bago (berde +) -> Pinagmulan ng Data -> MySQL - magbubukas ang isang window kung saan kailangan mong tukuyin ang username at password, itinakda namin ang mga ito kapag nag-i-install ng MySQL (halimbawa, ginamit ko ang root at root). Port (default para sa MySQL 3306), pangalan, atbp. iwanan ito bilang ay. Maaari mong subukan ang koneksyon gamit ang pindutang " Subukan ang Koneksyon ". Panimula sa Maven, Spring, MySQL, Hibernate at ang unang CRUD application (part 3) - 2

Panimula sa Maven, Spring, MySQL, Hibernate at ang unang CRUD application (part 3) - 2

I-click ang OK at ngayon ay nakakonekta na kami sa MySQL server. Susunod, gumawa tayo ng database. Upang gawin ito, maaari kang magsulat ng isang script sa console na magbubukas:

CREATE DATABASE test

I-click ang Execute at handa na ang database, maaari mo na itong ikonekta. Upang gawin ito, bumalik sa Data Source Properties at ilagay ang pangalan ng database (test) sa Database field, pagkatapos ay ipasok muli ang username at password at i-click ang OK. Ngayon ay kailangan nating gumawa ng mesa. Maaari kang gumamit ng mga graphical na tool, ngunit sa unang pagkakataon, malamang na sulit na magsulat ng script sa pamamagitan ng kamay upang makita kung ano ang hitsura nito:

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

Ang isang talahanayan ay nilikha gamit ang pangalan filmsna may mga hanay id, titleatbp. Para sa bawat column, ang uri ay ipinahiwatig (maximum na laki ng output sa mga panaklong).

PRIMARY KEY- ito ang pangunahing susi, na ginagamit upang natatanging tukuyin ang isang tala sa talahanayan (na nagpapahiwatig ng pagiging natatangi)
AUTO_INCREMENT— ang halaga ay awtomatikong bubuo (siyempre magiging non-zero ito, kaya hindi mo na kailangang tukuyin ito)
NOT NULL- dito halata din lahat, hindi pwedeng walang laman
DEFAULT— itakda ang default na halaga
COLLATE- encoding
CREATE UNIQUE INDEX— gawing kakaiba ang larangan
INSERT INTO— magdagdag ng tala sa talahanayan

Ang resulta ay isang senyales na tulad nito:

Marahil ay sulit na subukang kumonekta dito, sa ngayon, nang hiwalay sa aming web application. Paano kung magkaroon ng ilang problema dito, aayusin natin ito kaagad. Kung hindi, mamaya ay ikokonekta natin ang Hibernate , gagawa ng isang bagay, i-configure, tinker, at kung magkagulo tayo sa isang lugar, at least malalaman natin na wala dito ang problema. Well, para suriin ang koneksyon, gumawa tayo ng paraan main, pansamantala. Sa prinsipyo, maaari mong ilagay ito kahit saan, kahit na sa klase ng controller, kahit na sa modelo o pagsasaayos, hindi mahalaga, kailangan mo lamang itong gamitin upang matiyak na ang lahat ay maayos sa koneksyon at maaari mong tanggalin ito. Ngunit para mas maging maingat, gumawa tayo ng hiwalay na klase para dito 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();
        }
    }
}

Ang lahat ay simple dito, itinakda namin ang mga parameter ng koneksyon sa aming database at subukang lumikha ng isang koneksyon. Ilunsad natin ang isang ito mainat tingnan natin. Kaya, nakakuha ako ng exception, ilang problema sa time zone, at ilang iba pang babala tungkol sa SSL. Pagkatapos mag-browse sa Internet, maaari mong malaman na ito ay isang medyo karaniwang problema, at kapag gumagamit ng iba't ibang mga bersyon ng driver (mysql-connector-java), maaari itong manumpa nang iba. Halimbawa, nalaman ko sa eksperimento na kapag gumagamit ng bersyon 5.1.47 ay walang mga pagbubukod dahil sa time zone, ang koneksyon ay ginagawa nang normal, ngunit ang SSL na babala ay lumalabas pa rin. Sa ilang iba pang mga bersyon, tila mayroong isang pagbubukod tungkol sa SSL, at hindi lamang isang babala. Okay, hindi iyon ang punto. Maaari mong subukang harapin ang isyung ito nang hiwalay, ngunit hindi na namin ito sasagutin ngayon. Ang solusyon dito ay medyo simple, kailangan mong tukuyin ang mga karagdagang parameter sa url , ibig sabihin serverTimezone, kung ang problema ay nasa time zone, at useSSLkung ang problema ay nasa SSL:

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

Ngayon ay naitakda na namin ang time zone at hindi pinagana ang SSL. Inilunsad namin ito muli mainat voila - Matagumpay ang koneksyon! Well, mahusay, naisip namin kung paano lumikha ng isang koneksyon. Ang klase Mainay karaniwang nakumpleto ang gawain nito, maaari mo itong tanggalin.

ORM at JPA

Sa isang mabuting paraan, para sa isang mas mahusay na pag-unawa, ito ay mas mahusay na simulan ang pagkuha ng pamilyar sa mga database sa pagkakasunud-sunod, mula sa simula, nang walang anumang hibernate at iba pang mga bagay. Samakatuwid, magandang ideya na maghanap ng ilang mga gabay at subukan munang magtrabaho sa mga klase ng JDBC, manu-manong sumulat ng mga query sa SQL at iba pa. Buweno, lumipat tayo kaagad sa modelo ng ORM . Ano ang ibig sabihin nito? Siyempre, ipinapayong muli na basahin ang tungkol dito nang hiwalay, ngunit susubukan kong ilarawan ito nang maikli. Ang ORM (Object-Relational Mapping o object-relational mapping) ay isang teknolohiya para sa pagmamapa ng mga bagay sa relational database structures, i.e. upang kumatawan sa aming Java object bilang isang table row. Salamat sa ORM, hindi mo kailangang mag-alala tungkol sa pagsulat ng mga script ng SQL at tumuon sa pagtatrabaho sa mga bagay. Paano ito gamitin. Ang Java ay may isa pang magandang bagay, ang JPA (Java Persistence API), na nagpapatupad ng konsepto ng ORM. Ang JPA ay tulad ng isang detalye; inilalarawan nito ang mga kinakailangan para sa mga bagay, tinutukoy nito ang iba't ibang mga interface at annotation para sa pagtatrabaho sa database. Ang JPA ay mahalagang paglalarawan, isang pamantayan. Samakatuwid, mayroong maraming mga tiyak na pagpapatupad, isa sa kung saan (at isa sa pinakasikat) ay Hibernate, na siyang kakanyahan ng balangkas na ito. Ang hibernate ay isang pagpapatupad ng detalye ng JPA na idinisenyo upang malutas ang mga problema sa object-relational mapping (ORM). Kailangan nating ikonekta ang buong bagay na ito sa ating proyekto. Bilang karagdagan, upang ang aming Spring ay hindi tumayo sa gilid at lumahok din sa lahat ng kilusang ito na may mga database, kailangan naming ikonekta ang ilang higit pang mga module, dahil lahat ng nakuha namin mula sa spring-webmvc dependency ay hindi na sapat para dito. Kakailanganin din namin ang spring-jdbc para magtrabaho kasama ang database, spring-tx para suportahan ang mga transaksyon, at spring-orm para magtrabaho kasama ang Hibernate. Magdagdag tayo ng mga dependencies sa 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>

Ang dalawang dependency na ito ay sapat na. javax.persistence-apiay darating kasama ng hibernate-core , at spring-jdbc at spring-tx kasama ng spring-orm .

Entity

Kaya gusto naming Filmmai-imbak ang mga bagay sa klase sa database. Para magawa ito, dapat matugunan ng klase ang ilang kundisyon. Sa JPA mayroong isang bagay bilang isang Entity para dito . Ang klase ng entity ay isang ordinaryong klase ng POJO , na may mga pribadong field at getter at setter para sa kanila. Dapat itong magkaroon ng isang hindi pribadong konstruktor na walang mga parameter (o isang default na tagapagbuo), at dapat itong magkaroon ng pangunahing susi, i.e. isang bagay na natatanging makikilala ang bawat tala ng klase na ito sa database. Maaari mo ring basahin ang tungkol sa lahat ng mga kinakailangan para sa naturang klase nang hiwalay. Gawin nating Filmentity ang ating klase gamit ang mga anotasyon ng 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- nagpapahiwatig na ang klase na ito ay isang entity.
@Table- tumuturo sa isang partikular na talahanayan upang ipakita ang entity na ito.
@Id— ay nagpapahiwatig na ang field na ito ay isang pangunahing key, i.e. gagamitin ang property na ito para tukuyin ang bawat natatanging entry.
@Column— nag-uugnay ng field sa column ng table. Kung magkapareho ang mga pangalan ng column at table, maaari mong alisin ang mga ito.
@GeneratedValue— ang property ay awtomatikong bubuo; maaari mong tukuyin kung paano sa panaklong. Hindi natin ngayon mauunawaan kung paano gumagana ang eksaktong iba't ibang mga diskarte. Sapat na malaman na sa kasong ito ang bawat bagong halaga ay tataas ng 1 mula sa nauna.

Para sa bawat pag-aari, maaari kang magdagdag ng maraming iba pang mga bagay, halimbawa, kung ano ang dapat na hindi zero o natatangi, tukuyin ang default na halaga, maximum na laki, atbp. Ito ay magiging kapaki-pakinabang kung kailangan mong bumuo ng isang talahanayan batay sa klase na ito; Ang hibernate ay may ganitong opsyon. Ngunit ginawa na namin ang talahanayan sa aming sarili at na-configure ang lahat ng mga katangian, kaya magagawa namin nang wala ito. Isang maliit na tala.Inirerekomenda ng dokumentasyon ng Hibernate ang paggamit ng mga anotasyon hindi sa mga field, ngunit sa mga getter. Gayunpaman, ang pagkakaiba sa pagitan ng mga pamamaraang ito ay medyo banayad at sa aming simpleng aplikasyon ay hindi ito magkakaroon ng anumang epekto. Dagdag pa, karamihan sa mga tao ay naglalagay pa rin ng mga anotasyon sa itaas ng mga field. Kaya naman, hayaan na natin itong ganito, mukhang mas malinis.

Mga Katangian ng Hibernate

Well, simulan natin ang pag-set up ng ating Hibernate. At una sa lahat, maglagay tayo ng ilang impormasyon, tulad ng username at password, url at iba pa sa isang hiwalay na file. Maaari mong, siyempre, tukuyin ang mga ito bilang isang regular na linya nang direkta sa klase, tulad ng ginawa namin noong sinuri namin ang koneksyon ( String username = "root";at pagkatapos ay ipinasa ito sa paraan para sa paglikha ng koneksyon). Ngunit mas tama pa rin na mag-imbak ng naturang static na data sa ilang propertyfile. At kung, halimbawa, kailangan mong baguhin ang database, hindi mo na kailangang dumaan sa lahat ng mga klase at hanapin kung saan ito ginagamit; sapat na upang baguhin ang halaga sa file na ito nang isang beses. Gumawa tayo ng db.properties file sa direktoryo ng mga mapagkukunan :

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

Well, ang lahat ay malinaw mula sa itaas, mga parameter para sa pagkonekta sa database, i.e. pangalan ng klase ng driver, url, username at password. hibernate.dialect- kailangan ang property na ito upang ipahiwatig sa Hibernate kung aling partikular na bersyon ng wikang SQL ang ginagamit. Ang katotohanan ay sa bawat DBMS, upang mapalawak ang mga kakayahan, magdagdag ng ilang pag-andar o mag-optimize ng isang bagay, kadalasan ay bahagyang ginagawang makabago ang wika. Bilang resulta, lumalabas na ang bawat DBMS ay may sariling SQL dialect. Parang sa English, parang pareho lang ang wika, pero sa Australia, USA o Britain ay magkakaiba ito ng kaunti, at maaaring magkaiba ang kahulugan ng ilang salita. At upang maiwasan ang anumang mga problema sa pag-unawa, kailangan mong direktang sabihin sa Hibernate kung ano ang eksaktong kailangan nitong harapin. hibernate.show_sql— salamat sa property na ito, ang mga query sa database ay ipapakita sa console. Ito ay hindi kinakailangan, ngunit sa bagay na ito maaari mong hindi bababa sa tingnan kung ano ang nangyayari, kung hindi man ay maaaring mukhang ang Hibernate ay gumagawa ng ilang uri ng mahika. Well, siyempre, hindi ito magiging ganap na malinaw upang ipakita; mas mahusay na gumamit ng ilang uri ng logger para dito, ngunit iyon ay isang bagay para sa isa pang oras, sa ngayon ay gagawin ito.

pagsasaayos ng hibernate

Magpatuloy tayo sa pagse-set up ng configuration. configGumawa tayo ng klase sa package 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;
    }
}

Napakaraming bagong bagay dito, kaya pinakamahusay na maghanap ng karagdagang impormasyon sa bawat item sa iba't ibang mga mapagkukunan. Pag-usapan natin ito sandali.

@ConfigurationNapag-isipan na namin @ComponentScankung kailan namin ginawa ang klase WebConfig.
@EnableTransactionManagement— nagbibigay-daan sa iyong gamitin ito TransactionManagerupang pamahalaan ang mga transaksyon. Gumagana ang hibernate sa database gamit ang mga transaksyon; kailangan ang mga ito para sa isang tiyak na hanay ng mga operasyon na isasagawa bilang isang buo, i.e. kung ang pamamaraan ay may mga problema sa anumang isang operasyon, kung gayon ang lahat ng iba ay hindi isasagawa, upang hindi ito mangyari tulad ng sa klasikong halimbawa sa paglilipat ng pera, kapag ang operasyon ng pag-withdraw ng pera mula sa isang account ay nakumpleto, ngunit ang Ang operasyon ng pagsulat sa iba ay hindi gumana, bilang isang resulta nawala ang pera.
@PropertySource— pagkonekta sa properties file na ginawa namin kamakailan.
Environment- upang makakuha ng mga katangian mula propertysa isang file.
hibernateProperties- ang pamamaraang ito ay kinakailangan upang kumatawan sa mga katangian ng Hibernate bilang isang object ng Properties
DataSource— ginagamit upang lumikha ng koneksyon sa database. Ito ay isang alternatibo sa DriverManager , na ginamit namin kanina noong nilikha namin ang main. Sinasabi ng dokumentasyon na DataSourcemas mainam na gamitin. Iyon ang gagawin namin, siyempre, hindi nakakalimutang basahin sa Internet kung ano ang pagkakaiba at mga pakinabang. Ang isang partikular na benepisyo ay ang kakayahang lumikha ng Database Connection Pool (DBCP).
sessionFactory— upang lumikha ng mga session sa tulong ng kung aling mga operasyon na may mga bagay na entity ay isinasagawa. Dito namin itinakda ang data source, Hibernate properties at kung saang package kailangan naming maghanap ng mga entity class.
transactionManager— para i-configure ang transaction manager.

Isang maliit na tala tungkol sa DataSource. Sinasabi ng dokumentasyon na ang paggamit ng karaniwang pagpapatupad, ibig sabihin DriverManagerDataSource, ay hindi inirerekomenda, dahil ito ay kapalit lamang para sa normal na pagsasama-sama ng koneksyon at sa pangkalahatan ay angkop lamang para sa mga pagsubok at iba pa. Para sa isang normal na aplikasyon, mas mainam na gumamit ng ilang uri ng DBCP library. Well, para sa aming aplikasyon, siyempre, kung ano ang mayroon kami, ngunit upang makumpleto ang larawan, marahil ay gagamit pa rin kami ng isa pang pagpapatupad gaya ng ipinapayo. Idagdag natin ang pom.xmlsumusunod na dependency:

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

At sa paraan dataSourceng klase HibernateConfigay pinapalitan namin ito DriverManagerDataSourceng BasicDataSourceisa mula sa package org.apache.tomcat.dbcp.dbcp2:

BasicDataSource dataSource = new BasicDataSource();

Well, mukhang handa na ang lahat, handa na ang configuration, ang natitira lang ay idagdag ito sa aming AppInitializer :

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

Layer ng pag-access ng data

Oras na para sa wakas ay magsimula sa ating DAO. Pumunta kami sa klase FilmDAOImplat una sa lahat ay tinanggal namin ang listahan ng pagsubok mula doon, hindi na namin ito kailangan. Magdagdag tayo ng factory ng session at pagsikapan ito.

private SessionFactory sessionFactory;

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

Upang magsimula, gagawa kami ng isang pamamaraan para sa pagpapakita ng isang pahina na may isang listahan ng mga pelikula, sa loob nito ay makakatanggap kami ng isang sesyon at gagawa ng isang kahilingan sa database (bunutin ang lahat ng mga tala at bumubuo ng isang listahan):

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

Mayroong 2 puntos dito. Una, isang babala ang ipinakita. Ito ay dahil sa ang katunayan na gusto naming makatanggap ng isang parameterized List<Film>, ngunit ang paraan ay nagbabalik Listdahil lamang sa oras ng pag-compile ay hindi alam kung anong uri ang hiling na ibabalik. Kaya binabalaan tayo ng ideya na gumagawa tayo ng hindi ligtas na conversion, na maaaring magresulta sa problema. Mayroong ilang higit pang mga tamang paraan upang gawin ito upang hindi lumabas ang ganoong tanong. Maaari kang maghanap ng impormasyon sa Internet. Ngunit huwag na nating pakialaman ito ngayon. Ang katotohanan ay alam namin nang eksakto kung anong uri ang ibabalik, kaya walang mga problema na lilitaw dito, maaari mong balewalain ang babala. Ngunit, para hindi nakakasira sa paningin ang iyong mga mata, maaari kang mag-hang ng anotasyon sa itaas ng pamamaraan @SupressWarning("unchecked"). Sa paggawa nito, medyo sinasabi namin sa compiler, salamat, buddy, para sa iyong pag-aalala, ngunit alam ko kung ano ang ginagawa ko at nasa ilalim ng kontrol ang lahat, para makapagpahinga ka at huwag mag-alala tungkol sa pamamaraang ito. Pangalawa, ang ideya ay may salungguhit na pula " from Film". Isa lang itong query ng HQL (Hibernate Query Language) at hindi maintindihan ng ideya kung tama ba ang lahat o may error. Maaari kang pumunta sa mga setting ng ideya at manu-manong ayusin ang lahat (tumingin sa Internet kung interesado). O maaari ka lamang magdagdag ng suporta para sa Hibernate framework, upang gawin ito, i-right click sa proyekto, piliin ang Magdagdag ng Suporta sa Framework , lagyan ng check ang kahon para sa Hibernate at i-click ang OK. Pagkatapos nito, malamang sa klase ng entity ( Film) maraming bagay ang sasalungguhitan din ng pula, halimbawa, kung saan @Table(name = "films")maglalabas ang anotasyon ng babalang Cannot resolve table 'films' . Muli, walang mali dito, hindi ito isang error sa disenyo, lahat ay mag-compile at gagana. Ang ideya ay binibigyang-diin dahil wala itong nalalaman tungkol sa aming batayan. Upang ayusin ito, isama natin ang ideya sa database. View -> Tool Windows -> Persistense (magbubukas ang isang tab) -> kanang pindutan ng mouse, piliin ang Magtalaga ng Mga Pinagmulan ng Data -> sa Data Source, tukuyin ang koneksyon sa database at i-click ang OK . Panimula sa Maven, Spring, MySQL, Hibernate at ang unang CRUD application (part 3) - 3

Panimula sa Maven, Spring, MySQL, Hibernate at ang unang CRUD application (part 3) - 3

Nang maayos na ang lahat ng ito, may natitira pa. Pumunta tayo sa mas mataas na antas, sa serbisyo. Sa klase, FilmServiceImplminarkahan namin ang allFilmspamamaraan ng tagsibol ng isang anotasyon @Transactional, na magsasaad na ang pamamaraan ay dapat isagawa sa isang transaksyon (nang wala ito, ang Hibernate ay tumangging gumana):

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

Kaya, handa na ang lahat dito, hindi mo kailangang hawakan ang anumang bagay sa controller. Well, mukhang dumating na ang sandali ng katotohanan, i-click ang Run at tingnan kung ano ang mangyayari. Panimula sa Maven, Spring, MySQL, Hibernate at ang unang CRUD application (part 3) - 4

Panimula sa Maven, Spring, MySQL, Hibernate at ang unang CRUD application (part 3) - 4

At narito, ang aming tanda, at sa pagkakataong ito ay nakuha ito hindi mula sa isang listahan na ginawa namin mismo sa klase, ngunit mula sa isang database. Mahusay, tila gumagana ang lahat. Ngayon ginagawa namin ang lahat ng iba pang operasyon ng CRUD sa parehong paraan gamit ang mga pamamaraan ng session. Ang resultang klase ay ganito ang hitsura:

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

Ngayon ang natitira na lang ay huwag kalimutang pumunta sa serbisyo at magdagdag ng anotasyon sa mga pamamaraan @Transactional. Ayan, handa na. Maaari ka na ngayong tumakbo at suriin. I-click ang mga link at button, subukang magdagdag/magtanggal/mag-edit ng mga entry. Kung ang lahat ay ginawa nang tama, dapat itong gumana. Ngayon ito ay isang ganap na CRUD application gamit ang Hibernate, Spring, MySQL. Itutuloy... Ipinapakilala ang Maven, Spring, MySQL, Hibernate at ang unang CRUD application (part 1) Introducing Maven, Spring, MySQL, Hibernate at ang unang CRUD application (part 2) Introducing Maven, Spring, MySQL, Hibernate at ang unang CRUD application (bahagi 3) Panimula sa Maven, Spring, MySQL, Hibernate at ang unang CRUD application (bahagi 4)

Mga komento

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