streamalism.org

1. Úvod

V tomto tutoriále chceme spustiť aplikáciu Spring Boot s populárnou open-source databázou PostgreSQL. V predchádzajúcom článku pozreli sme sa na Docker Compose, aby sme zvládli viac kontajnerov naraz. Namiesto inštalácie PostgreSQL ako samostatnej aplikácie teda použijeme Docker Compose na spustenie Spring Boot a PostgreSQL.

2. Vytvorenie projektu Spring Boot

Poďme na Spring Initializer a vytvorme náš projekt Spring Boot. Pridáme Ovládač PostgreSQL a Jarné údaje JPA modulov. Po stiahnutí výsledného súboru ZIP a jeho rozbalení do priečinka môžeme spustiť našu novú aplikáciu:

./mvnw spring-boot: spustiť

Aplikácia zlyhá, pretože sa nemôže pripojiť k databáze:

**************************** APLIKÁCIA SA SPUSTILA ***************** ******** Popis: Nepodarilo sa nakonfigurovať zdroj údajov: atribút „url“ nie je zadaný a nemožno nakonfigurovať žiadny vložený zdroj údajov. Dôvod: Nepodarilo sa určiť vhodnú triedu vodiča 

3. Dockerfile

Skôr ako môžeme spustiť PostgreSQL s Docker Compose, musíme našu aplikáciu Spring Boot zmeniť na obrázok Dockeru. Prvým krokom je zabalenie aplikácie do súboru JAR:

./mvnw čistý balík -DskipTests

Tu najskôr vyčistíme naše predchádzajúce verzie pred zabalením aplikácie. Okrem toho preskakujeme testy, pretože bez PostgreSQL zlyhajú.

Teraz máme súbor JAR aplikácie v cieľ adresár. Tento súbor má v názve názov projektu a číslo verzie a končí sa -SNAPSHOT.jar. Takže jeho názov by mohol byť docker-spring-boot-postgres-0.0.1-SNAPSHOT.jar.

Poďme vyrobiť nový src / main / docker adresár. Potom tam skopírujeme súbor JAR aplikácie:

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

Nakoniec to vytvoríme Dockerfile v rovnakom adresári:

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

Tento súbor popisuje, ako by mal Docker spustiť našu aplikáciu Spring Boot. Používa Java 11 z AdoptOpenJDK a kopíruje súbor JAR aplikácie application.jar. Potom spustí tento súbor JAR a spustí našu aplikáciu Spring Boot.

4. Docker Compose File

Teraz napíšeme náš súbor Docker Compose, docker-compose.ymla uložiť do src / main / docker:

verzia: „2“ služby: aplikácia: obrázok: „docker-spring-boot-postgres: latest“ build: context:. container_name: app depends_on: - db environment: - SPRING_DATASOURCE_URL = jdbc: postgresql: // db: 5432 / compose-postgres - SPRING_DATASOURCE_USERNAME = compose-postgres - SPRING_DATASOURCE_PASSWORD = compose-postgres - SPRING_J__DATA: alpské 'container_name: db prostredie: - POSTGRES_USER = compose-postgres - POSTGRES_PASSWORD = compose-postgres

Názov našej aplikácie je aplikácia Je to prvá z dvoch služieb (riadky 4-15):

• Obrázok Spring Boot Docker má názov docker-spring-boot-postgres: najnovšie (riadok 5). Docker vytvára tento obrázok z Dockerfile v aktuálnom adresári (riadky 6-7)
• Názov kontajnera je aplikácia (riadok 8). Závisí to od db služba (linka 10). Preto sa to začína po db kontajner
• Naša aplikácia používa db Kontajner PostgreSQL ako zdroj údajov (riadok 12). Názov databázy, meno používateľa a heslo sú všetky compose-postgres (riadky 12-14)
• Hibernate automaticky vytvorí alebo aktualizuje všetky potrebné databázové tabuľky (riadok 15)

Názov má databáza PostgreSQL db a je druhou službou (riadky 17-22):

• Používame PostgreSQL 13.1 (riadok 18)
• Názov kontajnera je db (riadok 19)
• Používateľské meno a heslo sú obe compose-postgres (riadky 21-22)

5. Beh s programom Docker Compose

Spustime našu aplikáciu Spring Boot a PostgreSQL s Docker Compose:

ukotviť-zložiť

Najskôr sa tým vytvorí obraz Docker pre našu aplikáciu Spring Boot. Ďalej spustí kontajner PostgreSQL. Nakoniec spustí našu aplikáciu Docker image. Tentokrát naša aplikácia funguje dobre:

