streamalism.org

1. Introduktion

I denne vejledning ønsker vi at køre en Spring Boot-applikation med den populære open source-database PostgreSQL. I en tidligere artikel vi kiggede på Docker Compose for at håndtere flere containere på én gang. Så i stedet for at installere PostgreSQL som en separat applikation, vi bruger Docker Compose til at køre Spring Boot og PostgreSQL.

2. Oprettelse af Spring Boot Project

Lad os gå til Spring Initializer og oprette vores Spring Boot-projekt. Vi tilføjer PostgreSQL Driver og Spring Data JPA moduler. Når vi har downloadet den resulterende ZIP-fil og udpakket den til en mappe, kan vi køre vores nye applikation:

./mvnw spring-boot: kør

Applikationen mislykkes, fordi den ikke kan oprette forbindelse til databasen:

*************************** ANSØGNING MISLAGT AT STARTE ****************** ******** Beskrivelse: Kunne ikke konfigurere en DataSource: attributten 'url' er ikke angivet, og ingen integreret datakilde kunne konfigureres. Årsag: Kunne ikke bestemme en passende førerklasse 

3. Dockerfil

Før vi kan starte PostgreSQL med Docker Compose, vi er nødt til at gøre vores Spring Boot-applikation til et Docker-billede. Det første trin er at pakke applikationen som en JAR-fil:

./mvnw ren pakke -DskipTests

Her renser vi først vores tidligere builds, inden vi pakker applikationen. Derudover springer vi testene over, fordi de fejler uden PostgreSQL.

Vi har nu en JAR-applikationsfil i mål vejviser. Denne fil har projektnavnet og versionsnummeret i sit navn og slutter med -SNAPSHOT.jar. Så navnet kunne være docker-spring-boot-postgres-0.0.1-SNAPSHOT.jar.

Lad os lave det nye src / main / docker vejviser. Derefter kopierer vi applikations-JAR-filen der:

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

Endelig opretter vi dette Dockerfil i den samme mappe:

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

Denne fil beskriver, hvordan Docker skal køre vores Spring Boot-applikation. Det bruger Java 11 fra AdoptOpenJDK og kopierer applikationen JAR-fil til application.jar. Derefter kører den JAR-filen for at starte vores Spring Boot-applikation.

4. Docker komponere fil

Lad os nu skrive vores Docker Compose-fil, docker-compose.ymlog gem det i src / main / docker:

version: '2' tjenester: app: image: 'docker-spring-boot-postgres: seneste' build: kontekst:. containernavn: app afhænger af: - db-miljø: - SPRING_DATASOURCE_URL = jdbc: postgresql: // db: 5432 / compose-postgres - SPRING_DATASOURCE_USERNAME = compose-postgres - SPRING_DATASOURCE_PASSWORD = compose-postgres_HP_DATE: SPRING_DATASOURCE_PASWORD = alpine 'container_name: db-miljø: - POSTGRES_USER = compose-postgres - POSTGRES_PASSWORD = compose-postgres

Vores ansøgnings navn er app. Det er den første af to tjenester (linje 4-15):

• Spring Boot Docker-billedet har navnet docker-spring-boot-postgres: seneste (linje 5). Docker bygger dette billede fra Dockerfil i det aktuelle bibliotek (linje 6-7)
• Containernavnet er app (linje 8). Det afhænger af db service (linje 10). Derfor starter det efter db beholder
• Vores applikation bruger db PostgreSQL-container som datakilde (linje 12). Databasens navn, brugernavnet og adgangskoden er alle komponere-postgres (linje 12-14)
• Dvaletilstand opretter eller opdaterer automatisk de nødvendige databasetabeller (linje 15)

PostgreSQL-databasen har navnet db og er den anden service (linje 17-22):

• Vi bruger PostgreSQL 13.1 (linje 18)
• Containernavnet er db (linje 19)
• Brugernavnet og adgangskoden er begge komponere-postgres (linje 21-22)

