组件化架构详解

业务层 → 中间层 → 基础层

// MARK: - MGJRouter核心API

class MGJRouter {
    static let shared = MGJRouter()
    
    /// URL注册表：URL Pattern -> Handler
    private var routes: [String: ([String: Any]) -> Any?] = [:]
    
    /// 注册URL
    func registerURL(_ pattern: String, handler: @escaping ([String: Any]) -> Any?) {
        routes[pattern] = handler
    }
    
    /// 打开URL
    @discardableResult
    func openURL(_ url: String, params: [String: Any] = [:]) -> Any? {
        // 解析URL，匹配注册的pattern
        guard let (pattern, urlParams) = matchURL(url),
              let handler = routes[pattern] else {
            return nil
        }
        
        // 合并URL参数和额外参数
        var allParams = urlParams
        allParams.merge(params) { _, new in new }
        
        return handler(allParams)
    }
    
    private func matchURL(_ url: String) -> (String, [String: Any])? {
        // URL匹配逻辑...
        return nil
    }
}

// MARK: - 用户组件注册

class UserModule {
    static func registerRoutes() {
        // 注册用户详情页
        MGJRouter.shared.registerURL("user://profile") { params in
            guard let userId = params["id"] as? String else { return nil }
            let vc = UserProfileViewController(userId: userId)
            return vc
        }
        
        // 注册登录服务
        MGJRouter.shared.registerURL("user://login") { params in
            let completion = params["completion"] as? (Bool) -> Void
            LoginService.shared.login { success in
                completion?(success)
            }
            return nil
        }
    }
}

// MARK: - 首页组件调用

class HomeViewController: UIViewController {
    func showUserProfile(userId: String) {
        // 通过URL跳转，不需要import用户组件
        if let vc = MGJRouter.shared.openURL("user://profile?id=\(userId)") as? UIViewController {
            navigationController?.pushViewController(vc, animated: true)
        }
    }
    
    func checkLogin() {
        MGJRouter.shared.openURL("user://login", params: [
            "completion": { [weak self] success in
                if success {
                    self?.refreshData()
                }
            }
        ])
    }
}

// MARK: - CTMediator核心类

class CTMediator {
    static let shared = CTMediator()
    
    /// 核心方法：通过Runtime调用Target的Action
    func performTarget(_ targetName: String, 
                       action actionName: String, 
                       params: [String: Any]?, 
                       shouldCacheTarget: Bool = false) -> Any? {
        
        // 1. 拼接Target类名
        let targetClassString = "Target_\(targetName)"
        
        // 2. 获取Target类
        guard let targetClass = NSClassFromString(targetClassString) as? NSObject.Type else {
            // 降级处理
            return nil
        }
        
        let target = targetClass.init()
        
        // 3. 拼接Action方法名
        let actionString = "Action_\(actionName)WithParams:"
        let action = NSSelectorFromString(actionString)
        
        // 4. 检查方法是否存在
        guard target.responds(to: action) else {
            return nil
        }
        
        // 5. 执行方法
        return target.perform(action, with: params)?.takeUnretainedValue()
    }
}

// MARK: - 用户组件的Target（用户组件内部）

class Target_User: NSObject {
    
    /// 用户详情页
    /// - 方法名必须以 Action_ 开头，以 WithParams: 结尾
    @objc func Action_profileWithParams(_ params: [String: Any]) -> UIViewController {
        guard let userId = params["userId"] as? String else {
            return UIViewController()
        }
        return UserProfileViewController(userId: userId)
    }
    
    /// 获取用户信息
    @objc func Action_userInfoWithParams(_ params: [String: Any]) -> [String: Any]? {
        guard let userId = params["userId"] as? String else {
            return nil
        }
        return UserService.shared.getUserInfo(userId: userId)
    }
}

// MARK: - CTMediator的Category（调用方组件依赖）

extension CTMediator {
    /// 跳转用户详情页
    func userProfileViewController(userId: String) -> UIViewController? {
        performTarget("User", 
                      action: "profile", 
                      params: ["userId": userId]) as? UIViewController
    }
    
    /// 获取用户信息
    func userInfo(userId: String) -> [String: Any]? {
        performTarget("User", 
                      action: "userInfo", 
                      params: ["userId": userId]) as? [String: Any]
    }
}