Spustenie DemoApplication v0.0.1-SNAPSHOT pomocou Java 11.0.9 na f94e79a2c9fc s PID 1 (/application.jar spustený rootom v /) [...] Dokončenie skenovania jarných dátových úložísk za 28 ms. Našlo sa 0 rozhraní úložiska JPA. [...] Spustil DemoApplication za 4.751 sekúnd (JVM beží za 6.512)

Ako vidíme, Spring Data nenašli žiadne rozhranie úložiska. Je to správne - zatiaľ sme žiadny nevytvorili!

Ak chceme zastaviť všetky kontajnery, musíme najskôr stlačiť [Ctrl-C]. Potom môžeme Docker Compose zastaviť:

ukotviť-zložiť

6. Vytvorenie zákazníckej entity a úložiska

Ak chcete v našej aplikácii používať databázu PostgreSQL, vytvoríme jednoduchú entitu zákazníka:

@Entity @Table (name = "customer") verejná trieda Customer {@Id @GeneratedValue private long id; @Column (name = "first_name", nullable = false) private String firstName; @Column (name = "last_name", nullable = false) private String lastName;

The Zákazník má vygenerovaný id atribút a dva povinné atribúty: krstné meno a priezvisko.

Teraz, pre túto entitu môžeme napísať rozhranie úložiska:

verejné rozhranie CustomerRepository rozširuje JpaRepository {}

Jednoduchým predĺžením JpaRepository, dedíme metódy na vytváranie a dopytovanie našich Zákazník subjekt.

Nakoniec v našej aplikácii použijeme tieto metódy:

@SpringBootApplication verejná trieda DemoApplication {@Autowired súkromné ​​úložisko CustomerRepository; @EventListener (ApplicationReadyEvent.class) public void runAfterStartup () {List allCustomers = this.repository.findAll (); logger.info ("Počet zákazníkov:" + allCustomers.size ()); Customer newCustomer = new Customer (); newCustomer.setFirstName ("John"); newCustomer.setLastName ("Srnka"); logger.info ("Ukladanie nového zákazníka ..."); this.repository.save (newCustomer); allCustomers = this.repository.findAll (); logger.info ("Počet zákazníkov:" + allCustomers.size ()); }}

• Pristupujeme k nášmu Zákazník úložisko prostredníctvom vstrekovania závislostí
• Dotazujeme sa na počet existujúcich zákazníkov s úložiskom - toto bude nula
• Potom vytvoríme a zachránime zákazníka
• Keď potom znova zadáme dopyt existujúcim zákazníkom, očakávame, že nájdeme práve vytvoreného zákazníka

7. Beh s Docker Compose Again

Ak chcete spustiť aktualizovanú aplikáciu Spring Boot, musíme ju znova vytvoriť najprv. Preto tieto príkazy vykonáme ešte raz v koreňovom adresári projektu:

./mvnw čistý balík -DskipTests cieľ cp / docker-spring-boot-postgres-0.0.1-SNAPSHOT.jar src / main / docker

Ako obnovíme náš obraz Docker pomocou tohto aktualizovaného súboru JAR aplikácie? Najlepším spôsobom je odstrániť existujúci obrázok Dockeru, ktorého meno sme zadali v priečinku docker-compose.yml. To prinúti Dockera znovu vytvoriť obraz, keď nabudúce spustíme náš súbor Docker Compose:

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

Po zastavení našich kontajnerov teda odstránime obrázok aplikácie Docker. Potom znova spustíme náš súbor Docker Compose, ktorý znova vytvorí obraz aplikácie.

Tu je výstup aplikácie:

Skenovanie úložiska jarných údajov bolo dokončené za 180 ms. Nájdené 1 rozhrania úložiska JPA. [...] Počet zákazníkov: 0 Uloženie nového zákazníka ... Počet zákazníkov: 1

Spring Boot nájde naše prázdne úložisko zákazníkov. Preto začneme bez zákazníka, ale potom ho úspešne vytvoríme.

8. Záver

V tomto krátkom tutoriáli sme začali tvorbou aplikácie Spring Boot pre PostgreSQL. Ďalej sme napísali súbor Docker Compose na spustenie nášho aplikačného kontajnera s kontajnerom PostgreSQL.

Nakoniec sme vytvorili zákaznícku entitu a úložisko, ktoré nám umožnili uložiť zákazníka do PostgreSQL.

Ako obvykle, zdrojový kód tohto tutoriálu nájdete na GitHub.