JUnit-Lernprogramm: Einrichten, Schreiben und Ausführen von Java-Komponententests

Verstehen Sie die Grundlagen und skalieren Sie Ihre Unit-Test-Praxis wie ein Profi mit diesem Tutorial.

Möchten Sie die Grundlagen überspringen und sehen, wie Sie automatisieren können? Unit-Test-Generierung mit KI erweitert in <0 Minuten von 60 auf über 5 % Codeabdeckung gehen? Schauen Sie sich Jtest an >>

Wichtige Erkenntnisse

• JUnit ist der De-facto-Teststandard für Java. JUnit ist das am weitesten verbreitete Framework zum Schreiben und Ausführen automatisierter Unit-Tests, mit dem Fehler frühzeitig in der Entwicklung erkannt werden können.
• Das JUnit-Framework ist ausgereift und entwickelt sich ständig weiter. JUnit wird ständig weiterentwickelt, um den Bedürfnissen von Java-Entwicklern gerecht zu werden, und enthält viele Funktionen, die alle Aspekte einer robusten Unit-Testing-Praxis unterstützen.
• Die Einrichtung ist einfach. JUnit ist in gängigen IDEs wie Eclipse und IntelliJ vorkonfiguriert, während Build-Systeme wie Maven und Gradle mit wenigen Konfigurationszeilen so eingestellt werden können, dass sie JUnit verwenden, unabhängig von der verwendeten Version.
• JUnit-Tests folgen einem strukturierten Muster. Das JUnit-Framework bietet eine einfache API zur Testdefinition, während das Given-When-Then-Format eine nützliche Strukturierung des Testcodes ermöglicht.
• JUnit-Tests können überall ausgeführt werden. Tests können direkt in der IDE ausgeführt werden, um während der Entwicklung schnelles Feedback zu erhalten, oder über Maven- oder Gradle-Befehle, CI/CD-Pipelines und die Kommandozeile zur automatisierten Ausführung.
• Mocking-Frameworks lassen sich problemlos integrieren. Wenn der zu testende Code von externen Systemen oder komplexen Objekten abhängt, können Mocking-Frameworks wie Mockito verwendet werden, um den Code durch die Simulation von Abhängigkeiten zu isolieren und so fokussierte, zuverlässige Unit-Tests ohne Seiteneffekte zu ermöglichen.
• KI beschleunigt JUnit-Tests im großen Maßstab. Parasoft Jtest generiert automatisch Testfälle, Mocks und Assertions direkt in der IDE oder in Pull-Request-Workflows und hilft Teams so, eine signifikante Codeabdeckung zu erreichen und gleichzeitig den Aufwand für die Erstellung und Wartung von Tests um mehr als 50 % zu reduzieren.

Was ist JUnit-Testing?

JUnit ist das beliebteste Framework für Java-Komponententests. Ein Open-Source-Framework, das zum Schreiben und Ausführen wiederholbarer automatisierter Tests verwendet wird.

JUnit hat sich durch die Kombination leistungsstarker, durchdachter und nahtlos zusammenarbeitender Funktionen als De-facto-Standard für Java-Unit-Tests etabliert. Es war das erste entwickelte Unit-Test-Framework und ist dank seiner besonderen Eigenschaften und kontinuierlichen Weiterentwicklung bis heute die bevorzugte Wahl für Java-Entwickler weltweit.

Was sind die wichtigsten Merkmale von JUnit und die wesentlichen Unterschiede zwischen den Versionen?

Wie alles andere hat sich auch das JUnit-Testframework im Laufe der Zeit weiterentwickelt.

JUnit 4.0 wurde 2006 veröffentlicht, 5.0 im Jahr 2017 und 6.0 im September 2025.

Stand Februar 2026 ist die aktuellste Version 6.0.2.

• JUnit 5.x wurde auf eine modulare Architektur umgestellt und viele der früheren Einschränkungen von JUnit wurden behoben.
• JUnit 6.x ist eine sanftere Iteration, die den JUnit 5-Ansatz beibehält, aber das Framework weiter modernisiert und vereinfacht hat.
• JUnit 4 und 5 Beide erfreuen sich nach wie vor hoher Nutzung, doch die Zukunft gehört wahrscheinlich JUnit 6.

Hier sind einige der wichtigsten Aspekte und Funktionen von JUnit sowie die Unterschiede zwischen den Versionen:

Zusammenarbeit für umfassende Tests

Diese Funktionen ergänzen sich synergistisch und bilden ein vollständiges, erweiterbares Framework, das professionelle Softwareentwicklungspraktiken unterstützt.

• Isolation und Konsistenz prüfen. Die Setup- und Teardown-Methoden gewährleisten, dass jeder Test in einem gewünschten, vordefinierten Zustand startet.
• Organisatorische Flexibilität. Test-Suites, verschachtelte Tests und die Verschlagwortung ermöglichen es, die richtigen Tests zum richtigen Zeitpunkt zu organisieren und auszuführen.
• Klarer Testausdruck. Die Kern-API stellt die Werkzeuge bereit, die zum Schreiben verständlicher und wartbarer Tests benötigt werden.
• Skalierbarkeit Funktioniert sowohl für einzelne Entwickler, die eine Handvoll Tests schreiben, als auch für Unternehmensteams, die Tausende von Tests über mehrere Module hinweg pflegen.

So richten Sie JUnit-Tests ein

Dann legen wir mal los. Hier sind die Schritte zum Einrichten von JUnit.

In den gängigeren IDEs wie Eclipse und IntelliJ ist die JUnit-Testintegration bereits standardmäßig installiert.

Wenn Sie keine IDE verwenden und sich stattdessen ausschließlich auf ein Build-System wie Maven oder Gradle verlassen, erfolgt die Konfiguration von JUnit über die Datei pom.xml bzw. build.gradle.

Es ist wichtig das zu beachten Einheit 5 wurde in drei Module aufgeteilt, von denen eines ein älteres Modul ist, das die Ausführung von Einheit 4 und drei Tests von Einheit 5.

Einheit 6 Diese Architektur bleibt erhalten.

Einheit 3 Die Nutzung ist derzeit sehr gering und findet sich üblicherweise nur in viel älteren Projekten.

Wie man JUnit 6 einrichtet

Aufgrund des modularen Aufbaus von JUnit 6 wird eine Stückliste (POM) zum Importieren aller JUnit-Module und -Abhängigkeiten verwendet. Werden nur bestimmte Module benötigt, können stattdessen einzelne Gruppen oder Artefakte angegeben werden.

Fügen Sie pom.xml Folgendes hinzu, um Javen JUnit 6 zu Maven hinzuzufügen:

<dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>org.junit</groupId>
			<artifactId>junit-bom</artifactId>
			<version>6.0.2</version>
			<type>pom</type>
			<scope>import</scope>
		</dependency>
	</dependencies>
</dependencyManagement>
<dependencies>
	<dependency>
		<groupId>org.junit</groupId>
		<artifactId>junit-bom</artifactId>
		<version>6.0.2</version>
		<scope>test</scope>
	</dependency>
</dependencies>

Fügen Sie für Gradle Folgendes zur Datei build.gradle hinzu:

dependencies {
	testImplementation platform("org.junit:junit-bom:6.0.2")
	testImplementation "org.junit.jupiter:junit-jupiter-api"
	testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine"
	testRuntimeOnly "org.junit.platform:junit-platform-launcher"
}
test {
	useJUnitPlatform()
}

Wie man JUnit 5 einrichtet

Aufgrund des modularen Aufbaus von JUnit 5 wird eine Stückliste (POM) zum Importieren aller JUnit-Module und -Abhängigkeiten verwendet. Werden nur bestimmte Module benötigt, können stattdessen einzelne Gruppen oder Artefakte angegeben werden.

JUnit 5 wird auf die gleiche Weise konfiguriert wie JUnit 6:

<dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>org.junit</groupId>
			<artifactId>junit-bom</artifactId>
			<version>5.14.2</version>
			<type>pom</type>
			<scope>import</scope>
		</dependency>
	</dependencies>
</dependencyManagement>
<dependencies>
	<dependency>
		<groupId>org.junit</groupId>
		<artifactId>junit-bom</artifactId>
		<version>5.14.2</version>
		<scope>test</scope>
	</dependency>
</dependencies>

Fügen Sie für Gradle Folgendes zur Datei build.gradle hinzu:

dependencies {
	testImplementation platform("org.junit:junit-bom:5.14.2")
	testImplementation "org.junit.jupiter:junit-jupiter-api"
	testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine"
	testRuntimeOnly "org.junit.platform:junit-platform-launcher"
}
test {
	useJUnitPlatform()
}

Wie man JUnit 4 einrichtet

Um JUnit 4 zu Maven hinzuzufügen, fügen Sie Folgendes zu pom.xml hinzu.

<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.13.2</version>
	<scope>test</scope>
</dependency>

Fügen Sie für gradle Folgendes zur build.gradle hinzu:

dependencies {
	testImplementation 'junit:junit:4.13.2'
}
test {
	useJUnit()
}

