Proxy Design Pattern in Swift

The Proxy Design Pattern is a structural design pattern that provides a surrogate or placeholder for another object to control access to it. This pattern is particularly useful for implementing lazy initialization, access control, logging, and more. Let's dive into what the Proxy Design Pattern is, why it's beneficial, and how to implement it in Swift with a practical example.

What is the Proxy Design Pattern?

The Proxy Design Pattern involves creating a proxy object that represents another object. The proxy controls access to the original object, providing an interface identical to the original object. This allows the proxy to perform additional operations, such as lazy initialization, access control, and logging, before delegating requests to the actual object.

Why Use the Proxy Design Pattern?

• Lazy Initialization: Delays the creation and initialization of an expensive object until it is actually needed.
• Access Control: Manages access to sensitive objects by controlling who can access them.
• Logging/Monitoring: Keeps track of the requests made to the original object for debugging or logging purposes.
• Remote Proxy: Represents an object located in a different address space, such as in a different server or network.

How to Implement the Proxy Design Pattern in Swift

Let's consider a practical example where we implement a proxy for a Database class. The proxy will handle logging and access control.

Example: Proxy for a Database Class

import Foundation

// Protocol defining the common interface
protocol Database {
    func query(_ sql: String) -> String
}

// RealSubject: The actual Database implementation
class RealDatabase: Database {
    func query(_ sql: String) -> String {
        return "Executing query: \(sql)"
    }
}

// Proxy: The Proxy implementation that controls access to RealDatabase
class DatabaseProxy: Database {
    private var realDatabase: RealDatabase?
    private var userRole: String

    init(userRole: String) {
        self.userRole = userRole
    }

    func query(_ sql: String) -> String {
        guard userRole == "admin" else {
            return "Access Denied: Insufficient permissions"
        }

        if realDatabase == nil {
            realDatabase = RealDatabase() // Lazy initialization
        }

        print("Logging: \(sql)")
        return realDatabase!.query(sql)
    }
}

// Client code
let adminProxy = DatabaseProxy(userRole: "admin")
print(adminProxy.query("SELECT * FROM users")) // Logs and executes the query

let guestProxy = DatabaseProxy(userRole: "guest")
print(guestProxy.query("SELECT * FROM users")) // Access denied        

Breaking it Down:

• Protocol: Database defines the common interface for both the RealDatabase and DatabaseProxy.
• RealSubject: RealDatabase implements the actual database operations.
• Proxy: DatabaseProxy controls access to the RealDatabase. It checks the user's role before allowing query execution and logs the query.
• Client: Uses the DatabaseProxy to interact with the database, benefiting from added logging and access control.

Conclusion

The Proxy Design Pattern is a powerful tool for managing access to objects, implementing lazy initialization, logging, and more. By using a proxy, you can add additional behavior to existing classes without modifying their code. This pattern is particularly useful in scenarios where access control, lazy loading, or logging is needed.