streamalism.org

1. Bemutatkozás

Ebben az oktatóprogramban egy Spring Boot alkalmazást szeretnénk futtatni a népszerű nyílt forráskódú PostgreSQL adatbázissal. Egy előző cikkben megnéztük a Docker Compose-ot, hogy egyszerre több konténert kezeljünk. Tehát ahelyett, hogy a PostgreSQL-t külön alkalmazásként telepítené, a Docker Compose programot fogjuk használni a Spring Boot és a PostgreSQL futtatásához.

2. A tavaszi indító projekt létrehozása

Menjünk a Spring Initializer-hez, és készítsük el a Spring Boot projektünket. Hozzáadjuk a PostgreSQL illesztőprogram és Spring Data JPA modulok. Miután letöltöttük a kapott ZIP fájlt és kibontottuk egy mappába, futtathatjuk új alkalmazásunkat:

./mvnw spring-boot: fuss

Az alkalmazás sikertelen, mert nem tud csatlakozni az adatbázishoz:

**************************************************************************************************** ******** Leírás: Nem sikerült konfigurálni a DataSource-t: az 'url' attribútum nincs megadva, és nem lehet beágyazott adatforrást konfigurálni. Ok: Nem sikerült meghatározni a megfelelő vezetőosztályt 

3. Dockerfile

Mielőtt elindíthatnánk a PostgreSQL-t a Docker Compose alkalmazással, a Spring Boot alkalmazást Docker képpé kell alakítanunk. Az első lépés az alkalmazás JAR fájlként történő csomagolása:

./mvnw tiszta csomag -DskipTests

Itt először az alkalmazás csomagolása előtt tisztítjuk meg korábbi építményeinket. Ezenkívül kihagyjuk a teszteket, mert a PostgreSQL nélkül kudarcot vallanak.

Most van egy alkalmazás JAR fájl a cél Könyvtár. Ennek a fájlnak a neve és a projekt neve a verziószámmal végződik -SNAPSHOT.jar. Tehát a neve lehet docker-spring-boot-postgres-0.0.1-SNAPSHOT.jar.

Készítsük el az újat src / main / docker Könyvtár. Ezt követően átmásoljuk az alkalmazás JAR fájlját:

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

Végül létrehozzuk ezt Dockerfile ugyanabban a könyvtárban:

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

Ez a fájl leírja, hogy a Docker hogyan futtassa a Spring Boot alkalmazást. A Java 11 szoftvert használja az AdoptOpenJDK alkalmazásból, és az alkalmazás JAR fájlját másolja alkalmazás.jar. Ezután futtatja azt a JAR fájlt a Spring Boot alkalmazás elindításához.

4. Docker Compose File

Most írjuk meg a Docker Compose fájlt, dokkoló-összeállít.yml, és mentse be src / main / docker:

verzió: '2' services: app: image: 'docker-spring-boot-postgres: latest' build: context:. container_name: alkalmazás függ_on: - db környezet: - SPRING_DATASOURCE_URL = jdbc: postgresql: // db: 5432 / compose-postgres - SPRING_DATASOURCE_USERNAME = compose-postgres - SPRING_DATASOURCE_PASSWORD = SPOSTER_DATE_DOS_POSE_JELENY: POSZT_JELENY: Hozzászólás_dokumentum: POSZT_JELENY: Hozzászólás_dátum: POSZT_JEGYZET: POSZT_JELENY: Hozzászólás_kép: alpine 'container_name: db környezet: - POSTGRES_USER = compose-postgres - POSTGRES_PASSWORD = compose-postgres

Az alkalmazásunk neve kb. Ez a két szolgáltatás közül az első (4–15. sor):

• A Spring Boot Docker kép neve a docker-spring-boot-postgres: legújabb (5. sor). Docker ezt a képet a Dockerfile az aktuális könyvtárban (6-7. sor)
• A tároló neve: kb (8. sor). Attól függ db szolgáltatás (10. sor). Ezért kezdődik a db tartály
• Alkalmazásunk a db PostgreSQL tároló adatforrásként (12. sor). Az adatbázis neve, a felhasználónév és a jelszó egyaránt compose-postgres (12–14. sor)
• A hibernálás automatikusan létrehozza vagy frissíti a szükséges adatbázis-táblákat (15. sor)

A PostgreSQL adatbázis neve db és a második szolgáltatás (17–22. sor):

• PostgreSQL 13.1-et használunk (18. sor)
• A tároló neve: db (19. sor)
• A felhasználói név és a jelszó egyaránt compose-postgres (21–22. sor)

5. Futás a Docker Compose alkalmazással

Futtassuk a Spring Boot alkalmazást és a PostgreSQL-t a Docker Compose alkalmazással:

dokkoló-összeáll

