クリーンアーキテクチャ：保守性とテスト容易性を高め、変化に強いシステムを構築

// ドメイン層（内側）に定義されたインターフェース
public interface UserRepository {
    User findById(String id);
    void save(User user);
}

// インフラ層（外側）での実装
public class MySQLUserRepository implements UserRepository {
    @Override
    public User findById(String id) {
        // MySQLからユーザーを検索する具体的な実装
    }
    
    @Override
    public void save(User user) {
        // MySQLにユーザーを保存する具体的な実装
    }
}

// ユースケース層（内側）でのリポジトリの利用
public class UserService {
    private final UserRepository userRepository;
    
    // 依存性の注入（内側の層は具体的な実装を知らない）
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    public User getUserById(String id) {
        return userRepository.findById(id);
    }
}

src/
├── domain/          # エンティティとドメインロジック
│   ├── entities/
│   └── values/
├── application/     # ユースケース層
│   ├── services/
│   └── ports/
├── adapters/        # インターフェースアダプター層
│   ├── controllers/
│   ├── presenters/
│   └── gateways/
└── infrastructure/  # フレームワーク＆ドライバー層
    ├── database/
    ├── api/
    └── ui/

src/
├── user/
│   ├── domain/
│   ├── application/
│   ├── adapters/
│   └── infrastructure/
├── order/
│   ├── domain/
│   ├── application/
│   ├── adapters/
│   └── infrastructure/
└── payment/
    ├── domain/
    ├── application/
    ├── adapters/
    └── infrastructure/

// エンティティ
public class User {
    private final UserId id;
    private String name;
    private Email email;
    private Address address;
    
    // コンストラクタ、ゲッター、セッター、ビジネスメソッド
    
    public void changeName(String newName) {
        if (newName == null || newName.trim().isEmpty()) {
            throw new IllegalArgumentException("名前は空にできません");
        }
        this.name = newName;
    }
}

// 値オブジェクト
public class Email {
    private final String value;
    
    public Email(String value) {
        if (!isValid(value)) {
            throw new IllegalArgumentException("無効なメールアドレスです");
        }
        this.value = value;
    }
    
    private boolean isValid(String email) {
        // メールアドレスの検証ロジック
        return email.matches("^[A-Za-z0-9+_.-]+@(.+)$");
    }
    
    public String getValue() {
        return value;
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Email email = (Email) o;
        return Objects.equals(value, email.value);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(value);
    }
}

// ドメインサービス
public class OrderDomainService {
    public boolean canUserPlaceOrder(User user, Order order) {
        // ユーザーの注文権限の確認
        // 在庫の確認
        // その他のドメインルールの適用
        return true; // 簡略化
    }
    
    public void applyDiscounts(Order order, List<DiscountPolicy> policies) {
        // 割引の適用ロジック
        for (DiscountPolicy policy : policies) {
            policy.apply(order);
        }
    }
}

// コマンド（書き込み操作）
public class RegisterUserCommand {
    private final String name;
    private final String email;
    // その他のフィールドとコンストラクタ
}

public class RegisterUserUseCase implements UseCase<RegisterUserCommand, UserId> {
    private final UserRepository userRepository;
    
    public RegisterUserUseCase(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    @Override
    public UserId execute(RegisterUserCommand command) {
        // バリデーション
        Email email = new Email(command.getEmail());
        
        // ビジネスロジック
        User newUser = new User(
            new UserId(),
            command.getName(),
            email
        );
        
        // 保存
        userRepository.save(newUser);
        
        return newUser.getId();
    }
}

// クエリ（読み取り操作）
public class GetUserQuery {
    private final String userId;
    
    public GetUserQuery(String userId) {
        this.userId = userId;
    }
    
    public String getUserId() {
        return userId;
    }
}

public class GetUserUseCase implements UseCase<GetUserQuery, UserResponse> {
    private final UserRepository userRepository;
    
    public GetUserUseCase(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    @Override
    public UserResponse execute(GetUserQuery query) {
        User user = userRepository.findById(new UserId(query.getUserId()));
        
        if (user == null) {
            throw new UserNotFoundException(query.getUserId());
        }
        
        return new UserResponse(
            user.getId().getValue(),
            user.getName(),
            user.getEmail().getValue()
        );
    }
}

// インプットポート（ユースケースのインターフェース）
public interface UserManagementUseCase {
    UserId registerUser(String name, String email);
    void updateUserProfile(String userId, String name, String email);
    void deactivateUser(String userId);
}

// アウトプットポート（ユースケースが外部リソースにアクセスするためのインターフェース）
public interface UserRepository {
    User findById(UserId id);
    void save(User user);
    void remove(UserId id);
}

// ユースケース実装
public class UserManagementService implements UserManagementUseCase {
    private final UserRepository userRepository;
    
    public UserManagementService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    @Override
    public UserId registerUser(String name, String email) {
        // 実装
    }
    
