Maven, Spring, MySQL, Hibernate 및 첫 번째 CRUD 애플리케이션 소개(3부)

좋은 오후에요. 이 기사에서는 간단한 CRUD 애플리케이션을 생성하는 과정에서 Maven, Spring, Hibernate, MySQL 및 Tomcat과 같은 것들을 처음 접한 내용을 공유하고 싶습니다. 이것은 4의 세 번째 부분입니다. 이 기사는 주로 여기에서 이미 30-40 레벨을 완료했지만 아직 순수 Java를 넘어서는 모험을 하지 않았고 이제 막 오픈 월드에 들어가기 시작하는(또는 곧 시작하려고 하는) 사람들을 위한 것입니다. 이 모든 기술, 프레임워크 및 기타 생소한 단어입니다. 이것은 "Maven, Spring, MySQL, Hibernate 및 첫 번째 CRUD 애플리케이션 소개" 기사의 세 번째 부분입니다. 이전 부분은 다음 링크를 통해 보실 수 있습니다.

• Maven, Spring, MySQL, Hibernate 및 첫 번째 CRUD 애플리케이션 소개(1부)
• Maven, Spring, MySQL, Hibernate 및 첫 번째 CRUD 애플리케이션 소개(2부)

콘텐츠:

• 데이터베이스 생성 및 연결
• ORM과 JPA
• 실재
• 최대 절전 모드 속성
• 최대 절전 모드 구성
• 데이터 액세스 계층

데이터베이스 생성 및 연결

이제 데이터베이스 작업을 시작할 시간입니다. Hibernate를 연결 하고 그것이 그곳에서 어떻게 작동해야 하는지 생각하기 전에 먼저 데이터베이스 자체를 살펴보겠습니다. 만들고, 연결하고, 만들고, 표지판을 채워봅시다. 우리는 DBMS(Database Management System) MySQL을 사용할 것입니다 (물론, 먼저 다운로드하여 설치해야 합니다). SQL (Structured Query Language)은 관계형 데이터베이스에서 데이터를 생성, 수정 및 조작하는 데 사용되는 선언적 프로그래밍 언어입니다. 이러한 데이터베이스에서는 데이터가 테이블 형식으로 저장됩니다. 애플리케이션은 어떻게 데이터베이스와 통신합니까(SQL 쿼리를 데이터베이스에 전송하고 결과를 반환)? 이를 위해 Java 에는 간단히 말해서 데이터베이스 작업을 위한 인터페이스 및 클래스 세트인 JDBC(Java DataBase Connectivity) 와 같은 것이 있습니다 . 데이터베이스와 상호 작용하려면 연결을 만들어야 합니다. 이를 위해 패키지에는 java.sql클래스가 있습니다 Connection. 연결을 설정하는 방법에는 여러 가지가 있습니다. 예를 들어 getConnection클래스 메서드를 사용할 수 있습니다 DriverManager. 그러나 데이터베이스가 많고 서로 다르기 때문에 데이터베이스와의 상호 작용이 직접 수행되지 않습니다. 따라서 각각에는 자체 JDBC 드라이버가 있으며, 이 드라이버를 사용하여 데이터베이스에 대한 연결이 설정됩니다. 그러므로 우선 나중에 이것 때문에 주의가 산만해지지 않도록 MySQL 드라이버를 설치해 봅시다 . 다음 종속성을 추가해 보겠습니다 pom.xml.

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

이제 데이터베이스를 만들어 보겠습니다. 보기 -> 도구 창 -> 데이터베이스 - 데이터베이스 패널이 열립니다. 새로 만들기(녹색 +) -> 데이터 소스 -> MySQL - 사용자 이름과 비밀번호를 지정해야 하는 창이 열립니다. MySQL을 설치할 때 설정했습니다(예: 루트와 루트를 사용했습니다). 포트(MySQL 3306의 기본값), 이름 등 그대로 두십시오. " 연결 테스트 " 버튼을 사용하여 연결을 테스트할 수 있습니다 . 확인을 클릭하면 이제 MySQL 서버에 연결됩니다. 다음으로 데이터베이스를 만들어 보겠습니다. 이렇게 하려면 열리는 콘솔에서 스크립트를 작성하면 됩니다.

