Beliebte Suchanfragen
//

Quellcode analysieren: Git & IntelliJ für Source-Code-Archäologie (3/5)

17.11.2026 | 14 Minuten Lesezeit

Türkiser Farbverlauf-Banner mit grünem Badge „BLOGREIHE“ und dem Text „Source-Code-Archäologie“.

Auf einen Blick: Quellcode-Analyse mit Git und IntelliJ

  • Git ist ein unterschätztes Werkzeug für Source-Code-Archäologie: Hotspots, Churn, Bus-Faktor und logische Kopplung lassen sich mit Bordmitteln aus der Commit-Historie ableiten.
  • Hotspots machen oft nur 1-3 % der Codebasis aus, ziehen aber gleichzeitig einen überproportional großen Anteil der Entwicklungsaktivität auf sich. Diese Dateien sind deshalb der erste Prüfpunkt.
  • Der Bus-Faktor zeigt, wie viel Wissen bei wenigen Personen liegt. Commit-Nachrichten liefern das „Warum" hinter Änderungen, sofern sie aussagekräftig gepflegt werden.
  • In IntelliJ helfen Dependency Structure Matrix, UML-Diagramme, Call Hierarchy, Datenflussanalyse und „Annotate with Git Blame", Architektur und Abhängigkeiten zu verstehen. Die DSM setzt IntelliJ Ultimate voraus.
  • Werkzeuge liefern Landkarten, die Interpretation bleibt Aufgabe des Teams. Source-Code-Archäologie ist eine fortlaufende Haltung, keine einmalige Aktion.

 


 

Im Teil 2 der Serie haben wir euch viele gängige Werkzeuge für Source-Code-Archäologie vorgestellt. Dabei hat sich gezeigt, dass jedes Werkzeug seine eigenen Stärken und Schwächen hat und sich somit individuell auf unterschiedliche Probleme und Fragestellungen anwenden lässt. Es kommt also nicht auf die Nutzung eines einzigen Werkzeugs an – häufig ergänzen sich verschiedene Werkzeuge gegenseitig und maximieren so den Gesamtnutzen.

Neben kommerziellen Lösungen gibt es aber auch Werkzeuge, die viele von euch bereits in ihrer Systemlandschaft im Einsatz haben und die somit keinen zusätzlichen Integrationsaufwand bedeuten.

In diesem Blogbeitrag werfen wir einen Blick darauf, wie ihr Git und IntelliJ als effektive Analysewerkzeuge für die Source-Code-Archäologie einsetzen könnt, um unübersichtlichen Quellcode zu analysieren. Folgende Themen erwarten euch:

  • Historische Analyse mit Git: Git dient als Gedächtnis des Projekts, um Hotspots, fehleranfällige Dateien, Churn-Werte und den Bus-Faktor zu ermitteln.
  • Strukturelle Analyse mit IntelliJ: Die Dependency Structure Matrix (DSM) und UML-Diagramme machen zyklische Abhängigkeiten und „Gott-Klassen“ sofort sichtbar.
  • Kontroll- und Datenfluss verstehen: Call Hierarchy und Datenfluss-Analysen helfen dabei, den Weg von Daten und fachlichen Logiken durch komplexe Schichten nachzuvollziehen.

Der Bordmittel-Werkzeugkasten auf einen Blick

 

Ziel / Problemstellung
 
Methode / Werkzeug
 
Fehleranfällige Dateien finden (Hotspots & Code Churn)Git
Wissensmonopole aufdecken (Bus-Faktor)Git
Versteckte Abhängigkeiten erkennen (Logische Kopplung)Git
Architektur & Spaghetti-Code entwirrenIntelliJ (Dependency Structure Matrix/UML)
Aufrufhierarchien verstehenIntelliJ (Call Hierarchy)
Herkunft und Pfade von Werten entschlüsselnIntelliJ (Datenflussanalyse/Analyze Data Flow)
Historie einzelner Zeilen nachvollziehenIntelliJ/Git (Annotate with Git Blame/Show History)
Kognitive Last reduzieren & Orientierung behaltenIntelliJ (Structure Window/Quick Definition/ Bookmarks)

 

