[JAVA] Ich suchte nach einem leichten Framework, das das plötzliche "schnell machen" beantworten würde.

Einführung

"** Mach schnell so ein Modell. ** ”Warst du jemals einer Aufgabe mit einem so plötzlichen Wort ausgesetzt?

Bei der Durchführung von Fehleruntersuchungen und Machbarkeitsstudien erstellen wir manchmal eine Modellanwendung, die mit der zu untersuchenden Anwendung zusammenarbeitet. Die Aufgabe, die wir diesmal besprochen haben, ist jedoch auch die Erstellung dieser Modellanwendung.

Ich möchte nur eine Modellanwendung erstellen, die mit geringem Aufwand funktioniert. Dieses Mal suche ich zunächst nach einem ** Framework, das ich noch nicht verwendet habe und das schnell zu erstellen scheint.

Bedingungen für die Annahme des Rahmens

Funktionale Anforderungen zur Implementierung in Modellanwendungen

Wie man eigentlich geht

Zuerst suchte ich mit dem Suchschlüsselwort "Java Web Framework Microservice" nach dem von OSS mit ** GitHub ** bereitgestellten Framework. Die Suchergebnisse sind wie folgt. Betrachtet man die Anzahl von ★, ist ** beschwipst / javalin ** der erste Kandidat und ** pippo-java / pippo ** der zweite Kandidat. github_search.png

Überprüfen Sie anschließend die Funktionen des Frameworks auf der offiziellen Website und lesen Sie die Beschreibung auf der Website diagonal, um festzustellen, ob es die Bedingungen für die Übernahme und die zu implementierenden funktionalen Anforderungen erfüllen kann. Anscheinend erfüllen beide die festgelegten Bedingungen, daher interessierte ich mich dieses Mal für "bunte und populäre Symbole" und "größenbewusstes Design (Punkte, von denen angenommen wird, dass sie auch in eingebetteten Geräten verwendet werden)" Ich werde versuchen, den zweiten Kandidaten ** Pippo ** zu adoptieren.

pippo-logo.png

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).

Erstellen Sie eine Modellanwendung

Erstellen Sie sofort eine Mockup-Anwendungsentwicklungsumgebung.

Umgebung

Quelldatei abrufen

Holen Sie sich das Repository von GitHubs Repository in Ihre lokale Umgebung.

Erstellen Sie eine Modellanwendungsvorlage

Befolgen Sie die Anweisungen in Schnellstart, wechseln Sie in das Stammverzeichnis pippo des Repositorys, das in Ihre lokale Umgebung geklont wurde, und führen Sie den folgenden Befehl aus. Nur die Teile von -DgroupId und -DartifactId werden geändert.

mvn archetype:generate \
  -DarchetypeGroupId=ro.pippo \
  -DarchetypeArtifactId=pippo-quickstart \
  -DarchetypeVersion=1.5.0 \
  -DgroupId=com.example.mock \
  -DartifactId=example-mock

Sie werden gefragt, ob Sie die Version des erstellten Moduls festlegen möchten. Geben Sie sie hier ein, wenn Sie sie ändern möchten. Diesmal ist die Standardeinstellung "1.0-SNAPSHOT" in Ordnung. Lassen Sie sie also leer und drücken Sie die Eingabetaste.

Define value for property 'version' 1.0-SNAPSHOT: :

Als nächstes werden die Einstellungen bestätigt. Wenn also keine Probleme auftreten, geben Sie "Y" ein.