CREATE DATABASE test

실행을 클릭하면 데이터베이스가 준비되었으며 이제 연결할 수 있습니다. 이렇게 하려면 데이터 소스 속성으로 돌아가서 데이터베이스 필드에 데이터베이스 이름(테스트)을 입력한 다음 사용자 이름과 비밀번호를 다시 입력하고 확인을 클릭하세요. 이제 테이블을 만들어야 합니다. 그래픽 도구를 사용할 수 있지만 처음으로 스크립트를 직접 작성하여 어떻게 보이는지 확인하는 것이 좋습니다.

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

films컬럼 등 의 이름으로 테이블이 생성됩니다 id. title각 열에 대해 유형이 표시됩니다(괄호 안의 최대 출력 크기).

• PRIMARY KEY- 테이블의 레코드를 고유하게 식별하는 데 사용되는 기본 키입니다(고유성을 의미함).
• AUTO_INCREMENT— 값이 자동으로 생성됩니다(물론 0이 아니므로 이를 지정할 필요가 없습니다).
• NOT NULL-여기서 모든 것이 분명하므로 비워둘 수 없습니다.
• DEFAULT— 기본값을 설정합니다
• COLLATE- 인코딩
• CREATE UNIQUE INDEX— 필드를 고유하게 만듭니다.
• INSERT INTO— 테이블에 레코드 추가

결과는 다음과 같은 신호입니다. 아마도 지금은 웹 애플리케이션과 별도로 연결해 볼 가치가 있을 것입니다. 이에 대해 문제가 발생하면 즉시 해결해 드리겠습니다. 그렇지 않으면 나중에 우리는 Hibernate 에 연결 하고, 무언가를 하고, 구성하고, 수정하고, 어딘가에서 엉망이 되어도 적어도 문제가 여기에 없다는 것을 알게 될 것입니다. 자, 연결을 확인하기 위해 일시적으로 메서드를 만들어 보겠습니다 main. 원칙적으로는 컨트롤러 클래스, 모델이나 구성 등 어디에든 넣을 수 있습니다. 상관없습니다. 연결에 문제가 없는지 확인하고 삭제할 수 있습니다. 하지만 좀 더 조심하기 위해 별도의 클래스를 만들어 보겠습니다 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();
        }
    }
}

여기서는 모든 것이 간단합니다. 데이터베이스에 연결 매개변수를 설정하고 연결을 생성해 봅니다. 이것을 실행 main하고 살펴보겠습니다. 따라서 예외, 일부 시간대 문제 및 SSL에 대한 기타 경고가 발생했습니다. 인터넷을 탐색한 후에는 이것이 상당히 일반적인 문제라는 것을 알 수 있으며, 다른 버전의 드라이버(mysql-connector-java)를 사용할 때 다르게 표시될 수 있습니다. 예를 들어 5.1.47 버전을 사용하면 시간대에 따른 예외가 없고 정상적으로 연결이 생성되는데 SSL 경고가 계속 뜨는 것을 실험적으로 알아냈습니다. 일부 다른 버전에서는 단순한 경고가 아닌 SSL과 관련된 예외가 있는 것 같았습니다. 좋아, 그게 요점이 아니야. 이 문제를 별도로 처리할 수 있지만 지금은 다루지 않겠습니다. 이에 대한 해결책은 매우 간단합니다. 문제가 시간대에 있고 SSL에 문제가 있는 경우 url 에 추가 매개변수 , 즉 를 지정해야 합니다 .serverTimezoneuseSSL

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

이제 시간대를 설정하고 SSL을 비활성화했습니다. 다시 실행해 봤습니다 main. 짜잔! 연결이 성공했습니다! 좋습니다. 연결을 만드는 방법을 알아냈습니다. 클래스가 Main기본적으로 작업을 완료했으므로 삭제할 수 있습니다.

ORM과 JPA