// MARK: - 首页组件调用

class HomeViewController: UIViewController {
    func showUserProfile(userId: String) {
        // 通过Category调用，有类型提示
        if let vc = CTMediator.shared.userProfileViewController(userId: userId) {
            navigationController?.pushViewController(vc, animated: true)
        }
    }
}

// MARK: - 服务容器

class ServiceContainer {
    static let shared = ServiceContainer()
    
    /// Protocol -> Class 的映射表
    private var serviceMap: [String: AnyClass] = [:]
    /// 已创建的服务实例缓存（单例）
    private var serviceInstances: [String: Any] = [:]
    
    /// 注册服务
    func registerService<P>(_ protocol: P.Type, implClass: AnyClass) {
        let key = String(describing: `protocol`)
        serviceMap[key] = implClass
    }
    
    /// 获取服务（单例模式）
    func getService<P>(_ protocol: P.Type) -> P? {
        let key = String(describing: `protocol`)
        
        // 先从缓存获取
        if let instance = serviceInstances[key] as? P {
            return instance
        }
        
        // 创建新实例
        guard let implClass = serviceMap[key] as? NSObject.Type else {
            return nil
        }
        
        let instance = implClass.init()
        serviceInstances[key] = instance
        return instance as? P
    }
}

// MARK: - 用户组件对外协议（独立的协议库）

/// 用户服务协议 - 放在独立的Protocol组件中
protocol UserServiceProtocol {
    func getUserProfile(userId: String) -> UserProfile?
    func isLoggedIn() -> Bool
    func login(completion: @escaping (Bool) -> Void)
}

/// 用户页面协议
protocol UserRouterProtocol {
    func profileViewController(userId: String) -> UIViewController
    func settingsViewController() -> UIViewController
}

// MARK: - 用户组件实现（用户组件内部）

class UserServiceImpl: NSObject, UserServiceProtocol {
    func getUserProfile(userId: String) -> UserProfile? {
        // 实现获取用户信息
        return UserRepository.shared.getProfile(userId: userId)
    }
    
    func isLoggedIn() -> Bool {
        return UserSession.shared.isLoggedIn
    }
    
    func login(completion: @escaping (Bool) -> Void) {
        LoginManager.shared.showLogin { success in
            completion(success)
        }
    }
}

class UserRouterImpl: NSObject, UserRouterProtocol {
    func profileViewController(userId: String) -> UIViewController {
        return UserProfileViewController(userId: userId)
    }
    
    func settingsViewController() -> UIViewController {
        return UserSettingsViewController()
    }
}

// 用户组件入口 - 注册服务
class UserModule {
    static func registerServices() {
        ServiceContainer.shared.registerService(UserServiceProtocol.self, implClass: UserServiceImpl.self)
        ServiceContainer.shared.registerService(UserRouterProtocol.self, implClass: UserRouterImpl.self)
    }
}

// MARK: - 首页组件调用

class HomeViewController: UIViewController {
    // 通过协议获取服务
    var userService: UserServiceProtocol? {
        ServiceContainer.shared.getService(UserServiceProtocol.self)
    }
    
    var userRouter: UserRouterProtocol? {
        ServiceContainer.shared.getService(UserRouterProtocol.self)
    }
    
    func showUserProfile(userId: String) {
        // 类型安全的调用
        if let vc = userRouter?.profileViewController(userId: userId) {
            navigationController?.pushViewController(vc, animated: true)
        }
    }
    
    func checkLoginAndDoSomething() {
        guard let userService = userService else { return }
        
        if userService.isLoggedIn() {
            doSomething()
        } else {
            userService.login { [weak self] success in
                if success {
                    self?.doSomething()
                }
            }
        }
    }
}

// MARK: - 定义协议

protocol NetworkServiceProtocol {
    func request<T: Decodable>(url: String) async throws -> T
}

protocol UserRepositoryProtocol {
    func getUser(id: String) async throws -> User
}

protocol UserServiceProtocol {
    func getUserProfile(id: String) async throws -> UserProfile
}

// MARK: - 实现类（声明依赖，但不自己创建）