    @Override
    public void updateUserProfile(String userId, String name, String email) {
        // 実装
    }
    
    @Override
    public void deactivateUser(String userId) {
        // 実装
    }
}

// コントローラー（入力アダプター）
@RestController
@RequestMapping("/api/users")
public class UserController {
    private final RegisterUserUseCase registerUserUseCase;
    private final GetUserUseCase getUserUseCase;
    
    public UserController(RegisterUserUseCase registerUserUseCase, GetUserUseCase getUserUseCase) {
        this.registerUserUseCase = registerUserUseCase;
        this.getUserUseCase = getUserUseCase;
    }
    
    @PostMapping
    public ResponseEntity<UserCreatedResponse> registerUser(@RequestBody RegisterUserRequest request) {
        RegisterUserCommand command = new RegisterUserCommand(request.getName(), request.getEmail());
        UserId userId = registerUserUseCase.execute(command);
        
        UserCreatedResponse response = new UserCreatedResponse(userId.getValue());
        return ResponseEntity.status(HttpStatus.CREATED).body(response);
    }
    
    @GetMapping("/{userId}")
    public ResponseEntity<UserResponse> getUser(@PathVariable String userId) {
        GetUserQuery query = new GetUserQuery(userId);
        UserResponse response = getUserUseCase.execute(query);
        
        return ResponseEntity.ok(response);
    }
}

// プレゼンター（出力アダプター）
public class UserResponsePresenter implements UserOutputPort {
    @Override
    public UserResponse present(User user) {
        // ドメインモデルをレスポンスDTOに変換
        return new UserResponse(
            user.getId().getValue(),
            user.getName(),
            user.getEmail().getValue(),
            // 必要に応じて追加情報
            user.getRegistrationDate().format(DateTimeFormatter.ISO_DATE)
        );
    }
}

// リポジトリ実装（出力アダプター）
@Repository
public class JpaUserRepository implements UserRepository {
    private final UserJpaRepository jpaRepository;
    
    public JpaUserRepository(UserJpaRepository jpaRepository) {
        this.jpaRepository = jpaRepository;
    }
    
    @Override
    public User findById(UserId id) {
        return jpaRepository.findById(id.getValue())
            .map(this::mapToDomainEntity)
            .orElse(null);
    }
    
    @Override
    public void save(User user) {
        UserJpaEntity entity = mapToJpaEntity(user);
        jpaRepository.save(entity);
    }
    
    private User mapToDomainEntity(UserJpaEntity entity) {
        return new User(
            new UserId(entity.getId()),
            entity.getName(),
            new Email(entity.getEmail())
        );
    }
    
    private UserJpaEntity mapToJpaEntity(User user) {
        UserJpaEntity entity = new UserJpaEntity();
        entity.setId(user.getId().getValue());
        entity.setName(user.getName());
        entity.setEmail(user.getEmail().getValue());
        return entity;
    }
}

// JPA エンティティ（フレームワーク層の一部）
@Entity
@Table(name = "users")
public class UserJpaEntity {
    @Id
    private String id;
    
    private String name;
    
    private String email;
    
    // ゲッター・セッター
}

// Spring Data JPA リポジトリ（フレームワーク層の一部）
public interface UserJpaRepository extends JpaRepository<UserJpaEntity, String> {
    // 特別なクエリがあれば定義
}

// Spring Bootの場合のDI設定
@Configuration
public class UserConfiguration {
    
    @Bean
    public UserRepository userRepository(UserJpaRepository jpaRepository) {
        return new JpaUserRepository(jpaRepository);
    }
    
    @Bean
    public UserOutputPort userPresenter() {
        return new UserResponsePresenter();
    }
    
    @Bean
    public RegisterUserUseCase registerUserUseCase(UserRepository userRepository) {
        return new RegisterUserUseCase(userRepository);
    }
    
    @Bean
    public GetUserUseCase getUserUseCase(UserRepository userRepository, UserOutputPort userOutputPort) {
        return new GetUserUseCase(userRepository, userOutputPort);
    }
    
    @Bean
    public UserManagementUseCase userManagementUseCase(UserRepository userRepository) {
        return new UserManagementService(userRepository);
    }
}

// 外部決済サービスのアダプター
@Service
public class PaymentServiceAdapter implements PaymentGateway {
    private final PaymentApiClient apiClient;
    
    public PaymentServiceAdapter(PaymentApiClient apiClient) {
        this.apiClient = apiClient;
    }
    
    @Override
    public PaymentResult processPayment(Payment payment) {
        PaymentRequest request = mapToRequest(payment);
        PaymentResponse response = apiClient.sendPayment(request);
        return mapToResult(response);
    }
    
    private PaymentRequest mapToRequest(Payment payment) {
        // ドメインモデルを外部APIリクエストにマッピング
        return new PaymentRequest(
            payment.getOrderId().getValue(),
            payment.getAmount().getValue(),
            payment.getCurrency().getCode(),
            payment.getPaymentMethod().getType()
        );
    }
    