5. Kører med Docker Compose

Lad os køre vores Spring Boot-applikation og PostgreSQL med Docker Compose:

docker-komponere op

For det første bygger dette Docker Image til vores Spring Boot-applikation. Dernæst starter den en PostgreSQL-container. Endelig vil det starte vores applikation Docker-billede. Denne gang kører vores ansøgning fint:

Starter DemoApplication v0.0.1-SNAPSHOT ved hjælp af Java 11.0.9 på f94e79a2c9fc med PID 1 (/application.jar startet med root i /) [...] Færdig Spring Data repository scanning i 28 ms. Fundet 0 JPA-lagergrænseflader. [...] Startede DemoApplication på 4.751 sekunder (JVM kørte i 6.512)

Som vi kan se, fandt Spring Data ingen lagergrænseflade. Det er korrekt - vi oprettede ikke en endnu!

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

docker-komponere ned

6. Oprettelse af en kundeenhed og et lager

For at bruge PostgreSQL-databasen i vores applikation, vi opretter en simpel kundeenhed:

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

Det Kunde har en genereret id attribut og to obligatoriske attributter: fornavn og efternavn.

Nu, vi kan skrive lagergrænsefladen til denne enhed:

offentlig grænseflade CustomerRepository udvider JpaRepository {}

Ved blot at udvide JpaRepository, arver vi metoder til oprettelse og forespørgsel på vores Kunde enhed.

Endelig bruger vi disse metoder i vores ansøgning:

@SpringBootApplication offentlig klasse DemoApplication {@Autowired privat CustomerRepository repository; @EventListener (ApplicationReadyEvent.class) public void runAfterStartup () {List allCustomers = this.repository.findAll (); logger.info ("Antal kunder:" + allCustomers.size ()); Kunde newCustomer = ny kunde (); newCustomer.setFirstName ("John"); newCustomer.setLastName ("Doe"); logger.info ("Gemmer ny kunde ..."); this.repository.save (newCustomer); allCustomers = this.repository.findAll (); logger.info ("Antal kunder:" + allCustomers.size ()); }}

• Vi får adgang til vores Kunde lager via afhængighedsinjektion
• Vi spørger antallet af eksisterende kunder med lageret - dette vil være nul
• Derefter opretter og gemmer vi en kunde
• Når vi derefter spørger de eksisterende kunder igen, forventer vi at finde den, vi lige har oprettet

7. Kører med Docker Compose Again

For at køre den opdaterede Spring Boot-applikation skal vi genopbygge den først. Derfor udfører vi disse kommandoer igen i projektets rodmappe:

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

Hvordan genopbygger vi vores Docker-billede med denne opdaterede JAR-fil? Den bedste måde er at fjerne det eksisterende Docker-billede, hvis navn vi har angivet i docker-compose.yml. Dette tvinger Docker til at oprette billedet igen, næste gang vi starter vores Docker Compose-fil:

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

Så efter at have stoppet vores containere, sletter vi applikationen Docker-billede. Vi starter derefter vores Docker Compose-fil igen, som genopbygger applikationsbilledet.

Her er applikationsoutput:

Færdig scanning af Spring Data Repository i 180 ms. Fundet 1 JPA-lagergrænseflader. [...] Antal kunder: 0 Gemmer ny kunde ... Antal kunder: 1

Spring Boot finder vores tomme kundelager. Derfor starter vi uden nogen kunde, men opretter derefter en kunde.

8. Konklusion

I denne korte vejledning startede vi med at oprette en Spring Boot-applikation til PostgreSQL. Dernæst skrev vi en Docker Compose-fil for at køre vores applikationscontainer med en PostgreSQL-container.

Endelig oprettede vi en kundeenhed og lager, som gjorde det muligt for os at gemme en kunde til PostgreSQL.

Som normalt kan kildekoden til denne tutorial findes på GitHub.