class NetworkServiceImpl: NetworkServiceProtocol {
    func request<T: Decodable>(url: String) async throws -> T {
        // 网络请求实现
    }
}

class UserRepositoryImpl: UserRepositoryProtocol {
    // 依赖由外部注入
    let networkService: NetworkServiceProtocol
    
    init(networkService: NetworkServiceProtocol) {
        self.networkService = networkService
    }
    
    func getUser(id: String) async throws -> User {
        try await networkService.request(url: "/users/\(id)")
    }
}

class UserServiceImpl: UserServiceProtocol {
    // 依赖由外部注入
    let repository: UserRepositoryProtocol
    
    init(repository: UserRepositoryProtocol) {
        self.repository = repository
    }
    
    func getUserProfile(id: String) async throws -> UserProfile {
        let user = try await repository.getUser(id: id)
        return UserProfile(user: user)
    }
}

// MARK: - Swinject配置

import Swinject

class AppContainer {
    static let shared = AppContainer()
    let container = Container()
    
    func registerAll() {
        // 注册NetworkService（单例）
        container.register(NetworkServiceProtocol.self) { _ in
            NetworkServiceImpl()
        }.inObjectScope(.container)  // 单例
        
        // 注册UserRepository（自动注入NetworkService）
        container.register(UserRepositoryProtocol.self) { resolver in
            let networkService = resolver.resolve(NetworkServiceProtocol.self)!
            return UserRepositoryImpl(networkService: networkService)
        }
        
        // 注册UserService（自动注入UserRepository）
        container.register(UserServiceProtocol.self) { resolver in
            let repository = resolver.resolve(UserRepositoryProtocol.self)!
            return UserServiceImpl(repository: repository)
        }
    }
    
    func resolve<T>(_ type: T.Type) -> T? {
        container.resolve(type)
    }
}

// MARK: - 使用

class UserViewController: UIViewController {
    // 依赖注入
    var userService: UserServiceProtocol?
    
    func loadUser(id: String) async {
        guard let userService = userService else { return }
        
        do {
            let profile = try await userService.getUserProfile(id: id)
            updateUI(with: profile)
        } catch {
            showError(error)
        }
    }
}

// 创建ViewController时注入依赖
let vc = UserViewController()
vc.userService = AppContainer.shared.resolve(UserServiceProtocol.self)

monorepo/
├── apps/
│   └── MainApp/
├── modules/
│   ├── user/
│   ├── shop/
│   └── message/
├── foundation/
│   ├── network/
│   └── utils/
└── Podfile

# Podfile

# 业务组件
pod 'UserModule', :path => './modules/user'
pod 'ShopModule', :path => './modules/shop'
pod 'MessageModule', :path => './modules/message'

# 中间层
pod 'Router', :path => './foundation/router'
pod 'ServiceContainer', :path => './foundation/service'

# 基础组件
pod 'NetworkKit', :path => './foundation/network'
pod 'UIKit+Extensions', :path => './foundation/ui'

# modules/user/UserModule.podspec

Pod::Spec.new do |s|
  s.name         = 'UserModule'
  s.version      = '1.0.0'
  s.summary      = '用户模块'
  s.homepage     = 'https://github.com/xxx/UserModule'
  s.source       = { :git => 'xxx', :tag => s.version }
  s.source_files = 'Sources/**/*.swift'
  
  # 只依赖中间层和基础层，不依赖其他业务组件
  s.dependency 'Router'
  s.dependency 'ServiceContainer'
  s.dependency 'NetworkKit'
end

# 通过环境变量控制源码/二进制切换
if ENV['USE_BINARY'] == '1'
  pod 'UserModule', :http => 'https://cdn.xxx.com/UserModule-1.0.0.zip'
else
  pod 'UserModule', :path => './modules/user'
end

UserModule/
├── Sources/           # 组件源码
├── Resources/         # 组件资源
├── Tests/             # 单元测试
└── Example/           # 独立运行的Demo工程
    ├── ExampleApp/
    └── Podfile

# UserModule/Example/Podfile

target 'UserModuleExample' do
  pod 'UserModule', :path => '../'
  
  # Mock其他组件的服务
  pod 'MockServices', :path => './MockServices'
end