Zum Inhalt springen

Teil 3 von 3 — Better Java Projects Faster with JHipster and Docker

Explore the JHipster code

von Karsten Silz
Der JHipster-Code in IntelliJ

Bisher im Tutorial „Better Java Projects Faster with JHipster and Docker”

Im zweiten Teil des Tutorials „Better Java Projects Faster with JHipster and Docker” haben wir zunächst die gesamte benötigte Software installiert. Dann haben wir die JHipster-Anwendung generiert und gestartet. Zum Schluss haben wir uns ihren Administrations- und Entitätsbereich angeschaut. Ihr Projekt-Quellcode sollte jetzt so aussehen wie der „master“-Branch des GitHub-Projekts.

Dieser Tutorial-Teil ist veraltet!

Ursprünglich verwendete das Tutorial Gradle als Build-Datei und Angular als Front-End. Am 15. Juni 2021 bin ich auf Maven und React umgestiegen, da beide deutlich populärer sind. Sowohl die Screenshots als auch der Text beschreiben noch Gradle und die ältere Angular-Oberfläche.

Ziele für diesen Teil

In diesem dritten Teil des Tutorials schauen wir uns den JHipster-Code in unserer IDE an:

  • Wir installieren oder konfigurieren entweder Eclipse oder IntelliJ für Spring Boot und Angular.
  • Wir importieren das Projekt in Eclipse oder IntelliJ.
  • Wir untersuchen den Code, den JHipster für unsere Entitäten erzeugt hat.

Wie baut man das Projekt mit IDEs?

Bevor wir unser JHipster-Projekt in eine IDE importieren, müssen wir entscheiden, wie es in der IDE gebaut werden soll. Wir haben zwei Optionen:

  • IDE-Build verwenden
    Die IDE analysiert unser Projekt und ahmt die Gradle-Build-Schritte — etwa das Kompilieren von Java-Code oder das Erstellen einer JAR-Datei — mit eigenen Build-Aktionen nach.
  • Gradle-Build verwenden
    Die IDE führt genau das gleiche Gradle-Projekt aus, das wir auch von der Kommandozeile aus starten.

Der Hauptvorteil des IDE-Builds ist ein möglicher Gewinn an Eleganz und Geschwindigkeit: Die IDE kann ihre internen Build-Aktionen schneller starten und deren Ergebnisse leichter interpretieren, als einen kompletten Gradle-Build anzustoßen und dessen Ausgabe zu durchforsten. Aber es gibt auch viele Nachteile:

  • Zwei unterschiedliche Builds
    Einerseits verwenden Entwickler jetzt ein Build-System in ihrer täglichen Arbeit — das IDE-Build- System. Andererseits verwendet der Continuous-Integration-Server (CI) ein anderes Build-System — Gradle. Und wenn Ihr CI- Server Ihre Release-Dateien nicht baut, dann machen Sie das wahrscheinlich auch von einem Terminal aus mit Gradle. Im besten Fall führen diese doppelten Build- Systeme nur zu doppelter Arbeit. Im schlimmsten Fall führt das zu Unterschieden im Anwendungsverhalten, Bugs und Problemen.
  • Komplexität in der IDE
    Die IDE kann Gradle nur nachahmen, wenn sie tatsächlich für jeden Gradle-Build- Schritt eine interne Build-Aktion besitzt. Das ist nicht selbstverständlich. Nehmen Sie zum Beispiel Mapstruct, das Java-Entitätsdateien in Data Transfer Objects (DTOs) übersetzt und wieder zurück. Unser Tutorial-Projekt verwendet Mapstruct, das IDE-Build-System muss also auch Mapstruct ausführen. Vorab verraten: Weder Eclipse noch IntelliJ kann das von Haus aus, beide benötigen dafür Plug-ins. Aber es kommt noch mehr: Gradle macht es einfach, den Build durch kleine Methoden direkt in den Gradle-Build-Dateien anzupassen. Eine Methode hier, eine Methode dort, und schon geht es um echte Build-Anpassung. Wie soll die IDE damit umgehen?!

Um bei einem Build-System zu bleiben und diese Komplexität in der IDE zu vermeiden, verwenden wir auch in Eclipse und IntelliJ den Gradle-Build.

IDE-Projektdateien in Git

Sowohl Eclipse als auch IntelliJ legen Dateien in unserem Tutorial-Projekt an, um Einstellungen und Präferenzen zu speichern. Dank der Magie von .gitignore werden diese Dateien nicht in Git gespeichert. Ich halte das für die richtige Entscheidung für unser Tutorial-Projekt.

IntelliJ empfiehlt, Projektdateien selektiv über Git zu teilen. Damit hatte ich Probleme: Wir haben manchmal versehentlich unsere Run Configurations geteilt, die lokale JDK-Namen und zusätzliche JVM- Parameter enthielten und deshalb auf dem Rechner eines anderen nicht funktionierten.

Unsere Java-IDEs: Eclipse & IntelliJ

Ich beschreibe, wie man das Tutorial-Projekt in den beiden am weitesten verbreiteten IDEs importiert und ausführt: Eclipse und IntelliJ. Ich gehe davon aus, dass Sie nur eine der beiden verwenden, überspringen Sie also gerne die Abschnitte zur jeweils anderen IDE.

Wir beginnen mit Eclipse.

Eclipse: Bestehende Installation

Wenn Sie Eclipse als Ihre IDE bevorzugen und es bereits installiert haben, dann benötigen Sie Plug-ins für Angular und Spring Boot. Falls Sie diese nicht haben, finden Sie im nächsten Abschnitt eine Anleitung zur Installation der Plug-ins „Spring Tools” und „Angular Eclipse”. Fahren Sie danach bitte mit dem Abschnitt Eclipse: Globale Konfiguration ändern fort.

Eclipse: Neuinstallation

Wenn Sie Eclipse als Ihre IDE bevorzugen und es noch nicht installiert haben, gehen Sie zur Eclipse-Paketauswahl und laden Sie die Eclipse IDE for Java Developers herunter. Sie hat Stand 15. August 2019 die Version „2019-06 R”. Installieren Sie sie dann bitte auf Ihrem Rechner:

  • Windows
    Entpacken Sie das Archiv in ein Verzeichnis auf Ihrer Festplatte.
  • Mac
    Öffnen Sie das Installer-Image und ziehen Sie die Anwendung in Ihren Ordner Programme.

Installieren Sie nun zwei kostenlose Plug-ins für Angular und Spring Boot:

  • Gehen Sie in Eclipse zum Menü Help - Eclipse Marketplace….
  • Fügen Sie die folgende URL in das Feld Find: ein, um das „Spring Tools”-Plug-in anzuzeigen (Version 4.3.1 Stand 15. August 2019): https://marketplace.eclipse.org/content/spring-tools-4-spring-boot-aka-spring-tool-suite-4
  • Drücken Sie „Enter.” Sie sollten nun das „Spring Tools”-Plug-in sehen:

Spring Tools Eclipse-Plug-in

  • Klicken Sie auf die Schaltfläche Install, um das Plug-in hinzuzufügen, folgen Sie den Anweisungen und starten Sie Eclipse neu.
  • Gehen Sie erneut zum Menü Help - Eclipse Marketplace… und fügen Sie diese URL in das Feld Find: ein für das „Angular Eclipse”-Plug-in (Version 1.3.0 Stand 15. August 2019): https://marketplace.eclipse.org/content/angular-eclipse
  • Drücken Sie „Enter”, um das „Angular Eclipse”-Plug-in zu sehen:

Angular Eclipse-Plug-in

  • Installieren Sie auch dieses Plug-in und starten Sie Eclipse noch einmal neu.

Jetzt haben Sie die gesamte notwendige Software installiert, also fahren wir mit der Konfiguration von Eclipse fort.

Eclipse: Globale Konfiguration ändern

Jetzt müssen wir sicherstellen, dass Eclipse unser JHipster-Projekt tatsächlich mit JDK 11 ausführen kann:

  • Öffnen Sie die Eclipse-Präferenzen. Unter Windows ist das Window — Preferences, unter macOS Eclipse — Preferences…
  • Gehen Sie zu Java — Installed JREs und stellen Sie sicher, dass JDK 11 die Standard-JRE ist:

Installed JREs im Java-Abschnitt der Eclipse-Präferenzen

  • Gehen Sie nun zu Gradle und stellen Sie sicher, dass Gradle wrapper als Gradle distribution ausgewählt ist:

Gradle-Abschnitt der Eclipse-Präferenzen

  • Drücken Sie Apply and Close, um Ihre Einstellungen zu speichern.

Eclipse: Das Tutorial-Projekt importieren

Bringen wir nun das Tutorial-Projekt in Eclipse:

  • Wählen Sie das Menü File — Import…. Tippen Sie dann „grad”, bis die Option Gradle — Existing Gradle Project hervorgehoben ist. Wählen Sie sie aus:

Start des Imports eines bestehenden Gradle-Projekts in Eclipse

  • Drücken Sie nun Next >, um zu einem Gradle-Informationsbildschirm zu gelangen. Die wichtigste Empfehlung haben wir bereits im vorherigen Abschnitt umgesetzt — die Verwendung des Gradle-Wrappers. Drücken Sie einfach erneut Next >:

Informationen zur Gradle-Integration in Eclipse

  • Drücken Sie im nächsten Bildschirm Browse… und wählen Sie das Verzeichnis aus, in dem das Tutorial-Projekt auf Ihrem Rechner liegt. Drücken Sie dann Finish:

Auswahl des Tutorial-Projektverzeichnisses für den Import

  • Es kann jetzt eine Fehlermeldung auftreten, dass Eclipse das Tutorial-Projekt (ein Git-Projekt) nicht automatisch teilen konnte. Falls das passiert, bestätigen Sie das:

Mögliche Git-Fehlermeldung während des Imports

  • Das Explorer-Fenster sollte jetzt Ihr neues Projekt anzeigen. Es hat noch das falsche JDK, aber das beheben wir im nächsten Abschnitt:

Tutorial-Projekt importiert

Eclipse: Die Projektkonfiguration ändern

Nachdem wir unser Tutorial-Projekt jetzt in Eclipse haben, müssen wir sicherstellen, dass es mit JDK 11 läuft:

  • Klicken Sie mit der rechten Maustaste im Explorer-Fenster links auf Ihr Projekt und wählen Sie Properties, um die Tutorial-Projekteinstellungen zu öffnen.
  • Navigieren Sie zu den Einstellungen Java Build Path, Abschnitt Libraries, wählen Sie die JRE System Library aus und drücken Sie die Schaltfläche Edit…:

Libraries-Abschnitt in den Eclipse-Projektpräferenzen

  • Wählen Sie im nächsten Dialog die Option Workspace default JRE (die Sie im vorherigen Abschnitt auf JDK 11 gesetzt haben) und drücken Sie Finish:

Bearbeiten der JRE System Library in den Eclipse-Projektpräferenzen

  • Navigieren Sie zu den Einstellungen Java Compiler und wählen Sie „11” als Compiler compliance level:

Einstellen des Compiler compliance level in den Eclipse-Projektpräferenzen

  • Drücken Sie Apply and Close, um Ihre Einstellungen zu speichern. Wenn Eclipse fragt, ob das Projekt neu gebaut werden soll, wählen Sie Yes:

Dialog „Compiler-Einstellungen geändert”

  • Jetzt sollten Sie JDK 11 als JRE System Library im Explorer-Fenster sehen:

Tutorial-Projekt mit korrekter JDK-Version

Eclipse: Das Projekt ausführen

Endlich können wir das Tutorial-Projekt in Eclipse ausführen!

  • Wählen Sie das Projekt im Explorer-Fenster aus.
  • Verwenden Sie nun entweder das Menü Run — Run as… — Spring Boot App, oder drücken Sie den grünen Run-Button (mit dem „Play-Dreieck”) in der Werkzeugleiste und wählen Sie dann Run as… — Spring Boot App:

Run-Menü für das Tutorial-Projekt

  • Die Anwendung startet nun. Sie sollten die folgende Ausgabe in der Eclipse-Konsolenansicht sehen:

Konsolenausgabe des laufenden Tutorial-Projekts

Tutorial-Anwendung, läuft in Eclipse

Herzlichen Glückwunsch — Sie haben soeben das Tutorial-Projekt in Eclipse importiert und ausgeführt!

IntelliJ: Bestehende Installation

Wenn Sie IntelliJ als Ihre IDE bevorzugen und die Ultimate Edition bereits installiert haben, stellen Sie bitte sicher, dass Sie die richtigen Plug-ins für Angular und Spring Boot aktiviert haben. Sie sind im nächsten Abschnitt aufgelistet. Fahren Sie danach bitte mit dem Abschnitt IntelliJ: Globale Konfiguration ändern fort.

IntelliJ: Neuinstallation

Wenn Sie IntelliJ als Ihre IDE bevorzugen, beachten Sie, dass Sie die Ultimate Edition benötigen, denn nur diese Edition unterstützt TypeScript (das Angular verwendet) und Spring Boot. Sie müssen die Ultimate Edition kaufen, aber die Version, die Sie kostenlos herunterladen können, dient auch als Testversion.

Gehen Sie also zum IntelliJ-Downloadbereich und laden Sie die Ultimate Edition herunter. Sie hat Stand 15. August 2019 die Version „2019.2”. Installieren Sie sie dann bitte auf Ihrem Rechner:

  • Windows
    Führen Sie das Installationsprogramm aus.
  • Mac
    Öffnen Sie das Installer-Image und ziehen Sie die Anwendung in Ihren Ordner Programme.

Wenn IntelliJ zum ersten Mal startet, zeigt es eine Reihe von Anpassungsbildschirmen:

  • Zuerst wählen Sie ein UI-Theme. Ich bevorzuge Light, aber Ihr Geschmack kann davon abweichen:

Theme-Auswahl beim ersten Start von IntelliJ

  • Drücken Sie die Schaltfläche Next: Default plugins, um zum Bildschirm für die Standard-Plug-in-Konfiguration zu gelangen, der in Abschnitte unterteilt ist. Hier deaktivieren wir alle Plug-ins, die wir für unser Tutorial- Projekt nicht brauchen. Warum? Weil IntelliJ umso schneller läuft und umso weniger Ressourcen verbraucht, je weniger Plug-ins es hat. Der Bildschirm sieht am Ende so aus:

Bildschirm für Standard-Plug-ins beim ersten Start von IntelliJ

  • Als Erstes deaktivieren wir Java-Frameworks. Wählen Sie den Link Customize… im Abschnitt Java Frameworks und lassen Sie nur diese Einträge angehakt:

Empfohlene Java-Frameworks beim ersten Start von IntelliJ

  • Drücken Sie dann Save Changes and Go Back, um Ihre Auswahl zu speichern. Wählen Sie nun den Link Customize… im Abschnitt Build Tools und behalten Sie nur Gradle:

Empfohlene Build-Tools beim ersten Start von IntelliJ

  • Drücken Sie nun Save Changes and Go Back und wählen Sie den Link Customize… im Abschnitt Web Development. Stellen Sie sicher, dass diese Optionen aktiviert sind:

Empfohlene Web-Frameworks beim ersten Start von IntelliJ

  • Klicken Sie auf Save Changes and Go Back und dann auf den Link Customize… im Abschnitt Version Controls. Wir brauchen nur Git und Github (weil es das populärste Git-Repository ist):

Empfohlene Versionskontroll-Tools beim ersten Start von IntelliJ

  • Verwenden Sie Save Changes and Go Back und wählen Sie dann den Link Customize… im Abschnitt Test Tools. Aktivieren Sie diese Werte:

Empfohlene Test-Tools beim ersten Start von IntelliJ

  • Drücken Sie ein letztes Mal Save Changes and Go Back.
  • Jetzt deaktivieren Sie ganze Abschnitte mit ihrem jeweiligen Disable-Link:
    • Application Servers
    • Clouds
    • Swing
    • Android
    • Plugin Development
  • Die Abschnitte für Database Tools und Other Tools lassen wir unverändert. Die untere Bildschirmhälfte sollte nun so aussehen:

