Kjører Spring Boot med PostgreSQL i Docker Compose

1. Introduksjon

I denne opplæringen ønsker vi å kjøre en Spring Boot-applikasjon med den populære open source-databasen PostgreSQL. I en tidligere artikkel, vi så på Docker Compose for å håndtere flere containere samtidig. Så i stedet for å installere PostgreSQL som et eget program, vi bruker Docker Compose til å kjøre Spring Boot og PostgreSQL.

2. Opprette Spring Boot Project

La oss gå til Spring Initializer og lage vårt Spring Boot-prosjekt. Vi legger til PostgreSQL Driver og Vårdata JPA moduler. Etter at vi har lastet ned den resulterende ZIP-filen og hentet den til en mappe, kan vi kjøre den nye applikasjonen:

./mvnw spring-boot: run

Søknaden mislykkes fordi den ikke kan koble til databasen:

*************************** SØKNAD KAN IKKE STARTE ****************** ******** Beskrivelse: Kunne ikke konfigurere en DataSource: 'url' attributt er ikke spesifisert, og ingen innebygd datakilde kan konfigureres. Årsak: Kunne ikke bestemme en passende førerklasse 

3. Dockerfil

Før vi kan starte PostgreSQL med Docker Compose, vi trenger å gjøre vår Spring Boot-applikasjon til et Docker-bilde. Det første trinnet er å pakke applikasjonen som en JAR-fil:

./mvnw ren pakke -DskipTests

Her renser vi først opp våre tidligere bygninger før vi pakker applikasjonen. I tillegg hopper vi over testene fordi de mislykkes uten PostgreSQL.

Vi har nå en applikasjons-JAR-fil i mål katalog. Denne filen har prosjektnavnet og versjonsnummeret i navnet og ender med -SNAPSHOT.jar. Så navnet kan være docker-spring-boot-postgres-0.0.1-SNAPSHOT.jar.

La oss lage det nye src / main / docker katalog. Etter det kopierer vi JAR-filen der:

cp target / docker-spring-boot-postgres-0.0.1-SNAPSHOT.jar src / main / docker

Til slutt lager vi dette Dockerfil i den samme katalogen:

FRA adoptopenjdk: 11-jre-hotspot ARG JAR_FILE = *. Jar KOPIER $ {JAR_FILE} application.jar ENTRYPOINT ["java", "-jar", "application.jar"]

Denne filen beskriver hvordan Docker skal kjøre vår Spring Boot-applikasjon. Den bruker Java 11 fra AdoptOpenJDK og kopierer applikasjons-JAR-filen til application.jar. Den kjører deretter JAR-filen for å starte vår Spring Boot-applikasjon.

4. Docker komponere fil

La oss nå skrive vår Docker Compose-fil, docker-compose.yml, og lagre den på src / main / docker:

versjon: '2' tjenester: app: image: 'docker-spring-boot-postgres: latest' build: context:. container_name: app avhenger av: - db-miljø: - SPRING_DATASOURCE_URL = jdbc: postgresql: // db: 5432 / compose-postgres - SPRING_DATASOURCE_USERNAME = compose-postgres - SPRING_DATASOURCE_PASSWORD = compose-postgres_DATE_DATE: alpine 'container_name: db-miljø: - POSTGRES_USER = skriv-postgres - POSTGRES_PASSWORD = skriv-postgres

Søknaden vår heter app. Det er den første av to tjenester (linje 4-15):

  • Spring Boot Docker-bildet har navnet docker-spring-boot-postgres: siste (linje 5). Docker bygger det bildet fra Dockerfil i den gjeldende katalogen (linje 6-7)
  • Beholdernavnet er app (linje 8). Det kommer an på db tjeneste (linje 10). Derfor starter det etter db container
  • Vår applikasjon bruker db PostgreSQL container som datakilde (linje 12). Databasenavnet, brukernavnet og passordet er alle komponere-postgres (linje 12-14)
  • Dvalemodus oppretter eller oppdaterer automatisk alle databasetabeller som trengs (linje 15)

PostgreSQL-databasen har navnet db og er den andre tjenesten (linje 17-22):

  • Vi bruker PostgreSQL 13.1 (linje 18)
  • Beholdernavnet er db (linje 19)
  • Brukernavnet og passordet er begge komponere-postgres (linje 21-22)

5. Kjører med Docker Compose

La oss kjøre vår Spring Boot-applikasjon og PostgreSQL med Docker Compose:

docker-komponere opp

