Einführung

Als Hobbyentwicklung sprach das Team über die Erstellung eines Webdienstes mit Spring Boot. Ich verstehe Java, aber mein Wissen über Spring Boot ist 0, also habe ich versucht, eine REST-API mit Docker zu erstellen. Bei der Erstellung habe ich auf den folgenden Artikel verwiesen.

Die Entwicklungsumgebung ist wie folgt

OS: macOS High Sierra
docker: 17.12.0-ce
docker-compose version 1.18.0

Klicken Sie hier für die Quelle dieses Artikels

Github watariGIT/boot-get-started

Was zu machen

--DB Container verwendet vorhandenes MySQL Image

Der APP-Container erstellt eine Docker-Datei und stellt die Datei bereit, sodass bei jedem Erstellen kein neues Image erstellt werden muss. --Myadmin Container ist für die einfache Bedienung von MySQL

Erstellen Sie Spring Boot

Ich weiß nicht warum SpringBoot, deshalb werde ich RestApi als Vorbereitung lokal machen.

DB Vorbereitung

Legen Sie die erforderlichen Daten in den MySQL-Container und starten Sie ihn. Wenn Sie dies nicht tun, besteht der Test nicht und Sie können nicht erstellen. Was Sie beim Starten des Containers tun müssen, ist wie folgt

Wenn Sie eine SQL-Datei im Voraus erstellen und auf / docker-entrypoint-initdb.d mounten, wird sie beim Start ausgeführt, also mounten Sie sie. --Erstelle einen MySQL-Benutzer-Boot für Spring Boot --Link zu Port 3306 auf localhost

Wenn diese hinzugefügt werden, lautet der Befehl wie folgt. docker container run -v $(PWD)/sql:/docker-entrypoint-initdb.d -d -e MYSQL_DATABASE=mydb -e MYSQL_USER=sboot -e MYSQL_PASSWORD=sboot -e MYSQL_ROOT_PASSWORD=root-pass -p 3306:3306 -d mysql

Es wird eine lange Zeit dauern, aber lassen Sie uns das ertragen, bis wir eine Docker-Komposition machen.

Erstellen Sie build.gradle

SpringBoot scheint gradle für die Build- und Bibliotheksverwaltung zu verwenden. Füllen Sie die erforderlichen Elemente in SPRING INITIALIZR aus und legen Sie die Vorlage ab. Bearbeiten Sie die Datei build.gradle oben im Verzeichnis wie folgt.