[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: :

Implementierung

Ein Verzeichnis mit dem durch "-DartifactId" angegebenen Namen "example-mock" wird unter dem Stammverzeichnis "pippo" erstellt. Bearbeiten Sie daher die folgenden Dateien, um eine Modellanwendung zu erstellen.

pippo
└─ example-mock
　 ├─ pom.xml (Bearbeiten Sie diese Datei, um zu verwendende Module hinzuzufügen)
　 └─ src
　　  └─ main
　　　   ├─ java
　　　   │  └─ com
　　　   │     └─ example
　　　   │        └─ mock
　　　   │           ├─ PippoApplication.java (Dieses Mal werden wir den Prozess in dieser Datei implementieren)
　　　   │           └─ PippoLauncher.java
   　　　├─ resources
　　　   │  ├─ conf
　　　   │　│　├─ application.properties
　　　   │  │　├─ messages.properties
　　　   │  │　└─ messages_xx.properties etc (Nachrichten entsprechend dem Gebietsschema.Es gibt einige Eigenschaften)
　　　   │  ├─ templates
　　　   │　│　 └─ hello.ftl
　　　   │  └─ simplelogger.properties (Logger-Einstellungen bearbeiten diese Datei)
　　　   └─ webapp
　　　　    └─ WEB-INF
　　　　　     └─ web.xml

Erstellen Sie zunächst ein POJO, das die Anforderung und Antwort abbildet.

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;

}

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;

	//Antwortergebnis (1:OK、0:NG）
	public Integer result;
	public String message;
}

Implementieren Sie als Nächstes die Logik, die ausgeführt werden soll, wenn eine Anforderung im JSON-Format vom POST akzeptiert wird.

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"));

       //Der diesmal implementierte Teil ist hier
        POST("/reqJson", routeContext -> {

        	log.debug("Check Request Parameters:" + routeContext.getRequest().getParameters());
        	log.debug("Check Request Body:" + routeContext.getRequest().getBody());
           //Ordnen Sie den Hauptteil der Anforderung dem POJO für die Anforderung zu
        	RequestParameter reqParm = routeContext.createEntityFromBody(RequestParameter.class);

        	if (null == reqParm) {
        		throw new InvalidParameterException("Request Paramater is Invalid");
        	}

        	ResponseParameter resParm = new ResponseParameter();

           //Beurteilen Sie den Wert von Punkt B der Anforderung und wechseln Sie die Antwort
        	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");
        	}

            //Antwort im JSON-Format zurückgeben
        	routeContext.json().send(resParm);
        });
    }

}

Bearbeiten Sie simplelogger.properties und ändern Sie es so, dass das diesmal eingebettete Protokoll ausgegeben wird. Ändern Sie außerdem das Datum und die Uhrzeit der Protokollausgabe so, dass auch das Datum ausgegeben wird.

org.slf4j.simpleLogger.log.com.example.mock=debug
org.slf4j.simpleLogger.dateTimeFormat=yyyy-MM-dd HH:mm:ss

Kompilieren / starten

Da die diesmal erstellte Mock-Anwendung Jackson verwendet, fügen Sie die folgende Beschreibung zu "pom.xml" im Verzeichnis "example-mock" hinzu.

pom.xml


<!-- Jackson -->
<dependency>
  <groupId>ro.pippo</groupId>
  <artifactId>pippo-jackson</artifactId>
  <version>${pippo.version}</version>
</dependency>

Führen Sie den Befehl im Verzeichnis example-mock aus.

mvn compile exec:java

Betriebsüberprüfung

  1. Gehen Sie in Ihrem Browser zu http: // localhost: 8338 / und vergewissern Sie sich, dass ** Hello World ** angezeigt wird.

  2. Senden Sie eine JSON-Formatanforderung mit dem Befehl cURL und überprüfen Sie das Antwortergebnis.

$ 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"}

Protokollausgabeergebnis

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'

$ 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"}

Protokollausgabeergebnis

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'

Build Build

Erstellen Sie nach Abschluss der Betriebsüberprüfung "example-mock / src / main / Assembly / Assembly.xml" unter Bezugnahme auf die Beschreibung in Pippo-Site. Ich werde. Der Inhalt von "Assembly.xml" ist wie folgt.

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>

Dieses Mal müssen Sie pom.xml nicht bearbeiten, da es dem Verfahren von QuickStart folgt. (Bereits beim Erstellen der Modellanwendungsvorlage erwähnt) Ein Build example-mock-1.0-SNAPSHOT.zip mit dem Anwendungsserver Jetty wird im Verzeichnis target erstellt. Der auszuführende Befehl lautet wie folgt.

