network-api

网络 / API 层

网络层架构

• 基础层：URLSession（禁止引入 Alamofire，除非已存在）
• 封装层：NetworkService.swift 统一处理请求、错误、重试
• 接口定义：每个模块有对应 XxxAPI.swift，定义 endpoint + 参数

NetworkService 完整封装

protocol NetworkServiceProtocol {
    func request<T: Decodable>(_ endpoint: APIEndpoint) async throws -> T
    func upload<T: Decodable>(_ endpoint: APIEndpoint, data: Data) async throws -> T
}

final class NetworkService: NetworkServiceProtocol {
    private let session: URLSession
    private let keychain: KeychainStorage
    private let config: APIConfig

    init(session: URLSession = .shared, keychain: KeychainStorage = .shared, config: APIConfig = .current) {
        self.session = session
        self.keychain = keychain
        self.config = config
    }

    func request<T: Decodable>(_ endpoint: APIEndpoint) async throws -> T {
        let urlRequest = try buildRequest(for: endpoint)
        let response: T = try await executeWithRetry(urlRequest, maxRetries: endpoint.retryCount)
        return response
    }

    func upload<T: Decodable>(_ endpoint: APIEndpoint, data: Data) async throws -> T {
        var urlRequest = try buildRequest(for: endpoint)
        urlRequest.httpBody = data
        urlRequest.setValue("application/octet-stream", forHTTPHeaderField: "Content-Type")
        return try await execute(urlRequest)
    }

    private func buildRequest(for endpoint: APIEndpoint) throws -> URLRequest {
        var components = URLComponents(string: config.baseURL + endpoint.path)
        if let parameters = endpoint.queryParameters {
            components?.queryItems = parameters.map { URLQueryItem(name: $0.key, value: "\($0.value)") }
        }
        guard let url = components?.url else { throw NetworkError.invalidURL }

        var request = URLRequest(url: url)
        request.httpMethod = endpoint.method.rawValue
        request.timeoutInterval = endpoint.timeout

        if endpoint.requiresAuth {
            guard let token = keychain.loadToken() else { throw NetworkError.unauthorized }
            request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
        }

        if let body = endpoint.body {
            request.httpBody = try JSONSerialization.data(withJSONObject: body)
            request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        }

        request.setValue("application/json", forHTTPHeaderField: "Accept")
        request.setValue(Bundle.main.appVersion, forHTTPHeaderField: "X-App-Version")
        request.setValue(UIDevice.current.systemVersion, forHTTPHeaderField: "X-iOS-Version")

        return request
    }

    private func execute<T: Decodable>(_ request: URLRequest) async throws -> T {
        #if DEBUG
        logRequest(request)
        #endif

        let (data, urlResponse) = try await session.data(for: request)

        #if DEBUG
        logResponse(data, response: urlResponse)
        #endif

        guard let httpResponse = urlResponse as? HTTPURLResponse else {
            throw NetworkError.invalidResponse
        }

        switch httpResponse.statusCode {
        case 200...299:
            do {
                let decoder = JSONDecoder()
                decoder.keyDecodingStrategy = .convertFromSnakeCase
                decoder.dateDecodingStrategy = .iso8601
                return try decoder.decode(T.self, from: data)
            } catch {
                throw NetworkError.decodingFailed
            }
        case 401:
            throw NetworkError.unauthorized
        case 400...499:
            if let errorBody = try? JSONDecoder().decode(ErrorResponse.self, from: data) {
                throw NetworkError.clientError(httpResponse.statusCode, errorBody.message)
            }
            throw NetworkError.clientError(httpResponse.statusCode, "客户端错误")
        case 500...599:
            throw NetworkError.serverError(httpResponse.statusCode)
        default:
            throw NetworkError.unknown
        }
    }
}