buildscript {
    ext {
        springBootVersion = '1.5.2.RELEASE'
    }
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

jar {
    baseName = 'boot-get-started'
    version = '0.0.1-SNAPSHOT'
}

sourceCompatibility = 1.8

repositories {
    mavenCentral()
}


dependencies {
    compile('org.springframework.boot:spring-boot-starter-web')
    compile("org.springframework.boot:spring-boot-starter-data-jpa")
    compile("org.springframework.boot:spring-boot-starter-data-rest")
    compile('mysql:mysql-connector-java:6.0.6')
    compileOnly('org.projectlombok:lombok')
    testCompile('org.springframework.boot:spring-boot-starter-test')
}

Es ist praktisch, die erforderliche Bibliothek in den Abhängigkeiten auszufüllen. Ich bin froh, dass Sie wahrscheinlich bei testCompile testen. Ich möchte später mehr darüber erfahren.

gradlew clean build schließt die Bibliotheksinstallation ab.

Erstellung von Entität und Repository

Erstellen Sie Enttity und Repository für DB in src / main / java / com / example. Ich verstehe diesen Bereich nicht wirklich, weil ich gerade den [Referenzartikel] kopiert habe (https://blog.tiqwab.com/2017/03/21/docker-java.html). Dieses Mal liegt der Schwerpunkt auf dem Aufbau der Umwelt, daher werde ich sie aufteilen.

Application.yml erstellen

Erstellen Sie "src / main / resources / application.yml". Geben Sie hier das DB-Verbindungsziel ein. Beachten Sie, dass das Verbindungsziel unterschiedlich ist, je nachdem, ob die Anwendung lokal ausgeführt oder auf einem Container verbunden ist.

spring:
  profiles:
    active: localhost
---
spring:
  profiles: localhost
  datasource:
    driverClassName: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mydb
    username: sboot
    password: sboot
  jpa:
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
    show-sql: true
    hibernate:
      ddl-auto: update
  data:
    rest:
      base-path: /api

---
spring:
  profiles: docker
  datasource:
    driverClassName: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://dbserver/mydb
    username: sboot
    password: sboot
  jpa:
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
    show-sql: true
    hibernate:
      ddl-auto: update
  data:
    rest:
      base-path: /api

Erstellen Sie ein Profil, das localhost und Docker entspricht, und legen Sie localhost als Standard fest. Die Profilumschaltung erfolgt in DockerFile (später beschrieben).

Bauen

Führen Sie "gradlew build" mit dem eingerichteten MySQL-Container durch, und wenn "BUILD SUCCESS FUL" angezeigt wird, ist dies in Ordnung. Nachdem der Build erfolgreich war, ist es Zeit, die Anwendung zu containerisieren und auszuführen.

DockerFile erstellen und komponieren

Erstellen Sie zunächst eine Docker-Datei für Ihre Anwendung.

# use alpine as base image
FROM ubuntu:16.04

RUN apt-get update
RUN apt-get -y install openjdk-8-jdk
ENV JAVA_HOME /usr/lib/jvm/java-8-openjdk-amd64

# recommended by spring boot
VOLUME /tmp

# create directory for application
RUN mkdir /app
WORKDIR /app

# jar target
ENV JAR_TARGET "boot-get-started-0.0.1-SNAPSHOT.jar"

# set entrypoint to execute spring boot application
ENTRYPOINT ["sh","-c","java -jar -Dspring.profiles.active=docker build/libs/${JAR_TARGET}"]

Wechseln Sie zu dem in application.yml beschriebenen Profil mit -Dspring.profiles.active = docker von ENTRYPOINT. --Mounten Sie die zur Laufzeit erstellte Datei auf / app.
Führen Sie die in JAR_TARGET angegebene Datei aus. (Standardmäßig "boot-get-Start-0.0.1-SNAPSHOT.jar")

Schreiben Sie als Nächstes docker-compose.yml, das die Container db, app und phpmyadmin kombiniert.

version: '2'
services:

    dbserver:
        image: mysql
        volumes:
            - ./sql:/docker-entrypoint-initdb.d
            - mysql-db:/var/lib/mysql
        environment:
            MYSQL_DATABASE: mydb
            MYSQL_USER: sboot
            MYSQL_PASSWORD: sboot
            MYSQL_ROOT_PASSWORD: root
           
    app:
        build: .
        image: watari/boot:0.1.0                            
        depends_on:
            - dbserver
        ports:
            - "8080:8080"
        volumes:
            - .:/app
        environment:
            JAR_TARGET: boot-get-started-0.0.1-SNAPSHOT.jar

    myadmin:
        image: phpmyadmin/phpmyadmin
        depends_on:
            - dbserver
        environment:
            PMA_ARBITRARY: 1
            PMA_HOST: dbserver
            PMA_USER: root
            PMA_PASSWORD: root
        ports:
            - "1111:80"

volumes:
    mysql-db:
        driver: local

Lauf

Es kann mit "Docker-Compose Up" ausgeführt werden. Wenn Sie zum ersten Mal ein Bild aus einer Docker-Datei erstellen müssen, fügen Sie die Option "--build" hinzu. Überprüfen Sie den Container nach dem Starten und Ausführen mit dem Befehl curl.

$ curl http://localhost:8080/api/users
{
  "_embedded" : {
    "users" : [ {
      "firstName" : "Taro",
      "lastName" : "Yamada",
      "_links" : {
        "self" : {
          "href" : "http://localhost:8080/api/users/1"
        },
        "user" : {
          "href" : "http://localhost:8080/api/users/1"
        }
      }
    }, {
      "firstName" : "Hanako",
      "lastName" : "Tanaka",
      "_links" : {
        "self" : {
          "href" : "http://localhost:8080/api/users/2"
        },
        "user" : {
          "href" : "http://localhost:8080/api/users/2"
        }
      }
    } ]
  },
  "_links" : {
    "self" : {
      "href" : "http://localhost:8080/api/users"
    },
    "profile" : {
      "href" : "http://localhost:8080/api/profile/users"
    }
  }
}

abschließend

Ich habe keine Kenntnisse über Spring Boot, aber ich konnte mithilfe eines Containers problemlos eine Umgebung erstellen. Da ich jedoch lokal baue, habe ich das Gefühl, dass es etwas ist. Warum also nicht auch den Container den Build ausführen lassen? Ich denke auch. Außerdem entwickle ich jetzt basierend auf Emacs, aber ich denke, es ist notwendig, es gut zu kombinieren, wenn ich in Zukunft in einer integrierten Entwicklungsumgebung wie Eclipse entwickle (ich habe hier kein Know-how). Ich denke, ich werde dies als Ausgangspunkt für Versuch und Irrtum verwenden.

[JAVA] Erstellen Sie mit Docker eine Spring Boot-Entwicklungsumgebung