streamalism.org

1. Inleiding

In deze tutorial willen we een Spring Boot-applicatie draaien met de populaire open-source database PostgreSQL. In een vorig artikel, we hebben naar Docker Compose gekeken om meerdere containers tegelijk te verwerken. Dus in plaats van PostgreSQL als een aparte applicatie te installeren, we zullen Docker Compose gebruiken om Spring Boot en PostgreSQL uit te voeren.

2. Het Spring Boot-project maken

Laten we naar de Spring Initializer gaan en ons Spring Boot-project maken. We voegen de PostgreSQL-stuurprogramma en Spring Data JPA modules. Nadat we het resulterende ZIP-bestand hebben gedownload en in een map hebben uitgepakt, kunnen we onze nieuwe applicatie uitvoeren:

./mvnw spring-boot: run

De applicatie mislukt omdat het geen verbinding kan maken met de database:

*************************** AANVRAAG IS MISLUKT ********************************************************************************************************************************* ******** Beschrijving: Configuratie van een DataSource is mislukt: het kenmerk 'url' is niet opgegeven en er kan geen ingesloten gegevensbron worden geconfigureerd. Reden: kan geen geschikte stuurprogrammaklasse bepalen 

3. Dockerfile

Voordat we PostgreSQL kunnen starten met Docker Compose, we moeten onze Spring Boot-applicatie omzetten in een Docker-image. De eerste stap is om de applicatie te verpakken als een JAR-bestand:

./mvnw schoon pakket -DskipTests

Hier maken we eerst onze vorige builds schoon voordat we de applicatie verpakken. Bovendien slaan we de tests over omdat ze niet slagen zonder PostgreSQL.

We hebben nu een JAR-bestand voor toepassingen in het doelwit directory. Dat bestand heeft de projectnaam en het versienummer in de naam en eindigt op -SNAPSHOT.jar. Dus zijn naam zou kunnen zijn docker-spring-boot-postgres-0.0.1-SNAPSHOT.jar.

Laten we het nieuwe maken src / main / docker directory. Daarna kopiëren we het JAR-bestand van de applicatie daarheen:

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

Ten slotte creëren we dit Dockerfile in dezelfde directory:

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

Dit bestand beschrijft hoe Docker onze Spring Boot-applicatie moet draaien. Het gebruikt Java 11 van AdoptOpenJDK en kopieert het JAR-bestand van de applicatie naar application.jar. Vervolgens wordt dat JAR-bestand uitgevoerd om onze Spring Boot-applicatie te starten.

4. Docker Compose-bestand

Laten we nu ons Docker Compose-bestand schrijven, docker-compose.yml, en bewaar het in src / main / docker:

version: '2' services: app: image: 'docker-spring-boot-postgres: latest' build: context:. container_name: app afhankelijk_on: - db-omgeving: - SPRING_DATASOURCE_URL = jdbc: postgresql: // db: 5432 / compose-postgres - SPRING_DATASOURCE_USERNAME = compose-postgres - SPRING_DATASOURCE_PASSWORD_DATASOURCE_PASSWORD_ = update-postgres-postgres - afbeelding 13 alpine 'container_name: db omgeving: - POSTGRES_USER = compose-postgres - POSTGRES_PASSWORD = compose-postgres

De naam van onze applicatie is app. Het is de eerste van twee services (regels 4-15):

• De Spring Boot Docker-afbeelding heeft de naam docker-spring-boot-postgres: laatste (lijn 5). Docker bouwt die afbeelding op vanuit het Dockerfile in de huidige directory (regels 6-7)
• De containernaam is app (lijn 8). Het hangt af van de db service (lijn 10). Daarom begint het na de db container
• Onze applicatie maakt gebruik van de db PostgreSQL-container als de gegevensbron (regel 12). De databasenaam, de gebruikersnaam en het wachtwoord zijn allemaal compose-postgres (regels 12-14)
• Hibernate zal automatisch alle benodigde databasetabellen maken of bijwerken (regel 15)

De PostgreSQL-database heeft de naam db en is de tweede dienst (regels 17-22):

• We gebruiken PostgreSQL 13.1 (regel 18)
• De containernaam is db (lijn 19)
• De gebruikersnaam en het wachtwoord zijn beide compose-postgres (lijnen 21-22)

5. Hardlopen met Docker Compose

Laten we onze Spring Boot-applicatie en PostgreSQL uitvoeren met Docker Compose:

docker-compose