좋은 의미에서는 더 나은 이해를 위해 최대 절전 모드 및 기타 작업 없이 처음부터 데이터베이스에 대해 순서대로 익히는 것이 좋습니다. 따라서 몇 가지 가이드를 찾아 먼저 JDBC 클래스 작업을 시도하고 SQL 쿼리를 수동으로 작성하는 등의 작업을 수행하는 것이 좋습니다. 자, 바로 ORM 모델 로 넘어가겠습니다 . 이것은 무엇을 의미 하는가? 물론 이에 대해서는 별도로 읽어 보는 것이 좋지만 간략하게 설명하겠습니다. ORM (Object-Relational Mapping 또는 Object-Relational Mapping)은 객체를 관계형 데이터베이스 구조로 매핑하는 기술입니다. Java 객체를 테이블 행으로 표현합니다. ORM 덕분에 SQL 스크립트 작성에 대해 걱정할 필요가 없고 개체 작업에 집중할 수 있습니다. 사용 방법. Java에는 ORM 개념을 구현하는 또 다른 뛰어난 기능인 JPA(Java Persistence API)가 있습니다. JPA는 그러한 사양으로서 객체에 대한 요구 사항을 설명하고 데이터베이스 작업을 위한 다양한 인터페이스와 주석을 정의합니다. JPA는 본질적으로 설명이자 표준입니다. 따라서 많은 특정 구현이 있으며 그 중 하나(그리고 가장 인기 있는 것 중 하나)는 이 프레임워크의 핵심인 Hibernate입니다. Hibernate는 ORM(객체 관계형 매핑) 문제를 해결하도록 설계된 JPA 사양의 구현입니다. 우리는 이 모든 것을 우리 프로젝트에 연결해야 합니다. 또한 Spring이 방관하지 않고 데이터베이스를 통한 이 모든 움직임에 참여하지 않으려면 몇 가지 모듈을 더 연결해야 합니다. spring-webmvc 종속성 에서 얻은 모든 것만으로는 더 이상 충분하지 않습니다. 또한 데이터베이스와 작업하려면 spring-jdbc가 필요 하고, 트랜잭션을 지원하려면 spring-tx가 필요 하며 , Hibernate와 작업하려면 spring-orm이 필요합니다. 다음에 종속성을 추가해 보겠습니다 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>

이 두 가지 종속성으로 충분합니다. hibernate-core , spring-jdbc 및 spring-tx 와 함께 spring-ormjavax.persistence-api 과 함께 도착합니다 .

실재

그래서 우리는 클래스 객체가 Film데이터베이스에 저장될 수 있기를 원합니다. 이를 위해서는 클래스가 여러 가지 조건을 충족해야 합니다. JPA에는 이를 위한 엔터티 와 같은 것이 있습니다 . 엔터티 클래스는 개인 필드와 getter 및 setter가 있는 일반 POJO 클래스입니다. 매개변수가 없는 비공개 생성자(또는 기본 생성자)가 있어야 하며 기본 키가 있어야 합니다. 데이터베이스에서 이 클래스의 각 레코드를 고유하게 식별하는 것입니다. 해당 수업에 대한 모든 요구 사항을 별도로 읽을 수도 있습니다. FilmJPA 주석을 사용하여 클래스를 엔터티로 만들어 보겠습니다 .

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- 이 클래스가 엔터티임을 나타냅니다.
• @Table- 이 엔터티를 표시하기 위해 특정 테이블을 가리킵니다.
• @Id— 이 필드가 기본 키임을 나타냅니다. 이 속성은 각 고유 항목을 식별하는 데 사용됩니다.
• @Column— 필드를 테이블 열에 연결합니다. 필드와 테이블의 컬럼 이름이 동일할 경우 생략 가능합니다.
• @GeneratedValue— 속성이 자동으로 생성되며 괄호 안에 방법을 지정할 수 있습니다. 이제 우리는 서로 다른 전략이 정확히 어떻게 작동하는지 이해하지 못할 것입니다. 이 경우 각각의 새로운 값은 이전 값보다 1씩 증가한다는 것을 아는 것으로 충분합니다.