Verbleibende Standard-Plug-in-Abschnitte beim ersten Start von IntelliJ

  • Klicken Sie auf Next: Featured plugins, um Plug-ins zu sehen, die viele Nutzer heruntergeladen haben. Wir brauchen keines davon, also drücken Sie Start using IntelliJ IDEA:

Bereiche für empfohlene Plug-ins beim ersten Start von IntelliJ

  • Damit gelangen wir zum IntelliJ-Startbildschirm:

Der IntelliJ-Startbildschirm

IntelliJ: Globale Konfiguration ändern

Jetzt müssen wir sicherstellen, dass IntelliJ unser JHipster-Projekt tatsächlich ausführen kann:

  • Wählen Sie bitte die Einstellungen im Startbildschirm aus:

Auswahl der Einstellungen im IntelliJ-Startbildschirm

  • Navigieren Sie zum Abschnitt Build, Execution, Deployment — Compiler. Sie können alle Optionen aktivieren, außer Build project automatically. Spring Boot lädt den Server nach jedem Projekt-Build neu, deshalb wollen Sie das durch manuelles Bauen selbst kontrollieren. Und in IntelliJ-Versionen vor 2019.2 aktivierte diese Einstellung aufgrund eines Bugs versehentlich das interne IDE-Build-System, selbst wenn Sie das Build-System auf Delegate to Gradle konfiguriert hatten.

Konfiguration des Compilers in IntelliJ

  • Bleiben Sie nun im Abschnitt Build, Execution, Deployment und gehen Sie zu Build Tools — Gradle. Hier gibt es vier wichtige Einstellungen:
    • Automatically import this project on changes in build script files sollte deaktiviert sein. Andernfalls importiert IntelliJ ständig Gradle, sobald Sie irgendeine der Build-Dateien ändern. Bearbeiten Sie stattdessen einfach alle Gradle-Dateien, die Sie ändern möchten, und nutzen Sie dann den freundlichen Hinweis zum erneuten Import von Gradle, den IntelliJ automatisch unten rechts im Bildschirm anzeigt.
    • Wählen Sie sowohl für Build and run using als auch für Run tests using „Gradle”. Damit wird Gradle zum Build-System, wie wir es zu Beginn festgelegt haben.
    • Wählen Sie für die Gradle VM das JDK 11, das wir im zweiten Teil dieses Tutorials installiert haben.

Konfiguration von Gradle in IntelliJ

  • Drücken Sie OK, um zum Startbildschirm zurückzukehren. Wählen Sie nun die Plug-in-Konfiguration aus:

Auswahl der Plug-ins im IntelliJ-Startbildschirm

  • Geben Sie hier „spring” in das Suchfeld ein und aktivieren Sie die unten angezeigten Plug-ins. Wir haben im vorherigen Abschnitt bei der Einrichtung „Spring” als Java-Framework ausgewählt, deshalb bin ich mir nicht sicher, warum sie bei meinem Test alle deaktiviert waren. Dieser Schritt stellt sicher, dass alle Spring- Plug-ins, die wir brauchen, bereitstehen.

Auswahl der Spring-Plug-ins in IntelliJ, Teil 1

Auswahl der Spring-Plug-ins in IntelliJ, Teil 2

  • Drücken Sie OK und starten Sie IntelliJ neu, um die Spring-Plug-ins zu aktivieren.

IntelliJ: Das Tutorial-Projekt importieren

Importieren wir das Tutorial-Projekt in IntelliJ:

  • Wählen Sie im Startbildschirm Import Project:

Start des Projektimports in IntelliJ

  • Wählen Sie als Nächstes das Verzeichnis aus, in dem das Tutorial-Projekt liegt, und drücken Sie OK:

Auswahl des Projektverzeichnisses für den Import in IntelliJ

  • Wählen Sie nun Import project from external model, dann Gradle und drücken Sie OK:

Auswahl von Gradle beim Import in IntelliJ

  • IntelliJ importiert nun Ihr Projekt tatsächlich. Nach einer Weile sehen Sie diese zwei Meldungen unten rechts erscheinen. Um sie müssen wir uns kümmern.
    Nur Windows: Möglicherweise sehen Sie eine dritte Meldung, in der IntelliJ darauf hinweist, dass Windows Defender (der eingebaute Viren- und Malware-Schutz) Ihren Build verlangsamt. Lassen Sie in diesem Fall IntelliJ Windows Defender für Sie konfigurieren.

Meldungen nach dem Import in IntelliJ

  • Klappen Sie zuerst die Meldung Spring Configuration Check mit dem Dreieck oben rechts auf und wählen Sie dann den Link Create Default Context:

Behandlung der Meldung „Spring Configuration Check” in IntelliJ, Teil 1

  • Nun öffnet sich ein Dialogfenster Spring Configuration. Drücken Sie die Schaltfläche Open Facet Configuration:

Behandlung der Meldung „Spring Configuration Check” in IntelliJ, Teil 2

  • Das führt Sie zu den Projekteinstellungen. Gehen Sie zum Abschnitt Facets und stellen Sie sicher, dass ein Spring-Facet vorhanden ist. Drücken Sie dann OK:

