Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
Ich versuche gerade mit IntelliJ etwas "professioneller" zu werden und möchte ein Projekt auf mehrere Unterprojekte aufteilen. In der Sprache von IntelliJ: Ein Projekt und mehrere Module. Dazu habe ich
Neues leeres Projekt
Neues Modul1
Neues Modul2
Soweit so gut. Ich habe jetzt ein Projekt mit zwei Modulen (siehe Projekt.png)
Wenn ich jetzt die Projektstruktur öffne, finde ich vier Einträge (siehe Projektstruktur.png)
Was bedeuten diese vier Einträge?
Wie kann ich erreichen, dass ich im Modul2 Klassen von Modul1 importieren kann?
Afaik erstellt Intellij, wenn man gradle nutzt, für main und test noch mal einzelne Module. Das Projekt besteht dann aus den beiden gradle-Modulen und jeweils deren beiden Unter-Modulen.
Wenn du gradle nutzt, würde ich den ganzen Setup direkt über gradle machen. Dort kannst du dann das andere Projekt als Dependency angeben.
Ich weiß nicht, ob IntelliJ die build-files passend einrichtet, wenn man das nur über IntelliJ macht.
So würde ich das nicht ganz bezeichnen
Ich nutze gradle, um externe Abhängigkeiten einzubinden, aber ich fürchte, damit bleibe ich weit hinter den Möglichkeiten zurück.
Ich habe leider festgestellt, dass es für einen Hobbyprogrammierer nicht leicht ist Informationen zu finden, wie Softwareentwicklung halbwegs "professionell" gemanagt wird. Es gibt tausend Bücher über das Programmieren an sich, aber wie diverse Entwicklungstools auch für Laien korrekt im Zusammenspiel eingesetzt werden können, dazu finde ich nichts ordentliches.
Geht jetzt am eigentlichen Thema leicht vorbei (naja, eigentlich auch nicht), aber falls jemand eine gute Schritt-für-Schritt-Anleitung dazu hat, dann immer her damit
Ich habe inzwischen herausgefunden wie es über IntelliJ funktioniert: Über "Project structure" können für die einzelnen Module Dependencies hinzugefügt werden.
Ich habe leider festgestellt, dass es für einen Hobbyprogrammierer nicht leicht ist Informationen zu finden, wie Softwareentwicklung halbwegs "professionell" gemanagt wird. Es gibt tausend Bücher über das Programmieren an sich, aber wie diverse Entwicklungstools auch für Laien korrekt im Zusammenspiel eingesetzt werden können, dazu finde ich nichts ordentliches.
Geht jetzt am eigentlichen Thema leicht vorbei (naja, eigentlich auch nicht), aber falls jemand eine gute Schritt-für-Schritt-Anleitung dazu hat, dann immer her damit
Ich habe inzwischen herausgefunden wie es über IntelliJ funktioniert: Über "Project structure" können für die einzelnen Module Dependencies hinzugefügt werden.
Scheint nicht so, ich habe wie beschrieben Abhängigkeiten hinzugefügt (IntelliJ) aber in den einzelnen "build.gradle"-Dateien taucht nichts davon auf.
Außerdem sind die im obigen Bild "Projektstruktur" angezeigten Knoten mit den vier kleinen blauen Quadraten anscheinend "Modulgruppen".
Den Teil ignorier ich immer, da kann ich dir kaum weiterhelfen...
Ich manage das über Maven/Gradle direkt und importier es dann einfach. Der Vorteil von dem Build-Tool ist ja auch die IDE-Unabhängigkeit.
Das könnte daran liegen, dass irgendwelchen theoretischen Informatiker ungefähr vierteljährig neu definieren was ihrer Meinung nach professionell ist. Wenn man immer die aktuellen angeblichen professionellen Wege gehen würde, dann könnte man keine Software mehr fertig stellen da man innerhalb der eigentlichen Entwicklungszeit sein komplettes Entwicklungskonzept 3x umstellen müsste..
Professionell ist, nicht immer dem neusten Kram hinterherzulaufen sondern für ein vernünftiges Budget dem Kunden eine gute Lösung zu bieten egal mit welchen Mitteln oder auf welchem Weg....
Gradle und Maven sind beide älter als 10 Jahre, Jenkins als eine der verbreitetsten CI-Lösung ist 7, TDD ist etwa 20...wirklich neu ist davon nichts...
Keine Ahnung was daran „neuster Kram“ ist.
Unsere Meinungen gehen aber auch offensichtlich deutlich auseinander, was eine „gute Lösung“ ist.
(Wenn man den Build-Prozess von theoretischen Informatikern bestimmen lässt, ist allerdings klar, dass das nicht unbedingt gut wird...)
Ich plane gerade eine kleine Desktopanwendung, die ihre Daten in einer Datenbank verwaltet. Da ich hier unter Linux programmiere, würde ich für die Entwicklung erst mal auf H2 als Datenbank setzen, mit der Option später auf einen SQL Server wechseln zu können.
Ich würde jetzt schon mal auf jeden Fall zwei Module sehen, da in der produktiven Anwendung nur eines davon z.B. als jar benötigt werden wird:
- data_H2
- data_MSSQL
Desweiteren würde ich die GUI (JAVAFX) in einem separaten Projekt sehen:
- gui
Da die GUI auf austauschbaren Datenquellen arbeiten soll, außerdem noch eine API, die nur Interfaces für die DTOs, Repositories usw. enthält und von der GUI refereziert wird.
- domain_api
Jetzt fehlt noch die Implementierung zumindest eines Teils der API, z.B. ein AbstractRepository und DTOs die wiederum von den konkreten Datenzugriffsmodulen referenziert werden. Sollte das auch als separates Modul modelliert werden oder einfach als zusätzliches Package neben der domain_api?
Da es sich nur um eine recht einfache Lagerverwaltung (Materialstamm, Einbuchen, Ausbuchen, Bestandslisten) handelt, werde ich wohl keine zusätzliche Schicht zwischen Repositories und der GUI benötigen, oder? Die "Geschäftslogik" wäre demnach im GUI-Modul in den Controllern.
Ich würde aus "domain_api" das api streichen und "domain" draus machen, und da denn eben alle Dinge, die zur Domäne gehören, rein - wo sowohl Geschäftslogik, Domänen-Objekte als auch Repository(-Interfaces) zu gehören.
gui ist dann MVC-Konform wirklich nur die GUI mit View und Controllern, aber ohne Geschäftslogik.
Und data_* sind nur die Datenbank-relevanten Implementationen von Repositorys, DAOs etc.
Ein erstes Feedback für alle, die es möglicherweise interessiert. Ich habe jetzt folgendes gemacht:
IntelliJ => Create new project
Im nächsten Fenster "Additional Libraries and Frameworks" alles abwählen.
In den nächsten Fenstern GroupId, ArtifactId und ProjectName festlegen.
Damit erhält man ein relativ leeres Projekt mit einer "build.gradle" und einer "settings.gradle".
Rechtsklick auf das Toplevel-Element (= Projektname) => New => Module
Im Fenster "Additional Libraries..." diesmal z.B. "Java" auswählen.
ArtifactId und ModuleName festlegen.
Damit wurde ein Modul mit dem gewünschten Namen und einer separaten "build.gradle" angelegt und in der "settings.gradle" wurde ein entsprechender "import" eingefügt.
Punkte ab (5) wiederholen, bis alle Module angelegt sind.
Die einzelnen "build.gradle" nach Wunsch editieren.
Ist das folgende korrekt, wenn ich möchte, dass alle Unterprojekte (= Module) dieselbe sourceCompatibility, repositories und dependencies (zumindest teilweise) haben sollen?
Die Versionsnummer möchte ich für einzelne Module unabhängig haben und für den Rest einheitlich. Wie konfiguriere ich das?
Ist es möglich für einzelne Module zusätzliche dependencies einzufügen? Einfach in die entsprechende build.gradle schreiben?
EDIT: Hab es grade probiert, aber ich erhalte diverse Fehlermeldungen, wenn ich es so mache. Ich habe jetzt "repositories" und "dependencies" wieder in den einzelnen build-Dateien eingefügt.