ArchUnit Java 架構測試研究報告

<!-- JUnit 5 -->
<dependency>
    <groupId>com.tngtech.archunit</groupId>
    <artifactId>archunit-junit5</artifactId>
    <version>1.4.2</version>
    <scope>test</scope>
</dependency>

dependencies {
    testImplementation 'com.tngtech.archunit:archunit-junit5:1.4.2'
}

@AnalyzeClasses(
    packages = "com.example.myapp",
    importOptions = ImportOption.DoNotIncludeTests.class
)
public class ArchitectureTest {

    @ArchTest
    static final ArchRule myRule = classes()
        .that().resideInAPackage("..service..")
        .should().onlyBeAccessed().byAnyPackage("..controller..", "..service..");
}

@ArchTest
static final ArchRule layer_dependencies = layeredArchitecture()
    .consideringAllDependencies()
    .layer("Controller").definedBy("..controller..")
    .layer("Service").definedBy("..service..")
    .layer("Repository").definedBy("..repository..")
    .whereLayer("Controller").mayNotBeAccessedByAnyLayer()
    .whereLayer("Service").mayOnlyBeAccessedByLayers("Controller")
    .whereLayer("Repository").mayOnlyBeAccessedByLayers("Service");

@ArchTest
static final ArchRule services_should_not_depend_on_controllers = noClasses()
    .that().haveSimpleNameEndingWith("Service")
    .should().dependOnClassesThat().haveSimpleNameEndingWith("Controller");

@ArchTest
static final ArchRule controllers_should_not_depend_on_repositories = noClasses()
    .that().haveSimpleNameEndingWith("Controller")
    .should().dependOnClassesThat().haveSimpleNameEndingWith("Repository");

// source 套件不應依賴 foo 套件
noClasses().that().resideInAPackage("..source..")
    .should().dependOnClassesThat().resideInAPackage("..foo..");

// foo 套件只應被特定套件依賴
classes().that().resideInAPackage("..foo..")
    .should().onlyHaveDependentClassesThat().resideInAnyPackage("..source.one..", "..foo..");

// Service 和 Repository 不應依賴 Controller
noClasses()
    .that().resideInAnyPackage("..service..")
    .or().resideInAnyPackage("..repository..")
    .should().dependOnClassesThat().resideInAnyPackage("..controller..")
    .because("Services and repositories should not depend on web layer");

// 所有 Service 類別名稱必須以 "Service" 結尾，且位於 service 套件
classes().that().haveSimpleNameEndingWith("Service")
    .should().resideInAPackage("..service..");

// 所有 Repository 類別必須在 repository 套件
classes().that().haveNameMatching(".*Repository")
    .should().resideInAPackage("..repository..")
    .as("Repositories should reside in a package '..repository..'");

// 實作 Connection 介面的類別名稱必須以 "Connection" 結尾
classes().that().implement(Connection.class)
    .should().haveSimpleNameEndingWith("Connection");

// 公開 API 方法必須使用 camelCase 命名
methods().that().areDeclaredInClassesThat().resideInAPackage("..api..")
    .and().arePublic()
    .should().haveNameMatching("^[a-z][a-zA-Z0-9]*$");

// 使用 slices 檢查套件之間的循環依賴
slices().matching("com.myapp.(*)..").should().beFreeOfCycles();

// 更精細的控制：檢查所有 myapp 下的子套件
slices().matching("..myapp.(**)").should().beFreeOfCycles();

// 確保特定切片之間無循環
slices().matching("..myapp.(**).service..").should().notDependOnEachOther();

SliceAssignment customAssignment = new SliceAssignment() {
    @Override
    public SliceIdentifier getIdentifierOf(JavaClass javaClass) {
        if (javaClass.getPackageName().startsWith("com.oldapp")) {
            return SliceIdentifier.of("Legacy");
        }
        if (javaClass.getName().contains(".esb.")) {
            return SliceIdentifier.of("ESB");
        }
        return SliceIdentifier.ignore();
    }

    @Override
    public String getDescription() {
        return "custom package structure";
    }
};

slices().assignedFrom(customAssignment).should().beFreeOfCycles();

onionArchitecture()
    .domainModels("com.myapp.domain.model..")
    .domainServices("com.myapp.domain.service..")
    .applicationServices("com.myapp.application..")
    .adapter("cli", "com.myapp.adapter.cli..")
    .adapter("persistence", "com.myapp.adapter.persistence..")
    .adapter("rest", "com.myapp.adapter.rest..");

// 以 "Foo" 開頭的類別必須在 com.foo 套件下
classes().that().haveSimpleNameStartingWith("Foo")
    .should().resideInAPackage("com.foo");