For det første vil dette bygge Docker Image for Spring Boot-applikasjonen. Deretter starter den en PostgreSQL-container. Endelig vil den starte applikasjonen Docker image. Denne gangen går søknaden vår bra:

Starter DemoApplication v0.0.1-SNAPSHOT ved hjelp av Java 11.0.9 på f94e79a2c9fc med PID 1 (/application.jar startet av root i /) [...] Ferdig skanning av Spring Data repository på 28 ms. Fant 0 JPA repository grensesnitt. [...] Startet DemoApplication på 4,751 sekunder (JVM kjører i 6,512)

Som vi kan se, fant Spring Data ikke noe lagringsgrensesnitt. Det er riktig - vi opprettet ikke en enda!

Hvis vi vil stoppe alle containere, må vi først trykke på [Ctrl-C]. Da kan vi stoppe Docker Compose:

docker-komponer ned

6. Opprette en kundeenhet og et lager

For å bruke PostgreSQL-databasen i applikasjonen vår, vi oppretter en enkel kundeenhet:

@Entity @Table (name = "customer") offentlig klasse kunde {@Id @GeneratedValue privat lang id; @Column (name = "first_name", nullable = false) private String firstName; @Column (name = "last_name", nullable = false) private String etternavn;

De Kunde har en generert id attributt og to obligatoriske attributter: fornavn og etternavn.

Nå, vi kan skrive depotgrensesnittet for denne enheten:

offentlig grensesnitt CustomerRepository utvider JpaRepository {}

Ved ganske enkelt å utvide JpaRepository, arver vi metoder for å lage og spørre Kunde enhet.

Til slutt bruker vi disse metodene i applikasjonen vår:

@SpringBootApplication offentlig klasse DemoApplication {@Autowired private CustomerRepository repository; @EventListener (ApplicationReadyEvent.class) public void runAfterStartup () {List allCustomers = this.repository.findAll (); logger.info ("Antall kunder:" + allCustomers.size ()); Kunde newCustomer = ny kunde (); newCustomer.setFirstName ("John"); newCustomer.setLastName ("Doe"); logger.info ("Lagrer ny kunde ..."); this.repository.save (newCustomer); allCustomers = this.repository.findAll (); logger.info ("Antall kunder:" + allCustomers.size ()); }}
  • Vi får tilgang til vårt Kunde depot gjennom avhengighetsinjeksjon
  • Vi spør etter antall eksisterende kunder med depotet - dette vil være null
  • Så oppretter og redder vi en kunde
  • Når vi deretter spørrer om eksisterende kunder igjen, forventer vi å finne den vi nettopp opprettet

7. Kjører med Docker Compose Again

For å kjøre den oppdaterte Spring Boot-applikasjonen, må vi bygge den om først. Derfor utfører vi disse kommandoene en gang til i prosjektets rotkatalog:

./mvnw ren pakke -DskipTests cp target / docker-spring-boot-postgres-0.0.1-SNAPSHOT.jar src / main / docker

Hvordan bygger vi Docker-bildet vårt på nytt med denne oppdaterte JAR-filen? Den beste måten er å fjerne det eksisterende Docker-bildet hvis navn vi spesifiserte i docker-compose.yml. Dette tvinger Docker til å bygge bildet igjen neste gang vi starter Docker Compose-filen:

cd src / main / docker docker-compose down docker rmi docker-spring-boot-postgres: siste docker-compose up

Så etter at vi har stoppet containerne, sletter vi applikasjonen Docker-image. Vi starter deretter Docker Compose-filen igjen, som bygger om applikasjonsbildet på nytt.

Her er applikasjonsutgangen:

Ferdig skanning av vår datalager på 180 ms. Fant 1 JPA repository grensesnitt. [...] Antall kunder: 0 Sparer ny kunde ... Antall kunder: 1

Spring Boot finner vårt tomme kundedepot. Derfor starter vi uten kunde, men oppretter deretter en vellykket.

8. Konklusjon

I denne korte opplæringen startet vi med å lage en Spring Boot-applikasjon for PostgreSQL. Deretter skrev vi en Docker Compose-fil for å kjøre applikasjonsbeholderen vår med en PostgreSQL-container.

Til slutt opprettet vi en kundeenhet og et lager, som tillot oss å lagre en kunde i PostgreSQL.

Som vanlig kan kildekoden for denne opplæringen bli funnet på GitHub.


$config[zx-auto] not found$config[zx-overlay] not found