SO schreiben Sie eine REST-API mit DropWizard

Bei diesem Tutorial handelt es sich um einen Leitfaden für Einsteiger, mit dem Sie lernen, wie Sie Ihre ersten Dropwizard-Anwendungen erstellen und bereitstellen. In diesem Tutorial erkläre ich das Grundkonzept von Dropwizard und wie man mit diesem Framework einfache REST-Dienste schreibt. Ich habe in den letzten Monaten an Spring Boot gearbeitet und war sehr von seinen Konzepten und der Entwicklung der Microservice-REST-Anwendungen inspiriert.

  • Lesen Sie auch: Best Practices für das REST-API-Design

Das zwang mich, nach einem alternativen Framework zum Erstellen der REST-Dienste zu suchen und dieses mit Spring Boot zu vergleichen. Nun bin ich endlich hier, um Sie durch das Dropwizard-Framework zu führen. In meinem nächsten Tutorial werde ich Spring Boot und Dropwizard vergleichen. Bitte abonnieren Sie hier, um die Updates zu erhalten.

Wie schreibe ich eine REST-API mit DropWizard?

Inhaltsverzeichnis

  • Was ist Dropwizard?
  • Dropwizard-Standardbibliotheken
  • Maven-Konfiguration
  • Konfigurationsklasse definieren
  • Definieren Sie eine Anwendungsklasse
  • Definieren Sie eine Repräsentationsklasse
  • Definieren Sie eine Ressourcenklasse
  • Registrieren einer Ressource
  • Erstellen Sie Ihre Anwendung
  • Ausführen Ihrer Anwendung
  • Wie ändere ich den Kontextpfad?
  • Ressourcen zum Erlernen von Dropwizard
  • Quellcode herunterladen
  • Zusammenfassung
  • 1. Was ist Dropwizard?

    Was ist Dropwizard?

    Dropwizard ist ein Microservices-Framework. Dies hilft Ihnen, Ihre Anwendungen so zu verpacken, dass sie problemlos als eigenständiger Dienst in der Produktionsumgebung bereitgestellt werden können. Dropwizard konfiguriert automatisch eine Reihe von Frameworks und Bibliotheken für die Erstellung von RESTful-Webdiensten. Während mehrere Bibliotheken gebündelt werden, verwendet es eigene Standardwerte, die für Ihre Anwendungen am besten geeignet sind.

    Wenn Sie ein Anwendungsentwickler sind, müssen Sie sich keine Gedanken mehr über die Konfigurationen machen, die für jede von Ihrer Anwendung verwendete Bibliothek erforderlich sind (z. B. Ruhezustand, Ehcache usw.), die im Klassenpfad verfügbar sind. Dropwizard kümmert sich um die Konfiguration der sinnvollen Standardeinstellungen für Ihre Anwendungen.

    2. Dropwizard-Standardbibliotheken

    Dropwizard verwendet die sinnvollen Standardbibliotheken, damit Ihre Anwendungen schnell einsatzbereit sind. Im Folgenden finden Sie die Liste der verwendeten Standardbibliotheken, sofern Sie dies nicht ausdrücklich in Ihrer Build-Datei erwähnt haben:

    • Anlegestelle: Zum Ausführen einer Webanwendung benötigen Sie HTTP. Dropwizard bettet den Jetty-Servlet-Container zum Ausführen der Webanwendungen ein. Anstatt Ihre Anwendungen auf einem Anwendungsserver oder Webserver bereitzustellen, definiert Dropwizard eine Hauptmethode, die den Jetty-Server als eigenständigen Prozess aufruft. Dropwizard empfiehlt derzeit, die Anwendung nur mit Jetty auszuführen. Andere Webdienste wie Tomcat werden nicht offiziell unterstützt.
    • Trikot: Jersey ist eine der besten REST-API-Implementierungen auf dem Markt. Außerdem folgt es der Standard-JAX-RS-Spezifikation und ist die Referenzimplementierung für die JAX-RS-Spezifikation. Dropwizard verwendet Jersey als Standard-Framework für die Erstellung der RESTful-Webanwendungen.
    • Jackson: Jackson ist der De-facto-Standard für die Handhabung des JSON-Formats. Es ist eine der besten Objekt-Mapper-APIs für das JSON-Format.
    • Metriken: Dropwizard verfügt über ein eigenes Metrikmodul zum Offenlegen der Anwendungsmetriken über HTTP-Endpunkte.
    • Guave: das neben hochoptimierten unveränderlichen Datenstrukturen eine wachsende Anzahl von Klassen bereitstellt, um die Entwicklung in Java zu beschleunigen.
    • Logback und Slf4j: Diese beiden werden für bessere Protokollierungsmechanismen verwendet.
    • Freemarker und Schnurrbart: Die Auswahl der Template-Engines für Ihre Anwendung ist eine der wichtigsten Entscheidungen. Die gewählte Template-Engine muss flexibler sein, um bessere Skripte schreiben zu können. Dropwizard verwendet für die Erstellung der Benutzeroberflächen die bekannten und beliebten Template-Engines Freemarker und Mustache.

    Abgesehen von der obigen Liste gibt es viele andere Bibliotheken wie Joda Time, Liquibase, Apache HTTP Client und Hibernate Validadtor, die von Dropwizard zum Erstellen von REST-Diensten verwendet werden.

    3. Maven-Konfiguration

    Es wird empfohlen, den Maven für die Dropwizard-Anwendungen zu verwenden. Sie könnten auch andere Build-Tools wie Ant/Ivy, Buildr, Gradle, SBT, Leiningen usw. verwenden. Wenn Sie jedoch Maven verwenden, ist das cool und einfach, Ihre Anwendungen zu konfigurieren, da die meisten Anleitungen Maven als Build-Tool verwenden.

    Das Einrichten von Maven ist der erste Schritt bei der Konfiguration der Dropwizard-Anwendung. Bitte fügen Sie den folgenden Eintrag in Ihren Maven ein pom.xml Datei:

    <dependencies>
    <dependency>
    <groupId>io.dropwizard</groupId>
    <artifactId>dropwizard-core</artifactId>
    <version>${dropwizard.version}</version>
    </dependency>
    </dependencies>
    

    Bevor Sie den obigen Eintrag hinzufügen, können Sie Folgendes hinzufügen dropwizard.version wie nachstehend:

    <properties>
    <dropwizard.version>INSERT VERSION HERE</dropwizard.version>
    </properties>
    

    Das ist es. Sie haben das Schreiben der Maven-Konfigurationen abgeschlossen. Die oben genannten Konfigurationen würden alle erforderlichen Bibliotheken für Ihr Projekt abrufen. Jetzt werden wir mit dem Schreiben unserer ersten echten Anwendung mit Dropwizard fortfahren. Am Ende dieses Tutorials habe ich den gesamten für dieses Tutorial verwendeten Quellcode hochgeladen.

    4. Konfigurationsklasse definieren

    Dropwizard unterstützt die YAML Konfigurationsdatei zur Weitergabe der Nachrichten. Sie können das erstellen configuration.yml. im Projektstamm. Diese Datei wird dann in eine Instanz der Konfigurationsklasse Ihrer Anwendung deserialisiert und validiert. Die Konfigurationsdatei Ihrer Anwendung ist die Unterklasse von Configuration Klasse, die ihre Eigenschaften direkt der Klasse zuordnet configuration.yml.

    Hier ist das einfache Beispiel für Ihre Konfigurationsklasse:

    import io.dropwizard.Configuration;
    import com.fasterxml.jackson.annotation.JsonProperty;
    import org.hibernate.validator.constraints.NotEmpty;
    
    public class EmployeeConfiguration extends Configuration {
    @NotEmpty
    private String message;
    @NotEmpty
    private String defaultText1;
    @NotEmpty
    private String defaultText2;
    
    @JsonProperty
    public String getMessage() {
    return message;
    }
    
    @JsonProperty
    public void setMessage(String message) {
    this.message = message;
    }
    
    @JsonProperty
    public String getDefaultText1() {
    return defaultText1;
    }
    
    @JsonProperty
    public void setDefaultText1(String defaultText1) {
    this.defaultText1 = defaultText1;
    }
    
    @JsonProperty
    public String getDefaultText2() {
    return defaultText2;
    }
    
    @JsonProperty
    public void setDefaultText2(String defaultText2) {
    this.defaultText2 = defaultText2;
    }
    }
    

    Die obige Klasse wird aus dem deserialisiert YAML Datei und fügen Sie die Werte aus der YAML-Datei in dieses Objekt ein.

    Der YAML Datei employee-details würde so aussehen:

    message : Hello %s! You are learning %s!!
    defaultText1: Krishna
    defaultText2: Dropwizard
    

    5. Definieren Sie eine Anwendungsklasse

    Jetzt müssen Sie eine Hauptanwendungsklasse erstellen, die die Unterklasse der Konfigurationsklasse Ihrer Anwendung sein wird. Diese Anwendungsklasse würde alle Bundles zusammenführen und die Anwendung für die Verwendung betriebsbereit machen.

    Hier ist das Beispiel für die Anwendungsklasse:

    import io.dropwizard.Application;
    import io.dropwizard.setup.Bootstrap;
    import io.dropwizard.setup.Environment;
    import net.javabeat.dropwizard.resources.EmployeeResource;
    
    public class EmployeeApplication extends Application<EmployeeConfiguration> {
    public static void main(String[] args) throws Exception {
    new EmployeeApplication().run(args);
    }
    
    @Override
    public void initialize(Bootstrap<EmployeeConfiguration> bootstrap) {
    // nothing to do yet
    }
    
    @Override
    public void run(EmployeeConfiguration configuration,
    Environment environment) {
    final EmployeeResource resource = new EmployeeResource(
    configuration.getMessage(),
    configuration.getDefaultText1(),configuration.getDefaultText2());
    environment.jersey().register(resource);
    }
    
    }
    
    

    6. Definieren Sie eine Repräsentationsklasse

    Jetzt müssen wir anfangen, über unsere REST-API nachzudenken und darüber, wie unsere Ressource dargestellt werden soll. Wir müssen das JSON-Format und die entsprechende Darstellungsklasse entwerfen, die in das gewünschte JSON-Format konvertiert. Schauen wir uns das JSON-Beispielformat für dieses einfache Beispiel an:

    {
    {"content":"Hello Krishna! You are learning Dropwizard!!"}
    }
    

    Für das obige JSON-Format würden wir die Darstellungsklasse wie folgt erstellen:

    import com.fasterxml.jackson.annotation.JsonProperty;
    import org.hibernate.validator.constraints.Length;
    
    public class Representation {
    @Length(max = 3)
    private String content;
    
    public Representation() {
    // Jackson deserialization
    }
    
    @JsonProperty
    public String getContent() {
    return content;
    }
    
    public void setContent(String content) {
    this.content = content;
    }
    
    public Representation(String content) {
    this.content = content;
    }
    }
    

    Das ist ziemlich einfaches POJO.

    7. Definieren Sie eine Ressourcenklasse

    In der REST-API-Welt ist die Ressource alles. Eine Ressource ist nichts anderes als ein Endpunkt-URI für den Zugriff auf die Ressource im Server. In unserem Beispiel handelt es sich bei dieser Ressource um eine Controller-Klasse mit wenigen Anmerkungen für die Anforderungs-URI-Zuordnung. Da Dropwizard die JAX-RS-Implementierung verwendet, definiert eine Ressourcenklasse den URI-Pfad mithilfe von @Path Anmerkung.
    Hier ist eine Ressourcenklasse für unser Beispiel-Tutorial:

    import javax.ws.rs.GET;
    import javax.ws.rs.Path;
    import javax.ws.rs.Produces;
    import javax.ws.rs.QueryParam;
    import javax.ws.rs.core.MediaType;
    
    import com.codahale.metrics.annotation.Timed;
    import com.google.common.base.Optional;
    
    import net.javabeat.dropwizard.api.Representation;
    
    @Path("/emp-details")
    @Produces(MediaType.APPLICATION_JSON)
    public class EmployeeResource {
    private final String message;
    private final String defaultText1;
    private final String defaultText2;
    public EmployeeResource(String message, String defaultText1, String defaultText2) {
    this.message = message;
    this.defaultText1 = defaultText1;
    this.defaultText2 = defaultText2;
    }
    
    @GET
    @Timed
    public Representation sayHello(@QueryParam("param1") Optional<String>
    param1, @QueryParam("param2") Optional<String> param2) {
    final String value = String.format(message, param1.or(defaultText1),
    param2.or(defaultText2));
    return new Representation(value);
    }
    }
    

    8. Registrieren einer Ressource

    Nachdem Sie die Ressourcenklasse erstellt haben, muss diese bei der Anwendungsklasse registriert werden, die wir zuvor in diesem Tutorial definiert haben. Wie ich bereits erwähnt habe, ist die Anwendungsklasse die Startmaschine für den Dropwizard-Dienst, daher muss jede Registrierung von Klassen in der Anwendungsklasse erfolgen. Sie fügen einfach den folgenden Code hinzu für:

    @Override
    public void run(EmployeeConfiguration configuration,
    Environment environment) {
    final EmployeeResource resource = new EmployeeResource(
    configuration.getMessage(),
    configuration.getDefaultText1(),configuration.getDefaultText2());
    environment.jersey().register(resource);
    }
    
    

    9. Erstellen Sie Ihre Anwendung

    Es wird empfohlen, eine einzelne FAT-JAR-Datei zu erstellen, die alle zum Ausführen Ihrer Anwendung erforderlichen .class-Dateien enthält. Dieselbe JAR-Datei kann in unterschiedlichen Umgebungen vom Test bis zur Produktion bereitgestellt werden, ohne dass Änderungen an den Abhängigkeitsbibliotheken erforderlich sind. Um mit dem Aufbau unserer Beispielanwendung als Fat JAR zu beginnen, müssen wir ein Maven-Plugin namens konfigurieren maven-shade. Sie müssen die folgenden Einträge hinzufügen plugins Abschnitt Ihrer pom.xml-Datei.

    Hier ist die Beispiel-Maven-Konfiguration zum Erstellen der JAR-Datei.

    <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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>net.javabeat</groupId>
    <artifactId>DropWizardExample</artifactId>
    <packaging>jar</packaging>
    <version>1.0.0</version>
    <name>SampleApp Maven Webapp</name>
    <properties>
    <dropwizard.version>0.9.2</dropwizard.version>
    </properties>
    <dependencies>
    <dependency>
    <groupId>io.dropwizard</groupId>
    <artifactId>dropwizard-core</artifactId>
    <version>${dropwizard.version}</version>
    </dependency>
    </dependencies>
    <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>net.javabeat.dropwizard.EmployeeApplication</mainClass>
    </transformer>
    </transformers>
    </configuration>
    </execution>
    </executions>
    </plugin>
    </plugins>
    </build>
    </project>
    

    10. Ausführen Ihrer Anwendung

    Der letzte Schritt besteht darin, Ihre Anwendung auszuführen. Es ist sehr einfach, wenn Sie Ihre JAR-Datei im vorherigen Abschnitt erfolgreich erstellt haben. Sie müssen die Eingabeaufforderung öffnen und einfach den folgenden Befehl ausführen, um Ihre JAR-Datei auszuführen:

    java -jar target/DropWizardExample-1.0.0.jar server employee-details.yml
    

    Wenn Ihre Anwendung ohne Fehler gestartet wurde, wird auf dem Bildschirm eine Meldung wie die folgende angezeigt:

    INFO  [2011-12-03 00:38:32,927] io.dropwizard.cli.ServerCommand: Starting emp-details
    INFO  [2011-12-03 00:38:32,931] org.eclipse.jetty.server.Server: jetty-7.x.y-SNAPSHOT
    INFO  [2011-12-03 00:38:32,936] org.eclipse.jetty.server.handler.ContextHandler: started o.e.j.s.ServletContextHandler{/,null}
    INFO  [2011-12-03 00:38:32,999] com.sun.jersey.server.impl.application.WebApplicationImpl: Initiating Jersey application, version 'Jersey: 1.10 11/02/2011 03:53 PM'
    INFO  [2011-12-03 00:38:33,041] io.dropwizard.setup.Environment:
    
    GET     /emp-details (net.javabeat.dropwizard.resources.EmployeeResource)
    
    INFO  [2011-12-03 00:38:33,215] org.eclipse.jetty.server.handler.ContextHandler: started o.e.j.s.ServletContextHandler{/,null}
    INFO  [2011-12-03 00:38:33,235] org.eclipse.jetty.server.AbstractConnector: Started [email protected]:8080 STARTING
    INFO  [2011-12-03 00:38:33,238] org.eclipse.jetty.server.AbstractConnector: Started [email protected]:8081 STARTING
    

    Ausführen einer Beispiel-Dropwizard-Anwendung in Ihrem lokalen Netzwerk

    Jetzt überwacht Ihre Dropwizard-Anwendung die Ports 8080 für Anwendungsanfragen und 8081 für Verwaltungsanfragen.

    Beachten Sie, dass server employee-details.yml wird zum Starten des HTTP-Servers und zum Übergeben des verwendet YAML Speicherort der Konfigurationsdatei auf dem Server. Wenn Sie diese Argumente nicht übergeben, wird möglicherweise die folgende Meldung auf dem Bildschirm angezeigt:

    usage: java -jar DropWizardExample-1.0.0.jar.jar
    [-h] [-v] {server} ...
    
    positional arguments:
    {server}               available commands
    
    optional arguments:
    -h, --help             show this help message and exit
    -v, --version          show the service version and exit
    

    Zu den Bewerbungen gelangen Sie unter http://localhost:8080/emp-details oder mit Parametern wie http://localhost:8080/emp-details?param1=Ashwanth&param2=Spring%20Boot. Sie würden den Bildschirm wie folgt sehen:

    Dropwizard-Beispiel für AnfängerDropwizard-Beispiel mit Abfrageparameter

    Exzellent!! Schließlich haben wir mithilfe des Dropwizard-Frameworks einen Microservice implementiert. Jetzt lass uns eine Pause machen und eine Tasse Tee trinken, das hast du wirklich gut gemacht :).

    11. So ändern Sie den Kontextpfad

    Standardmäßig wird die Dropwizard-Anwendung im gestartet und ausgeführt /. Wenn Sie beispielsweise nichts über den Kontextpfad der Anwendung erwähnen, kann standardmäßig über die URL auf die Anwendung zugegriffen werden http://localhost:8080/. Wenn Sie Ihren eigenen Kontextpfad für Ihre Anwendung konfigurieren möchten, fügen Sie bitte die folgenden Einträge zu Ihrem hinzu YAML Datei.

    server:
    applicationContextPath: /application
    

    12. Ressourcen zum Erlernen von Dropwizard

    Hier finden Sie einige nützliche Dropwizard-Tutorials und Dokumentationen, die Ihnen beim Erlernen des Dropwizrad-Frameworks helfen.

    13. Laden Sie den Quellcode herunter

    Den Quellcode für das obige Tutorial können Sie hier herunterladen:

    Symbol

    DropWizard-Beispiel

    1 Datei(en) 6,27 KB Download

    14. Zusammenfassung

    In diesem Dropwizard-Tutorial habe ich die wichtigsten Komponenten und Konfigurationen erklärt, die zum Ausführen eines REST-Webdienstes mit dem Dropwizard-Framework erforderlich sind. Es umfasst die Erstellung einer YAML-Konfigurationsdatei, die Zuordnung zu einer Konfigurationsklasse, das Schreiben einer Anwendungsklasse sowie das Erstellen einer Ressourcendarstellung und einer Ressourcenklasse. Abschließend habe ich die Maven-Build-Konfiguration erklärt, um die FAT-JAR-Datei zu erstellen und Ihre Anwendung über die Eingabeaufforderung auszuführen.

    Ich habe keines der fortgeschrittenen Themen in diesem Tutorial behandelt und auch nicht versucht, die Standardeinstellungen für die Ausführung des Dienstes zu ändern. Dieses Tutorial wäre sehr nützlich für Anfänger, die mit dem Erlernen des Dropwizard-Frameworks beginnen. In meinem nächsten Tutorial werde ich erweiterte Konfigurationen für die Ausführung Ihrer Dropwizard-Anwendung entwickeln.

    Wenn Sie Fragen zu Microservices-Frameworks wie Dropwizard oder Spring Boot haben, posten Sie Ihre Fragen bitte hier oder schreiben Sie mir eine E-Mail.

    Vielen Dank, dass Sie meinen Blog gelesen haben!! Viel Spaß beim Lernen!!

    Kommentar verfassen

    Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

    Nach oben scrollen