각 속성에 대해 0이 아니거나 고유해야 하는 항목, 기본값, 최대 크기 등을 지정하는 등 다양한 항목을 추가로 지정할 수 있습니다. 이것은 이 클래스를 기반으로 테이블을 생성해야 하는 경우 유용할 것입니다; Hibernate에는 이 옵션이 있습니다. 하지만 우리는 이미 테이블을 직접 만들고 모든 속성을 구성했으므로 테이블 없이도 작업을 수행할 수 있습니다. 작은 메모.Hibernate 문서에서는 필드가 아닌 getter에서 주석을 사용하도록 권장합니다. 그러나 이러한 접근 방식 간의 차이는 매우 미묘하며 간단한 응용 프로그램에서는 아무런 효과가 없습니다. 게다가 대부분의 사람들은 어쨌든 필드 위에 주석을 넣습니다. 그러니 이대로 놔두자, 더 깔끔해 보인다.

최대 절전 모드 속성

이제 Hibernate 설정을 시작하겠습니다. 그리고 먼저 사용자 이름과 비밀번호, URL 등의 정보를 별도의 파일에 넣어 보겠습니다. 물론 연결을 확인할 때와 마찬가지로 클래스에서 직접 일반 줄로 지정할 수 있습니다( String username = "root";그런 다음 연결을 생성하는 메서드에 전달했습니다). 그러나 이러한 정적 데이터를 일부 파일에 저장하는 것이 여전히 더 정확합니다 property. 예를 들어 데이터베이스를 변경해야 하는 경우 모든 클래스를 살펴보고 해당 클래스가 사용되는 위치를 찾을 필요가 없으며 이 파일의 값을 한 번만 변경하면 충분합니다. 리소스 디렉터리 에 db.properties 파일을 생성해 보겠습니다 .

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

글쎄, 위에서 데이터베이스에 연결하기 위한 매개변수 등 모든 것이 명확합니다. 드라이버 클래스 이름, URL, 사용자 이름 및 비밀번호. hibernate.dialect- 이 속성은 어떤 특정 버전의 SQL 언어가 사용되는지를 Hibernate에 나타내기 위해 필요합니다. 사실 모든 DBMS에서는 기능을 확장하거나 기능을 추가하거나 최적화하기 위해 일반적으로 언어를 약간 현대화합니다. 결과적으로 각 DBMS에는 고유한 SQL 언어가 있는 것으로 나타났습니다. 영어와 마찬가지로 언어도 같은 것 같지만 호주, 미국, 영국에서는 약간 다르며 일부 단어의 의미가 다를 수 있습니다. 그리고 이해에 따른 어떤 문제도 피하기 위해, 당신은 Hibernate가 정확히 무엇을 다루어야 하는지 직접적으로 알려줄 필요가 있습니다. hibernate.show_sql— 이 속성 덕분에 데이터베이스에 대한 쿼리가 콘솔에 표시됩니다. 이것은 꼭 필요한 것은 아니지만 이것으로 적어도 무슨 일이 일어나고 있는지 볼 수 있습니다. 그렇지 않으면 Hibernate가 일종의 마술을 하고 있는 것처럼 보일 수 있습니다. 물론, 표시하는 것이 완전히 명확하지는 않을 것입니다. 이를 위해 일종의 로거를 사용하는 것이 더 좋지만 그것은 나중에 할 일이므로 지금은 그렇게 할 것입니다.

최대 절전 모드 구성

구성 설정으로 넘어 갑시다. 패키지에 config클래스를 생성해 보겠습니다 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;
    }
}

여기에는 새로운 내용이 많이 있으므로 다양한 소스에서 각 항목에 대한 정보를 추가로 찾는 것이 가장 좋습니다. 여기서는 간략하게 살펴보겠습니다.