Prüfung des Spring-Facets in den IntelliJ-Projekteinstellungen

  • Die Meldung Spring Configuration Check sollte jetzt verschwunden sein. Kümmern wir uns als Nächstes um die Meldung Frameworks Detected, indem Sie auf deren Link Configure klicken. Das öffnet ein neues Fenster:

Konfiguration des Web-Frameworks in IntelliJ

  • Drücken Sie einfach OK, um die Web-Anwendungskonfiguration zu bestätigen. Hoffentlich gibt es jetzt keine weiteren Meldungen mehr, und die Project View zeigt unser Tutorial-Projekt:

Project View in IntelliJ nach abgeschlossenem Import

IntelliJ: Die Projektkonfiguration ändern

Nachdem das Projekt importiert ist, müssen wir noch einige seiner Einstellungen ändern:

  • Die Project View zeigt drei Build-Verzeichnisse an, zwei von Gradle (.gradle und build) und eines von Angular (node_modules). Sie nehmen Platz in der Ansicht ein und wahrscheinlich auch einige Ressourcen (node_modules hat auf meinem Rechner fast 75.000 Dateien!). Am besten blenden Sie sie aus — außerhalb von IntelliJ können Sie sie sich jederzeit ansehen. Klicken Sie also auf das Zahnrad-Symbol oben rechts in der Project View und deaktivieren Sie Show Excluded Files:

Ausblenden ausgeschlossener Dateien in IntelliJ

  • Die Project View hat jetzt keine Build-Verzeichnisse mehr:

Project View in IntelliJ ohne ausgeschlossene Dateien

  • Klicken Sie nun mit der rechten Maustaste auf das Projekt, die oberste Ebene in der Project View, und wählen Sie Open Module Settings. Schauen Sie sich den Abschnitt Problems an, in dem IntelliJ sich möglicherweise über ein fehlendes JDK beschwert:

Fehlendes Projekt-SDK-Problem in IntelliJ

  • Gehen Sie also zum Abschnitt SDKs, wo Sie wahrscheinlich sehen, dass das eingebaute JDK, mit dem IntelliJ selbst läuft, das einzige verfügbare JDK ist. Bringen wir nun das JDK 11 ins Spiel, das wir im zweiten Teil dieses Tutorials installiert haben. Klicken Sie oben auf das + und wählen Sie JDK:

Hinzufügen eines Projekt-JDKs in IntelliJ

  • Weisen Sie IntelliJ nun auf das Verzeichnis hin, in dem Sie das JDK installiert haben. Das ist unter Windows wahrscheinlich C:\Program Files und unter macOS /Library/Java/JavaVirtualMachines:

Auswahl des JDK-Verzeichnisses unter Windows

Auswahl des JDK-Verzeichnisses unter macOS

  • Sobald Sie das richtige Verzeichnis ausgewählt haben, geben Sie dem neuen JDK einen aussagekräftigen Namen, etwa „OpenJDK Hotspot 11”:

Benennung des Projekt-JDKs in IntelliJ

  • Beheben wir nun unser fehlendes JDK, indem wir zum Abschnitt Project navigieren. IntelliJ weist auf das fehlende JDK hin:

Fehlendes Projekt-JDK in IntelliJ

  • Wählen Sie hier also das gerade definierte JDK als Project SDK aus und wählen Sie „11” als Project language level:

Behobenes Projekt-JDK in IntelliJ

  • Gehen Sie nun zum Abschnitt Modules und setzen Sie das Language level sowohl für das Hauptmodul als auch für das Test-Modul auf „11”:

Korrektur des Language Level für das Hauptmodul in IntelliJ

Korrektur des Language Level für das Test-Modul in IntelliJ

  • Werfen Sie noch einmal einen Blick auf den Abschnitt Facets — er sollte jetzt zwei Einträge haben, einen für das Hauptmodul und einen für das Test-Modul:

Zwei Spring-Facets in den IntelliJ-Projekteinstellungen

  • Unsere letzte Station ist noch einmal Problems. Dort sollte nichts mehr sein:

Keine Projektprobleme mehr in IntelliJ

  • Wenn Sie jetzt OK drücken, wird das Projekt eventuell neu gebaut. Haben Sie einfach etwas Geduld.

IntelliJ: Das Projekt ausführen

Endlich können wir das Tutorial-Projekt in IntelliJ ausführen! Nun ja, eigentlich noch nicht. 😭

Zuerst müssen wir eine Run Configuration definieren. Also los geht’s:

  • Klicken Sie auf die Schaltfläche Add Configuration in der Werkzeugleiste:

Kurz vor dem Hinzufügen einer Run Configuration in IntelliJ

  • Klicken Sie im Fenster Run/Debug Configuration oben links auf die Schaltfläche + und wählen Sie Spring Boot aus der Vorlagenliste. Falls dieser Eintrag nicht sofort erscheint, klicken Sie bitte auf den Link X more items… am Ende der Liste:

Vorlagen für Run Configurations in IntelliJ

  • Damit wird eine neue Spring-Boot-Konfiguration erstellt. Aber wie Sie am kleinen roten Kreuz links erkennen können, funktioniert sie momentan nicht. Zeit, das zu beheben! Zuerst müssen wir die Main-Klasse festlegen. Drücken Sie dazu die Schaltfläche rechts:

