Repository Pattern | Business Logic | Iosdevelopment Tutorial

Introduction

The Repository Pattern is a design pattern that mediates data from and to the Domain and Data Mapping layers, such as databases, web services, etc. It provides a collection-like interface for accessing domain objects, separating the data access logic and business logic.

Why Use the Repository Pattern?

Using the Repository Pattern can help in:

Decoupling the data access logic from the business logic.
Providing a clear separation of concerns.
Making the code more maintainable and testable.
Facilitating unit testing by allowing the use of mock repositories.

Implementing the Repository Pattern in iOS

Let's walk through an example of implementing the Repository Pattern in an iOS application.

Step 1: Define the Repository Protocol

First, we'll define a protocol that outlines the methods our repository will implement.

protocol UserRepository {
    func fetchAllUsers() -> [User]
    func fetchUser(by id: Int) -> User?
    func addUser(_ user: User)
    func deleteUser(by id: Int)
}

Step 2: Create the Repository Implementation

Next, we'll create a class that implements the UserRepository protocol. This class will handle the data access logic.

class UserRepositoryImpl: UserRepository {
    private var users: [User] = []

    func fetchAllUsers() -> [User] {
        return users
    }

    func fetchUser(by id: Int) -> User? {
        return users.first { $0.id == id }
    }

    func addUser(_ user: User) {
        users.append(user)
    }

    func deleteUser(by id: Int) {
        users.removeAll { $0.id == id }
    }
}

Step 3: Use the Repository in the Business Logic

Now, we can use the UserRepository in our business logic layer. This ensures that our business logic is decoupled from the data access logic.

class UserService {
    private let userRepository: UserRepository

    init(userRepository: UserRepository) {
        self.userRepository = userRepository
    }

    func getAllUsers() -> [User] {
        return userRepository.fetchAllUsers()
    }

    func getUser(by id: Int) -> User? {
        return userRepository.fetchUser(by: id)
    }

    func createUser(_ user: User) {
        userRepository.addUser(user)
    }

    func removeUser(by id: Int) {
        userRepository.deleteUser(by: id)
    }
}

Step 4: Example Usage

Finally, let's see how we can use our UserService with a UserRepository implementation.

let userRepository = UserRepositoryImpl()
let userService = UserService(userRepository: userRepository)

// Adding users
userService.createUser(User(id: 1, name: "John Doe"))
userService.createUser(User(id: 2, name: "Jane Smith"))

// Fetching users
let users = userService.getAllUsers()
print(users)  // Output: [User(id: 1, name: "John Doe"), User(id: 2, name: "Jane Smith")]

// Fetching a user by ID
if let user = userService.getUser(by: 1) {
    print(user)  // Output: User(id: 1, name: "John Doe")
}

// Deleting a user
userService.removeUser(by: 1)

Conclusion

The Repository Pattern is a powerful way to separate data access logic from business logic in your iOS applications. By using this pattern, you can make your code more modular, maintainable, and testable.

Repository Pattern in iOS Development