streamalism.org

1. Oversikt

I denne artikkelen tar vi en titt på hvordan du bruker Spring Boot med Hibernate.

Vi bygger et enkelt Spring Boot-program og ser hvor enkelt det er å integrere det med dvalemodus.

2. Bootstrapping av applikasjonen

Vi bruker Spring Initializr til å starte vår Spring Boot-applikasjon. For dette eksemplet bruker vi bare de nødvendige konfigurasjonene og avhengighetene for å integrere dvalemodus og legge til Internett, JPA, og H2 avhengigheter. Vi forklarer disse avhengighetene i neste avsnitt.

La oss generere prosjektet og åpne det i vår IDE. Vi kan sjekke den genererte prosjektstrukturen og identifisere konfigurasjonsfilene vi trenger.

Slik vil prosjektstrukturen se ut:

3. Maven-avhengigheter

Hvis vi åpner oss pom.xml, vi får se at vi har spring-boot-starter-web og vår-støvel-start-test som maven avhengigheter. Som navnene antyder, starter disse avhengighetene i Spring Boot.

La oss se raskt på avhengighet som trekker i JPA:

 org.springframework.boot spring-boot-starter-data-jpa 

Denne avhengigheten inkluderer JPA API, JPA Implementation, JDBC og andre nødvendige biblioteker. Siden standard JPA-implementering er dvalemodus, er denne avhengigheten faktisk nok til å bringe den inn også.

Til slutt vil vi bruke H2 som en veldig lett database for dette eksemplet:

 com.h2database h2 kjøretid 

Vi kan bruke H2-konsollen til å sjekke at DB er oppe og går, også for en brukervennlig brukergrensesnitt for datainnføringen. La oss gå videre og aktivere det application.properites:

spring.h2.console.enabled = true

Dette er alt vi trengte for å konfigurere å inkludere dvalemodus og H2 for vårt eksempel. Vi kan sjekke at konfigurasjonen var vellykket i loggene når vi startet Spring Boot-applikasjonen:

HHH000412: Hibernate Core {#Version}

HHH000206: hibernate.properties ikke funnet

HCANN000001: Hibernate Commons Annotations {#Version}

HHH000400: Bruker dialekt: org.hibernate.dialect.H2Dialect

Vi kan nå få tilgang til H2-konsollen på localhost: // localhost: 8080 / h2-konsoll /.

4. Opprette enheten

For å kontrollere at vår H2 fungerer som den skal, oppretter vi først en JPA-enhet i en ny modeller mappe:

@Entity public class Bestill {@Id @GeneratedValue private Lang id; privat strengnavn; // standard konstruktører // standard getters og setters}

Vi har nå en grunnleggende enhet, som H2 kan lage en tabell fra. Start programmet på nytt og sjekk H2-konsollen, en ny tabell kalt Bok vil bli opprettet.

For å legge til noen innledende data i applikasjonen vår, må vi opprette en ny SQL-fil, med noen innsettingsuttalelser og legge den i vår ressurser mappe. Vi kan bruke import.sql (Dvalemodus-støtte) eller data.sql (Spring JDBC support) filer for å laste inn data.

Her er våre eksempler på data:

sett inn i bokverdier (1, 'The Tartar Steppe'); sett inn i bokverdier (2, 'Poem Strip'); sett inn i bokverdier (3, 'Restless Nights: Selected Stories of Dino Buzzati');

Igjen kan vi starte Spring Boot-applikasjonen på nytt og sjekke H2-konsollen - dataene er nå i Bok bord.

5. Opprette lageret og tjenesten

Vi fortsetter å lage de grunnleggende komponentene for å teste søknaden vår. La oss først legge til JPA Repository i et nytt repositories mappe:

@Repository offentlig grensesnitt BookRepository utvider JpaRepository {}

Vi kan bruke JpaRepository grensesnitt fra Spring framework, som gir en standardimplementering for det grunnleggende CRUD operasjoner.

La oss deretter legge til BookService i en ny tjenester mappe:

@Service offentlig klasse BookService {@Autowired private BookRepository bookRepository; public List list () {return bookRepository.findAll (); }}

For å teste søknaden vår, må vi sjekke at dataene som er opprettet kan hentes fra liste() metoden for tjenesten.

Vi skriver følgende SpringBootTest:

@RunWith (SpringRunner.class) @SpringBootTest offentlig klasse BookServiceUnitTest {@Autowired private BookService bookService; @Test offentlig ugyldig nårApplicationStarts_thenHibernateCreatesInitialRecords () {List books = bookService.list (); Assert.assertEquals (books.size (), 3); }}

Ved å kjøre denne testen kan vi sjekke at dvalemodus oppretter Bok data som deretter hentes vellykket av tjenesten vår. Det var det, Hibernate kjører med Spring Boot.

6. Navn på store bokstaver

Noen ganger kan det hende vi trenger å ha tabellnavnene i databasen vår skrevet med store bokstaver. Som vi allerede vet, som standard vil dvalemodus generere navnene på tabellene med små bokstaver.

Vi kan også prøve å eksplisitt sette tabellnavnet, slik:

@Entity (name = "BOOK") public class Book {// medlemmer, standard getters og setters}

Det ville imidlertid ikke fungere. Det som fungerer er å sette denne eiendommen i application.properties:

spring.jpa.hibernate.naming.physical-strategy = org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl

Som et resultat kan vi sjekke i databasen vår at tabellene er opprettet med store bokstaver.

7. Konklusjon

I denne artikkelen så vi på hvor enkelt det er å integrere dvalemodus med Spring Boot. Vi brukte H2-databasen, som en veldig lett løsning i minnet.

Vi ga et fullstendig eksempel på en applikasjon som bruker alle disse teknologiene, og til slutt ga vi også et lite hint om hvordan du setter tabellnavnene i store bokstaver i databasen vår.

Som alltid kan alle kodebitene som er nevnt i denne artikkelen finnes på GitHub-depotet vårt.