[JAVA] Créez une application Web simple avec Dropwizard
Créez une application Web simple avec Dropwizard
L'objectif de cette fois
--Créer une application Web simple --Lorsque vous entrez à partir de l'écran, le contenu de l'entrée sera renvoyé.
Environnement de développement
- OS：Windows7 --Langue: Java8 --Framework: Dropwizard 9.2
- IDE：Eclipse 4.4.2
Fichier implémenté cette fois
- DropTestApplication.java
- DropTestConfiguration.java
- SampleResource.java
- index.html
- index.js
- config.yml
- pom.xml
Procédure d'exécution
- Créer un projet maven
- Créez un fichier de paramètres
- Créez pom.xml
- Créez config.yml
- Création d'une classe principale pour Dropwizard
- Créer une classe de configuration
- Créer une classe d'application
- Créez un socket côté serveur
- Créez SampleResource.java
- Création d'écran
- Créez index.html
- Créez index.js
- Construire
- Exécuter
1. Créer un projet maven
En utilisant eclipse, cliquez avec le bouton droit dans l'Explorateur de projets → Nouveau → Projet Maven → Projet Maven → Cliquez sur Suivant Cette fois, cochez Créer un projet simple et cliquez sur Suivant Entrez un ID de groupe (ID d'organisation), un ID d'artefact (ID d'identification, qui sera le nom du projet), vérifiez que l'emballage est un pot, puis cliquez sur Terminer.
En fonction des paramètres d'éclipse, la configuration de package suivante sera terminée.
2. Créez un fichier de paramètres
Ici, spécifiez le package à utiliser dans maven dans pom.xml et définissez l'application dans config.yml.
2-1. Créez pom.xml
Sélectionnez et éditez pom.xml créé directement sous le projet.
Il est nécessaire de décrire que dropwizard est utilisé ici, et cette fois, spécifiez la bibliothèque nécessaire, la classe principale et maven-shadow en supposant que fat-jar au moment de la construction.
pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>priv.jp.y.suzuki</groupId>
<artifactId>dropTest</artifactId>
<version>0.0.1-SNAPSHOT</version>
<properties>
<dropwizard.version>0.9.2</dropwizard.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>2.3</version>
<configuration>
<createDependencyReducedPom>true</createDependencyReducedPom>
<filters>
<filter>
<artifact>*:*</artifact>
<excludes>
<exclude>META-INF/*.SF</exclude>
<exclude>META-INF/*.DSA</exclude>
<exclude>META-INF/*.RSA</exclude>
</excludes>
</filter>
</filters>
</configuration>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
<transformers>
<transformer
implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer" />
<transformer
implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
<mainClass>dropTest.priv.jp.y.suzuki.DropTestApplication</mainClass>
</transformer>
</transformers>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>io.dropwizard</groupId>
<artifactId>dropwizard-core</artifactId>
<version>${dropwizard.version}</version>
</dependency>
<dependency>
<groupId>io.dropwizard</groupId>
<artifactId>dropwizard-auth</artifactId>
<version>${dropwizard.version}</version>
</dependency>
<dependency>
<groupId>io.dropwizard</groupId>
<artifactId>dropwizard-assets</artifactId>
<version>${dropwizard.version}</version>
</dependency>
</dependencies>
</project>
2-2. Créez config.yml
Décrivez les paramètres utilisés dans l'application.
Cette fois, créez un fichier yml (n'importe quel nom) directement sous la racine du projet (au même emplacement que pom.xml),
Spécifiez le port et définissez le chemin racine lors du démarrage de l'application.
Avec les paramètres ci-dessous, l'application se lance sur le port 8090 et le chemin racine est défini sur / api /.
config.yml
# Application server setting.
server:
applicationConnectors:
- type: http
port: 8090
rootPath: '/api/*'
3. Création d'une classe principale pour Dropwizard
Nous créerons les fichiers nécessaires avec Dropwizard.
Cette fois, j'ai créé un package appelé dropTest.priv.jp.y.suzuki sous src / main / java et créé une classe principale en dessous.
3-1. Création de la classe de configuration
Ici, définissez les paramètres de chaque environnement. Les informations contenues dans le fichier yaml décrit à l'étape précédente seront chargées dans cette classe. Par exemple, supposons que vous ayez défini les paramètres suivants (décrits) dans le fichier yaml.
config.yml
~ Omis ~
# template sentence
template: Hello!!
Créez ensuite une classe de configuration comme indiqué ci-dessous
DropTestConfiguration.java
package priv.jp.y.suzuki;
import io.dropwizard.Configuration;
public class DropTestConfiguration extends Configuration {
/**Lire à partir du fichier de paramètres*/
private String template;
public String getTemplate() {
return template;
}
}
En faisant cela, vous pouvez lire ceci dans la classe Application etc. et l'utiliser.
3-2. Création d'une classe d'application
Créez une classe Application positionnée pour être la classe principale de Java. Ici, la fonction principale, les paramètres du bundle et l'enregistrement de la classe de ressources sont exécutés. Je n'ai pas encore créé la classe de ressources, je vais donc la commenter.
DropTestApplication.java
package dropTest.priv.jp.y.suzuki;
import io.dropwizard.Application;
import io.dropwizard.assets.AssetsBundle;
import io.dropwizard.setup.Bootstrap;
import io.dropwizard.setup.Environment;
public class DropTestApplication extends Application<DropTestConfiguration> {
//Réglages principaux
public static void main(String[] args) throws Exception {
new DropTestApplication().run(args);
}
//Paramètres du bundle
@Override
public void initialize(Bootstrap<DropTestConfiguration> bootstrap) {
bootstrap.addBundle(new AssetsBundle("/assets", "/", "index.html"));
bootstrap.addBundle(new AssetsBundle("/assets/css", "/css", null, "css"));
bootstrap.addBundle(new AssetsBundle("/assets/js", "/js", null, "js"));
}
//Inscription de classe de ressources
@Override
public void run(DropTestConfiguration conf, Environment env) throws Exception {
//Obtenir les informations lues à partir du fichier de paramètres
String template = conf.getTemplate();
System.out.println(template); //S'il pouvait être lu
// env.jersey().register(new SampleResource());
}
}
4. Créez un socket côté serveur
Créez une classe de ressources qui a pour rôle de recevoir des valeurs du côté de l'écran. Le lieu de création est le suivant.
Lieu de création: dropTest.priv.jp.y.suzuki.resource
Cette fois, il prend une valeur et la renvoie avec "" mot d'entrée: ""
SampleResource.java
package dropTest.priv.jp.y.suzuki.resource;
import javax.ws.rs.Consumes;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
@Path("/message")
public class SampleResource {
@POST
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.TEXT_PLAIN)
@Path("/response/{sentence}")
public String responseMessage(@PathParam("sentence") String sentence) {
String message = "Mot d'entrée:" + sentence;
return message;
}
}
Les points ci-dessus sont des annotations diverses.
-- @ POST spécifie que l'appel doit être effectué uniquement pendant la communication POST.
-- @ Consumes ・ @ Produces spécifie le format d'entrée / sortie. Cette fois, le format JSON et le format TEXT sont spécifiés.
-- @ PathParam est spécifié pour recevoir la valeur de l'écran, et la partie {phrase} est acquise avec le type spécifié (String cette fois).
-- @ Path spécifie la cible de l'appel lors de la communication REST par URL
Dans ce cas, cette classe de ressources est / message et la méthode que vous voulez exécuter est / response / {phrase}.
Par conséquent, il est supposé être exécuté avec l'URL suivante, y compris le chemin racine spécifié dans le fichier yml.
Communication POST: / api / message / response /" instruction d'entrée "
Enfin, enregistrez la classe de ressources avec la classe Application créée jusqu'à présent, et vous avez terminé.
DropTestApplication.java
import dropTest.priv.jp.y.suzuki.resource.SampleResource;
// ~Omission~
//Inscription de classe de ressources
@Override
public void run(DropTestConfiguration conf, Environment env) throws Exception {
//Obtenir les informations lues à partir du fichier de paramètres
String template = conf.getTemplate();
System.out.println(template); //S'il pouvait être lu
env.jersey().register(new SampleResource()); //Validez ce qui a été commenté plus tôt
}
}
5. Création d'écran
Ici, html et javascript sont décrits pour créer l'écran.
Tout d'abord, créez un dossier appelé ʻassets sous src / main / resources. Créez un fichier ʻindex.html et un dossierjs sous les ʻassetscréés, Dans le dossierjs créé, créez un fichier javascript qui décrit le mouvement de ʻindex.html (cette fois, ʻindex.js`).
Exemple de package: src/main/resources |__ assets |__ index.html |__ js |__ index.js
5-1. Créez index.html
Cette fois, je vais en créer un simple qui affiche le champ de saisie, le bouton d'envoi et les caractères renvoyés par le serveur.
Il est supposé que jQuery sera utilisé pour l'affichage à l'écran et la communication REST.
Par conséquent, [Téléchargez] jQuery (https://code.jquery.com/jquery-3.2.1.min.js) et placez-le dans le fichier js.
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>DropwizardTEST</title>
<script src="js/jquery-3.2.1.min.js"></script>
<script src="js/index.js"></script>
</head>
<body>
<input type="text" id="inputSentence"><br>
<input type="button" id="start" value="Communication REST"><br>
<div><span id="result">Le contenu de la réponse est écrit ici</span></div>
</body>
</html>
5-2. Créez index.js
Ici, la communication REST est exécutée lorsque le bouton est enfoncé et le résultat est sorti. Cette fois, nous utiliserons l'ajax de jQuery.
index.js
/**Répond à la pression du bouton*/
$(document).on('click', '#start', function() {
var SendData = $("#inputSentence").val();
Request("/api/message/response/" + SendData, "POST", null, resultOpen, FailAnon);
return false;
});
/**Pour ajax*/
function Request(Uri, Method, Data, CallbackFunc, ErrorCallbackFunc) {
$.ajax({
url: Uri,
type: Method,
data: Data,
contentType: "application/json; charset=utf-8",
cache: false
}).done(function(response){
CallbackFunc(response);
return false;
}).fail(function(XMLHttpRequest, textStatus, errorThrown) {
ErrorCallbackFunc();
return false;
});
return false;
}
/**Appelé quand ajax échoue*/
function FailAnon() {
$("#result").html("<b>ERROR!</b>La communication a échoué");
return false;
}
/**Afficher le résultat*/
function resultOpen(response) {
$("#result").html(response + "<br>");
return false;
}
6. Construire
Créez l'application terminée. La construction se fait à Maven. Construisez à partir du répertoire du projet avec la commande suivante. Si "BUILD SUCCESS" s'affiche, cela signifie qu'il réussit. Un fichier jar doit être créé sous le répertoire cible.
Commande de construction: maven package
7. Exécuter
Deux fichiers sont requis pour l'exécution. Il existe deux fichiers, un fichier jar créé par la compilation et un fichier yaml qui est un fichier de configuration.
La commande d'exécution est la suivante.
Exemple de commande d'exécution: java -jar target / droptest-0.0.1-SNAPSHOT.jar server config.yml
- Par mesure de précaution au moment de l'exécution, un avertissement sera émis pour implémenter la classe de vérification de l'état car elle n'est pas implémentée cette fois. La classe de vérification de l'état est une fonction fournie par Dropwizard qui vérifie si la base de données, etc. fonctionne normalement. Cela fonctionne sans lui, mais il est recommandé de le configurer. Cette fois, il n'est pas créé car il n'est pas connecté à d'autres modules.
À la fin
Ouvrons réellement le Web et vérifions-le lorsque le démarrage est terminé avec succès. Si vous ne pouvez pas vous connecter, la cause peut être facilement comprise en utilisant le journal de sortie ou le mode développeur tel que F12.
À propos, l'application lancée peut être arrêtée par la commande Ctrl + c comme de nombreuses applications.
Recommended Posts