Teil 3 von 3 — Better Java Projects Faster with JHipster and Docker
Explore the JHipster code
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:

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

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

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

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

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

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

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

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

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

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

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

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

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

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:

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

- Öffnen Sie nun „http://127.0.0.1:8080/” in Ihrem Browser, um die laufende Anwendung zu sehen:

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:

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

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

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

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

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

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

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

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

- Damit gelangen wir zum 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:

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

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

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

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


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

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

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

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

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

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

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

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

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

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:

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

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

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

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


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

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

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

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


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

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

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

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

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

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

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

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

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


- Öffnen Sie nun „http://127.0.0.1:8080/” in Ihrem Browser, um die laufende Anwendung zu sehen:

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.gradlefü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.

gradle.propertiesenthä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.

- JHipster hat einige Gradle-Tasks in
gradle/profile_dev.gradlehinzugefügt. Falls Sie sich je gefragt haben, warum das Starten von Spring Boot ein NPM-Install auslöst, hier die Antwort:bootJarhängt vonprocessResourcesab, das wiederum vonwebpackBuildDevabhängt, das seinerseits vonnpmInstallabhängt. Wenn Sie also nur diese letzte Abhängigkeit auskommentieren, sparen Sie sich bei jedem Build ein paar Sekunden!

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

- 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 abersrc/main/resources/config/application-dev.yml, das die Konfiguration für — Sie haben es wahrscheinlich schon erraten — das Spring-Profildeventhä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
buildspeichert. Deshalb verschafft Ihnen eingradle cleaneinen frischen Datenbankstart — einfach und praktisch!
- aktiviert das Profil

- Im Paket
com.betterprojectsfaster.tutorial.jhipsterdocker.configinsrc/main/javagibt 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/trackerzugreifen.
- Die erste rote Box im Screenshot unten enthält spezielle REST-API-URLs, auf die Nutzer zugreifen können, die nicht eingeloggt sind
(

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.

- Als Nächstes folgt die Tabellendefinition für unsere „Product”-Entität in
src/main/resources/config/liquibase/changelog/20190801122745_added_entity_Product.xml. Das ist wirklich eine SQL-Tabellendefinition in XML!

- 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.csverzeugt hat. Fragen Sie sich, warum das in IntelliJ wie eine Tabelle aussieht? Das ist die Arbeit des sehr empfehlenswerten CSV Plugin!

- Und endlich richtiger Java-Code! Passenderweise ist es die JPA-Entität für „Product”,
com.betterprojectsfaster.tutorial.jhipsterdocker.domain.Productinsrc/main/java. Sie hat jede Menge Annotationen.

- Als Nächstes haben wir die Datenbankabfragen für die „Product”-Entität mit
com.betterprojectsfaster.tutorial.jhipsterdocker.repository.ProductRepositoryinsrc/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) imJpaRepositorymit, von dem unser Interface erbt. Und da wir gerade keine weiteren Abfragen brauchen, ist dieses Interface leer.

- Da wir für alle unsere Entitäten die Verwendung von Data Transfer Objects (DTO) angegeben haben, hat JHipster diese bereitwillig für
uns erstellt. Hier ist das für das Product, das die Entität aus dem vorletzten Punkt widerspiegelt. Es ist
com.betterprojectsfaster.tutorial.jhipsterdocker.service.dto.ProductDTOinsrc/main/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.ProductMapperinsrc/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önntegetDisplayName()auf einerUser-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, dennremoveProductOrderist 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).

- Das Business-Service-Interface
com.betterprojectsfaster.tutorial.jhipsterdocker.service.ProductServiceinsrc/main/javaverwendet dieses DTO. Das Interface fasstcreate()undupdate()in einersave()-Methode zusammen:

- Die Business-Service-Implementierung ist
com.betterprojectsfaster.tutorial.jhipsterdocker.service.impl.ProductServiceImplinsrc/main/java. Hier sehen Sie die ersten beiden Methoden, die einfach ohne viel Aufhebens das Repository und den Mapper aufrufen:

- Die letzte Etappe auf der Java-Seite ist die REST-API in Form eines Spring-REST-Controllers. Hier haben wir
com.betterprojectsfaster.tutorial.jhipsterdocker.web.rest.ProductResourceinsrc/main/java. Dercreate-REST-API-Aufruf ist eine HTTP-POST-Anfrage an/api/productsund ruft einfach die Business-Service- Methode auf:

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.tsinsrc/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 eineenum-Definition.

- 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.tsinsrc/main/webapp.(entity name)Componentist die Tabelle mit der Liste aller Entitäten.(entity name)DetailComponentist die schreibgeschützte Ansicht einer einzelnen Entität.(entity name)UpdateComponentist das Formular zum Erstellen oder Aktualisieren einer einzelnen Entität.(entity name)DeletePopupComponentlöscht eine einzelne Entität, nachdem in(entity name)DeleteDialogComponentmit einem „Sind Sie sicher?“-Dialog bestätigt wurde.

- Schauen wir uns nun die Typescript-Klasse der Angular-Komponente an, die die Entitätstabelle anzeigt (
ProductComponentim Screenshot unten). JHipster erstellt eine MethodeloadAll(), die alle Entitäten vom Back-End abruft, und ruft diese Methode im Angular-Lifecycle-AufrufngOnInit()auf. Das folgende Beispiel stammt ausapp/entities/product/product.component.tsinsrc/main/webapp.

- Die Methode
loadAll()aus dem vorherigen Punkt verwendet eine Service-Klasse. Hier ist diese Klasse:app/entities/product/product.service.tsinsrc/main/webapp. Sie hat fünf Methoden für CRUD (es gibt zwei Lese-Methoden —query()für mehrere Products undfind()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.

- Die HTML-Vorlage, die alle Products anzeigt, ist
app/entities/product/product.component.htmlinsrc/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
jhiTranslatelokalisiert. 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!
- Die Tabellenüberschriften werden mit dem Attribut

- 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.jsoninsrc/main/webapp, die englische Übersetzungsdatei für das Product.

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!