Schaltfläche zur Auswahl der Main-Klasse in der Run Configuration in IntelliJ

  • Klicken Sie im nächsten Fenster oben in das Suchfeld. Als einziges Suchergebnis sollte automatisch „MySimpleShopApp” erscheinen. Falls nicht, tippen Sie „MySimpleShopApp”:

Auswahl der Main-Klasse für die Run Configuration in IntelliJ

  • Klicken Sie auf OK, um Ihre Klasse zu bestätigen. Auf dem nächsten Bildschirm müssen Sie nun einige Änderungen vornehmen. Der folgende Screenshot hilft Ihnen dabei:
    • Ändern Sie ganz oben den Name in „Back-End”. Warum? Weil Sie während der Entwicklung Angular (das „Front-End”) in einem eigenen Prozess ausführen, und Spring Boot dann „nur das Back-End” ist. Sobald Sie den Namen ändern, aktualisiert er sich automatisch links in der Liste der Konfigurationen.
    • Stellen Sie sicher, dass im Abschnitt Environment in der Mitte des Formulars das Dropdown Use classpath of module auf „my-simple-shop.main.” gesetzt ist.
    • Direkt unter diesem Feld muss JRE dasselbe JDK anzeigen, das Sie im vorherigen Abschnitt definiert und als Projekt-SDK festgelegt haben.
    • Wieder direkt darunter finden Sie Shorten command line. Worum geht es dabei? Ihre Spring-Boot-Anwendung ist schließlich eine Java- Anwendung, gestartet mit „java …“. Bei Java 8 und nur unter Windows war der Befehl zum Starten von Spring Boot zu lang für Java 8 (ich glaube, länger als 128 Zeichen), sodass die Anwendung gar nicht startete. Unter macOS funktionierte Java einwandfrei. Also war das Anlegen eines „JAR-Manifests” und das Verschieben einiger Kommandozeilenparameter dorthin einer der Wege, um besagten Java- Kommandozeilenbefehl unter Windows zu kürzen. Es scheint, dass mit Java 11 der lange Java-Befehl auch unter Windows funktioniert. Sie könnten hier also wahrscheinlich „none” auswählen, aber sicherheitshalber löst die Wahl von „JAR manifest” das Problem definitiv und schadet nicht, falls der lange Java- Befehl ohnehin funktionieren würde.
    • Fügen Sie im Abschnitt Spring Boot weiter unten „dev” zu den Active Profiles hinzu. Warum hier der Plural? Sie können in Spring gleichzeitig mehrere Profile haben. Und JHipster-Anwendungen haben das tatsächlich — das „swagger”-Profil sehen Sie gleich.
    • Stellen Sie schließlich sicher, dass im Abschnitt Before launch „Build” aufgeführt ist. Das stellt sicher, dass Ihr Java-Code kompiliert wird, bevor Sie starten. Das sollte standardmäßig dort stehen, dies ist also nur eine Kontrolle.

Empfohlene Änderungen in der Run Configuration in IntelliJ

  • Drücken Sie nun OK. Ihre neue Run Configuration sollte jetzt verfügbar sein:

Neue Run Configuration in IntelliJ

  • Klicken Sie auf das grüne „Run”-Dreieck rechts neben dem Konfigurations-Dropdown, um Ihr Projekt zu starten. Die Konsole zeigt dann die Log-Ausgabe der Anwendung:

Konsolenausgabe des laufenden Tutorial-Projekts, Teil 1

Konsolenausgabe des laufenden Tutorial-Projekts, Teil 2

Tutorial-Anwendung, läuft in IntelliJ

Herzlichen Glückwunsch — Sie haben soeben das Tutorial-Projekt in IntelliJ importiert und ausgeführt!

Quellcode: Build-System & Konfiguration

Nachdem wir das Projekt sowohl in Eclipse als auch in IntelliJ importiert und ausgeführt haben, schauen wir uns jetzt die generierten Quelldateien an, einverstanden? Wir beginnen mit dem Build-System und konzentrieren uns auf die besonderen Anpassungen, die JHipster in unser Projekt einbringt.

  • Unten sehen Sie einen Ausschnitt aus der Gradle-Build-Datei build.gradle für unser Java-Back-End. Er zeigt, wie leicht man einschränken kann, welche Java-Version das Projekt bauen darf. Und ja, wir könnten „11” einfach so stehen lassen, um uns auf Java 11 festzulegen.

Einschränkung der Java-Version in Gradle

  • gradle.properties enthält die Versionsnummern für die wichtigsten Abhängigkeiten. Hier sehen Sie die Long-Term-Support-(LTS-)Version 10 von Node, Spring Boot 2.1.6 und Hibernate 5.3.10.

Versionsnummern für die wichtigsten Gradle-Abhängigkeiten

  • JHipster hat einige Gradle-Tasks in gradle/profile_dev.gradle hinzugefügt. Falls Sie sich je gefragt haben, warum das Starten von Spring Boot ein NPM-Install auslöst, hier die Antwort: bootJar hängt von processResources ab, das wiederum von webpackBuildDev abhängt, das seinerseits von npmInstall abhängt. Wenn Sie also nur diese letzte Abhängigkeit auskommentieren, sparen Sie sich bei jedem Build ein paar Sekunden!

Wichtige Gradle-Task-Abhängigkeiten

  • Auch Angular hat eine Build-Datei — nämlich package.json. Angular 8 und Bootstrap 4.3.1 sind die wichtigsten Abhängigkeiten:

