Suche
Ut unum sint

Neues von Jooby: Wie man Large-Scale-Anwendungen mit dem Micro-Framework baut

Edgar Espina

© Shutterstock.com / kulvinder singh

Jooby ist ein modulares Micro-Framework für das Entwickeln von Web-Anwendungen mit Java und Kotlin. Micro-Frameworks sind ideal, um kleine Anwendungen zu erstellen, aber sind sie auch geeignet, die Umsetzung mittelgroßer oder sehr komplexer Projekte zu durchzuführen? In diesem Artikel gehen wir der Frage auf den Grund, wie man Jooby nutzt, um umfangreiche Web-Anwendungen zu erstellen, und den Code dennoch wartbar und gut strukturiert hält.

Sagen wir, wir wollen ein HTTP-API für User erstellen. Dann könnte eine erste Anwendung eventuell wie folgt aussehen:

import org.jooby.Jooby;

public class App extends Jooby {

  {
    /** User API: */
    use("/api/users")
      /** List all users. */
      .get(() -> {
        UserDao dao = require(UserDao.class);
        return dao.list();
      })
      /** Find user by ID. */
      .get("/:id", req -> {
        String id = req.param("id").value();
        UserDao dao = require(UserDao.class);
        return dao.get(id);
      })
      /** Create new user. */
      .post(req-> {
        User user = req.body(User.class);
        UserDao dao = require(UserDao.class);
        return dao.create(dao);
      })
      /** Delete by ID. */
      .delete(req-> {
        String id = req.param("id").value();
        UserDao dao = require(UserDao.class);
        return dao.delete(id);
      });
  }

  public static void main(String[] args) {
    run(App::new, args);
  }
}

Und schon sind wir fertig! Die Anwendung ist bereit für den Einsatz, sie sieht sauber aus und leicht zu verstehen ist sie ebenfalls. Simplizität ist immerhin eine von Joobys Kerneigenschaften. Nun aber wollen wir die Anwendung erweitern. Etwa mit einem HTTP-API für Blogs, einem HTTP-API für Kommentare und einem User Interface für die Nutzer, Blogs und Kommentare. Wir könnten die bereits geschriebene Anwendung weiterverwenden und einfach die Zahl der Codezeilen in unserer App.java vergrößern. Das ist ein valider Ansatz, immerhin gehört die Applikation uns.

Was aber tun, wenn man den Quelltext ein wenig besser organisieren und strukturieren will? Geht das? Bei den meisten Micro-Frameworks lautet die Antwort „nein“. Aber nicht so bei Jooby: Das Framework hat einige Features und Patterns, die eine gute Organisation und Zusammenstellung der Anwendung ermöglichen.

MVC Routes (Controller)

MVC Routes (auch bekannt als Controller) ist ein aus anderen Java-Frameworks bekanntes Pattern, bei dem Methoden annotiert und damit dem Zugriff über HTTP geöffnet werden:

import javax.inject.Inject;
import org.jooby.mvc.Path;
import org.jooby.mvc.GET;

@Path("/api/pets")
public class UserController {

  private UserDAO dao;

  @Inject
  public UserController(UserDAO dao) {
    this.dao = dao;
  }

  @Path("/:id")
  @GET
  public Pet get(String id) {
    return dao.get(id);
  }

  @GET
  public List<Pet> list() {
    return dao.list();
  }
}

Wir können die Script Routes durch unseren neuen Controller ersetzen, unsere Anwendung sieht also nun wie folgt aus:

import org.jooby.Jooby;

public class App extends Jooby {

  {
    use(UserController.class);
  }

  public static void main(String[] args) {
    run(App::new, args);
  }
}

Das gleiche Muster kann nun auch auf Blogs, Kommentare und UI-Controller angewandt werden:

import org.jooby.Jooby;

public class App extends Jooby {

  {
    /** UI: */
    use(WebPageController.class);
    /** User API: */
    use(UserController.class);
    /** Blog API: */
    use(BlogController.class);
    /** Comment API: */
    use(CommentController.class);
  }

  public static void main(String[] args) {
    run(App::new, args);
  }
}

Die Nutzung von Controller-Klassen und Annotationen ist der übliche Weg, um eine Anwendung in verschiedene Komponenten aufzuteilen. Wäre es nicht großartig, wenn wir die Script Routes behalten und damit den Quelltext wohlstrukturiert halten könnten?

Eingebettete Anwendungen

Dieses Pattern gibt Nutzern alles an die Hand, um eine oder mehrere Anwendungen in eine große Anwendung zusammenzufassen. Für alle, die Script Routes lieben und sie gerne möglichst gut organisiert mögen, ist es perfekt. Wir teilen also unsere Anwendung in vier verschiedene Komponenten, wie wir das zuvor mit den Controllern gemacht haben. Diesmal ist allerdings jede Komponente selbst eine Anwendung.

import org.jooby.Jooby;

public class Users extends Jooby {

  {
    /** User API: */
    use("/api/users")
      /** List all users. */
      .get(() -> {
        UserDao dao = require(UserDao.class);
        return dao.list();
      })
      /** Find user by ID. */
      .get("/:id", req -> {
        String id = req.param("id").value();
        UserDao dao = require(UserDao.class);
        return dao.get(id);
      })
      /** Create new user. */
      .post(req-> {
        User user = req.body(User.class);
        UserDao dao = require(UserDao.class);
        return dao.create(dao);
      })
      /** Delete by ID. */
      .delete(req-> {
        String id = req.param("id").value();
        UserDao dao = require(UserDao.class);
        return dao.delete(id);
      });
  }
}

Nun wird es Zeit, das Ganze einzubetten. Das funktioniert exakt so wie beim Beispiel der Controller.

import org.jooby.Jooby;

public class App extends Jooby {
  {
    /** UI: */
    use(new WebPages());
    /** User API: */
    use(new Users());
    /** Blog API: */
    use(new Blogs());
    /** Comment API: */
    use(new Comments());
  }

  public static void main(String[] args) {
    run(App::new, args);
  }
}

Durch diesen Ansatz können eigenständige Anwendungen erstellt werden, die dann in eine große Anwendung eingebettet werden.

Fazit

In diesem Artikel habe ich gezeigt, wie man mit Jooby umfangreiche Anwendungen erstellen kann, die auch aus mehreren eigenständigen Anwendungen bestehen können. Dabei habe ich MVC bzw. Script Routes verwendet. Manche ziehen MVC Routes den Script Routes vor, wobei es durchaus möglich ist, beide zu verwenden oder sie zusammenzuwerfen. Jooby sorgt dafür, dass die richtigen Werkzeuge zur Verfügung stehen – die Entscheidung bleibt aber beim User.

Lesen Sie auch: Jooby 1.1 macht Kotlin zum Bürger erster Klasse

Weitere Informationen zu Jooby gibt es auf der offiziellen Homepage des Mikro-Frameworks. Der vorliegende Artikel wurde vom Autor im Original auf Hackernoon veröffentlicht.

Geschrieben von
Edgar Espina
Edgar Espina
Vater. Open-Source-Enthusiast. Schöpfer von Jooby & handlebars.java
Kommentare

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.