--Créez une simple application Web d'affichage Hello World avec l'environnement standard Google App Engine Java 11 + configuration Spring Boot
├── build.gradle
├── settings.gradle
└── src
├── main
│ ├── appengine
│ │ └── app.yaml
│ ├── java
│ │ └── com
│ │ └── example
│ │ └── helloworld
│ │ ├── HelloworldApplication.java
│ │ ├── HelloworldController.java
│ │ └── HelloworldErrorController.java
│ └── resources
│ ├── application.yml
│ ├── static
│ │ └── assets
│ │ └── helloworld.png
│ └── templates
│ ├── error.html
│ └── helloworld.html
└── test
└── java
└── com
└── example
└── helloworld
└── HelloworldApplicationTests.java
build.gradle
Un fichier qui décrit le processus lié à la création dans Gradle. Le plug-in Google App Engine Gradle utilise la série version 2.
build.gradle
buildscript {
repositories {
mavenCentral()
}
dependencies {
//Utiliser le plugin Spring Boot Gradle
classpath 'org.springframework.boot:spring-boot-gradle-plugin:2.2.0.RELEASE'
//Utiliser le plugin Gradle de Google App Engine
classpath 'com.google.cloud.tools:appengine-gradle-plugin:2.2.0'
}
}
plugins {
//Introduction du plug-in Java
id 'java'
// https://plugins.gradle.org/plugin/org.springframework.boot
id 'org.springframework.boot' version '2.2.0.RELEASE'
// https://plugins.gradle.org/plugin/io.spring.dependency-management
id 'io.spring.dependency-management' version '1.0.8.RELEASE'
}
//Introduction du plug-in App Engine
apply plugin: 'com.google.cloud.tools.appengine'
repositories {
mavenCentral()
}
dependencies {
//Dernière version de l'API App Engine
implementation 'com.google.appengine:appengine-api-1.0-sdk:+'
// Thymeleaf
implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
// Spring Web
implementation 'org.springframework.boot:spring-boot-starter-web'
// Test
testImplementation('org.springframework.boot:spring-boot-starter-test') {
//Exclure la prise en charge de JUnit 4
exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
}
}
test {
//Activer la prise en charge de JUnit 5
useJUnitPlatform()
testLogging {
//Afficher la sortie standard et la sortie d'erreur standard pendant le test
showStandardStreams true
//Événement de sortie(TestLogEvent)
events 'started', 'skipped', 'passed', 'failed'
}
}
//ID et version du groupe d'applications Web
group = "com.example.helloworld"
version = "0.0.1"
//Utilisez Java 11
sourceCompatibility = '11'
targetCompatibility = '11'
//Paramètres des tâches Google App Engine
appengine {
//Paramètres de déploiement
// GCLOUD_Si vous spécifiez CONFIG
//Les informations du projet définies dans gcloud config sont définies
deploy {
//Déployer l'ID de projet Google Cloud de destination
projectId = "GCLOUD_CONFIG"
//Version de l'application Web reflétée par le déploiement
//Si non spécifié, un nouveau sera généré
version = "GCLOUD_CONFIG"
}
}
//Exécuter des tests avant le déploiement
appengineDeploy.dependsOn test
appengineStage.dependsOn test
référence:
settings.gradle
Si vous ne définissez pas setting.gradle, vous irez dans le répertoire parent pour trouver setting.gradle, alors mettez-le également dans un seul projet.
settings.gradle
rootProject.name = 'helloworld'
app.yaml
Fichier de configuration pour Google App Engine. Décrivez les informations de l'application Web.
#Utilisez Java 11
runtime: java11
#Java 8 runtime F1 avait 128 Mo de mémoire, mais Java 11 avait 256 Mo
instance_class: F1
#Paramètre de mise à l'échelle automatique pour le nombre d'instances
automatic_scaling:
max_instances: 1 #Nombre maximum d'instances
min_instances: 0 #Nombre minimum d'instances. S'il est défini sur 0, le nombre d'instances sera égal à 0 lorsqu'il n'est pas utilisé.
target_cpu_utilization: 0.95 #Facteur de charge du processeur qui déclenche le lancement d'une nouvelle instance(0.5 à 0.Spécifié entre 95)
max_concurrent_requests: 80 #Nombre autorisé de demandes simultanées(La valeur maximale pouvant être spécifiée est 80)
#Définir les variables d'environnement
env_variables:
JAVA_TOOL_OPTIONS: "-XX:MaxRAM=256m -XX:ActiveProcessorCount=2 -Xmx32m"
référence:
HelloworldApplication.java
Classe d'application. J'écris uniquement le traitement de routine pour l'utilisation de Spring Boot.
package com.example.helloworld;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class HelloworldApplication {
public static void main(String[] args) {
SpringApplication.run(HelloworldApplication.class, args);
}
}
HelloworldController.java
Classe de contrôleur.
package com.example.helloworld;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.servlet.ModelAndView;
@Controller
public class HelloworldController {
/**
* application.Message obtenu de yml.
*/
@Value("${application.message}")
private String applicationYamlMessage;
/**
*Renvoie la réponse de la première page.
*
* @retour d'informations sur l'affichage de la page
*/
@GetMapping("/")
public ModelAndView index() {
System.out.println("HelloworldController#index");
//Définissez les données à afficher
ModelAndView mav = new ModelAndView();
mav.addObject("applicationYamlMessage", applicationYamlMessage);
mav.setViewName("helloworld"); //Afficher le nom. Spécifiez le fichier de modèle Thymeleaf
return mav;
}
/**
*Une méthode de test qui affiche une page d'erreur.
*/
@GetMapping("/exception/")
public void exception() {
System.out.println("HelloworldController#exception");
throw new RuntimeException("This is a sample exception.");
}
}
HelloworldErrorController.java
Classe de contrôleur d'erreur pour l'ensemble de l'application Web. Il gère Not Found etc. qui ne peut pas être capturé par une classe de contrôleur générale. Seul le traitement minimum est décrit ici, mais personnalisez-le si nécessaire.
package com.example.helloworld;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.servlet.error.ErrorController;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
/**
*Contrôleur d'erreur pour l'ensemble de l'application Web.
*Classe d'implémentation d'interface ErrorController.
*/
@Controller
@RequestMapping("${server.error.path:${error.path:/error}}") //Mappage vers la page d'erreur
public class HelloworldErrorController implements ErrorController {
/**
*Chemin de la page d'erreur.
*/
@Value("${server.error.path:${error.path:/error}}")
private String errorPath;
/**
*Renvoie le chemin de la page d'erreur.
*
* @return Chemin de la page d'erreur
*/
@Override
public String getErrorPath() {
return errorPath;
}
/**
*Renvoie un objet ModelAndView pour la réponse.
*
* @param req demande d'informations
* @informations de réponse param mav
* @Objet ModelAndView pour la réponse HTML de retour
*/
@RequestMapping
public ModelAndView error(HttpServletRequest req, ModelAndView mav) {
System.out.println("HelloWorldErrorController#error");
//404 introuvable pour une erreur
//Le code du stator et le contenu de sortie peuvent être personnalisés selon les besoins.
mav.setStatus(HttpStatus.NOT_FOUND);
mav.setViewName("error"); // error.html
return mav;
}
}
application.yml
Un fichier qui décrit les informations de configuration de l'application Web. Il peut également s'agir de application.properties. Cette fois, seules les informations propres à l'application sont définies.
application:
message: Hello, application yaml.
helloworld.png
Une image placée comme un échantillon montrant le stockage de fichiers statiques. Si vous placez le fichier statique dans src / main / resources / static, il sera mappé sur http: // hostname /. Cette fois, lorsque vous accédez à http: //hostname/assets/helloworld.png, le fichier src / main / resources / static / assets / helloworld.png est livré.
error.html
Fichier de modèle HTML Thymeleaf à afficher lorsqu'une erreur se produit. Cette fois, la valeur dynamique n'est pas incorporée, mais il est possible de définir la valeur dans la classe du contrôleur d'erreur selon les besoins et de la personnaliser pour qu'elle s'affiche du côté du modèle.
<!DOCTYPE html>
<html lang="ja" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>404 Not Found</title>
</head>
<body>
<h1>404 Not Found</h1>
</body>
</html>
helloworld.html
Un fichier de modèle HTML Thymeleaf pour afficher les valeurs définies par la classe de contrôleur.
<!DOCTYPE html>
<html lang="ja" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>Hello, world.</title>
</head>
<body>
<h1>Hello, world.</h1>
<div th:text="'application.yml: ' + ${applicationYamlMessage}"></div>
<div><img src="./assets/helloworld.png "></div>
</body>
</html>
HelloworldApplicationTests.java
Classe de test minimale. Seules les choses formelles sont décrites. Ne teste rien.
package com.example.helloworld;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class HelloworldApplicationTests {
@Test
void contextLoads() {
}
}
Vous pouvez exécuter le test avec la tâche de test gradle.
$ gradle test
Vous pouvez démarrer le serveur local http: // localhost: 8080 / avec gradle bootRun.
$ gradle bootRun
La tâche bootRun est une fonctionnalité du plugin Spring Boot Gradle, elle ne charge donc pas le fichier de configuration app.yaml pour Google App Engine.
Peut être déployé sur Google App Engine avec gradle appengineDeploy.
$ gradle appengineDeploy
Vous pouvez voir la liste des tâches disponibles dans les tâches graduées.
$ gradle tasks
> Task :tasks
------------------------------------------------------------
Tasks runnable from root project
------------------------------------------------------------
App Engine app.yaml based projects tasks
----------------------------------------
appengineCloudSdkLogin - Login and set the Cloud SDK common configuration user
appengineDeploy - Deploy an App Engine application
appengineDeployAll - Deploy an App Engine application and all of its config files
appengineDeployCron - Deploy Cron configuration
appengineDeployDispatch - Deploy Dispatch configuration
appengineDeployDos - Deploy Dos configuration
appengineDeployIndex - Deploy Index configuration
appengineDeployQueue - Deploy Queue configuration
appengineShowConfiguration - Show current App Engine plugin configuration
appengineStage - Stage an App Engine app.yaml based project for deployment
checkCloudSdk - Validates the Cloud SDK
downloadCloudSdk - Download the Cloud SDK
Application tasks
-----------------
bootRun - Runs this project as a Spring Boot application.
(Ce qui suit est omis)
Recommended Posts