Először ez építi fel a Docker Image alkalmazást a Spring Boot alkalmazáshoz. Ezután elindítja a PostgreSQL tárolót. Végül elindítja a Docker image alkalmazást. Ezúttal az alkalmazásunk jól működik:

A DemoApplication v0.0.1-SNAPSHOT indítása a Java 11.0.9 használatával az f94e79a2c9fc fájlon PID 1-vel (/application.jar root által elindítva a / ban) [...] 28 ms alatt befejeződött a Spring Data repository szkennelése. Talált 0 JPA repository interfészt. [...] 4,751 másodperc alatt elindította a DemoApplication alkalmazást (a JVM 6,512-ig fut)

Mint láthatjuk, a Spring Data nem talált tárházi felületet. Ez helyes - még nem hoztunk létre egyet!

Ha le akarjuk állítani az összes konténert, akkor először a [Ctrl-C] gombot kell megnyomnunk. Ezután leállíthatjuk a Docker Compose programot:

dokkoló-komponálj le

6. Ügyfél entitás és adattár létrehozása

A PostgreSQL adatbázis használatához alkalmazásunkban létrehozunk egy egyszerű ügyfél entitást:

@Entity @Table (name = "customer") public class Customer {@Id @GeneratedValue private long id; @ Oszlop (név = "keresztnév", nullable = hamis) privát karakterlánc keresztnév; @ Oszlop (név = "vezetéknév", nullable = hamis) privát karakterlánc vezetéknév;

A Vevő generált id attribútum és két kötelező attribútum: keresztnév és vezetéknév.

Most, megírhatjuk ennek az entitásnak a tároló felületét:

nyilvános felület A CustomerRepository kiterjeszti a JpaRepository {}

Egyszerűen meghosszabbítva JpaRepository, örököljük a módszerek létrehozását és lekérdezését Vevő entitás.

Végül ezeket a módszereket fogjuk használni alkalmazásunkban:

@SpringBootApplication public class DemoApplication {@Autowired private CustomerRepository repository; @EventListener (ApplicationReadyEvent.class) public void runAfterStartup () {List allCustomers = this.repository.findAll (); logger.info ("Ügyfelek száma:" + allCustomers.size ()); Ügyfél newCustomer = új Ügyfél (); newCustomer.setFirstName ("John"); newCustomer.setLastName ("Doe"); logger.info ("Új ügyfél mentése ..."); this.repository.save (newCustomer); allCustomers = this.repository.findAll (); logger.info ("Ügyfelek száma:" + allCustomers.size ()); }}

• Hozzáférünk a mi Vevő adattár függőségi injekcióval
• Megkérdezzük a meglévő ügyfelek számát az adattárral - ez nulla lesz
• Ezután létrehozunk és megmentünk egy ügyfelet
• Amikor ezután újra megkérdezzük a meglévő ügyfeleket, akkor elvárjuk, hogy megtaláljuk az imént létrehozottakat

7. Futás a Docker Compose Again alkalmazással

A frissített Spring Boot alkalmazás futtatásához újra kell építenünk első. Ezért ezeket a parancsokat még egyszer végrehajtjuk a projekt gyökérkönyvtárában:

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

Hogyan építhetjük fel Docker képünket ezzel a frissített alkalmazás JAR-fájllal? A legjobb módszer a meglévő Docker-kép eltávolítása, amelynek nevét a dokkoló-összeállít.yml. Ez arra kényszeríti a Docker-t, hogy a Docker Compose fájl következő indításakor újra elkészítse a képet:

cd src / main / docker docker-compose down dokkoló rmi docker-spring-boot-postgres: legújabb docker-compose up

Tehát a tárolók leállítása után töröljük a Docker image alkalmazást. Ezután újra elindítjuk a Docker Compose fájlt, amely újjáépíti az alkalmazás képét.

Itt van az alkalmazás kimenete:

180 ms alatt befejeződött a tavaszi adattár keresése. Talált 1 JPA adattár interfészt. [...] Ügyfelek száma: 0 Új ügyfél mentése ... Ügyfelek száma: 1

A Spring Boot megtalálja az üres ügyféltárunkat. Ezért nem vevővel indulunk, de aztán sikeresen létrehozunk egyet.

8. Következtetés

Ebben a rövid bemutatóban egy Spring Boot alkalmazás létrehozásával kezdtük a PostgreSQL-t. Ezután írtunk egy Docker Compose fájlt, hogy futtassuk az alkalmazás-tárolónkat egy PostgreSQL-tárolóval.

Végül létrehoztunk egy ügyfél entitást és adattárat, amely lehetővé tette számunkra az ügyfelek mentését a PostgreSQL-be.

Szokás szerint az oktatóanyag forráskódja megtalálható a GitHubon.