mvn clean package

Wenn ein separater Anwendungsserver wie Tomcat vorbereitet ist, führen Sie den folgenden Befehl aus, um die War-Datei der Modellanwendung zu erstellen.

mvn -Pwar package

Anlaufen

Entpacken Sie die erstellte Zip-Datei "example-mock-1.0-SNAPSHOT.zip" in ein beliebiges Verzeichnis, verschieben Sie sie in das entpackte Verzeichnis und führen Sie den folgenden Befehl aus.

java -jar example-mock-1.0-SNAPSHOT.jar

Zusammenfassung

Es war ein Eindruck, dass ich in Eile einen Modellantrag mit ** Pippo ** gestellt habe, aber ich konnte bestätigen, dass die Bedingung für ** schnelles ** Erfüllen vollständig erfüllt war.

Bedingungen einstellen Auswertung
Muss ein von OSS bereitgestelltes Framework sein ○　Apache 2.Mit 0 Lizenz versehen
Was kann in Java implementiert werden ○
Bereitstellung aus der Umgebungskonstruktion/In der Lage sein, die Arbeit bis zum Start schnell zu erledigen ○ Die Beschreibung des Dokuments war leicht zu verstehen und ich konnte es schnell tun, ohne zu verstopfen.
Vermeiden Sie so viel Serverressourcen wie möglich ○ Sowohl die Größe der Festplatte als auch die verwendete Speichergröße sind klein.

Die Größe der Webanwendung, auf die ich mich auf der Festplatte freute, betrug ** ca. 5,9 MB **. (Einschließlich Anwendungsserver) Zum Vergleich: Als ich beim Bereitstellen der War-Datei auf Tomcat die Größe auf der Festplatte überprüfte (8.5.30: Distribution ist Core), betrug sie ** ungefähr 14,5 MB **. Es gab einen Unterschied von mehr als dem Doppelten in der Größe der Scheibe, und ich hatte den Eindruck, dass sie ziemlich klein war.

Darüber hinaus kann die Heap-Größe der JVM mit dem Standardwert betrieben werden, und die vom Task-Manager bestätigte Speichernutzung beträgt ** ca. 61 MB **, was verwendet wird, da dies auch für die Verwendung in eingebetteten Geräten berücksichtigt wird. Sie können die Überlegung für die Größe sehen.

Zum Vergleich war die Speichernutzung beim Starten von Tomcat und Jetty mit den Standardeinstellungen wie folgt.

Ich werde auch die modularisierten Andere Funktionen vorstellen, wenn ich eine Chance habe.

Referenzinformationen

Offizielle Website von Pippo

GitHub Repository

Recommended Posts

Ich suchte nach einem leichten Framework, das das plötzliche "schnell machen" beantworten würde.
Ich habe mit Gem in Ruby nach einem Webframework gesucht
Eine Notiz, die ich aufgegeben habe, um eine benutzerdefinierte Anmerkung für Lombok zu erstellen
So erstellen Sie eine leichte JRE für den Vertrieb
Ich habe einen Testcode (Junit & mockit) für den Code geschrieben, der die AWS-API (Java) aufruft.
Ich habe ein Check-Tool für das Release-Modul erstellt
Ich habe den lesbaren Code gelesen, machen Sie sich also eine Notiz
Was soll ich für das Test-Framework verwenden [Rails]
Wie erstelle ich einen MOD für Slay the Spire?
[Java] Ich habe versucht, ein Janken-Spiel zu erstellen, das Anfänger auf der Konsole ausführen können
Ich habe eine Antwortfunktion für die Erweiterung Rails Tutorial (Teil 4) erstellt: Eine Funktion, die den Benutzer einzigartig macht
Ich habe versucht, mir zu erlauben, die Verzögerung für den Android UDP-Client einzustellen
Ich habe eine GitHub-Aktion erstellt, die es einfach macht, das Ausführungsergebnis von RSpec zu verstehen
Wie gehe ich mit dem Typ um, den ich 2 Jahre lang über das Schreiben eines Java-Programms nachgedacht habe?