• 우리는 수업을 들을 때 @Configuration이미 알아냈습니다 .@ComponentScanWebConfig
• @EnableTransactionManagement— 이를 사용하여 TransactionManager거래를 관리할 수 있습니다. Hibernate는 트랜잭션을 사용하여 데이터베이스와 작동하며 특정 작업 집합이 단일 전체로 수행되는 데 필요합니다. 방법이 하나의 작업에 문제가 있으면 다른 모든 작업은 실행되지 않으므로 한 계정에서 돈을 인출하는 작업이 완료되었을 때 돈 이체의 고전적인 예와 같이 발생하지 않지만 다른 사람에게 쓰는 작업이 작동하지 않아 돈이 사라졌습니다.
• @PropertySource— 최근에 생성한 속성 파일을 연결합니다.
• Environmentproperty- 파일 에서 속성을 가져오기 위해 .
• hibernateProperties- 이 메소드는 Hibernate 속성을 Properties 객체로 표현하는 데 필요합니다.
• DataSource— 데이터베이스에 대한 연결을 생성하는 데 사용됩니다. 이는 앞서 .dll 파일을 만들 때 사용한 DriverManager 의 대안입니다 main. 문서에는 어느 DataSource것이 더 나은지 나와 있습니다. 물론, 인터넷에서 차이점과 장점이 무엇인지 읽는 것을 잊지 말고 우리가 할 일입니다. 특히 한 가지 이점은 데이터베이스 연결 풀(DBCP)을 생성할 수 있다는 것입니다.
• sessionFactory— 엔터티 객체에 대한 작업이 수행되는 세션을 생성합니다. 여기서 우리는 데이터 소스, Hibernate 속성 및 엔터티 클래스를 찾아야 하는 패키지를 설정합니다.
• transactionManager— 트랜잭션 관리자를 구성합니다.

에 대한 작은 메모입니다 DataSource. 문서에 따르면 표준 구현, 즉 를 사용하는 DriverManagerDataSource것은 권장되지 않습니다. 이는 일반 연결 풀링을 대체할 뿐이며 일반적으로 테스트 등에 적합합니다. 일반적인 애플리케이션의 경우 일종의 DBCP 라이브러리를 사용하는 것이 좋습니다. 물론 우리의 애플리케이션에는 우리가 가지고 있는 것만으로도 충분하지만 그림을 완성하려면 아마도 조언에 따라 다른 구현을 계속 사용할 것입니다. 다음 종속성을 추가해 보겠습니다 pom.xml.

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

그리고 dataSource클래스 메소드에서는 이를 패키지의 메소드 로 HibernateConfig대체합니다 . DriverManagerDataSourceBasicDataSourceorg.apache.tomcat.dbcp.dbcp2

BasicDataSource dataSource = new BasicDataSource();

이제 모든 것이 준비된 것 같습니다. 구성도 준비되었습니다. 남은 것은 이를 AppInitializer에 추가하는 것 뿐입니다 .

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

데이터 액세스 계층

드디어 DAO를 시작할 시간입니다. 우리는 수업에 가서 FilmDAOImpl먼저 거기에서 시험 목록을 삭제하므로 더 이상 필요하지 않습니다. 세션 팩토리를 추가하고 작업해 보겠습니다.

private SessionFactory sessionFactory;

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

우선, 영화 목록이 포함된 페이지를 표시하는 방법을 만듭니다. 그 안에서 세션을 수신하고 데이터베이스에 요청합니다(모든 기록을 꺼내고 목록 작성).

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

