10 Fragen zu Intellij

Wenn du ein Projekt über IntelliJ IDEA auf einen JBoss-Server (z. B. WildFly) deployst, hängt der Speicherort der deployten Dateien davon ab, wie der Server konfiguriert ist und wie das Deployment erfolgt (lokal, remote, als exploded oder packaged deployment). Standardmäßig gilt bei einer lokalen JBoss/WildFly-Installation: - **Deployments-Verzeichnis:** Die deployten Dateien (z. B. WAR, EAR, JAR) werden im Verzeichnis `<JBOSS_HOME>/standalone/deployments/` abgelegt. `<JBOSS_HOME>` ist das Installationsverzeichnis deines JBoss/WildFly-Servers. - **Exploded Deployment:** Wenn du ein "exploded" Deployment verwendest (also entpackte Verzeichnisse statt einzelner Archive), findest du dort ein gleichnamiges Verzeichnis (z. B. `meinprojekt.war/`). - **Packaged Deployment:** Bei einem "packaged" Deployment liegt dort die entsprechende Datei (z. B. `meinprojekt.war`). **Beispielpfad:** `/opt/wildfly/standalone/deployments/meinprojekt.war` oder `C:\wildfly\standalone\deployments\meinprojekt.war` **Hinweis:** Wenn du in IntelliJ einen "Application Server" konfiguriert hast, kannst du im Server-Setup nachsehen, welches JBoss-Installationsverzeichnis verwendet wird. Dort findest du dann das `deployments`-Verzeichnis. **Weitere Infos:** - [WildFly Dokumentation: Application Deployment](https://docs.wildfly.org/26/Admin_Guide.html#deploying-applications) - [IntelliJ IDEA: Application Servers](https://www.jetbrains.com/help/idea/application-servers-support.html) Falls du einen Domain-Mode verwendest, ist der Pfad entsprechend `<JBOSS_HOME>/domain/servers/<server-name>/deployments/`. **Zusammengefasst:** Die deployten Dateien findest du im Regelfall im `deployments`-Verzeichnis deiner JBoss/WildFly-Installation, abhängig vom Betriebsmodus und der Serverkonfiguration.

In IntelliJ IDEA gibt es keine direkte, dauerhafte Einstellung für die Schriftgröße speziell beim Drucken von Quellcode. Die Druckfunktion verwendet standardmäßig die Editor-Schriftgröße, bietet aber beim Drucken einen Dialog, in dem du die Schriftgröße temporär anpassen kannst. Diese Einstellung wird jedoch nicht dauerhaft gespeichert. **So gehst du vor:** 1. **Drucken-Dialog öffnen:** Datei → Drucken… (oder Strg+P) 2. **Schriftgröße einstellen:** Im Druckdialog kannst du unter „Font Size“ die gewünschte Schriftgröße auswählen. 3. **Dauerhafte Änderung (Workaround):** Wenn du immer mit einer bestimmten Schriftgröße drucken möchtest, kannst du die Editor-Schriftgröße dauerhaft ändern: - Einstellungen öffnen: Datei → Einstellungen (oder Strg+Alt+S) - Editor → Schriftart (Font) - „Größe“ anpassen **Achtung:** Diese Änderung wirkt sich auf die gesamte Editor-Anzeige aus, nicht nur auf den Druck. **Fazit:** Eine dauerhafte, nur für den Druck gültige Einstellung der Schriftgröße ist in IntelliJ IDEA aktuell nicht möglich. Du musst die Schriftgröße beim Drucken jedes Mal neu einstellen oder die Editor-Schriftgröße anpassen. Weitere Infos findest du in der offiziellen Dokumentation: [IntelliJ IDEA Printing Source Code](https://www.jetbrains.com/help/idea/printing-source-code.html)

Um in IntelliJ IDEA einen lokalen JBoss-Server hinzuzufügen, gehe wie folgt vor: 1. **JBoss herunterladen und entpacken** Lade dir die gewünschte JBoss-Version (z.B. [WildFly](https://www.wildfly.org/downloads/)) herunter und entpacke sie an einen Ort deiner Wahl. 2. **JBoss-Integration in IntelliJ IDEA** - Öffne dein Projekt in IntelliJ IDEA. - Gehe zu **File > Settings** (bzw. **IntelliJ IDEA > Preferences** auf macOS). - Navigiere zu **Build, Execution, Deployment > Application Servers**. - Klicke auf das **"+"**-Symbol, wähle **JBoss Server** (bzw. **WildFly Server**) aus. - Gib einen Namen ein und wähle das Installationsverzeichnis deines JBoss/WildFly-Servers aus. - Bestätige mit **OK**. 3. **Run/Debug Configuration anlegen** - Gehe zu **Run > Edit Configurations...** - Klicke auf das **"+"**-Symbol und wähle unter **JBoss Server** (bzw. **WildFly Server**) die Option **Local**. - Wähle den zuvor hinzugefügten Server aus. - Konfiguriere ggf. weitere Einstellungen (z.B. Deployment, Ports). - Speichere die Konfiguration. 4. **Server starten** - Wähle oben rechts im Dropdown-Menü die neue Server-Konfiguration aus. - Klicke auf den grünen Start-Button. **Hinweis:** Für die JBoss-Integration benötigst du die Ultimate Edition von IntelliJ IDEA, da die Community Edition keine Unterstützung für Application Server wie JBoss/WildFly bietet. Weitere Infos findest du in der offiziellen [IntelliJ IDEA Dokumentation](https://www.jetbrains.com/help/idea/2024.1/jboss.html).

Bei einem **Update Project** in IntelliJ (z.B. beim Arbeiten mit Git) gibt es verschiedene Möglichkeiten, wie lokale und entfernte Änderungen zusammengeführt werden können. Die beiden Optionen bedeuten: **1. Merge incoming changes into the current branch** - Hierbei werden die Änderungen vom entfernten Branch (z.B. origin/main) in deinen aktuellen Branch **gemergt**. - Es entsteht ein sogenannter **Merge-Commit**, der beide Entwicklungsstränge zusammenführt. - Die Historie bleibt verzweigt, d.h. man sieht, dass es zwei parallele Entwicklungen gab, die dann zusammengeführt wurden. - Vorteil: Die Historie bleibt vollständig erhalten. - Nachteil: Die Commit-Historie kann unübersichtlicher werden, wenn viele Merges stattfinden. **2. Rebase the current branch on top of incoming changes** - Hierbei wird dein aktueller Branch so umgeschrieben, als ob er **auf den neuesten Stand des entfernten Branches** aufgesetzt wurde. - Deine lokalen Commits werden „abgehoben“ und auf die Spitze des entfernten Branches „draufgesetzt“. - Es entsteht **kein Merge-Commit**; die Historie sieht linear aus. - Vorteil: Die Commit-Historie ist sauber und linear. - Nachteil: Beim Rebase kann es zu Konflikten kommen, und die Commit-Hashes deiner lokalen Commits ändern sich (was bei gemeinsam genutzten Branches problematisch sein kann). **Zusammengefasst:** - **Merge**: Fügt die Änderungen zusammen, Historie bleibt verzweigt. - **Rebase**: Setzt deine Änderungen oben drauf, Historie bleibt linear. Mehr Infos findest du z.B. in der [IntelliJ-Dokumentation](https://www.jetbrains.com/help/idea/update-project.html).

Um lokale Änderungen in IntelliJ IDEA für ein Git-Repository zu verwerfen, gibt es mehrere Möglichkeiten: 1. **Einzelne Datei zurücksetzen:** - Rechtsklick auf die Datei im Projektfenster. - Wähle **Git** > **Discard** oder **Revert** (je nach Version). - Bestätige den Vorgang. 2. **Alle Änderungen im Projekt verwerfen:** - Gehe zu **VCS** > **Git** > **Show Local Changes** (oder klicke unten auf das „Commit“-Fenster). - Wähle die gewünschten Dateien oder alle Dateien aus. - Rechtsklick und **Discard** auswählen. - Bestätige das Verwerfen der Änderungen. 3. **Über die Kommandozeile (Terminal in IntelliJ):** - Öffne das Terminal in IntelliJ. - Gib ein: ``` git checkout -- <dateiname> ``` oder für alle Änderungen: ``` git reset --hard ``` - Achtung: Nicht gespeicherte Änderungen gehen verloren! **Hinweis:** Verwerfene Änderungen können nicht wiederhergestellt werden. Stelle sicher, dass du nichts Wichtiges verlierst. Weitere Infos findest du in der [IntelliJ IDEA Dokumentation](https://www.jetbrains.com/help/idea/undo-changes.html).

Bei einem **Fetch** in IntelliJ unter Verwendung von **Git** werden die neuesten Änderungen aus dem entfernten Repository (z. B. von GitHub, GitLab oder Bitbucket) auf deinen lokalen Rechner heruntergeladen, aber **nicht** automatisch in deinen aktuellen Arbeitszweig (Branch) integriert. Konkret bedeutet das: - IntelliJ ruft alle neuen Commits, Branches und Tags vom Remote-Repository ab. - Deine lokalen Branches bleiben unverändert. - Die heruntergeladenen Änderungen werden in den sogenannten „Remote-Tracking-Branches“ gespeichert (z. B. `origin/main`). - Du kannst dir die Unterschiede anschauen und entscheiden, ob und wie du die Änderungen in deinen eigenen Branch übernehmen möchtest (z. B. durch einen Merge oder Rebase). **Fetch** ist also ein sicherer Weg, um auf dem Laufenden zu bleiben, ohne dass deine aktuelle Arbeit beeinflusst wird. Weitere Infos findest du in der offiziellen Dokumentation von JetBrains: [Git fetch in IntelliJ IDEA](https://www.jetbrains.com/help/idea/fetching-changes-from-a-remote-repository.html)

In IntelliJ IDEA kannst du das Kontextmenü (Popup-Menü) zum Auskommentieren ganzer Blöcke und das Menü zur Auswahl diverser Browser über die Einstellungen anpassen: **1. Kontextmenü zum Auskommentieren ganzer Blöcke:** - Das Auskommentieren von Codeblöcken ist standardmäßig über das Kontextmenü (Rechtsklick im Editor) verfügbar. - Falls es nicht angezeigt wird, kannst du die Tastenkombination `Strg` + `/` (für einzelne Zeilen) oder `Strg` + `Shift` + `/` (für Blöcke, je nach Sprache) verwenden. - Um das Kontextmenü wieder einzublenden, stelle sicher, dass du im Editor-Fenster rechtsklickst und nicht in einer anderen Ansicht. - Die Menüeinträge kannst du unter **Settings > Appearance & Behavior > Menus and Toolbars** anpassen. Dort kannst du das Kontextmenü für den Editor bearbeiten und Einträge wie "Comment with Line Comment" oder "Comment with Block Comment" hinzufügen oder entfernen. **2. Menü zur Auswahl diverser Browser:** - Das Browser-Auswahlmenü erscheint meist, wenn du HTML-Dateien öffnest oder auf "Open in Browser" klickst. - Um dieses Menü auszublenden oder zu deaktivieren, kannst du unter **Settings > Tools > Web Browsers** die Standardbrowser festlegen oder nicht benötigte Browser deaktivieren. - Wenn du das Menü nicht mehr sehen möchtest, entferne die Häkchen bei den Browsern, die nicht angezeigt werden sollen, oder setze einen Standardbrowser, sodass das Auswahlmenü nicht mehr erscheint. **Weitere Hinweise:** - Die genaue Bezeichnung der Menüpunkte kann je nach IntelliJ-Version leicht variieren. - Mehr Infos findest du in der offiziellen Dokumentation: [IntelliJ IDEA Menus and Toolbars](https://www.jetbrains.com/help/idea/menus-and-toolbars.html) und [Web Browsers in IntelliJ IDEA](https://www.jetbrains.com/help/idea/opening-html-files-in-browser.html). Falls du spezifische Menüpunkte vermisst oder anpassen möchtest, hilft oft ein Blick in die Einstellungen unter "Menus and Toolbars".

Um in **Git** einen bestimmten Inhalt (z.B. einen Text, eine Funktion oder ein Wort) **über alle Repositories, Branches und Revisionen** zu suchen, gibt es verschiedene Methoden – sowohl in der **Kommandozeile** als auch in **IntelliJ IDEA**. Hier eine umfassende Übersicht: --- ## 1. Git Konsole (CLI) ### a) Suche in allen Branches eines Repositories **1. Alle Branches lokal durchsuchen:** ```bash git grep "Suchbegriff" $(git rev-list --all) ``` - `git grep` sucht nach dem Begriff. - `git rev-list --all` gibt alle Commits aller Branches zurück. **2. Alle Branches remote durchsuchen:** Zuerst alle Branches holen: ```bash git fetch --all ``` Dann wie oben suchen. **3. Alle Branches einzeln durchsuchen:** ```bash for branch in $(git branch -a | grep -v HEAD); do git checkout $branch git grep "Suchbegriff" . done ``` *Hinweis: Das Skript wechselt die Branches, was lokale Änderungen überschreiben kann.* --- ### b) Suche in allen Commits (Revisionen) **1. Mit `git log -S` (zeigt Commits, in denen der Begriff hinzugefügt/entfernt wurde):** ```bash git log -S"Suchbegriff" --all ``` - Zeigt alle Commits, in denen der Begriff zum ersten Mal auftaucht oder verschwindet. **2. Mit `git log -G` (zeigt Commits, in denen der Begriff im Diff auftaucht):** ```bash git log -G"Suchbegriff" --all ``` - Zeigt alle Commits, in denen der Begriff im Patch auftaucht. **3. Mit `git grep` über alle Commits:** ```bash git rev-list --all | while read rev; do git grep "Suchbegriff" $rev done ``` - Sucht in jedem Commit nach dem Begriff. --- ### c) Suche über mehrere Repositories Wenn du mehrere Repositories hast (z.B. in verschiedenen Ordnern), kannst du ein Skript verwenden: ```bash for repo in */.git; do cd $(dirname $repo) echo "Repository: $(pwd)" git grep "Suchbegriff" $(git rev-list --all) cd .. done ``` - Durchläuft alle Repositories im aktuellen Verzeichnis. --- ## 2. IntelliJ IDEA ### a) Suche in allen Branches 1. **Branches einchecken:** IntelliJ durchsucht standardmäßig nur den aktuellen Branch. Um andere Branches zu durchsuchen, musst du sie auschecken oder als "Local Branch" anlegen. 2. **"Find in Path" (Strg+Shift+F / Cmd+Shift+F):** - Öffne das Suchfenster. - Wähle "Directory" und ggf. das ganze Projekt. - Suche nach dem Begriff. - **Achtung:** Nur der aktuell ausgecheckte Branch wird durchsucht. 3. **Mehrere Branches durchsuchen:** - Du kannst mit "Git Branches" (unten rechts) zwischen Branches wechseln und jeweils "Find in Path" nutzen. - Es gibt keine eingebaute Funktion, um alle Branches gleichzeitig zu durchsuchen. ### b) Suche in allen Commits (History) 1. **Git Log durchsuchen:** - Öffne das "Git" Tool Window (View → Tool Windows → Git). - Gehe auf "Log". - Nutze das Suchfeld oben rechts, um nach Commit-Messages, Autoren oder Hashes zu suchen. - Für die Suche im Diff: Rechtsklick auf einen Commit → "Show Diff". 2. **"Show All Branches":** - Im Log-Tab kannst du oben "Show All Branches" aktivieren, um die Historie aller Branches zu sehen. 3. **Spezielle Plugins:** - Es gibt Plugins wie "GitToolBox", die die Suche erweitern, aber keine, die alle Branches und alle Revisionsinhalte gleichzeitig durchsuchen. --- ## Zusammenfassung - **Kommandozeile:** Mit `git grep`, `git log -S`, `git log -G` und Skripten kannst du sehr flexibel und mächtig suchen – auch über alle Branches, Commits und Repositories hinweg. - **IntelliJ IDEA:** Sehr komfortabel für die Suche im aktuellen Branch und in der Commit-Historie, aber keine native Unterstützung für die gleichzeitige Suche in allen Branches oder Repositories

Um die „Floating Toolbar“ (das kleine Menü, das beim Markieren mehrerer Zeilen erscheint) in IntelliJ IDEA wiederherzustellen, gehe wie folgt vor: 1. **Einstellungen öffnen:** Gehe zu `Datei` > `Einstellungen` (bzw. `File` > `Settings` auf Englisch) oder drücke `Strg+Alt+S`. 2. **Editor-Einstellungen suchen:** Navigiere zu `Editor` > `General`. 3. **Floating Toolbar aktivieren:** Suche nach der Option **"Show floating toolbar on code selection"** (auf Deutsch etwa: „Schwebende Symbolleiste bei Codeauswahl anzeigen“). Setze das Häkchen bei dieser Option. 4. **Einstellungen übernehmen:** Klicke auf `OK` oder `Übernehmen`, um die Änderung zu speichern. Jetzt sollte die Floating Toolbar beim Markieren von Code wieder angezeigt werden. **Hinweis:** Falls du eine ältere oder stark angepasste Version von IntelliJ verwendest, kann die Option leicht anders benannt oder an einer anderen Stelle zu finden sein. In aktuellen Versionen ist sie jedoch wie oben beschrieben erreichbar. Weitere Infos findest du auch in der offiziellen [IntelliJ IDEA Dokumentation](https://www.jetbrains.com/help/idea/).

Um in IntelliJ IDEA beim Wechsel des Codefensters automatisch die entsprechende Datei in der Projektstruktur (Project View) auf der linken Seite hervorzuheben, gehe wie folgt vor: 1. Öffne die **Project View** (meistens links im Fenster, sonst über `View` > `Tool Windows` > `Project`). 2. Klicke oben in der Project View auf das kleine Zahnrad-Symbol (Einstellungen). 3. Aktiviere die Option **"Always Select Opened File"** (auf Deutsch: **"Geöffnete Datei immer auswählen"**). Jetzt wird beim Wechseln zwischen Dateien im Editor automatisch die entsprechende Datei im Projektbaum markiert und angezeigt. Weitere Infos findest du in der offiziellen Dokumentation von JetBrains: [https://www.jetbrains.com/help/idea/navigating-through-the-source-code.html#select-opened-file](https://www.jetbrains.com/help/idea/navigating-through-the-source-code.html#select-opened-file)