// 帶有 @Entity 註解的類別必須在 domain 套件下
classes().that().areAnnotatedWith(Entity.class)
    .should().resideInAPackage("..domain..");

// 繼承特定基底類別的類別，名稱必須以特定字串結尾
classes().that().areAssignableTo(AbstractRepository.class)
    .should().haveSimpleNameEndingWith("Repository");

// 實作 EntityManager 的類別只能被 persistence 套件的類別依賴
classes().that().areAssignableTo(EntityManager.class)
    .should().onlyHaveDependentClassesThat().resideInAnyPackage("..persistence..");

// 帶有 @Transactional 註解的類別，其呼叫者也必須有 @Transactional\n
classes().that().areAssignableTo(EntityManager.class)
    .should().onlyHaveDependentClassesThat().areAnnotatedWith(Transactional.class);

// Controller 的所有公開方法必須帶有 @RequestMapping 或 @GetMapping 等註解
methods().that().areDeclaredInClassesThat()
    .haveSimpleNameEndingWith("Controller")
    .and().arePublic()
    .should().beAnnotatedWith(Mapping.class)
    .because("All public controller methods should be mapped to an endpoint");

import static com.tngtech.archunit.library.GeneralCodingRules.NO_CLASSES_SHOULD_THROW_GENERIC_EXCEPTIONS;

@ArchTest
static final ArchRule no_generic_exceptions = NO_CLASSES_SHOULD_THROW_GENERIC_EXCEPTIONS;

import static com.tngtech.archunit.library.GeneralCodingRules.NO_CLASSES_SHOULD_ACCESS_STANDARD_STREAMS;

@ArchTest
static final ArchRule no_standard_streams = NO_CLASSES_SHOULD_ACCESS_STANDARD_STREAMS;

import static com.tngtech.archunit.library.GeneralCodingRules.NO_CLASSES_SHOULD_USE_JODATIME;

@ArchTest
static final ArchRule no_jodatime = NO_CLASSES_SHOULD_USE_JODATIME;

import static com.tngtech.archunit.library.GeneralCodingRules.NO_CLASSES_SHOULD_USE_JAVA_UTIL_LOGGING;

@ArchTest
static final ArchRule no_jul = NO_CLASSES_SHOULD_USE_JAVA_UTIL_LOGGING;

import static com.tngtech.archunit.library.GeneralCodingRules.NO_CLASSES_SHOULD_USE_FIELD_INJECTION;

@ArchTest
static final ArchRule no_field_injection = NO_CLASSES_SHOULD_USE_FIELD_INJECTION;

modules().that().resideInAPackage("..domain..")
    .should().notDependOnModulesThat().resideInAPackage("..infrastructure..");

modules().definedByPackages("..myapp.(*)..")
    .should().notDependOnEachOther();

// 只有 api 套件中的類別可以是 public
classes().that().arePublic()
    .should().resideInAPackage("..api..");

// 公開方法不應存取標準串流
methods().that().arePublic()
    .should().notCallMethod(System.class, "out")
    .because("Production code should use a logging framework");

import com.tngtech.archunit.library.metrics.ArchitectureMetrics;

JavaClasses classes = // ...
Set<JavaPackage> packages = classes.getPackage("com.example").getSubpackages();

MetricsComponents<JavaClass> components = MetricsComponents.fromPackages(packages);
LakosMetrics metrics = ArchitectureMetrics.lakosMetrics(components);

System.out.println("CCD: " + metrics.getCumulativeComponentDependency());
System.out.println("ACD: " + metrics.getAverageComponentDependency());

@AnalyzeClasses(
    packages = "com.example",
    importOptions = ImportOption.DoNotIncludeTests.class
)

# 忽略 LegacyService 的所有違規
.*some\.pkg\.LegacyService.*

noClasses().that().resideInAPackage("..service..")
    .should().dependOnClassesThat().resideInAPackage("..controller..")
    .because("Service layer should be independent of the web layer");

import static com.tngtech.archunit.library.GeneralCodingRules.NO_CLASSES_SHOULD_ACCESS_STANDARD_STREAMS;
import static com.tngtech.archunit.library.GeneralCodingRules.NO_CLASSES_SHOULD_THROW_GENERIC_EXCEPTIONS;

// 組合規則
static final ArchRule general_coding_rules = CompositeArchRule
    .of(NO_CLASSES_SHOULD_ACCESS_STANDARD_STREAMS)
    .and(NO_CLASSES_SHOULD_THROW_GENERIC_EXCEPTIONS);

ArchRule rule = ArchRuleDefinition.noClasses()
    .that().resideInAPackage("..service..")
    .should().dependOnClassesThat().resideInAPackage("..controller..");

# GitHub Actions 範例
- name: Run Architecture Tests
  run: mvn test -Dtest=ArchitectureTest