Angular-Build-Datei „package.json”

  • JHipster verwendet ausschließlich YAML-Konfigurationsdateien. Es gibt eine gemeinsame Konfiguration für alle Profile in src/main/resources/config/application.yml. Unten sehen Sie aber src/main/resources/config/application-dev.yml, das die Konfiguration für — Sie haben es wahrscheinlich schon erraten — das Spring-Profil dev enthält. Es
    • aktiviert das Profil swagger,
    • aktiviert die Spring Boot Developer Tools und
    • richtet die eingebettete Datenbank H2 so ein, dass sie ihre Datendatei im Verzeichnis build speichert. Deshalb verschafft Ihnen ein gradle clean einen frischen Datenbankstart — einfach und praktisch!

Spring-Konfiguration für das Profil „dev”

  • Im Paket com.betterprojectsfaster.tutorial.jhipsterdocker.config in src/main/java gibt es außerdem eine ganze Reihe von Java-Konfigurationsklassen. Ich habe „SecurityConfiguration.java” (die URLs absichert) als Beispiel ausgewählt.
    • Die erste rote Box im Screenshot unten enthält spezielle REST-API-URLs, auf die Nutzer zugreifen können, die nicht eingeloggt sind (.permitAll()).
    • Die zweite Box zeigt dagegen, dass für alle anderen REST-API-URLs eine Anmeldung erforderlich ist (authenticated()). Und nur Nutzer mit der Rolle „ADMIN” können auf /websocket/tracker zugreifen.

Schutz von URLs in der Spring-Security-Konfiguration

Quellcode: Java

Build-Dateien sind ja schön und gut, aber schauen wir uns nun echten Code im Java-Back-End an!

  • Alles beginnt mit der Datenbank. Bei JHipster bedeutet das Liquibase, das Tabellen für mehrere Datenbanksysteme erstellt und ändert und Daten lädt. Wie Sie unten sehen, ist es die einzige XML-Konfiguration, die in unserem Projekt noch übrig ist — so viel zu dem „echten Code”, den ich gerade versprochen habe! Der Screenshot zeigt src/main/resources/config/liquibase/master.xml, die zentrale Konfigurationsdatei.
    • Die erste Box enthält Definitionen von Typen und Funktionen, die sich zwischen Datenbanksystemen unterscheiden.
    • Die zweite Box enthält Tabellendefinitionen, sowohl für die eingebauten JHipster-Tabellen (00000000000000_initial_schema.xml) als auch für die Tabellen, die die aus der JDL-Datei abgeleiteten Entitäten beherbergen (201908011227**_added_entity_*.xml).
    • Dateien mit Definitionen von Indizes und Fremdschlüsseln stehen in der letzten Box.

Zentrale Liquibase-Konfigurationsdatei in Java

Product-Datenbanktabelle in Liquibase in Java

  • Liquibase erlaubt das Laden von Daten aus CSV-Dateien in Tabellen. Unten sehen Sie die „Fake-Daten”, die JHipster für unsere „Product”-Entität in src/main/resources/config/liquibase/fake-data/product.csv erzeugt hat. Fragen Sie sich, warum das in IntelliJ wie eine Tabelle aussieht? Das ist die Arbeit des sehr empfehlenswerten CSV Plugin!

Fake-Daten für die Product-Datenbanktabelle in Liquibase in Java

Product JPA-Entität in Java

  • Als Nächstes haben wir die Datenbankabfragen für die „Product”-Entität mit com.betterprojectsfaster.tutorial.jhipsterdocker.repository.ProductRepository in src/main/java. Und nein, das ist der richtige Screenshot — es ist ein Interface, keine Klasse, und es definiert tatsächlich gar keine Abfragen! Wie funktioniert das? JHipster verwendet Spring Data JPA. Diese Bibliothek verwendet Interfaces zur Definition von Datenbankabfragen und erzeugt Implementierungsklassen während des Gradle-Builds. Sie bringt Standard- CRUD-Abfragen (create, read, update und delete) im JpaRepository mit, von dem unser Interface erbt. Und da wir gerade keine weiteren Abfragen brauchen, ist dieses Interface leer.

Product Spring Data JPA Repository in Java