Ten eerste zal dit de Docker-afbeelding voor onze Spring Boot-applicatie bouwen. Vervolgens start het een PostgreSQL-container. Ten slotte zal het onze applicatie Docker-afbeelding starten. Deze keer werkt onze applicatie prima:

DemoApplication v0.0.1-SNAPSHOT starten met Java 11.0.9 op f94e79a2c9fc met PID 1 (/application.jar gestart door root in /) [...] Scannen van de Spring Data-opslagplaats in 28 ms voltooid. 0 JPA-repository-interfaces gevonden. [...] DemoApplication gestart in 4.751 seconden (JVM draait voor 6.512)

Zoals we kunnen zien, vond Spring Data geen repository-interface. Dat klopt - we hebben er nog geen gemaakt!

Als we alle containers willen stoppen, moeten we eerst op [Ctrl-C] drukken. Dan kunnen we Docker Compose stoppen:

docker-compose neer

6. Creëren van een klantentiteit en repository

Om de PostgreSQL-database in onze applicatie te gebruiken, we zullen een eenvoudige klantentiteit creëren:

@Entity @Table (name = "klant") openbare klasse Klant {@Id @GeneratedValue lange privé-ID; @Column (name = "first_name", nullable = false) private String firstName; @Column (name = "last_name", nullable = false) private String lastName;

De Klant heeft een gegenereerd ID kaart attribuut en twee verplichte attributen: Voornaam en achternaam.

Nu, we kunnen de repository-interface voor deze entiteit schrijven:

openbare interface CustomerRepository breidt JpaRepository {} uit

Door simpelweg uit te breiden JpaRepository, erven we methoden voor het maken en doorzoeken van onze Klant entiteit.

Ten slotte gebruiken we deze methoden in onze applicatie:

@SpringBootApplication openbare klasse DemoApplication {@Autowired privé CustomerRepository-repository; @EventListener (ApplicationReadyEvent.class) openbare ongeldige runAfterStartup () {Lijst allCustomers = this.repository.findAll (); logger.info ("Aantal klanten:" + allCustomers.size ()); Klant newCustomer = nieuwe klant (); newCustomer.setFirstName ("John"); newCustomer.setLastName ("Doe"); logger.info ("Nieuwe klant opslaan ..."); this.repository.save (nieuwe klant); allCustomers = this.repository.findAll (); logger.info ("Aantal klanten:" + allCustomers.size ()); }}

• We hebben toegang tot onze Klant repository via afhankelijkheidsinjectie
• We vragen het aantal bestaande klanten met de repository - dit is nul
• Vervolgens maken we een klant aan en slaan we deze op
• Als we vervolgens de bestaande klanten opnieuw ondervragen, verwachten we degene te vinden die we zojuist hebben gemaakt

7. Opnieuw uitvoeren met Docker Compose

Om de bijgewerkte Spring Boot-applicatie uit te voeren, moeten we deze opnieuw opbouwen eerste. Daarom voeren we deze opdrachten nogmaals uit in de hoofdmap van het project:

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

Hoe bouwen we onze Docker-image opnieuw op met dit bijgewerkte JAR-bestand van de applicatie? De beste manier is om de bestaande Docker-afbeelding te verwijderen waarvan we de naam hebben gespecificeerd in het docker-compose.yml. Dit dwingt Docker om de afbeelding opnieuw te bouwen de volgende keer dat we ons Docker Compose-bestand starten:

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

Dus nadat we onze containers hebben gestopt, verwijderen we de Docker-afbeelding van de applicatie. We starten dan ons Docker Compose-bestand opnieuw, dat de applicatie-image opnieuw opbouwt.

Hier is de applicatie-output:

Scannen van de Spring Data-opslagplaats voltooid in 180 ms. 1 JPA-repository-interfaces gevonden. [...] Aantal klanten: 0 Nieuwe klant redden ... Aantal klanten: 1

Spring Boot vindt onze lege klantenrepository. Daarom beginnen we zonder klant, maar maken we er met succes een aan.

8. Conclusie

In deze korte tutorial zijn we begonnen met het maken van een Spring Boot-applicatie voor PostgreSQL. Vervolgens hebben we een Docker Compose-bestand geschreven om onze applicatiecontainer uit te voeren met een PostgreSQL-container.

Ten slotte hebben we een klantentiteit en repository gemaakt, waardoor we een klant in PostgreSQL konden opslaan.

Zoals gewoonlijk is de broncode voor deze tutorial te vinden op GitHub.