Why Clean Architecture is Essential for Modern iOS Apps in Swift

 

Clean Architecture is more popular nowadays because modern applications demand scalability, testability, and maintainability. As mobile apps grow in complexity, Clean Architecture helps developers structure their code efficiently, reducing dependencies and making the codebase easier to manage. It allows teams to scale their applications while ensuring separation of concerns, making unit testing simpler and keeping business logic independent of UI and external frameworks.

Clean Architecture is a software design pattern that ensures the separation of concerns, making your iOS app more scalable, testable, and maintainable. It was introduced by Robert C. Martin (Uncle Bob) and consists of multiple layers that isolate dependencies between different parts of the system.

Why Use Clean Architecture?

1. Separation of Concerns — Divides the codebase into distinct layers.
2. Scalability — New features can be added without affecting existing code.
3. Testability — Business logic is independent, making it easier to write unit tests.
4. Maintainability — Code is structured and follows a clear pattern.
5. Flexibility — UI and data sources can change without affecting business logic.

Layers of Clean Architecture

Clean Architecture divides an app into three primary layers:

1. Presentation Layer (UI & ViewModels)

• Handles UI logic and user interaction.
• Uses MVVM (Model-View-ViewModel) or other UI patterns.
• Communicates with the Use Case (Interactor).

2. Domain Layer (Business Logic)

• Contains business rules and entities.
• Uses Use Cases (Interactors) to process data.
• Should be independent of UI, frameworks, and external dependencies.

3. Data Layer (Repositories & Data Sources)

• Handles data fetching and storage.
• Uses Repositories to abstract data sources.
• Works with APIs, databases, or local storage.

Project Structure

├── Presentation
│   ├── Views
│   ├── ViewModels
│   └── Coordinators
├── Domain
│   ├── Entities
│   ├── UseCases
│   └── Interfaces
├── Data
│   ├── Repositories
│   ├── DataSources
│   ├── API Clients
│   └── Persistence
└── Supporting Files

Code Examples with Explanation

1. Domain Layer (Business Logic)

Entity (Model)

This struct represents a User entity that contains basic user information.

struct User {
    let id: Int
    let name: String
    let email: String
}

Use Case (Interactor)

This use case handles fetching a user by ID and abstracts the data retrieval logic from the UI.

protocol FetchUserUseCase {
    func execute(userId: Int) async throws -> User
}

class FetchUserUseCaseImpl: FetchUserUseCase {
    private let repository: UserRepository
    
    init(repository: UserRepository) {
        self.repository = repository
    }
    
    func execute(userId: Int) async throws -> User {
        return try await repository.getUser(userId: userId)
    }
}

2. Data Layer (Repository & Data Sources)

Repository Protocol

Defines the contract for fetching user data.

protocol UserRepository {
    func getUser(userId: Int) async throws -> User
}

Repository Implementation

Implements the repository protocol by fetching data from a data source.

class UserRepositoryImpl: UserRepository {
    private let dataSource: UserDataSource
    
    init(dataSource: UserDataSource) {
        self.dataSource = dataSource
    }
    
    func getUser(userId: Int) async throws -> User {
        return try await dataSource.fetchUser(userId: userId)
    }
}

Remote Data Source (API Call)

Responsible for making network requests to fetch user data from an API.

protocol UserDataSource {
    func fetchUser(userId: Int) async throws -> User
}

class RemoteUserDataSource: UserDataSource {
    func fetchUser(userId: Int) async throws -> User {
        let url = URL(string: "https://api.example.com/users/\(userId)")!
        let (data, _) = try await URLSession.shared.data(from: url)
        let userDTO = try JSONDecoder().decode(UserDTO.self, from: data)
        return userDTO.toDomain()
    }
}

DTO (Data Transfer Object) for Decoding API Response

Converts raw JSON data into a User entity.

struct UserDTO: Codable {
    let id: Int
    let name: String
    let email: String
    
    func toDomain() -> User {
        return User(id: id, name: name, email: email)
    }
}

3. Presentation Layer (UI & ViewModel)

ViewModel

Manages the UI state and calls the FetchUserUseCase to fetch user data.

class UserViewModel: ObservableObject {
    private let fetchUserUseCase: FetchUserUseCase
    
    @Published var user: User?
    @Published var isLoading = false
    
    init(fetchUserUseCase: FetchUserUseCase) {
        self.fetchUserUseCase = fetchUserUseCase
    }
    
    func loadUser(userId: Int) async {
        isLoading = true
        do {
            let fetchedUser = try await fetchUserUseCase.execute(userId: userId)
            DispatchQueue.main.async {
                self.user = fetchedUser
                self.isLoading = false
            }
        } catch {
            print("Error fetching user: \(error)")
            isLoading = false
        }
    }
}

SwiftUI View

Displays user data and handles the UI.

struct UserView: View {
    @StateObject var viewModel: UserViewModel
    
    var body: some View {
        VStack {
            if viewModel.isLoading {
                ProgressView("Loading...")
            } else if let user = viewModel.user {
                Text("User: \(user.name)")
            } else {
                Text("No User Data")
            }
        }
        .onAppear {
            Task {
                await viewModel.loadUser(userId: 1)
            }
        }
    }
}

Conclusion

Clean Architecture provides a clear separation of concerns, making your iOS apps scalable and testable. By following this approach, you ensure that your business logic is independent of frameworks and UI, improving maintainability and flexibility.