Falls Sie JUnit für JUnit-Tests manuell zum Klassenpfad hinzufügen müssen, müssen Sie die JAR-Datei(en) direkt referenzieren. Dies ist jedoch normalerweise nicht erforderlich. JUnit 4, 5 und 6 bieten die JAR-Datei(en) zum direkten Download an. Für JUnit 5 und 6 benötigen Sie eine Fat-JAR-Datei (auch Uber-JAR genannt), wie beschrieben. werden auf dieser Seite erläutert.

Welche Komponenten umfasst ein JUnit-Test?

Nachdem wir nun ein wenig über das JUnit-Setup gesprochen haben, wollen wir mit der eigentlichen Konstruktion und Ausführung dieser Tests fortfahren. Um die Erstellung von JUnits am besten zu veranschaulichen, beginnen wir mit etwas Grundlegendem. Im folgenden JUnit-Testbeispiel haben wir eine einfache Methode (links), der Fahrenheit in Celsius umwandelt, und einen JUnit-Test (Recht) geschrieben, um unsere Methode zu testen. Ich habe die wichtigsten Teile des JUnit-Tests nummeriert und werde jeden Teil unten im Detail besprechen.

 

Importe und Abhängigkeiten in JUnit

Die Teile 1 und 2 im obigen Screenshot zeigen die Importe der JUnit-Klassen und -Methoden, die im Unit-Test verwendet werden. Die Importe können als einzelne Klassen oder Methoden angegeben werden, üblicherweise werden jedoch ganze Pakete mit Sternchen (*) angegeben. Beide Varianten funktionieren – die Granularität der Importe ist Geschmackssache.

Wie man eine JUnit-Testklasse definiert

Teil 3 definiert den Beginn unserer Testklasse. Wichtig hierbei ist die Namenskonvention für die Klasse, die wie folgt lautet: KlassennameTest. Diese Namenskonvention ist nicht erforderlich, aber es ist die gebräuchlichste Art, JUnit-Klassen zu benennen, da der Name den Zweck der Unit-Test-Klasse und die Klasse, die sie testet, prägnant beschreibt.

JUnit-Annotationen und ihre Verwendung

In Teil 4 lernen wir unsere erste JUnit-spezifische Syntax kennen: die @Test-Annotation. Annotationen sind beim Erstellen von JUnit-Tests extrem wichtig. Sie dienen dem JUnit-Framework dazu, die relevanten Teile des Unit-Tests zu identifizieren. In unserem Beispiel weist die @Test-Annotation JUnit an, die öffentliche void-Methode, an die sie angehängt ist, als Testfall auszuführen.

Es gibt noch viele weitere Annotationen, aber einige der gebräuchlichsten für JUnit 5 und 6 sind die folgenden.

• Die @BeforeEach-Anweisung kennzeichnet eine Methode, die vor jeder Testmethode in der Klasse ausgeführt werden soll. Sie wird typischerweise verwendet, um den Zustand zu aktualisieren oder zurückzusetzen, der für die korrekte Ausführung der Testmethoden erforderlich ist.
• @AfterEach kennzeichnet eine Methode, die nach jeder Testmethode in der Klasse ausgeführt werden soll. Sie kann verwendet werden, um Variablen zurückzusetzen, temporäre Dateien zu löschen usw.
• @Disabled gibt an, dass eine Testmethode nicht ausgeführt werden soll.
• @BeforeAll kennzeichnet eine Methode, die einmalig vor dem Ausführen von Testmethoden ausgeführt werden soll.
• @AfterAll kennzeichnet eine Methode, die einmalig ausgeführt werden soll, nachdem alle Testmethoden ausgeführt wurden.

Benennung von Testmethoden in JUnit

Beachten Sie für Teil 5 erneut die Namenskonvention. testMethodenname, Wobei Methodenname ist der Name der Methode, die in der zu testenden Klasse getestet wird. Diese Namenskonvention ist üblich, aber nicht zwingend erforderlich. Manchmal wird dem Namen eine zusätzliche Beschreibung hinzugefügt, um das spezifische Verhalten zu beschreiben, das durch den Test überprüft wird.

Der Abschnitt „Gegeben“ und wie man einen Test einrichtet

In Teil 6, Gegeben Abschnitt des Tests konstruieren wir eine neue Instanz der zu testenden Klasse und initialisieren sie entsprechend. Dies ist notwendig, da die Testmethode die zu testende Methode aufrufen muss, um sie zu testen. In unserem Beispiel ist neben der Instanziierung der Klasse keine weitere Initialisierung erforderlich, aber in vielen Fällen müssen möglicherweise zusätzliche Einstellungen vorgenommen werden, z. B. das Initialisieren von Objekten zur Übergabe an den Konstruktor oder das Aufrufen von Methoden, die den Zustand der zu testenden Klasse konfigurieren.

