Ce serait plus facile si l'environnement de développement pour Java et Spring était également configuré avec Docker. Dans cet article, j'ai également inclus VSCode dans Docker. Étant donné que tout l'environnement de développement peut être géré avec Docker, il est recommandé car il est facile à gérer.

Personnage

Qu'est-ce que Docker

C'est un environnement pour exécuter une application dans un conteneur sous Linux. Les applications et bibliothèques peuvent être regroupées dans le même conteneur et réutilisées. https://ja.wikipedia.org/wiki/Docker

VSCode https://ja.wikipedia.org/wiki/Visual_Studio_Code Éditeur fabriqué par Microsoft. Si vous installez Dart Plugin, vous pouvez utiliser la fonction d'interpolation, etc. et c'est pratique.

Code-Server C'est un gars formidable qui peut exécuter VSCode en tant que service Web. https://github.com/cdr/code-server

Essayez de créer un environnement

https://github.com/kyorohiro/my-code-server/tree/master/java_spring

(1) Ecrire un fichier docker

FROM openjdk:11

#
# GRADLE
RUN mkdir /works
WORKDIR /works

RUN apt-get update
RUN apt-get install -y curl wget gnupg less lsof net-tools git apt-utils -y
RUN apt-get install -y build-essential libssl-dev curl git-core
RUN apt-get install -y emacs

RUN wget https://downloads.gradle.org/distributions/gradle-5.4.1-bin.zip
RUN unzip gradle-5.4.1-bin.zip
ENV PATH="/works/gradle-5.4.1/bin:${PATH}"

#
#Peut ne pas être nécessaire
# https://marketplace.visualstudio.com/items?itemName=vscjava.vscode-java-Pour dépendance
# nodejs for vscode plugin
RUN curl -sL https://raw.githubusercontent.com/creationix/nvm/v0.33.11/install.sh -o install_nvm.sh
RUN sh install_nvm.sh
ENV NVM_DIR="/root/.nvm"

RUN chmod o+x /root/.nvm/nvm.sh
RUN /bin/bash -c "source /root/.nvm/nvm.sh && nvm install v12.0.0"
ENV PATH="/root/.nvm/versions/node/v12.0.0/bin/:${PATH}"

#
# code-server
RUN wget https://github.com/cdr/code-server/releases/download/1.939-vsc1.33.1/code-server1.939-vsc1.33.1-linux-x64.tar.gz
RUN tar xzf code-server1.939-vsc1.33.1-linux-x64.tar.gz -C ./ --strip-components 1

(1) Exécuter l'image du menu fixe

docker build -t java_spring_vscode .
docker run -p 8443:8443 -p 8080:8080 -it java_spring_vscode bash

(2) Démarrer vscode en utilisant le serveur de code

mkdir /works/w
/works/code-server /works/w --allow-http --no-auth

(3) et ouvrez'http: //127.0.0.1: 8443 / 'dans un navigateur

Installer le plug-in Java

(1) https://marketplace.visualstudio.com/items?itemName=redhat.java

(2) Peut être inutile

.vscode/settings.json

{
    "java.home": "/usr/lib/jvm/java-11-openjdk-amd64",
    "java.maven.downloadSources": true,
    "java.import.gradle.enabled": true,
    "java.errors.incompleteClasspath.severity": "warning",
    "java.configuration.updateBuildConfiguration": "automatic"
}

Écrivons HelloWorld.

(1) Terminal -> New Terminal on VSCODE

(2) Sur le terminal

$ gradle init --type java-application
$ gradle build

(3) Ajouter eclipse à build.gradle pour le plugin java redhat

Parce que je souhaite utiliser la fonction d'interpolation automatique

plugins {
    id 'java'
    id 'application'
    id 'eclipse'
}

repositories {
    jcenter()
}

dependencies {
    implementation 'com.google.guava:guava:27.0.1-jre'
   testImplementation 'junit:junit:4.12'
}

mainClassName = 'hello.App'

(4) Essayez d'exécuter Hello World !!.

$ gradle eclipse
$ gradle build
$ gradle run

Lançons Spring Boot.

(1) Modifier build.gradle

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:2.0.5.RELEASE")
    }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'

bootJar {
    baseName = 'gs-rest-service'
    version =  '0.1.0'
}

repositories {
    mavenCentral()
}

sourceCompatibility = 11
targetCompatibility = 11

dependencies {
    compile("org.springframework.boot:spring-boot-starter-web")
    testCompile('org.springframework.boot:spring-boot-starter-test')
}

(2) Téléchargement d'un package

Il peut être nécessaire de recharger le navigateur

$ gradle build
$ gradle eclipse

(3) src/main/java/hello/App.java

package hello;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class App {

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

(4) src/main/java/hello/Greeting.java

package hello;

public class Greeting {
    private final long id;
    private final String content;

    public Greeting(long id, String content) {
        this.id = id;
        this.content = content;
    }

    public long getId(){
        return this.id;
    }

    public String getContent() {
        return this.content;
    }
}

(5) src/main/java/hello/GreetingController.java

package hello;

import java.util.concurrent.atomic.AtomicLong;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class GreetingController {

    private static final String template = "Hello, %s!";
    private final AtomicLong counter = new AtomicLong();

    @RequestMapping("/greeting")
    public Greeting greeting(@RequestParam(value="name", defaultValue="World") String name) {
        return new Greeting(counter.incrementAndGet(),
                            String.format(template, name));
    }
}

(6) Essayez de commencer

 $ SERVER_PORT=8080 SERVER_HOST=0.0.0.0 gradle tasks bootRun

(7) and, open 'http://127.0.0.1:8080/greeting' at your browser

c'est tout.

Code-Server était très pratique. https://github.com/cdr/code-server

la fin.

Le code pour cette fois est résumé ci-dessous. https://github.com/kyorohiro/my-code-server/tree/master/java_spring

[a] Si vous souhaitez reprendre

$ docker ps -a
check id and
$ docker start < id > 
$ docker exec -it < id > bash

[b] Si vous souhaitez modifier les paramètres

$ docker commit < id > java_spring_vscode_xxx
$ docker run -p 8443:8443 -p 8080:8080 -it java_spring_vscode_xxx bash

[c] Monter

$ docker run -p 8443:8443 -p 8080:8080 -v /Users/kyorohiro/w/xxx:/app/w -it java_spring_vscode bash

Construire Java x Spring x VSCode x Gradle sur Docker (1)