billing
├── api
└── internal
    ├── batchjob
    |   └── internal
    └── database
        ├── api
        └── internal

database
├── api
|   ├── + LineItem
|   ├── + ReadLineItems
|   └── + WriteLineItems
└── internal
    └── o BillingDatabase

@Component
class BillingDatabase implements WriteLineItems, ReadLineItems {
  ...
}

@Component
@RequiredArgsConstructor
class LoadInvoiceDataBatchJob {
  private final WriteLineItems writeLineItems;
  @Scheduled(fixedRate = 5000)
  void loadDataFromBillingSystem() {
    ...
    writeLineItems.saveLineItems(items);
  }
}

billing
├── api
|   ├── + Invoice
|   └── + InvoiceCalculator
└── internal
    ├── batchjob
    ├── database
    └── o BillingService

@Component
@RequiredArgsConstructor
class BillingService implements InvoiceCalculator {
  private final ReadLineItems readLineItems;
  @Override
  public Invoice calculateInvoice(
        Long userId,
        LocalDate fromDate,
        LocalDate toDate) {
    List<LineItem> items = readLineItems.getLineItemsForUser(
      userId,
      fromDate,
      toDate);
    ...
  }
}

billing
└── internal
    ├── batchjob
    |   └── internal
    |       └── o BillingBatchJobConfiguration
    ├── database
    |   └── internal
    |       └── o BillingDatabaseConfiguration
    └── o BillingConfiguration

@Configuration
@EnableJpaRepositories
@ComponentScan
class BillingDatabaseConfiguration {
}

@Configuration
@EnableScheduling
@ComponentScan
class BillingBatchJobConfiguration {
}

@Configuration
@ComponentScan
class BillingConfiguration {
}

@Target(ElementType.PACKAGE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface InternalPackage {
}

@InternalPackage
package io.reflectoring.boundaries.billing.internal.database.internal;
import io.reflectoring.boundaries.InternalPackage;

class InternalPackageTests {
  private static final String BASE_PACKAGE = "io.reflectoring";
  private final JavaClasses analyzedClasses =
      new ClassFileImporter().importPackages(BASE_PACKAGE);
  @Test
  void internalPackagesAreNotAccessedFromOutside() throws IOException {
    List<String> internalPackages = internalPackages(BASE_PACKAGE);
    for (String internalPackage : internalPackages) {
      assertPackageIsNotAccessedFromOutside(internalPackage);
    }
  }
  private List<String> internalPackages(String basePackage) {
    Reflections reflections = new Reflections(basePackage);
    return reflections.getTypesAnnotatedWith(InternalPackage.class).stream()
        .map(c -> c.getPackage().getName())
        .collect(Collectors.toList());
  }
  void assertPackageIsNotAccessedFromOutside(String internalPackage) {
    noClasses()
        .that()
        .resideOutsideOfPackage(packageMatcher(internalPackage))
        .should()
        .dependOnClassesThat()
        .resideInAPackage(packageMatcher(internalPackage))
        .check(analyzedClasses);
  }
  private String packageMatcher(String fullyQualifiedPackage) {
    return fullyQualifiedPackage + "..";
  }
}

class InternalPackageTests {
  private static final String BASE_PACKAGE = "io.reflectoring";
  @Test
  void internalPackagesAreNotAccessedFromOutside() throws IOException {
    // make it refactoring-safe in case we're renaming the base package
    assertPackageExists(BASE_PACKAGE);
    List<String> internalPackages = internalPackages(BASE_PACKAGE);
    for (String internalPackage : internalPackages) {
      // make it refactoring-safe in case we're renaming the internal package
      assertPackageIsNotAccessedFromOutside(internalPackage);
    }
  }
  void assertPackageExists(String packageName) {
    assertThat(analyzedClasses.containPackage(packageName))
        .as("package %s exists", packageName)
        .isTrue();
  }
  private List<String> internalPackages(String basePackage) {
    ...
  }
  void assertPackageIsNotAccessedFromOutside(String internalPackage) {
    ...
  }
}