Der Abschnitt „Wann“ und wie die zu testende Methode aufgerufen wird

In Teil 7, Wenn die Funktion Der Abschnitt des Tests umfasst das Initialisieren von Variablen, die übergeben werden müssen, wenn die zu testende Methode aufgerufen wird, und dann das Aufrufen der Testmethode (Teil 8). Den Variablen sollten aussagekräftige Werte gegeben werden, die bewirken, dass der Test die Teile der Testmethode ausführt, die uns wichtig sind. Beachten Sie, dass eine Variable, die ein Objekt ist, instanziiert oder verspottet werden kann.

Erfassen Sie die Ausgabe der zu testenden Methode.

In Teil 8 sollte, falls die zu testende Methode einen Wert zurückgibt, dieser in einer Variablen gespeichert werden, damit sein Wert überprüft werden kann.

Der "Dann"-Abschnitt und die Verwendung von Assertions zur Überprüfung von Testergebnissen

Unit-Tests sind nur dann sinnvoll, wenn sie Assertions enthalten, die überprüfen, ob die getestete Methode den korrekten Wert zurückgibt und/oder den Zustand anderer Objekte wie erwartet anpasst. Ohne Assertions, wie in Teil 9 gezeigt, findet keine Verifizierung statt. Ihr Test ist bestenfalls ein Smoke-Test, der nur dann Feedback liefert, wenn eine Ausnahme ausgelöst wird.

Die JUnit-Assertionsmethoden, die in JUnit 5 und 6 in der Klasse `org.junit.jupiter.api.Assertions` und in JUnit 4 in der Klasse `org.junit.Assert` enthalten sind, werden häufig verwendet, um den Status von Testfällen (bestanden/nicht bestanden) zu ermitteln. Nur fehlgeschlagene Assertions werden vom JUnit-Framework gemeldet. Ähnlich wie bei Annotationen gibt es zahlreiche Assertionsoptionen.

In unserem obigen Beispiel-JUnit verwenden wir die Methode assertEquals (erwartet, aktuell, Delta). Das erste Argument ist:

• Das erwartetes Ergebnis, die der Testautor definiert.
• Das tatsächliche Leistung, was der Rückgabewert der aufgerufenen Methode ist
• Das Delta, die eine akzeptable Abweichung zwischen erwarteten und tatsächlichen Werten zulässt. Dieses Delta ist spezifisch für die Tatsache, dass wir den Wert eines Double-Typs validieren.

So führen Sie eine JUnit aus

Wähle dein eigenes Abenteuer! Hier betrachten wir drei Möglichkeiten, JUnits auszuführen:

• Direkt von der Kommandozeile
• Aus der IDE (Eclipse und IntelliJ)
• Verwendung von Build-Systemen (Maven und Gradle)

So führen Sie eine JUnit über die IDE aus

Eclipse

Suchen Sie im Paket-Explorer Ihren JUnit-Test. Klicken Sie mit der rechten Maustaste und wählen Sie Ausführen als > JUnit-Test. Dadurch werden Ihre Test- und Berichtsergebnisse in der JUnit Eclipse-Ansicht ausgeführt.

IntelliJ

Das Ausführen eines Tests in IntelliJ ähnelt Eclipse. Suchen Sie im Projektfenster Ihren Test, klicken Sie mit der rechten Maustaste, und wählen Sie „Testname“ ausführen aus. Wie bei Eclipse öffnet sich ein JUnit-Fenster mit den Ergebnissen des Tests.

Wie man einen JUnit-Test aus dem Maven-Buildsystem ausführt

Maven

Maven vereinfacht das Ausführen von Unit-Tests. Stellen Sie sicher, dass Sie sich im richtigen Verzeichnis Ihrer Konsole befinden und die pom.xml-Datei Ihres Projekts korrekt konfiguriert ist. Anschließend können Sie Ihre JUnit-Tests mit folgendem Befehl ausführen.

So führen Sie die gesamte Testsuite aus:

mvn test

So führen Sie einen oder mehrere einzelne/spezifische Tests durch:

mvn -D test=TestName test

Wie man einen JUnit-Test aus dem Gradle-Build-System ausführt

Gradle hat, ähnlich wie Maven, das Ausführen von Tests vereinfacht.

So führen Sie die gesamte Testsuite aus:

gradlew test

So führen Sie einen oder mehrere einzelne/spezifische Tests durch:

gradlew -D test.single=testName test