Wie lässt sich Quellcode mit Bordmitteln wie Git analysieren?

Mit wenigen Befehlen liefert Git erste Hinweise auf Hotspots, Churn, Bus-Faktor und logische Kopplung, die ihr direkt aus der Commit-Historie ablesen könnt.

Hotspots und Code Churn: Fehleranfällige Dateien per Git identifizieren

Bevor wir mit den großen Geschützen auf unseren Code losgehen, möchten wir zunächst ein Bordmittel vorstellen, welches jede*r Entwickelnde direkt einsetzen kann, sofern natürlich Git zur Versionierung eingesetzt wird.

Mit Git lässt sich beispielsweise ermitteln, welche Dateien am häufigsten verändert wurden (Hotspots). Der folgende Befehl zeigt die 20 am häufigsten geänderten Dateien inklusive der Anzahl ihrer Änderungen an. Da dieses Bild bei langlebigen Projekten schnell durch ältere, längst abgeschlossene Entwicklungsphasen verzerrt sein kann, lässt sich der Befehl mittels --after=<Datum> bzw. --before=<Datum> zeitlich eingrenzen, um ein aussagekräftigeres Bild zu erhalten.

Und wo häufig etwas geändert wird, entstehen oftmals auch Fehler. Adam Tornhill beschreibt in Software Design X-Rays (2018), dass Hotspots häufig nur 1-3 % der Codebasis ausmachen, gleichzeitig aber einen überproportional großen Anteil der Entwicklungsaktivität nach sich ziehen. Besonders interessant sind dabei Bereiche, die sowohl häufig verändert werden als auch eine hohe Komplexität aufweisen.
Auch die Volatilität (Code Churn) von Dateien lässt sich mit Git ermitteln. Der folgende Befehl summiert dazu die hinzugefügten und gelöschten Zeilen je Datei über den optional zeitlich eingegrenzten Verlauf und zeigt die 20 Dateien mit dem höchsten Churn-Wert an:

Ein hoher Churn einer Datei ist wie die Änderungsrate ein Indikator für eine hohe Fehlerrate. Bereits 2005 zeigte Microsoft Research am Beispiel von Windows Server 2003, dass diese Metrik mit sehr hoher Wahrscheinlichkeit fehleranfällige Module anzeigt.

Über die reinen Zahlen hinaus bieten insbesondere die Commit-Nachrichten wertvolle Einblicke in die Historie und die Hintergründe (das „Warum“) von Codeänderungen. Sie erklären, welche Motivation oder fachliche Anforderung hinter einer Anpassung steckte. Dies setzt jedoch voraus, dass im Team aussagekräftige Commit-Nachrichten gepflegt werden und generische Begriffe vermieden werden. Mögliche Verweise auf weitere Dokumentation wie Jira-Tickets unterstützen diesen Prozess zusätzlich.

Wie lässt sich der Bus-Faktor mit Git ermitteln?

Der Bus-Faktor – die minimale Anzahl an Teammitgliedern, deren Ausfall ein Projekt zum Stillstand bringt – lässt sich über die Commit-Historie ermitteln, indem man analysiert, wer die meisten Codezeilen im aktuellen Stand verantwortet. In der Source-Code-Archäologie hilft diese Kennzahl, riskante Wissensmonopole frühzeitig aufzudecken. Mit dem folgenden Befehl lässt sich die Verteilung der Code-Autor*innen direkt im Terminal anstoßen:

Dieser identifiziert die Personen, deren Beiträge im aktuellen Code am stärksten vertreten sind – und damit auch diejenigen, die ihn am besten verstehen. Fällt diese Person aus, entsteht ein entsprechendes Wissensrisiko. Da es durchaus vorkommen kann, dass der oder die selbe Autor*in mit unterschiedlichen Namen eincheckt, ist es gegebenenfalls nötig, die Namen zusammenzuführen, indem man sich zunächst eine Mail-Map-Datei erzeugen lässt wie hier beschrieben:

