如何实现全局可用的JSON解析函数？iOS应用架构模式咨询

嘿，这个需求其实在iOS开发里特别常见——想让通用的网络请求方法能在全应用的视图控制器里方便调用，同时还得兼顾代码的可维护性。我给你几个靠谱的方案，你可以根据项目的规模和未来的扩展需求来选：

这是很多项目初期都会用的方式，简单粗暴，马上就能上手。核心思路是把fetchJsonFor封装到一个单例类里，让整个应用都能通过类名直接访问。

代码实现： #

class NetworkManager {
    // 全局唯一实例
    static let shared = NetworkManager()
    
    // 私有初始化，防止外部随便创建实例
    private init() {}
    
    // 注意：把原同步方法改成异步的，避免阻塞主线程！
    func fetchJsonFor(path: String, language: String) async throws -> Any {
        var components = URLComponents()
        components.scheme = Constants.APIScheme
        components.host = Constants.APIHost
        components.path = Constants.APIPath + path
        
        // 把language参数加到请求的query里（根据你的API需求调整）
        components.queryItems = [URLQueryItem(name: "lang", value: language)]
        
        // 校验URL合法性
        guard let url = components.url else {
            throw NetworkError.invalidURL
        }
        
        // 发起异步网络请求
        let (data, response) = try await URLSession.shared.data(from: url)
        
        // 校验响应状态码
        guard let httpResponse = response as? HTTPURLResponse, 
              (200...299).contains(httpResponse.statusCode) else {
            throw NetworkError.invalidResponse
        }
        
        // 解析JSON
        let json = try JSONSerialization.jsonObject(with: data)
        return json
    }
    
    // 自定义错误类型，方便统一处理网络错误
    enum NetworkError: Error, LocalizedError {
        case invalidURL
        case invalidResponse
        case parsingFailed
        
        var errorDescription: String? {
            switch self {
            case .invalidURL: return "无效的请求URL"
            case .invalidResponse: return "服务器响应异常"
            case .parsingFailed: return "JSON解析失败"
            }
        }
    }
}

怎么用？ #

在任何视图控制器里直接调用就行：

class UserListVC: UIViewController {
    func loadUsers() {
        Task {
            do {
                let userJson = try await NetworkManager.shared.fetchJsonFor(
                    path: "/users", 
                    language: "en"
                )
                // 拿到JSON后处理数据
            } catch {
                // 处理错误，比如弹提示
                print("请求失败：\(error.localizedDescription)")
            }
        }
    }
}

优缺点： #

✅ 优点：零学习成本，代码少，快速落地
❌ 缺点：耦合度高，单元测试难（没法替换成模拟请求），后期扩展复杂时容易变成“上帝类”

如果你的项目规模比较大，或者想让代码更易测试、易维护，那依赖注入是更好的选择。核心是把网络请求的能力抽象成协议，然后在需要的视图控制器里注入这个协议的实现，而不是直接依赖单例。

代码实现： #

// 第一步：定义网络服务协议，抽象请求能力
protocol NetworkService {
    func fetchJsonFor(path: String, language: String) async throws -> Any
}

// 第二步：实现协议的默认网络服务类
class DefaultNetworkService: NetworkService {
    func fetchJsonFor(path: String, language: String) async throws -> Any {
        // 这里的实现和单例里的完全一样，省略重复代码
        var components = URLComponents()
        components.scheme = Constants.APIScheme
        components.host = Constants.APIHost
        components.path = Constants.APIPath + path
        components.queryItems = [URLQueryItem(name: "lang", value: language)]
        
        guard let url = components.url else {
            throw NetworkError.invalidURL
        }
        
        let (data, response) = try await URLSession.shared.data(from: url)
        
        guard let httpResponse = response as? HTTPURLResponse, 
              (200...299).contains(httpResponse.statusCode) else {
            throw NetworkError.invalidResponse
        }
        
        let json = try JSONSerialization.jsonObject(with: data)
        return json
    }
    
    enum NetworkError: Error, LocalizedError {
        case invalidURL, invalidResponse, parsingFailed
        
        var errorDescription: String? {
            // 同单例里的错误描述
            switch self {
            case .invalidURL: return "无效的请求URL"
            case .invalidResponse: return "服务器响应异常"
            case .parsingFailed: return "JSON解析失败"
            }
        }
    }
}