Hinweis: Maven und Gradle sind ihre eigenen Bestien. Was hier gezeigt wird, ist minimal, um die Grundlagen abzudecken. Schauen Sie sich ihre Dokumentation an, wenn Sie mehr erfahren möchten.

So führen Sie einen JUnit-Test über die Kommandozeile aus

Um ein JUnit direkt von der Kommandozeile aus auszuführen, benötigen Sie ein paar Dinge:

• JDK auf Ihrem Weg
• Die entsprechende(n) JUnit-JAR-Datei(en)
• Die Quell- und Testklassen

Am einfachsten lässt sich dies in JUnit 5 und 6 mit dem JUnit Console Launcher wie folgt bewerkstelligen.

java -jar /path/to/junit-platform-console-standalone-<version>.jar execute -cp /path/to/source/classes -cp /path/to/test/classes <test class name>

Hinweis: Das Ausführen eines Tests über die Befehlszeile erfolgt am häufigsten über einen CI/CD-Prozess, der in einem Buildsystem wie Jenkins oder Azure DevOps ausgeführt wird.

Fortsetzung des Unit-Tests

Unser Beispiel durchlief einen einfachen Unit-Test, und das ist natürlich nur der Anfang von Unit-Tests. Komplexere zu testende Methoden rufen möglicherweise Methoden in abhängigen Klassen auf oder verbinden sich mit externen Systemen wie einer Datenbank. In solchen Fällen kann es sinnvoll sein, den Code durch Mocking zu isolieren.

Mocking hilft dabei, Codeeinheiten zu isolieren, sodass sich unsere Komponententests nur auf die spezifische zu testende Klasse/Methode konzentrieren können. Das am häufigsten zum Mocking in JUnit-Tests verwendete Framework ist Mockito.

Um mehr über das Spotten zu erfahren, lesen Sie den Beitrag meines Kollegen: So automatisieren Sie einen Java-Komponententest, einschließlich Verspottungen und Behauptungen.

Wenn Unit-Tests so wichtig sind, warum werden sie dann nicht von allen konsequent durchgeführt? Trotz ihrer Bedeutung sind Unit-Tests nicht immer einfach zu implementieren und zu pflegen. Sie erfordern fundiertes Entwicklungswissen und kontinuierlichen Aufwand, um die Test-Suites aktuell zu halten. Daher werden Unit-Tests oft vernachlässigt – bis es zu Regressionen kommt.

Aber so muss es nicht sein.

Beschleunigen Sie JUnit-Tests mit KI

Hier ist Parasoft Test kommt ins Spiel. Sein KI-gestützter Unit-Test-Assistent wurde entwickelt, um die Hürden beim Schreiben und Pflegen von Unit-Tests zu beseitigen. Mit nur wenigen Klicks können Teams, die bei 0 % beginnen, sofort loslegen. Codeabdeckung kann automatisch robuste Testsuiten generieren, die 60 % oder mehr ihres Java-Codes abdecken. Als eine Finanzdienstleistungsunternehmen bemerkte: „Seit wir Parasoft Jtest implementiert haben, konnten wir den Zeitaufwand für die Erstellung und Wartung von Unit-Tests erfolgreich um mehr als 50 % reduzieren.“

So kann Ihr Team Ihre Testpraxis skalieren.

• Automatische Generierung von JUnit-Testfällen für zuvor nicht entdeckten Code mithilfe der intelligenten Massentesterstellung.
• Zielerstellung für geänderten Code direkt in der IDE oder innerhalb von Pull-Request-Workflows.
• Schützen Sie Ihre Daten mit der proprietären KI von Parasoft, die vor Ort ausgeführt werden kann – kein Code oder Daten verlässt Ihre Umgebung.
• Mocks und Stubs generieren um Abhängigkeiten zu isolieren und Ihre Tests zu fokussieren. Dies spart Zeit und macht das manuelle Schreiben von Mocking-Logik überflüssig.
• Anpassen und Erweitern von Tests mit Ein-Klick-Aktionen zum Hinzufügen von Behauptungen, Parametrisieren von Testfällen und Verbessern der Wartbarkeit.
• Beschleunigen Sie die Testausführung mit eingebauten Test Impact Analysis , Live-Unit-Tests, das nur die Tests identifiziert und ausführt, die zur Validierung Ihrer letzten Codeänderungen erforderlich sind.

Wenn Ihnen das Schreiben und Warten von JUnit-Tests wie eine lästige Pflicht vorkommt, ist es Zeit, Ihren Ansatz zu modernisieren. KI-gestützte Testlösungen wie diese können die Testerstellung von einem Engpass in einen strategischen Vorteil verwandeln – und Ihnen mehr Zeit für die Entwicklung großartiger Software geben.