Nach manueller Anpassung dieser Liste – sodass jede Person durch genau eine kanonische Zeile repräsentiert wird – muss die Datei unter dem Namen .mailmap im Root-Verzeichnis des Repositories abgelegt werden. Git wendet sie ab diesem Zeitpunkt automatisch bei blame, log, shortlog und anderen Befehlen an.

Logische Kopplung: Versteckte Abhängigkeiten in der Historie erkennen

Neben dem Bus-Faktor kann Git auch die Rohdaten für logische Kopplung liefern, denn Dateien, die häufig zusammen geändert werden, haben einen hohen Kopplungsgrad. Mit

werden pro Commit die geänderten (modified, added, deleted) Dateien aufgelistet. Während man über einen kleinen Zeitraum oder bei einer kleinen Codebase mit wenigen Commits noch manuell erkennen kann, wo hier eine Kopplung vorliegt, benötigt man bei vielen Commits weitere Hilfsmittel, um hieraus die Kopplungen zu extrahieren.

Mit diesen und weiteren Befehlen erweist sich Git somit als hervorragendes Werkzeug für einen ersten Einblick in eine Codebasis. Es zeigt nicht nur, was in der Vergangenheit passiert ist, sondern erlaubt auch Rückschlüsse darauf, wo sich Schwachstellen verbergen. So nutzt CodeScene genau solche Git-Log-Daten als Grundlage für seine Analysen, während andere Werkzeuge wie CodeCharta mit ihrem integrierten Git-Log-Parser entsprechende Metriken automatisiert anwenden.

Wer sich tiefer mit dem Thema befassen möchte, dem sei Adam Tornhills, „Your Code as a Crime Scene" empfohlen. Das Buch gilt als Grundstein der sogenannten Behavioral Code Analysis – einem Ansatz, der Code nicht nur strukturell, sondern auch anhand seiner Entstehungsgeschichte (Commits, Änderungshäufigkeit, Autor*innen) untersucht.

Strukturelle Code-Analyse mit IntelliJ: Architektur und Datenflüsse verstehen

IntelliJ zeigt euch Architektur, Aufrufketten und Datenflüsse direkt in der IDE, ohne dass ihr zusätzliche Werkzeuge braucht.

Die Git-Historie gibt uns erste Hinweise auf fehleranfällige Code-Bereiche und verrät uns das Warum zu all den Änderungen in der Vergangenheit. Doch um zu verstehen, wie die Anwendung im Hier und Jetzt funktioniert, müssen wir eine Ebene tiefer gehen: In die Struktur, die Call History und den Datenfluss. Auch hierfür braucht es keine externen Erweiterungen. IntelliJ bringt bereits ab Werk eine hervorragende Ausstattung an Funktionen und Werkzeugen mit, um bestehende Anwendungen präzise zu durchleuchten.

Architektur und Spaghetti-Code aufdecken: Dependency Structure Matrix (DSM) und UML

Mit der Dependency Structure Matrix und UML-Diagrammen in IntelliJ macht ihr zyklische Abhängigkeiten und Gott-Klassen sofort sichtbar.
Wer vor einem großen, teils unübersichtlichen, Bestandssystem steht, sollte gar nicht erst versuchen, sofort Zeile für Zeile zu lesen. Eine erfolgreiche Analyse beginnt stattdessen auf der Architekturebene. Mit einer IntelliJ Ultimate Subscription und dem von JetBrains entwickelten Plugin „Dependency Structure Matrix” (DSM) lässt sich über das Menü Code → Analyze Code → Dependency Matrix die Dependency Structure Matrix der gesamten Codebasis erstellen. Diese Matrix stellt Module und Pakete in einem quadratischen Raster gegenüber und bildet sämtliche Abhängigkeiten untereinander auf Paket- und Klassenebene ab.

Screenshot „Dependency Structure Matrix” (DSM)

Der besondere Nutzen der DSM liegt in ihrer Fähigkeit, schlechte Architekturmuster sofort zu entlarven: Rot markierte Zellen signalisieren zyklische Abhängigkeiten, bei denen Komponenten gegenseitig voneinander abhängen: Die klassischen Strukturen, die Entwicklende oft als Spaghetti-Code bezeichnen. Zudem lassen sich sogenannte „Gott-Klassen” auf einen Blick identifizieren, da sie als Zeilen oder Spalten mit extrem hohen Zahlen aus dem Raster hervorstechen. Das spart stundenlange manuelle Recherche bei der Frage, wo die architektonischen Schwachstellen des Projekts liegen.