여기에는 2개의 포인트가 있습니다. 먼저 경고가 표시되었습니다. 이는 우리가 매개변수화된 을 수신하려고 하지만 컴파일 타임에 요청이 어떤 유형을 반환할지 알 수 없기 때문에 List<Film>메서드가 반환된다는 사실 때문입니다. List따라서 이 아이디어는 우리가 안전하지 않은 변환을 수행하고 있으며 이로 인해 문제가 발생할 수 있음을 경고합니다. 그러한 질문이 발생하지 않도록 이를 수행하는 몇 가지 올바른 방법이 더 있습니다. 인터넷에서 정보를 검색할 수 있습니다. 하지만 지금은 이것에 신경쓰지 말자. 사실 우리는 어떤 유형이 반환될지 정확히 알고 있으므로 여기서는 문제가 발생하지 않으며 경고를 무시하면 됩니다. 그러나 눈이 거슬리지 않도록 메소드 위에 주석을 걸 수 있습니다 @SupressWarning("unchecked"). 이렇게 함으로써 우리는 컴파일러에게 걱정해 주셔서 감사합니다. 하지만 나는 내가 무엇을 하고 있는지 알고 있고 모든 것을 통제할 수 있으므로 이 방법에 대해 걱정하지 말고 긴장을 풀 수 있다고 말합니다. 둘째, 아이디어에 빨간색 " from Film" 밑줄이 그어져 있습니다. 이는 단지 HQL(Hibernate Query Language) 쿼리일 뿐이며 아이디어는 모든 것이 올바른지 또는 오류가 있는지 이해하지 못합니다. 아이디어 설정으로 이동하여 모든 것을 수동으로 조정할 수 있습니다(관심이 있으면 인터넷을 찾아보세요). 또는 간단히 Hibernate 프레임워크에 대한 지원을 추가할 수 있습니다. 이렇게 하려면 프로젝트를 마우스 오른쪽 버튼으로 클릭하고 Add Framework Support를 선택한 다음 Hibernate 확인란을 선택 하고 확인을 클릭하세요. 그 후에는 엔터티 클래스( Film)에서 많은 항목에 빨간색 밑줄이 표시될 가능성이 높습니다. 예를 들어 주석은 'films' 테이블을 확인할 수 없다는@Table(name = "films") 경고를 발행합니다 . 다시 말하지만 여기에는 잘못된 것이 없습니다. 이는 설계 오류가 아니며 모든 것이 컴파일되고 작동합니다. 이 아이디어는 우리 기지에 대해 아무것도 모르기 때문에 강조됩니다. 이 문제를 해결하기 위해 아이디어를 데이터베이스와 통합해 보겠습니다. 보기 -> 도구 창 -> 지속성 (탭이 열림) -> 마우스 오른쪽 버튼을 클릭하고 데이터 소스 할당 -> 데이터 소스에서 데이터베이스에 대한 연결을 지정 하고 확인을 클릭합니다 . 이 모든 것이 고쳐졌을 때, 아직 뭔가가 남아 있었습니다. 더 높은 수준의 서비스로 가자. 클래스에서 우리는 메소드가 트랜잭션에서 실행되어야 함을 나타내는 주석으로 spring 메소드를 표시합니다(이것이 없으면 Hibernate는 작동을 거부합니다):FilmServiceImplallFilms@Transactional

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

이제 모든 것이 준비되었으므로 컨트롤러에서 아무 것도 만질 필요가 없습니다. 이제 진실의 순간이 온 것 같습니다. 실행을 클릭 하고 무슨 일이 일어나는지 확인하세요. 그리고 여기에 우리의 사인이 있습니다. 이번에는 우리가 수업 시간에 직접 만든 목록이 아니라 데이터베이스에서 얻은 것입니다. 좋습니다. 모든 것이 제대로 작동하는 것 같습니다. 이제 세션 메서드를 사용하여 동일한 방식으로 다른 모든 CRUD 작업을 수행합니다. 결과 클래스는 다음과 같습니다.

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

이제 남은 것은 서비스로 이동하여 메소드에 주석을 추가하는 것입니다 @Transactional. 그게 다야, 준비 됐어. 이제 실행하여 확인할 수 있습니다. 링크와 버튼을 클릭하고 항목을 추가/삭제/편집해 보세요. 모든 것이 올바르게 수행되면 제대로 작동할 것입니다. 이제 이것은 Hibernate, Spring, MySQL을 사용하는 본격적인 CRUD 애플리케이션입니다. 계속하려면... Maven, Spring, MySQL, Hibernate 및 첫 번째 CRUD 애플리케이션 소개(1부) Maven, Spring, MySQL, Hibernate 및 첫 번째 CRUD 애플리케이션 소개(2부) Maven, Spring, MySQL, Hibernate 및 첫 번째 CRUD 애플리케이션 소개 첫 번째 CRUD 애플리케이션(3부) Maven, Spring, MySQL, Hibernate 및 첫 번째 CRUD 애플리케이션 소개(4부)