    private PaymentResult mapToResult(PaymentResponse response) {
        // 外部APIレスポンスをドメインモデルにマッピング
        return new PaymentResult(
            new PaymentId(response.getTransactionId()),
            PaymentStatus.fromString(response.getStatus()),
            response.getMessage()
        );
    }
}

// エンティティのテスト
public class UserTest {
    @Test
    public void shouldChangeNameWhenValidNameIsProvided() {
        // Arrange
        User user = new User(new UserId(), "古い名前", new Email("test@dx-media.example"));
        String newName = "新しい名前";
        
        // Act
        user.changeName(newName);
        
        // Assert
        assertEquals(newName, user.getName());
    }
    
    @Test
    public void shouldThrowExceptionWhenEmptyNameIsProvided() {
        // Arrange
        User user = new User(new UserId(), "古い名前", new Email("test@dx-media.example"));
        String emptyName = "";
        
        // Act & Assert
        assertThrows(IllegalArgumentException.class, () -> {
            user.changeName(emptyName);
        });
    }
}

// ドメインサービスのテスト
public class OrderDomainServiceTest {
    private OrderDomainService service;
    
    @BeforeEach
    public void setUp() {
        service = new OrderDomainService();
    }
    
    @Test
    public void shouldApplyDiscountsToOrder() {
        // Arrange
        Order order = new Order(/* パラメータ */);
        List<DiscountPolicy> policies = Arrays.asList(
            new PercentageDiscountPolicy(10),
            new FixedAmountDiscountPolicy(new Money(500))
        );
        
        // Act
        service.applyDiscounts(order, policies);
        
        // Assert
        // 割引が正しく適用されたことを検証
    }
}

public class RegisterUserUseCaseTest {
    private RegisterUserUseCase useCase;
    private UserRepository userRepository;
    
    @BeforeEach
    public void setUp() {
        // リポジトリのモック作成
        userRepository = mock(UserRepository.class);
        
        // テスト対象のユースケース作成
        useCase = new RegisterUserUseCase(userRepository);
    }
    
    @Test
    public void shouldRegisterUserSuccessfully() {
        // Arrange
        RegisterUserCommand command = new RegisterUserCommand("テストユーザー", "test@dx-media.example");
        
        // Act
        UserId result = useCase.execute(command);
        
        // Assert
        assertNotNull(result);
        verify(userRepository).save(any(User.class)); // リポジトリのsaveメソッドが呼ばれたか検証
    }
    
    @Test
    public void shouldThrowExceptionWhenEmailIsInvalid() {
        // Arrange
        RegisterUserCommand command = new RegisterUserCommand("テストユーザー", "invalid-email");
        
        // Act & Assert
        assertThrows(IllegalArgumentException.class, () -> {
            useCase.execute(command);
        });
        
        verify(userRepository, never()).save(any(User.class)); // saveメソッドが呼ばれていないことを検証
    }
}

public class UserControllerTest {
    private UserController controller;
    private RegisterUserUseCase registerUserUseCase;
    private GetUserUseCase getUserUseCase;
    
    @BeforeEach
    public void setUp() {
        registerUserUseCase = mock(RegisterUserUseCase.class);
        getUserUseCase = mock(GetUserUseCase.class);
        controller = new UserController(registerUserUseCase, getUserUseCase);
    }
    
    @Test
    public void shouldRegisterUserAndReturnCreatedStatus() {
        // Arrange
        RegisterUserRequest request = new RegisterUserRequest("テストユーザー", "test@dx-media.example");
        UserId userId = new UserId("test-id");
        
        when(registerUserUseCase.execute(any(RegisterUserCommand.class))).thenReturn(userId);
        
        // Act
        ResponseEntity<UserCreatedResponse> response = controller.registerUser(request);
        
        // Assert
        assertEquals(HttpStatus.CREATED, response.getStatusCode());
        assertEquals(userId.getValue(), response.getBody().getUserId());
    }
}

@SpringBootTest
public class UserIntegrationTest {
    @Autowired
    private UserController controller;
    
    @Autowired
    private UserRepository userRepository;
    
    @Test
    public void shouldCreateAndRetrieveUser() {
        // ユーザー登録リクエスト
        RegisterUserRequest request = new RegisterUserRequest("統合テストユーザー", "integration@dx-media.example");
        
        // 登録APIを呼び出し
        ResponseEntity<UserCreatedResponse> createResponse = controller.registerUser(request);
        assertEquals(HttpStatus.CREATED, createResponse.getStatusCode());
        
        String userId = createResponse.getBody().getUserId();
        
        // 取得APIを呼び出し
        ResponseEntity<UserResponse> getResponse = controller.getUser(userId);
        assertEquals(HttpStatus.OK, getResponse.getStatusCode());
        
        UserResponse user = getResponse.getBody();
        assertEquals(request.getName(), user.getName());
        assertEquals(request.getEmail(), user.getEmail());
    }
}