Darüber hinaus unterstützt die DSM aktiv bei Refactoring-Vorhaben: Da sich Auswirkungen von Abhängigkeiten visualisieren lassen, erkennt man sofort, welche Klassen durch eine Änderung potenziell beeinflusst werden. Sie dient somit nicht nur als Diagnose-Werkzeug. Sie ist eineEntscheidungsgrundlage, um die Kopplung schrittweise zu reduzieren und die Wartbarkeit nachhaltig zu verbessern.

Um unsere Anwendung im nächsten Schritt visuell greifbar zu machen, bietet uns IntelliJ das Diagrams-Plugin. Mit einem einfachen Rechtsklick auf eine Klasse oder ein Paket im Projektbaum und der Auswahl von Diagrams → Show Diagram generiert die IDE ad hoc ein interaktives UML-Diagramm. Der Nutzen besteht vor allem darin, komplexe Strukturen abstrahiert zu durchschauen: Wir sehen auf einen Blick tief verschachtelte Vererbungshierarchien, welche Implementierungen tatsächlich existieren und welche Klassen überraschend stark miteinander gekoppelt sind. Über das Diagramm lässt sich die Sichtbarkeit von Feldern oder Methoden gezielt ein- und ausblenden, um sich rein auf die Beziehungen zu konzentrieren, ohne von Zeilen voller Implementierungsdetails abgelenkt zu werden.

Wie analysiert man Aufrufhierarchien mit der Call Hierarchy?

Ihr startet bei fachlichen Einstiegspunkten wie REST-Endpunkten oder Listenern und verfolgt die Aufrufe mit der Call Hierarchy.

Bei der Analyse von Aufrufhierarchien ist die Wahl des Einstiegspunkts entscheidend. Während Entwicklende intuitiv oft zur main-Methode oder zu technischen Startup-Listenern greifen, sind diese für die Source-Code-Archäologie meist wenig ergiebig, da sie lediglich die Infrastruktur initialisieren, aber kaum fachliche Logik abbilden.

Welcher Einstiegspunkt der richtige ist, hängt stark von der Architektur der Anwendung ab. Bei Web-Anwendungen bilden REST-Endpunkte (z. B. @GetMapping oder @PostMapping) die fachlichen Schnittstellen, während in Event-getriebenen Systemen Listener wie @JmsListener oder @KafkaListener als Einstiegspunkte dienen. Bei Batch-Systemen oder Hintergrundprozessen lohnen sich hingegen Analysen von @Scheduled-Methoden oder Queue-Consumer-Logik.

Um diese fachlichen Einstiege zu finden, hilft die Funktion „Search Everywhere” (zweimal Shift), um gezielt nach Annotationen zu suchen. Sobald ein solcher fachlicher Endpunkt gefunden ist, lässt sich mit dem Tastenkürzel Ctrl + Alt + H (Windows/Linux) bzw. ⌥^H (macOS) die Call Hierarchy öffnen. So lässt sich der tatsächliche Datenfluss – etwa vom Controller über den Service bis hin zum Repository – präzise verfolgen.

Die Vorteile der Call Hierarchy liegen auf der Hand:

  • Auswirkungsanalyse: Bevor man eine Methode ändert oder entfernt, sieht man sofort, wer sie aufruft und welche Seiteneffekte auftreten könnten.
  • Verständnis des Kontrollflusses: Komplexe Aufrufketten werden transparent, ohne dass man manuell durch den Code springen muss.
  • Beschleunigte Navigation: Sie ermöglicht den direkten Sprung zum Aufrufer oder zur aufgerufenen Methode eines Aufrufs, was die Orientierung in großen, unbekannten Codebasen massiv beschleunigt.

Datenflussanalyse in IntelliJ: Herkunft und Pfade von Werten entschlüsseln