Product DTO in Java

  • Wie kommen wir also noch mal von einer Entität zu einem DTO? Gut, dass Sie fragen! Das ist die Aufgabe von Mapstruct, einer Bibliothek, die zwischen JPA-Entitäten und DTOs für uns übersetzt. Sie erinnern sich vielleicht, dass ich diese Bibliothek vor zehn Minuten zu Beginn dieses Tutorials als Exhibit B in meinem Fall gegen IDE-Builds angeführt habe. Genau wie bei Spring Data JPA definieren Sie ein Interface, und Mapstruct erzeugt Implementierungsklassen während des Gradle-Builds. Das Mapper-Interface für Products ist com.betterprojectsfaster.tutorial.jhipsterdocker.service.mapper.ProductMapper in src/main/java. Wenn Mapstruct nun zwischen zwei Klassen übersetzt und in beiden ein Attribut mit demselben Namen und Typ findet, kopiert es diese Attributdaten automatisch. Im Interface geben Sie also die Ausnahmen an — welche Attribute ignoriert werden sollen oder welche Attribute aus „speziellen Methoden” befüllt werden sollen. Ein Beispiel für so eine „spezielle Methode” könnte getDisplayName() auf einer User-Entität sein, die den Vornamen zurückgibt, falls vorhanden, sonst den Nachnamen, falls vorhanden, und schließlich den Login-Namen, wenn alles andere fehlschlägt.
    Wie auch immer, diese ausführliche Erklärung macht hoffentlich verständlicher, warum der Product-Mapper im Screenshot unten nur zwei Annotationen hat, die ihm sagen, dass er beim Kopieren von einem DTO zwei Entitätsattribute ignorieren soll. Ich verwende den Begriff „Entitäts- attribut” hier eher locker, denn removeProductOrder ist kein Attribut, sondern — wie der Name schon andeutet — eine Entitätsmethode, die eine Bestellung aus einer Sammlung entfernt. Das scheint ein Bug in Mapstruct zu sein, den Ihr bescheidener Autor gefunden und gemeldet hat (es ist #9726).

Product-Mapping-Interface in Java

Product Business-Service-Interface in Java

Product Business-Service-Implementierung in Java

Product REST API in Java

Quellcode: Angular

Die letzte Station auf unserer Reise durch den Quellcode ist Angular.

  • Beginnen wir mit dem Model, dem Angular-Pendant zum Java-DTO. Alle Angular-Komponenten für diese Entität verwenden dieses Model. Hier haben wir das Product-Model, das ist app/shared/model/product.model.ts in src/main/webapp. JHipster generiert immer ein Interface und eine Klasse mit optionalen Attributen (siehe das „?” nach jedem Attributnamen). Ganz oben in der Datei finden wir außerdem eine enum-Definition.

Product-Model in Angular

  • JHipster erstellt für jede Entität ein Modul mit fünf Komponenten. Unten sehen Sie das Product-Modul. Es ist app/entities/product/product.module.ts in src/main/webapp.
    • (entity name)Component ist die Tabelle mit der Liste aller Entitäten.
    • (entity name)DetailComponent ist die schreibgeschützte Ansicht einer einzelnen Entität.
    • (entity name)UpdateComponent ist das Formular zum Erstellen oder Aktualisieren einer einzelnen Entität.
    • (entity name)DeletePopupComponent löscht eine einzelne Entität, nachdem in (entity name)DeleteDialogComponent mit einem „Sind Sie sicher?“-Dialog bestätigt wurde.

Product-Modul in Angular

  • Schauen wir uns nun die Typescript-Klasse der Angular-Komponente an, die die Entitätstabelle anzeigt (ProductComponent im Screenshot unten). JHipster erstellt eine Methode loadAll(), die alle Entitäten vom Back-End abruft, und ruft diese Methode im Angular-Lifecycle-Aufruf ngOnInit() auf. Das folgende Beispiel stammt aus app/entities/product/product.component.ts in src/main/webapp.

Product-Typescript-Klasse für die Entitätsliste in Angular

  • Die Methode loadAll() aus dem vorherigen Punkt verwendet eine Service-Klasse. Hier ist diese Klasse: app/entities/product/product.service.ts in src/main/webapp. Sie hat fünf Methoden für CRUD (es gibt zwei Lese-Methoden — query() für mehrere Products und find() für ein einzelnes), die unsere Java-REST-API aufrufen. JHipster erzeugt nur dann komplizierteren Code, wenn eine Klasse Datums- oder Zeitattribute hat, weil diese vor dem Senden an die REST-API oder nach dem Empfang von ihr konvertiert werden müssen.

Product-Service-Klasse in Angular

  • Die HTML-Vorlage, die alle Products anzeigt, ist app/entities/product/product.component.html in src/main/webapp. Es ist eine schlichte Tabelle, die aber zwei Funktionen nutzt, die JHipster in die Angular-Tabelle eingebracht hat:
    • Die Tabellenüberschriften werden mit dem Attribut jhiTranslate lokalisiert. Wie Sie sich vielleicht aus dem zweiten Teil dieses Tutorials erinnern, unterstützt die Anwendung sowohl Englisch als auch Deutsch.
    • Bilder werden direkt in der Tabelle angezeigt, und Binärdateien werden an den Browser übergeben. Das ist die Arbeit der Methode openFile(). Und ja, das bedeutet, dass die REST-API tatsächlich den Binärinhalt dieser Felder enthält, was für den Produktivbetrieb wahrscheinlich keine gute Idee ist!

HTML-Vorlage für die Entitätsliste in Angular

  • Für die Lokalisierung ins Englische und Deutsche braucht es die eigentlichen Übersetzungen. JHipster generiert dafür eine JSON-Datei pro Entität und Sprache. Hier ist i18n/en/product.json in src/main/webapp, die englische Übersetzungsdatei für das Product.

Englische Product-Übersetzungsdatei in Angular

Fazit

Damit ist der dritte Tutorial-Teil abgeschlossen. Was haben wir erreicht?

  • Wir haben Eclipse oder IntelliJ für Spring Boot und Angular installiert oder konfiguriert.
  • Wir haben das Projekt in Eclipse oder IntelliJ importiert.
  • Wir haben den Code untersucht, den JHipster für unsere Entitäten erzeugt hat.

Ihr Projekt-Quellcode sollte weiterhin so aussehen wie der „master“-Branch des GitHub-Projekts — wir haben nichts verändert.

Demnächst im Tutorial „Better Java Projects Faster with JHipster and Docker”

Im nächsten Teil schauen wir uns die Tests an, die JHipster für uns generiert hat, und führen sie aus. Bleiben Sie dran!