Zum Inhalt springen

IT-Tage 365 2021 Juni: „Technologien und Tools mit JHipster schneller auswählen“

Veröffentlicht am · Aktualisiert am · 5 Min. Lesezeit
IT-Tage-365-Logo

Teilen

Rahmendaten

Konferenz

Die IT-Tage 365 2021 waren eine deutsche Online-Konferenz. Die Hauptveranstaltung lief vom 6. bis 9. Dezember 2021 — zusätzlich gab es aber übers Jahr verteilt einzelne Sessions wie meine.

Vortrag

Ich hielt bei den IT-Tagen 365 die Session „Technologien und Tools mit JHipster schneller auswählen“ (auf Englisch angekündigt als „Pick Technologies & Tools Faster with JHipster“). Ich erklärte, warum wir Java-Entwickler heute mehr Tools öfter auswählen müssen, welche Herausforderungen das mit sich bringt und wie Codegenerierung mit JHipster beim schnelleren Auswählen von Technologien & Tools half.

Ich hatte meine zweite JHipster-Anwendung im Mai 2021 in Produktion gebracht. Frühere Fassungen dieses Vortrags hielt ich bereits bei der London Java Community und beim CinJUG (kein Video).

Abstract

Unsere Java-Projekte werden heute von Technologien wie Microservices, Container, Cloud, DevOps und Apps bestimmt, die sich rasant weiterentwickeln. Deshalb wählen wir Java-Entwickler heute mehr Technologien als je zuvor aus – und auch noch häufiger. Wie können wir also zuerst einmal die richtigen Technologien auswählen? Und wie können wir dann technologisch auf dem Laufenden bleiben?

Ich diskutierte typische Herausforderungen bei der Auswahl von Technologien und Tools. Dann stellte ich JHipster vor, einen Open-Source-Anwendungsgenerator mit 170.000 monatlichen Downloads. JHipster hat keine proprietären Schichten und erzeugt produktionsreifen Code. Mit JHipster können wir einfach die gleiche Anwendung mit unterschiedlichen Technologien generieren: Monolith und Microservices, Backend mit NoSQL und SQL, Spring Boot und Micronaut und Node.js und .NET, Frontend mit React und Angular und Vue.js. Wir können diese Anwendungen dann mit unseren Daten in unserer Umgebung verändern, testen, debuggen, in Betrieb nehmen und zur Laufzeit überwachen. Wir lernen also Technologien und Tools, indem wir Code ausführen! Das ist viel besser, als aus veralteten Artikeln mit „Spielzeugbeispielen“ zu lernen, die unsere Umgebungen und Daten gar nicht kennen können!

Während des Vortrags demonstrierte ich live, wie man mit JHipster eine Anwendung generiert.

Historischer Hinweis (Stand: Juni 2021): Während des Vortrags konnten Teilnehmerinnen und Teilnehmer live über Mentimeter abstimmen und Feedback geben.

Folien

Die Folien standen als PDF (3,7 MB) zur Verfügung; hier steht die PDF-Fassung zum Download bereit.

Folien herunterladen (PDF)

Daneben gab es die Folien auch im ursprünglichen Keynote-Format (5,4 MB) — mit weniger Text, dafür animiert und mit Blick hinter die Kulissen einzelner Effekte; diese Fassung steht hier allerdings nicht zum Download bereit.

Video

Ein Video zu diesem Vortrag ist nicht bekannt.

Historischer Hinweis (Stand: Juni 2021): Damals suchte ich ein neues Projekt ab Oktober 2022.

Weitere Informationen zum Vortrag

Mehr Technologien & öfter

  • Folie Java & TypeScript: Die Java-Versionen stammen aus Wikipedia, ebenso die TypeScript-Versionen. Stand 15. Juni 2021 fehlte dort noch das TypeScript-4.3-Release.
  • Folie Frameworks: Die beiden blauen Punkte links und rechts stehen für Java EE und Spring Boot. Die fünf roten Punkte rechts stehen für MicroProfile, Quarkus, Micronaut, DropWizard und Helidon.
  • Folie Java-Distributionen: Die beiden blauen Punkte links und rechts stehen für Oracles JDK und IBMs OpenJ9 (2017 als Eclipse-Projekt umbenannt von „J9“). Der erste rote Punkt rechts steht für AdoptOpenJDK, das gerade zu einem Eclipse-Projekt namens „Adoptium“ wurde und sowohl OpenJ9- als auch „reguläre“ OpenJDK-Releases vertreibt. Die übrigen roten Punkte stehen für OpenJDK-Distributionen von Oracle, Microsoft, Amazon, RedHat, Azul, Alibaba, Bell Soft und SAP.

Was ist JHipster?

  • Für das Live-Coding steckte ich sowohl die Anwendungskonfiguration als auch das Datenmodell in eine JDL-Datei. Das sollte man nicht tun: So wird beim erneuten Import mit JHipster jedes Mal die gesamte Anwendung neu gebaut, sobald sich nur der Datenmodell-Teil ändert! Besser ist es, Anwendung und Datenmodell in getrennte JDL-Dateien zu packen.
  • Meine JDL-Datei war dieselbe, die ich für mein JHipster-Tutorial verwendete. Sie liegt auf GitHub und sah am 15. Juni 2021 so aus:
    • Der application-Abschnitt beschreibt die Konfiguration meiner Anwendung — keine Überraschungen: ein Spring-Boot-Monolith mit H2 als Entwicklungsdatenbank und PostgreSQL als Produktivdatenbank, mehrsprachig (Englisch, Deutsch, Russisch).
    • deployment dokumentiert die Bereitstellung über eine Docker-Compose-Datei.
    • Ich deklariere verschiedene Domänenobjekte (entity) und ihre relationships.
    • In Spring Boot generiere ich sowohl Service-Interfaces als auch Implementierungsklassen (service) sowie Data Transfer Objects (dto).
application {
  config {
    baseName my_simple_shop
    applicationType monolith
    authenticationType jwt
    buildTool maven
    cacheProvider ehcache
    clientFramework react
    clientPackageManager npm
    clientTheme litera
    clientThemeVariant primary
    databaseType sql
    devDatabaseType h2Disk
    dtoSuffix DTO
    enableHibernateCache true
    enableTranslation true
    jhiPrefix bpf
    languages [en, de, ru]
    messageBroker false
    nativeLanguage en
    packageName com.betterprojectsfaster.tutorial.jhipsterdocker
    prodDatabaseType postgresql
    reactive false
    searchEngine false
    serverPort 8080
    skipClient false
    skipServer false
    skipUserManagement false
    websocket spring-websocket
    testFrameworks [cypress]
  }
  entities *
}

deployment {
  deploymentType docker-compose
  dockerRepositoryName "joedata"
}

entity Product {
  name String required unique minlength(2) maxlength(90)
  price Float required min(0)
  description TextBlob required
  picture ImageBlob required
  specification Blob
  category ProductCategory
  inventory Integer required min(0)
}

enum ProductCategory {
  Laptop, Desktop, Phone, Tablet, Accessory
}

entity Address {
  addressLine1 String required minlength(2) maxlength(80)
  addressLine2 String minlength(2) maxlength(80)
  city String minlength(2) maxlength(80)
  postalCode String minlength(5) maxlength(5)
}

entity ShoppingOrder {
  name String required unique minlength(2) maxlength(90)
  totalAmount Float min(0)
  ordered LocalDate
}

entity ProductOrder {
  amount Integer required min(0) max(5)
}

entity Shipment {
  shippedAt LocalDate required
}

relationship OneToOne {
  Shipment{order(name) required} to ShoppingOrder{shipment(shippedAt)}
}

relationship OneToMany {
  Product to ProductOrder{product(name) required}
  ShoppingOrder{orders} to ProductOrder{overallOrder(name) required}
}

relationship ManyToOne {
  Address{user(login) required} to User
  ProductOrder{buyer(login) required} to User
  ShoppingOrder{buyer(login) required} to User
  Shipment{shippedBy(login) required} to User
}

service * with serviceImpl
dto * with mapstruct

Wie hilft JHipster?

Vorauswahl: JHipster-Folien:

  • Framework: Spring Boot ist Teil des JHipster-Kerns. Alle anderen Optionen brauchen Plugins (siehe den Abschnitt Plugins unten).
  • Sprache: Java ist die Standard-Backend-Sprache. Über ein Plugin lässt sich Kotlin nutzen. Mit .NET oder Node.js wechselt die Sprache zu C# bzw. JavaScript.
  • Architektur: JHipster generiert wahlweise einen Monolithen oder Microservices. Details zur Microservices-Architektur stehen in diesem Abschnitt der JHipster-Website.
  • Build-Tool: Maven oder Gradle.
  • Authentifizierung: JWT, OAuth 2 oder sitzungsbasierte Authentifizierung standen zur Wahl. Details in diesem Abschnitt der JHipster-Website.
  • Caching: JHipster bietet mehrere Caching-Optionen. Details in diesem Abschnitt der JHipster-Website.
  • Tests: JHipster legt standardmäßig Unit-Tests an. Optional lassen sich Frameworks für End-to-End-Web-Tests oder Performance-Tests hinzunehmen. JHipster wählt und konfiguriert die Frameworks dafür, die Tests selbst musste man aber trotzdem noch schreiben. Details hier.
  • Continuous Integration: JHipster erzeugt die Konfigurationsdateien für alle gängigen CI-Frameworks. Details auf der JHipster-Website.
  • Deployment: Der Abschnitt „Production“ der JHipster-Website beschreibt die Bereitstellung; die Seitenleiste links listet die verfügbaren Optionen.
  • Monitoring: JHipster bringt ein eingebautes Dashboard mit und unterstützt auch andere Monitoring-Systeme. Details auf der JHipster-Website.

Einstieg in JHipster

Für die jeweils aktuellen Informationen lohnt sich immer ein Blick auf die JHipster-Website.

Mein Tutorial

Für den Einstieg in JHipster eignete sich mein dreiteiliges JHipster-Tutorial:

  • Der erste Teil ist optional. Er erzählt, wie JHipster und Docker mein erstes Angular-Java-Projekt retteten.
  • Der zweite Teil half bei der Installation von JHipster. Danach generierten wir unsere erste JHipster-Anwendung und erkundeten die Oberfläche für Administration und Entitäten.
  • Im dritten und letzten Teil sahen wir uns den JHipster-Code an: Eclipse/IntelliJ konfigurieren, das Projekt importieren und den Code untersuchen.

Plugins

Plugins verändern den von JHipster generierten Code. Sie sind optional; JHipster nennt sie „Blueprints“.

Offiziell unterstützte Blueprints gibt es hier:

Grundsätzlich ließen sich mehrere Blueprints gleichzeitig nutzen. Zumindest das Kotlin-Blueprint schien sich aber nicht mit anderen Blueprints zu vertragen.

Die vollständige Liste aller Blueprints auf der JHipster-Website enthielt zum Beispiel auch das Quarkus-Blueprint.