[JAVA] J'ai recherché un framework léger qui répondrait au soudain "faites-le vite"
introduction
"** Créez rapidement une maquette comme celle-ci. ** ”Avez-vous déjà été exposé à une tâche avec un mot aussi soudain?
Lors de la réalisation d'enquêtes de problèmes et d'études de faisabilité, nous créons parfois une application de maquette qui fonctionne avec l'application à étudier, mais la tâche dont nous avons discuté cette fois est également la création de cette application de maquette.
Je veux juste créer une application de maquette qui fonctionne avec un petit effort, donc cette fois je vais commencer par chercher un ** framework que je n'ai pas encore utilisé et qui semble être rapide à faire.
Conditions fixées pour l'adoption du cadre
- Doit être un framework fourni par OSS
- Ce qui peut être implémenté en Java
- Construction de l'environnement ⇒ Implémentation / compilation ⇒ Les travaux de déploiement / démarrage peuvent être effectués ** rapidement ** (c'est le plus important cette fois)
- Ne consommez pas autant que possible les ressources du serveur
Conditions requises pour les fonctionnalités à implémenter dans les applications de maquette
- Pouvoir vérifier le contenu de la requête HTTP reçue plus tard
- Pouvoir échanger des données au format JSON
- Le résultat de la réponse (OK / NG) peut être commuté en fonction d'un paramètre spécifique de la demande.
Comment y aller
Tout d'abord, j'ai recherché le framework fourni par OSS avec ** GitHub ** en utilisant le mot-clé de recherche java web framework microservice. Les résultats de la recherche sont les suivants.
En regardant le nombre de ★, ** tipy / javalin ** est le premier candidat et ** pippo-java / pippo ** est le deuxième candidat.
Ensuite, vérifiez les fonctionnalités du framework sur le site officiel, et lisez la description sur le site en diagonale pour voir s'il peut remplir les conditions d'adoption et les exigences fonctionnelles à mettre en œuvre. Apparemment, les deux remplissent les conditions fixées, donc je me suis intéressé aux «icônes colorées et pop» et à la conception sensible à la taille (points qui sont également supposés être utilisés dans les appareils embarqués) », donc cette fois Essaiera d'adopter le deuxième candidat ** Pippo **.
- J'ai été intéressé par la description suivante sur le site officiel de Pippo.
The core is small (around 140 KB) and we intend to keep it as small/simple as possible and to push new functionalities in pippo modules and third-party repositories/modules. You are not forced to use a specific template engine or an embedded web server. Furthermore you have multiple out of the box options (see Templates and Server). Also, Pippo comes with a very small footprint that makes it excellent for embedded devices (Raspberry Pi for example).
Créer une application de maquette
Créez immédiatement un environnement de développement d'applications de maquette.
Environnement
- JDK 1.8
- Maven 3
Obtenir le fichier source
Récupérez le référentiel dans votre environnement local à partir du [Repository] de GitHub (https://github.com/pippo-java/pippo).
Créer un modèle d'application de maquette
Suivez les instructions dans Quickstart, déplacez-vous vers le répertoire racine pippo du référentiel cloné dans votre environnement local et exécutez la commande suivante.
Seules les parties de -DgroupId et -DartifactId sont modifiées.
mvn archetype:generate \
-DarchetypeGroupId=ro.pippo \
-DarchetypeArtifactId=pippo-quickstart \
-DarchetypeVersion=1.5.0 \
-DgroupId=com.example.mock \
-DartifactId=example-mock
Il vous sera demandé si vous souhaitez définir la version du module intégré, alors entrez-la ici si vous souhaitez la modifier. Cette fois, la valeur par défaut "1.0-SNAPSHOT" convient, laissez-la vide et appuyez sur la touche Entrée.
Define value for property 'version' 1.0-SNAPSHOT: :
Ensuite, les paramètres seront confirmés, donc s'il n'y a pas de problème, entrez «Y».
[INFO] Using property: package = com.example.mock
Confirm properties configuration:
groupId: com.example.mock
artifactId: example-mock
version: 1.0-SNAPSHOT
package: com.example.mock
Y: :
la mise en oeuvre
Un répertoire avec le nom ʻexample-mock spécifié par -DartifactIdest créé sous le répertoire racinepippo`.
pippo
└─ example-mock
├─ pom.xml (Modifiez ce fichier pour ajouter des modules à utiliser)
└─ src
└─ main
├─ java
│ └─ com
│ └─ example
│ └─ mock
│ ├─ PippoApplication.java (Cette fois, nous implémenterons le processus dans ce fichier)
│ └─ PippoLauncher.java
├─ resources
│ ├─ conf
│ │ ├─ application.properties
│ │ ├─ messages.properties
│ │ └─ messages_xx.properties etc (Messages selon les paramètres régionaux.Il y a quelques propriétés)
│ ├─ templates
│ │ └─ hello.ftl
│ └─ simplelogger.properties (Les paramètres de l'enregistreur modifient ce fichier)
└─ webapp
└─ WEB-INF
└─ web.xml
Tout d'abord, créez un POJO qui mappe la demande et la réponse.
- Demander POJO
RequestParameter.java
package com.example.mock.common;
import java.io.Serializable;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement
public class RequestParameter implements Serializable {
private static final long serialVersionUID = 1L;
public String itemA;
public Boolean itemB;
}
- Réponse POJO
ResponseParameter.java
package com.example.mock.common;
import java.io.Serializable;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement
public class ResponseParameter implements Serializable {
private static final long serialVersionUID = 1L;
//Résultat de la réponse (1:OK、0:NG）
public Integer result;
public String message;
}
Ensuite, implémentez la logique à exécuter lorsqu'une requête au format JSON est acceptée par POST.
PippoApplication.java
package com.example.mock;
import java.security.InvalidParameterException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.example.mock.common.RequestParameter;
import com.example.mock.common.ResponseParameter;
import ro.pippo.core.Application;
/**
* A simple Pippo application.
*
* @see com.example.mock.PippoLauncher#main(String[])
*/
public class PippoApplication extends Application {
private final static Logger log = LoggerFactory.getLogger(PippoApplication.class);
@Override
protected void onInit() {
getRouter().ignorePaths("/favicon.ico");
// send 'Hello World' as response
GET("/", routeContext -> routeContext.send("Hello World"));
//La partie implémentée cette fois est ici
POST("/reqJson", routeContext -> {
log.debug("Check Request Parameters:" + routeContext.getRequest().getParameters());
log.debug("Check Request Body:" + routeContext.getRequest().getBody());
//Mapper la partie Corps de la demande au POJO de la demande
RequestParameter reqParm = routeContext.createEntityFromBody(RequestParameter.class);
if (null == reqParm) {
throw new InvalidParameterException("Request Paramater is Invalid");
}
ResponseParameter resParm = new ResponseParameter();
//Juger la valeur de itemB de la demande et changer la réponse
if (Boolean.FALSE == reqParm.itemB) {
// NG
resParm.result = Integer.valueOf(0);
resParm.message = "NG:" + reqParm.itemA;
log.debug("Check Result:NG");
} else {
// OK
resParm.result = Integer.valueOf(1);
resParm.message = "OK:" + reqParm.itemA;
log.debug("Check Result:OK");
}
//Renvoyer la réponse au format JSON
routeContext.json().send(resParm);
});
}
}
Editez simplelogger.properties et modifiez-le pour que le journal incorporé cette fois soit sorti.
Modifiez également le format de date et d'heure de sortie du journal afin que la date soit également sortie.
org.slf4j.simpleLogger.log.com.example.mock=debug
org.slf4j.simpleLogger.dateTimeFormat=yyyy-MM-dd HH:mm:ss
Compiler / démarrer
Puisque l'application fictive créée cette fois-ci utilise Jackson, ajoutez la description suivante à pom.xml sous le répertoire ʻexample-mock`.
pom.xml
<!-- Jackson -->
<dependency>
<groupId>ro.pippo</groupId>
<artifactId>pippo-jackson</artifactId>
<version>${pippo.version}</version>
</dependency>
Exécutez la commande dans le répertoire ʻexample-mock`.
mvn compile exec:java
Vérification du fonctionnement
-
Allez sur
http: // localhost: 8338 /avec votre navigateur et vérifiez que ** Hello World ** est affiché. -
Envoyez une requête au format JSON avec la commande cURL et vérifiez le résultat de la réponse.
- Résultat de la réponse Modèle OK
$ curl -H "Content-Type: application/json" -X POST "http://localhost:8338/reqJson" -d '{"itemA": "Test Request", "itemB": true}' -i
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 80 100 40 100 40 183 183 --:--:-- --:--:-- --:--:-- 197HTTP/1.1 200 OK
Date: Mon, 17 Dec 2018 02:53:48 GMT
Content-Type: application/json;charset=utf-8
Content-Length: 40
Server: Jetty(9.4.6.v20170531)
{"result":1,"message":"OK:Test Request"}
Résultat de sortie du journal
2018-12-17 11:53:48 [qtp188599000-16] DEBUG ro.pippo.core.PippoFilter - Request POST '/reqJson'
2018-12-17 11:53:48 [qtp188599000-16] DEBUG ro.pippo.core.route.DefaultRouter - Found 1 route matches for POST '/reqJson'
2018-12-17 11:53:48 [qtp188599000-16] DEBUG ro.pippo.core.route.DefaultRouteContext - Executing handler for POST '/reqJson'
2018-12-17 11:53:48 [qtp188599000-16] DEBUG com.example.mock.PippoApplication - Check Request Parameters:{}
2018-12-17 11:53:48 [qtp188599000-16] DEBUG com.example.mock.PippoApplication - Check Request Body:{"itemA": "Test Request", "itemB": true}
2018-12-17 11:53:48 [qtp188599000-16] DEBUG com.example.mock.PippoApplication - Check Result:OK
2018-12-17 11:53:48 [qtp188599000-16] DEBUG ro.pippo.core.route.RouteDispatcher - Returned status code 200 for POST '/reqJson'
- Résultat de la réponse Modèle NG
$ curl -H "Content-Type: application/json" -X POST "http://localhost:8338/reqJson" -d '{"itemA": "Test Request", "itemB": false}' -i
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 81 100 40 100 41 182 187 --:--:-- --:--:-- --:--:-- 187HTTP/1.1 200 OK
Date: Mon, 17 Dec 2018 02:53:55 GMT
Content-Type: application/json;charset=utf-8
Content-Length: 40
Server: Jetty(9.4.6.v20170531)
{"result":0,"message":"NG:Test Request"}
Résultat de sortie du journal
2018-12-17 11:53:55 [qtp188599000-19] DEBUG ro.pippo.core.PippoFilter - Request POST '/reqJson'
2018-12-17 11:53:55 [qtp188599000-19] DEBUG ro.pippo.core.route.DefaultRouter - Found 1 route matches for POST '/reqJson'
2018-12-17 11:53:55 [qtp188599000-19] DEBUG ro.pippo.core.route.DefaultRouteContext - Executing handler for POST '/reqJson'
2018-12-17 11:53:55 [qtp188599000-19] DEBUG com.example.mock.PippoApplication - Check Request Parameters:{}
2018-12-17 11:53:55 [qtp188599000-19] DEBUG com.example.mock.PippoApplication - Check Request Body:{"itemA": "Test Request", "itemB": false}
2018-12-17 11:53:55 [qtp188599000-19] DEBUG com.example.mock.PippoApplication - Check Result:NG
2018-12-17 11:53:55 [qtp188599000-19] DEBUG ro.pippo.core.route.RouteDispatcher - Returned status code 200 for POST '/reqJson'
Construire la construction
Après avoir terminé la vérification de l'opération, créez ʻexample-mock / src / main / assembly / assembly.xml en vous référant à la description dans [Pippo site](http://www.pippo.ro/doc/deployment.html). Je vais. Le contenu de ʻassembly.xml est le suivant.
assembly.xml
<?xml version="1.0" encoding="UTF-8"?>
<assembly>
<id>app</id>
<formats>
<format>zip</format>
</formats>
<includeBaseDirectory>false</includeBaseDirectory>
<dependencySets>
<dependencySet>
<useProjectArtifact>false</useProjectArtifact>
<scope>runtime</scope>
<outputDirectory>lib</outputDirectory>
<includes>
<include>*:jar:*</include>
</includes>
</dependencySet>
</dependencySets>
<fileSets>
<fileSet>
<directory>${project.build.directory}</directory>
<outputDirectory>.</outputDirectory>
<includes>
<include>*.jar</include>
</includes>
<excludes>
<exclude>*-javadoc.jar</exclude>
<exclude>*-sources.jar</exclude>
</excludes>
</fileSet>
</fileSets>
</assembly>
Cette fois, vous n'avez pas besoin de modifier pom.xml car il suit la procédure de QuickStart. (Déjà mentionné lors de la création du modèle d'application de maquette)
Un build ʻexample-mock-1.0-SNAPSHOT.zip avec le serveur d'application Jettyest créé dans le répertoiretarget`. La commande à exécuter est la suivante.
mvn clean package
Si un serveur d'applications distinct tel que Tomcat est préparé, exécutez la commande suivante pour créer le fichier War de l'application de maquette.
mvn -Pwar package
Commencez
Décompressez le fichier Zip créé ʻexample-mock-1.0-SNAPSHOT.zip` dans n'importe quel répertoire, déplacez-vous vers le répertoire décompressé, puis exécutez la commande suivante.
java -jar example-mock-1.0-SNAPSHOT.jar
Résumé
J'ai eu l'impression d'avoir fait une application de maquette en utilisant ** Pippo ** à la hâte, mais j'ai pu confirmer que la condition de ** faire rapidement ** était pleinement satisfaite.
| Définir les conditions | Évaluation |
|---|---|
| Doit être un framework fourni par OSS | ○ Apache 2.Fourni avec 0 licence |
| Ce qui peut être implémenté en Java | ○ |
| Déployer à partir de la construction de l'environnement/Être capable de faire rapidement le travail jusqu'au démarrage | ○ La description du document était facile à comprendre et j'ai pu le faire rapidement sans colmatage. |
| Évitez autant que possible de consommer les ressources du serveur | ○ La taille du disque et la taille de la mémoire utilisée sont petites. |
La taille de l'application Web que j'attendais avec impatience sur le disque était ** d'environ 5,9 Mo **. (Y compris le serveur d'applications) À titre de comparaison, lorsque j'ai vérifié la taille sur le disque lors du déploiement du fichier War sur Tomcat (8.5.30: la distribution est Core), elle était ** d'environ 14,5 Mo **. Il y avait une différence de plus de deux fois dans la taille du disque, et j'ai eu l'impression qu'il était assez petit.
En outre, la taille du tas de la JVM peut être utilisée avec la valeur par défaut et l'utilisation de la mémoire confirmée par le gestionnaire de tâches est ** d'environ 61 Mo **, ce qui est utilisé car il est également envisagé pour une utilisation dans des périphériques intégrés. Vous pouvez voir la considération pour la taille.
À titre de comparaison, l'utilisation de la mémoire lors du démarrage de Tomcat et Jetty avec les paramètres par défaut était la suivante.
- Tomcat (8.5.30) fait ** environ 110 Mo **
- Jetty (9.4.14.v20181114) fait ** environ 66 Mo **
J'introduirai également les [Autres fonctionnalités] modulaires (http://www.pippo.ro/doc/demo.html) si j'en ai l'occasion.
Informations de référence
Recommended Posts