Das Java Framework ArchUnit ist ein leistungsstarkes Werkzeug für die Gewährleistung von Softwarearchitektur und Code-Qualität in Java-Projekten.
Durch die Möglichkeit, deklarative Regeln zu erstellen und automatisierte Tests zu schreiben, hilft ArchUnit, konsistente und hochwertige Software zu entwickeln.
Die Integration in Build-Tools ermöglicht eine kontinuierliche Überwachung der Architekturstandards während des gesamten Entwicklungsprozesses. Durch die Verwendung von ArchUnit können Entwickler und Architekten sicherstellen, dass ihre Softwareprojekte den höchsten Standards in Bezug auf Architektur und Code-Qualität entsprechen.
Was ist nötig? Die neue Version in der pom.xml eintragen und einen Quicktest.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
<!-- Architektur validation --> <dependency> <groupId>com.tngtech.archunit</groupId> <artifactId>archunit-junit5</artifactId> <version>1.2.1</version> <scope>test</scope> </dependency> <dependency> <groupId>com.tngtech.archunit</groupId> <artifactId>archunit</artifactId> <version>1.2.1</version> <scope>test</scope> </dependency> <dependency> <groupId>com.tngtech.archunit</groupId> <artifactId>archunit-junit5-api</artifactId> <version>1.2.1</version> <scope>test</scope> </dependency> |
Die Entwicklung von Softwareanwendungen wird immer komplexer und anspruchsvoller. Um sicherzustellen, dass Softwareprojekte effizient, skalierbar und wartbar sind, ist die Einhaltung einer soliden Softwarearchitektur und Code-Qualität von entscheidender Bedeutung. Hier kommt das Java Framework ArchUnit ins Spiel, das sich als unverzichtbares Werkzeug für die Überprüfung und Aufrechterhaltung dieser Standards etabliert hat.
ArchUnit ist ein Open-Source-Framework für statische Codeanalyse in Java-Anwendungen. Es wurde entwickelt, um Entwicklern und Architekten dabei zu helfen, die Einhaltung von vordefinierten Architekturrichtlinien und -regeln in ihrem Java-Code sicherzustellen. Das Framework ermöglicht es, Architekturvorgaben in Form von Java-Codeausdrücken zu definieren und automatisierte Tests zu schreiben, um sicherzustellen, dass diese Vorgaben im gesamten Projekt eingehalten werden.
Hier noch mal vier Hauptmerkmale von ArchUnit
1. Deklarative Regeln:
ArchUnit ermöglicht die Definition von Architekturregeln und -richtlinien mithilfe einer deklarativen Syntax. Entwickler können benutzerdefinierte Regeln erstellen, die sicherstellen, dass bestimmte Klassen, Pakete oder Schichten nicht in unerwünschter Weise aufeinander zugreifen.
2. Testbasierte Überprüfung:
Das Framework ermöglicht das Schreiben von Tests (JUnit), die sicherstellen, dass die definierten Architekturvorgaben eingehalten werden. Diese Tests können in den automatischen Build-Prozess integriert werden, um sicherzustellen, dass Verstöße gegen die Architektur sofort erkannt werden.
3. Integration in Build-Tools:
ArchUnit kann nahtlos in Build-Tools wie Gradle oder Maven integriert werden, um automatisierte Architekturüberprüfungen während des Build-Vorgangs durchzuführen. Dadurch wird sichergestellt, dass die Architekturrichtlinien kontinuierlich überwacht werden.
4. Unterstützung für komplexe Szenarien:
Das Framework ermöglicht die Formulierung von komplexen Regeln und Szenarien, um sicherzustellen, dass die Softwarearchitektur den Anforderungen gerecht wird. Es kann beispielsweise überprüfen, ob bestimmte Pakete nur von bestimmten Schichten aus zugänglich sind oder ob Abhängigkeiten zwischen Modulen korrekt gehandhabt werden.
Und wer jetzt noch nicht überzeugt ist, vier Vorteile von ArchUnit
Konsistente Architektur: ArchUnit gewährleistet, dass die festgelegten Architekturrichtlinien konsistent und über den gesamten Code hinweg eingehalten werden.
Frühzeitige Fehlererkennung: Durch die Integration von ArchUnit-Tests in den Build-Prozess können Architekturverletzungen frühzeitig erkannt und behoben werden, bevor sie sich auf die Produktionsumgebung auswirken.
Wartbarkeit und Skalierbarkeit: ArchUnit unterstützt bei der Erstellung von wartbarem und skalierbarem Code, da es dazu beiträgt, eine klare Trennung der Komponenten und Schichten zu gewährleisten.
Dokumentation der Architektur: Die deklarativen Regeln in ArchUnit dienen auch als Dokumentation der gewünschten Architektur, wodurch das Verständnis und die Kommunikation im Entwicklungsteam verbessert werden.
Bei mir gehört ArchUnit gleich zum Projektstart in jedes Projekt! Der Start ist auch nicht schwer, dank der guten Anleitung.
Und hier mal ein Beispiel einer Regelklasse in Java:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
/** * Architektur vorgaben. * * Siehe https://www.archunit.org/userguide/html/000_Index.html * * @author Thomas Wenzlaff */ @AnalyzeClasses(packages = "de.wenzlaff") public class ArchitekturValidator { /** * Das be Package darf nicht auf das Blockchain Package zugreifen. * * Nur umgekehrt. */ @ArchTest static final ArchRule Package_BE_Regel = noClasses().that().resideInAPackage("..blockchain.be..").should().dependOnClassesThat().resideInAPackage("..blockchain") .because("Architektur Package BE Regel"); /** * Klasse hat kein Zugriff auf System.in , System.out or System.err * * Klasse soll kein java util logging nutzen * * Klasse soll kein joda time * * Methoden sollen keine Generic Exception werfen */ @ArchTest static final ArchRule Allgemeine_Regel = CompositeArchRule.of(GeneralCodingRules.NO_CLASSES_SHOULD_ACCESS_STANDARD_STREAMS) .and(GeneralCodingRules.NO_CLASSES_SHOULD_THROW_GENERIC_EXCEPTIONS).and(GeneralCodingRules.NO_CLASSES_SHOULD_USE_JAVA_UTIL_LOGGING) .and(GeneralCodingRules.NO_CLASSES_SHOULD_USE_JODATIME).because("Allgemeine Architektur Regel"); /** * Apache Log4J Logger nur private, final und static und Feldname LOG */ @ArchTest static final ArchRule Logger_Regel = fields().that().haveRawType(Logger.class).should().bePrivate().andShould().beStatic().andShould().beFinal().andShould().haveName("LOG") .because("Eigene Architektur Regel"); } |