La primavera non fa paura, ovvero come popolare un database h2 (e un po' di ibernazione)

CONTENUTI DEL CICLO DI ARTICOLI Continuiamo il nostro progetto. Come creare un progetto web. Colleghiamo il database al nostro progetto web . Questa volta ci saranno più lettere, non ce la faremo in cinque minuti. Nell'ultimo articolo, ti avevo consigliato di leggere diverse pagine o diversi articoli su Spring , o almeno cercare su Google cosa sono i bean, contesto, entità, inserimento delle dipendenze in Spring, modi per configurare i bean. In caso contrario, ti consiglio di farlo subito o dopo questo articolo. Prima di riempire la nostra base h2. È necessario creare una classe di utilità per eseguire metodi per riempire il database al suo interno. Nel pacchetto

ru.java.rush

Creazione di un pacchetto per le utilità

utils

E l'utilità stessa:

package ru.java.rush.utils;

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Service;

@Service //annotation помечает бин How сервис
public class InitiateUtils implements CommandLineRunner { //имплементируем интерфейс CommandLineRunner (командная строка запуска)

    @Override
//переопределяем метод который позволит
//нам выполнять методы нашего applications при запуске
    public void run(String... args) throws Exception {
        System.out.println("run"); //проверим что это работает
    }
}

Eseguiamo l'applicazione e nella console verrà visualizzato "esegui" . Abbiamo bisogno di questa utility come alternativa alla classe Applications, poiché dovrebbe essere responsabile solo dell'avvio dell'applicazione. Creiamo entità. Un'entità è un bean il cui scopo è archiviare alcuni dati. Nel pacchetto

ru.java.rush

Crea un pacchetto per le entità

entities

E l'essenza stessa, lascia che sia frutto:

package ru.java.rush.entities;

import org.hibernate.annotations.GenericGenerator;

import javax.persistence.*;

@Entity//помечаем бин How сущность
@Table(name = "fruit_table")//в этой аннотации можно указать Name создаваемой таблицы
public class FruitEntity {

    @Id//annotation из пакета avax.persistence.*, помечает поле How id
    @Column(name = "id_fruit")//в этой аннотации можно указать Name поля
    @GenericGenerator(name = "generator", strategy = "increment")//незаметно добрались до hibernate,
// здесь указывается что id будет автоматически увеличиваться при новых записях
    @GeneratedValue(generator = "generator")//annotation генерации id
    private Integer id;

    @Column(name = "fruit_name")
    private String fruitName;

    @Column(name = "provider_code")
    private Integer providerCode;

   //что бы в с классом можно было совершать манипуляции создается
  //пустой конструктор, геттеры, сеттеры и переопределяется метод toString()

  public FruitEntity(){ //пустой конструктор

 }

public Integer getId() {
    return id;
}

 //геттеры, сеттеры
public String getFruitName() {
    return fruitName;
}

public FruitEntity setFruitName(String fruitName) {
    this.fruitName = fruitName;
    return this;
}

public Integer getProviderCode() {
    return providerCode;
}

public FruitEntity setProviderCode(Integer providerCode) {
    this.providerCode = providerCode;
    return this;
}

//переопределяем toString()
@Override
public String toString() {
    return "FruitEntity{" +
            "id=" + id +
            ", fruitName='" + fruitName + '\'' +
            ", providerCode=" + providerCode +
            '}';
}
}

Il costruttore, i getter, i setter e toString() non devono essere scritti a mano; possono essere generati rapidamente . Ok, la nostra entità interagisce con il database e memorizza i dati dal database. L'essenza è al lavoro. Ma qualcuno deve gestire l'entità nell'applicazione. A questo scopo hanno creato un “repository”. Nel pacchetto

ru.java.rush

Creazione di un pacchetto per i repository

repositories

E il repository stesso

package ru.java.rush.repositories;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import ru.java.rush.entities.FruitEntity;

@Repository//помечаем что этот бин - репозиторий
public interface FruitRepository extends JpaRepository<FruitEntity,Integer> {
//репозиторий является интерфейсом, который наследуется от другого интерфейса JpaRepository<>
//для него необходимо указать с Howой сущность он должен работать, у нас это FruitEntity
//и тип данных у поля id данной сущности, у нас это Integer
}

La domanda è: perché il corpo dell'interfaccia è vuoto e non esiste un unico metodo che dichiara? Per rispondere, tieni premuto Ctrl e fai clic su JpaRepository e vedi che esso stesso eredita da PagingAndSortingRepository<t, ""> e QueryByExampleExecutor<>, dichiarano anche alcuni metodi. Non copierò i metodi qui; cerca tu stesso. Poiché il repository è un'interfaccia, non fa nulla, dichiara solo metodi, è necessario che qualcun altro implementi questi metodi. Per questo è stato inventato un “servizio”. Nel pacchetto

ru.java.rush

Creazione di un pacchetto di servizi

services

E il servizio stesso

package ru.java.rush.services;

import org.springframework.stereotype.Service;

@Service//помечаем что этот бин - сервис
public class FruitService {
}

Ora siamo arrivati ​​ad un punto importante: “Come e perché iniettare un bean” (iniettare una dipendenza). Se non capisci cosa intendo, allora ti chiedo di leggere su questo argomento, ora o più tardi, prestando particolare attenzione ai metodi di "iniezione", quanti ce ne sono, quale è meglio, quale è peggio e perché . Usiamo uno dei metodi. Abbiamo bisogno che il “servizio” sia in qualche modo connesso al “repository”. Integriamo il nostro servizio con un'annotazione e una variabile.

package ru.java.rush.services;

import org.springframework.stereotype.Service;
import ru.java.rush.repositories.FruitRepository;

@Service
public class FruitService {

    private final FruitRepository fruitRepository;  //final переменная репозитория

public FruitService(FruitRepository fruitRepository) {//внедрor зависимость через конструктор
    this.fruitRepository = fruitRepository;
}

}

Ora puoi implementare il metodo dal “repository” Integriamo il “servizio”

package ru.java.rush.services;

import org.springframework.stereotype.Service;
import ru.java.rush.entities.FruitEntity;
import ru.java.rush.repositories.FruitRepository;

@Service
public class FruitService {

    private final FruitRepository fruitRepository;

public FruitService(FruitRepository fruitRepository) {//внедor зависимость
    this.fruitRepository = fruitRepository;
}

//создали публичный метод (название любое может быть)
//на вход принимает сущность и сохраняет ее в базу
    public void save(FruitEntity fruitEntity){
        fruitRepository.save(fruitEntity); //реализовали метод внедренного бина
    }

//возвращает лист всех сущностей из базы
    public List<FruitEntity> getAll(){
       return fruitRepository.findAll(); //реализовали метод внедренного бина
    }
}

Non resta che implementare questo nella nostra utility.Passiamo alla classe InitiateUtils

package ru.java.rush.utils;


import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Service;
import ru.java.rush.entities.FruitEntity;
import ru.java.rush.services.FruitService;

import java.util.List;

@Service
public class InitiateUtils implements CommandLineRunner {

    private final FruitService fruitService;

public InitiateUtils (FruitService fruitService) {//незабываем конструктор для внедрения
    this. fruitService = fruitService;
}

    @Override
    public void run(String... args) throws Exception {

//создаем несколько сущностей фруктов, через сеттеры заполняем поля
        FruitEntity fruitEntity1 = new FruitEntity();
        fruitEntity1.setFruitName("fruit1");
        fruitEntity1.setProviderCode(1);

        FruitEntity fruitEntity2 = new FruitEntity();
        fruitEntity2.setFruitName("fruit2");
        fruitEntity2.setProviderCode(2);

        FruitEntity fruitEntity3 = new FruitEntity();
        fruitEntity3.setFruitName("fruit3");
        fruitEntity3.setProviderCode(3);

//с помощью переменной сервиса вызываем методы сохранения в базу, по разу для одного an object
        fruitService.save(fruitEntity1);
        fruitService.save(fruitEntity2);
        fruitService.save(fruitEntity3);

//здесь вытаскиваем базу обратно
        List<FruitEntity> all = fruitService.getAll();

//и выводим что получилось
        for (FruitEntity entity : all) {
            System.out.println(entity);
        }
    }
}

Output della console: FruitEntity(id=1, fruitName=fruit1, providerCode=1) FruitEntity(id=2, fruitName=fruit2, providerCode=2) FruitEntity(id=3, fruitName=fruit3, providerCode=3) Qui puoi finire . "Solo un secondo!" - esclamerà il lettore più attento - “Dov’è Hibernate comunque?” E Hibernate qui agisce come un combattente sul fronte invisibile; ha fatto una cosa molto importante: ha creato per noi strutture di database. Quando abbiamo scritto i campi nell'“entità” e li abbiamo contrassegnati con le annotazioni necessarie, Hibernate ha fatto il suo lavoro. Infatti, quando sviluppi al volo, difficilmente ti occuperai della struttura del database; tutto sarà già creato e distribuito per te. Ma in progetti così piccoli, Hibernate con la sua capacità di creare strutture di database semplicemente non può essere sostituito; ovviamente, questo non è il suo unico vantaggio, ad esempio, è bravo a creare entità correlate (non le useremo in questo progetto). Salutiamo questo umile lavoratore: andiamo su IDEA nella struttura del progetto (a sinistra c'è un albero con cartelle e file), lì troveremo Librerie esterne, apriamola e vediamola tra le altre librerie

Maven: org.hibernate.common:hibernate-commons-annotations:5.1.0.Final
Maven: org.hibernate.validator:hibernate-validator:6.0.17.Final
Maven: org.hibernate:hibernate-core:5.4.6.Final

In particolare, Hibernate è stato scaricato per noi da Maven e

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

In realtà il signor Hiber ha portato a termine un'altra operazione segreta, ma ne parleremo nel prossimo articolo. Questo è tutto certo adesso. Come esercizio di formazione, ti suggerisco di implementare tu stesso il metodo saveAll() per FruitEntity , che salverà tutte le entità nel database contemporaneamente. Successivamente, vediamo come abbreviare il codice del progetto utilizzando la libreria Lombok