Construction de l'environnement Docker × Spring Boot

Aperçu

Utilisez Docker pour créer un environnement Spring Boot. Pour vérifier l'opération, affichez Hello World sur le navigateur.

environnement

--macOS Catalina version 10.15.5

Docker version 19.03.8
docker-compose version 1.25.5
openjdk 14.0.1 2020-04-14
Spring Boot 2.3.1

Constitution

La configuration finale sera la suivante.

├── docker-compose.yml
└── server
    ├── HELP.md
    ├── build
    │   ├── classes
    │   │   └── java
    │   │       ├── main
    │   │       │   └── com
    │   │       │       └── example
    │   │       │           └── api
    │   │       │               └── ApiApplication.class
    │   │       └── test
    │   │           └── com
    │   │               └── example
    │   │                   └── api
    │   │                       └── ApiApplicationTests.class
    │   ├── generated
    │   │   └── sources
    │   │       ├── annotationProcessor
    │   │       │   └── java
    │   │       │       ├── main
    │   │       │       └── test
    │   │       └── headers
    │   │           └── java
    │   │               ├── main
    │   │               └── test
    │   ├── libs
    │   │   └── api-0.0.1-SNAPSHOT.jar
    │   ├── reports
    │   │   └── tests
    │   │       └── test
    │   │           ├── classes
    │   │           │   └── com.example.api.ApiApplicationTests.html
    │   │           ├── css
    │   │           │   ├── base-style.css
    │   │           │   └── style.css
    │   │           ├── index.html
    │   │           ├── js
    │   │           │   └── report.js
    │   │           └── packages
    │   │               └── com.example.api.html
    │   ├── resources
    │   │   └── main
    │   │       ├── application.properties
    │   │       ├── static
    │   │       └── templates
    │   ├── test-results
    │   │   └── test
    │   │       ├── TEST-com.example.api.ApiApplicationTests.xml
    │   │       └── binary
    │   │           ├── output.bin
    │   │           ├── output.bin.idx
    │   │           └── results.bin
    │   └── tmp
    │       ├── bootJar
    │       │   └── MANIFEST.MF
    │       ├── compileJava
    │       └── compileTestJava
    ├── build.gradle
    ├── gradle
    │   └── wrapper
    │       ├── gradle-wrapper.jar
    │       └── gradle-wrapper.properties
    ├── gradlew
    ├── gradlew.bat
    ├── settings.gradle
    └── src
        ├── main
        │   ├── java
        │   │   └── com
        │   │       └── example
        │   │           └── api
        │   │               └── ApiApplication.java
        │   └── resources
        │       ├── application.properties
        │       ├── static
        │       └── templates
        └── test
            └── java
                └── com
                    └── example
                        └── api
                            └── ApiApplicationTests.java

procédure

1. Créez docker-compose.yml

Cette fois, il s'agit d'une configuration simple avec un seul conteneur java.

`docker-compose.yml`


version: '3.6'
services:
  java:
    image: openjdk:14-slim
    ports:
      - 8080:8080
    tty: true
    volumes:
      - ./server:/srv:cached
    working_dir: /srv

2. Créer un projet Gradle

2.1 Créer un modèle de projet Gradle avec spring initializr スクリーンショット 2020-07-10 11.37.29.png

2.2 Téléchargez le modèle de projet Gradle スクリーンショット 2020-07-10 11.43.22.png

2.3 Développer au projet Créez un répertoire serveur directement sous le répertoire du projet. Extrayez ʻapi.ziptéléchargé en 2.2 et déplacez le contenu directement sousserver`.

3. Modifiez le fichier de candidature

Modifiez server / src / main / java / com / example / api / ApiApplication.java comme suit.

`server/src/main/java/com/example/api/ApiApplication.java`


package com.example.api;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class ApiApplication {

    @RequestMapping("/")
    public String home() {
        return "Hello World";
    }

    public static void main(String[] args) {
        SpringApplication.run(ApiApplication.class, args);
    }

}

4. Démarrez Docker

//build de l'environnement Docker
% docker-compose build

//Démarrer le docker en arrière-plan
% docker-compose up -d

5. Construisez Gradle

//Inspection sur le conteneur Java
% docker-compose exec java bash

//construction gradle
root@62acca270468:/srv# sh gradlew build
...
BUILD SUCCESSFUL in 1m 38s
5 actionable tasks: 3 executed, 2 up-to-date

Assurez-vous que le répertoire build est créé directement sous le serveur.

6. Exécutez l'application

root@62acca270468:/srv# java -jar build/libs/api-0.0.1-SNAPSHOT.jar

7. Contrôle de fonctionnement

Accédons à http: // localhost: 8080 /. Si «Hello World» est affiché, il réussit.

[JAVA] Construction de l'environnement Docker × Spring Boot