Mit „Analyze Data Flow to/from Here" seht ihr, welche Codepfade einen Wert setzen und wohin er weitergereicht wird.
Während die Aufrufhierarchie den Kontrollfluss von Methoden beleuchtet, hilft die Funktion „Analyze Data Flow to/from Here“ dabei, den tatsächlichen Weg von Daten durch die Anwendung zu verstehen. Ein Rechtsklick auf eine Variable oder einen Parameter ermöglicht es, zu analysieren, welche Codepfade den Wert setzen (to here) oder wohin der Wert nach der Zuweisung weitergereicht wird (from here). Gerade in Legacy-Systemen, in denen Zustände über viele Schichten hinweg gereicht werden, ist dies eine große Hilfe, um die Herkunft oder Verwendung komplexer Datenstrukturen zu entschlüsseln, ohne die gesamte Historie manuell nachverfolgen zu müssen.

Historie einzelner Codezeilen mit git blame nachvollziehen

Mit git blame – in IntelliJ als „Annotate with Git Blame“ integriert – seht ihr pro Zeile, wer sie wann geändert hat, und mit „Show History for Selection“ die Entwicklung eines Abschnitts.

Um die Entwicklung des Codes direkt im Editor nachzuvollziehen, bietet IntelliJ eine Verknüpfung der Versionsverwaltung. Mit einem Rechtsklick auf den Editor-Rand (Gutter) und der Wahl der entsprechenden Option zur Git-Analyse** („Annotate with Git Blame")** lässt sich für jede Zeile sofort erkennen, wer sie wann geändert hat. Das hilft, direkt die Person mit dem entsprechenden Fachwissen zu identifizieren, ohne in externen Systemen suchen zu müssen. Oft liefern die zugehörigen Commit-Kommentare zudem den nötigen Kontext, um komplexe oder unlogische Implementierungen zu verstehen.
Wenn nicht die ganze Datei, sondern nur ein spezifischer Abschnitt oder eine Methode von Interesse ist, lässt sich mit der Funktion „Show History for Selection" der Fokus auf diesen Bereich legen. Dies blendet Änderungen an anderen Teilen der Datei aus und zeigt präzise, wie sich genau diese Geschäftslogik über die Zeit entwickelt hat.

Kognitive Last bei großen Klassen reduzieren: Navigation und Bookmarks

Mit der Strukturansicht, der Schnellansicht (Quick Definition) und Lesezeichen findet ihr relevante Stellen, ohne lange zu scrollen.
Besonders bei umfangreichen Klassen erschweren viele Details oft das Verständnis der wesentlichen Logik. Die Strukturansicht (Structure Window) bietet hier eine übersichtliche Zusammenfassung aller Methoden und Felder einer Datei, wodurch man schnell zu relevanten Stellen navigieren kann, ohne lange scrollen zu müssen.

Ergänzend dazu erlaubt die Schnellansicht (Quick Definition), den Inhalt einer Methode oder Klasse direkt an der aktuellen Stelle in einem kleinen Fenster einzublenden. Dies ermöglicht es, Definitionen nachzuschlagen, ohne den aktuellen Kontext im Editor zu verlassen oder zwischen verschiedenen Dateien wechseln zu müssen.

Ebenso hilfreich für die Orientierung sind Lesezeichen (Bookmarks). Sie erlauben es, wichtige oder häufig besuchte Stellen im Code zu markieren, um jederzeit schnell dorthin zurückzukehren, ohne die Navigation durch die gesamte Projektstruktur erneut durchlaufen zu müssen. Mit dem Tastenkürzel F11 (Windows/Linux) oder F3 (macOS) lässt sich ein Lesezeichen setzen. Die Liste aller gesetzten Lesezeichen kann mit Shift + F11 (Windows/Linux) oder Cmd + F3 (macOS) aufgerufen werden.

Zusammenfassend lässt sich sagen: IntelliJ ist weit mehr als nur ein Werkzeug zum Schreiben von Code. Es ist ein mächtiges Instrumentarium für die Source-Code- Archäologie. Indem wir die IDE als Analyse-Plattform nutzen, verwandeln wir statische Dateien in ein lebendiges Modell der Anwendung, das uns hilft, den „Code-Dschungel” zu durchdringen. Doch bei aller Werkzeugunterstützung bleibt der entscheidende Faktor immer die menschliche Neugier. Die Werkzeuge liefern uns die Landkarten, aber interpretieren und verstehen müssen wir die Struktur des Systems am Ende selbst. Mit diesem Werkzeugkasten im Rücken sind wir nun bestens gerüstet, um auch in den tiefsten Legacy-Strukturen nicht nur zu navigieren, sondern sie Schritt für Schritt zu entwirren.

Fazit: Warum Git und IntelliJ für eine effektive Quellcode-Diagnose ausreichen

Die historische Sicht aus Git und die strukturelle Sicht aus IntelliJ liefern zusammen ein belastbares Bild des Systems.
Wir haben in diesem Beitrag gesehen, dass effektive Source-Code-Archäologie keine Frage von komplexen Spezial-Werkzeugen ist, sondern eine Frage der Perspektive. Die wirkliche Stärke liegt in der Kombination zweier komplementärer Sichtweisen, die wir bereits täglich auf unserem Rechner haben:

  • Die historische Perspektive (Git): Sie fungiert als unser Gedächtnis. Sie zeigt uns, wo die unruhigen Stellen im Code liegen, wo sich technische Schulden ansammeln und wer über das meiste implizite Wissen verfügt.
  • Die strukturelle Perspektive (IntelliJ): Sie ist unser Röntgengerät für den Ist-Zustand. Sie hilft uns, Architekturknoten zu entwirren, Abhängigkeiten zu visualisieren und den Datenfluss nachzuvollziehen.

Beide Ansätze erlauben es, ein Legacy-System nicht einfach nur „blind“ zu bearbeiten, sondern mit einer fundierten Diagnose zu starten. Die Befunde helfen, die Bereiche auszuwählen, deren Wartungsaufwand oder Änderungsrisiko für das Geschäft besonders relevant sind. Im nächsten Teil dieser Blogreihe untersuchen wir Beziehungen über viele Klassen und Komponenten hinweg und zeigen, wie sie sich als Graph gezielt abfragen lassen. Source-Code-Archäologie ist dabei kein einmaliges Ereignis, sondern eine fortlaufende Haltung in der Softwareentwicklung. Fangt also an, eure täglichen Begleiter – Git und eure IDE – gezielt für die Analyse zu nutzen. Die Antworten auf eure Architekturfragen liegen oft schon direkt vor euch. Man muss sie nur gezielt ans Licht bringen.

Quellen & Referenzen

 


Die Blogreihe zu „Source-Code-Archäologie”

  • Teil 1: Grundlagen & Business-Sicht – Was Source-Code-Archäologie leistet und warum der verlässlichste Weg, um Legacy-Systeme zu modernisieren, beim Verstehen der bestehenden Fachlogik und des technischen Zustands der Anwendung beginnt.
  • Teil 2: Der Tool-Markt – Welche Werkzeuge im Bereich der Source-Code-Archäologie existieren und welches Tool für welches Problem geeignet ist.
  • Teil 3: Quellcode-Analyse mit Bordmitteln – Wie Entwicklungsteams mit vorhandenen Standard-Werkzeugen ohne Zusatzbudget wertvolles Systemwissen freilegen.
  • Teil 4: Graphenbasierte Code-Analyse – Konventionelle Werkzeuge im Vergleich mit KI-gestützten Code-Graphen und wie sich beide Ansätze kombinieren lassen.
    (Erscheint am 24.11.2026)
  • Teil 5: Künstliche Intelligenz & Autonomie – Von MCP-Servern bis zu KI-Agenten: Kann generative KI die Source-Code-Archäologie bald vollständig übernehmen?
    (Erscheint am 01.12.2026)

   

//

Mehr zu Software-Modernisierung

//

Weitere Artikel in diesem Themenbereich

Entdecke spannende weiterführende Themen und lass dich von der codecentric Welt inspirieren.

//
Jetzt für unseren Newsletter anmelden

Alles Wissenswerte auf einen Klick:
Unser Newsletter bietet dir die Möglichkeit, dich ohne großen Aufwand über die aktuellen Themen bei codecentric zu informieren.