// 第三步：在视图控制器里注入服务实例
class UserDetailVC: UIViewController {
    private let networkService: NetworkService
    
    // 通过初始化方法注入，默认用DefaultNetworkService
    init(networkService: NetworkService = DefaultNetworkService()) {
        self.networkService = networkService
        super.init(nibName: nil, bundle: nil)
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    func loadUserDetail(userId: String) {
        Task {
            do {
                let userDetail = try await networkService.fetchJsonFor(
                    path: "/users/\(userId)", 
                    language: "ar"
                )
                // 处理数据
            } catch {
                print(error.localizedDescription)
            }
        }
    }
}

为什么好？ #

• 解耦：视图控制器只依赖NetworkService协议，不关心具体是哪个类实现的，后续换网络框架（比如从URLSession换成Alamofire）只需要改DefaultNetworkService就行，不用动所有VC的代码。
• 易测试：写单元测试时，可以创建一个MockNetworkService实现NetworkService协议，返回模拟的JSON数据，不用真的发网络请求。

优缺点： #

✅ 优点：解耦性强，可测试性高，适合长期维护
❌ 缺点：初期需要写额外的协议和注入代码，对新手稍微有点门槛

如果你的项目是用SwiftUI写的，那用EnvironmentObject简直是量身定做——把网络管理器放到应用的环境里，所有视图都能直接访问，不用手动传递实例。

代码实现： #

import SwiftUI

class NetworkManager: ObservableObject {
    func fetchJsonFor(path: String, language: String) async throws -> Any {
        // 实现同上，省略重复代码
        var components = URLComponents()
        components.scheme = Constants.APIScheme
        components.host = Constants.APIHost
        components.path = Constants.APIPath + path
        components.queryItems = [URLQueryItem(name: "lang", value: language)]
        
        guard let url = components.url else {
            throw NetworkError.invalidURL
        }
        
        let (data, response) = try await URLSession.shared.data(from: url)
        
        guard let httpResponse = response as? HTTPURLResponse, 
              (200...299).contains(httpResponse.statusCode) else {
            throw NetworkError.invalidResponse
        }
        
        let json = try JSONSerialization.jsonObject(with: data)
        return json
    }
    
    enum NetworkError: Error, LocalizedError {
        case invalidURL, invalidResponse, parsingFailed
        
        var errorDescription: String? {
            switch self {
            case .invalidURL: return "无效的请求URL"
            case .invalidResponse: return "服务器响应异常"
            case .parsingFailed: return "JSON解析失败"
            }
        }
    }
}

// 在App入口注入环境对象
@main
struct MyApp: App {
    let networkManager = NetworkManager()
    
    var body: some Scene {
        WindowGroup {
            HomeView()
                .environmentObject(networkManager)
        }
    }
}

// 在SwiftUI视图里使用
struct HomeView: View {
    @EnvironmentObject private var networkManager: NetworkManager
    
    var body: some View {
        Button("加载数据") {
            Task {
                do {
                    let data = try await networkManager.fetchJsonFor(
                        path: "/home", 
                        language: "fr"
                    )
                    // 处理数据
                } catch {
                    print(error.localizedDescription)
                }
            }
        }
    }
}

适用场景： #

纯SwiftUI项目，或者SwiftUI和UIKit混合的项目（UIKit里也可以通过UIHostingController拿到环境对象）。

最后给你提几个优化原代码的小细节：

1. 别用同步方法：原代码里同步返回AnyObject会阻塞主线程，导致界面卡顿，一定要改成async/await或者闭包/Combine的异步方式。
2. 类型安全解析：尽量别返回Any，可以用Codable定义模型，把方法改成泛型：

   func fetch<T: Codable>(path: String, language: String) async throws -> T {
       // 网络请求逻辑...
       let model = try JSONDecoder().decode(T.self, from: data)
       return model
   }
   

   这样调用的时候直接拿到模型，不用手动转类型，更安全。
3. 统一API配置：把Constants.APIScheme、APIHost这些放到一个单独的APIConfig结构体里，比如：

   struct APIConfig {
       static let baseURL = "https://api.yourdomain.com"
       static let defaultLanguage = "en"
   }
   

   后续修改API地址只需要改这一个地方，更方便。

内容的提问来源于stack exchange，提问作者Badr Bujbara