Question

我正在建立一个由客户实施的图书馆项目。

在共享一些代码之前，我将尝试共享我的需求：

该库由基本实体和基本逻辑类组成，并且应提供应扩展的基本实现。某些逻辑类应该与其他类一起注入（如您将在代码后面看到的那样）。

客户端应该能够通过扩展实体并添加唯一变量以及为客户端添加其他唯一逻辑来与库集成。

我在库中尝试的方法是将逻辑类声明为泛型。

在客户端中，我为库中的每个对应类创建一个包装器类。应该为包装器提供注入，其中派生实体是通用的，因此我既可以使用派生实体，又可以添加独特的逻辑。

库代码：

class BaseUser {

    var firstName = "firstName"
}

class BaseCredentials {

    var token = "token"
}

class CredentialsManager<T: BaseCredentials> {

    var credentials: BaseCredentials!

    // Injection

    init(credentials: T) {

        self.credentials = credentials
    }

    func getCurrentCredentialsToken() -> String {

        return self.credentials.token
    }
}

class UserManager<T: BaseUser> {

    var credentialsManager: CredentialsManager<BaseCredentials>
    var users = [BaseUser]()

    // Injection

    init (credentialsManager: CredentialsManager<BaseCredentials>) {

        self.credentialsManager = credentialsManager
    }

    func addUser(user: T) -> Bool {

        // Some base logic

        if (credentialsManager.credentials.token == "some token") {

            self.users.append(user)
            return true
        }

        return false
    }
}

客户端代码：

class DerrivedUser: BaseUser {

    var lastName = "lastName"
}

class DerrivedCredentials: BaseCredentials {

    var credentialsType = 1
}

class ClientUserManagerWrapper {

    let userManager: UserManager<DerrivedUser>

    // Injection

    init (userManager: UserManager<DerrivedUser>) {

        self.userManager = userManager
    }

    func addNewUser() {

        let user = DerrivedUser()

        // Call to base logic

        if (self.userManager.addUser(user: user)) {

            // Perform unique client logic

            user.lastName = "just added"
        }
    }
}

class DependencyInjection {

  func provideUserManagerWrapper() -> ClientUserManagerWrapper {

        let credentials = BaseCredentials()
        let credentialsManager = CredentialsManager(credentials: credentials)
        let userManager: UserManager<DerrivedUser> = UserManager(credentialsManager: credentialsManager)
        return ClientUserManagerWrapper(userManager: userManager)
    }
 }

我不确定这是做我实际上想做的事情的正确方法

有人可以阐明这件事吗？

谢谢

通过泛型在库代码和客户端代码中提供依赖注入-这是正确的方法吗？

0 个答案: