Moya 网络框架

Moya 网络框架

通过 Moya 进行网络请求的一般步骤如下：
1. 定义 TargetType：为每个 API 请求创建一个枚举，遵循 TargetType 协议，指定基础 URL、请求路径、方法、参数等。
2. 创建 MoyaProvider：实例化 MoyaProvider，并传入对应的 TargetType 枚举。
3. 发送请求：使用 MoyaProvider 发起请求并处理响应。
4. 解析数据：对响应数据进行解析（通常是 JSON 格式）。
5. 使用 RxSwift（可选）：如果你需要响应式编程，可以将请求转换为 Observable，并使用 RxSwift 提供的操作符来处理异步数据流。
6. 处理错误：通过检查 MoyaError 来处理网络请求中的各种错误。

定义enum类型，有多种接口就定义多少种，然后实现TargetType协议

import Foundation
//导入网络框架
import Moyaenum DefaultService {//广告列表case ads(position : Int)case sheets(size:Int)case sheetDetail(data: String)case register(data : User)
}// MARK: - 实现TargetType协议
extension DefaultService:TargetType {//返回API地址var baseURL: URL {return URL(string: Config.ENDPOINT)!}//返回每个请求的路径var path: String {switch self {case.ads(_):return "v1/ads"case .sheets :return "v1/sheets"case .sheetDetail(let data):return "v1/sheets/\(data)"case .register(_) :return "v1/users"default:fatalError("error")}}//请求方式var method: Moya.Method {switch self {case .register :return .postdefault:return .get}}var task: Moya.Task {switch self {case .ads(let position):return ParamUtil.urlRequestParamters(["position":position])case .sheets(let size):return ParamUtil.urlRequestParamters(["size":size])default ://不传递任何参数return .requestPlain}}var headers: [String : String]? {var headers: Dictionary<String,String> = [:]return headers}}

使用方法

        let provider = MoyaProvider<DefaultService>()provider.request(.sheets(size: 10)) { result inprint(result)switch result {case let .success(response) :let data = response.datalet statusCode = response.statusCodelet datastring = String(data: data,encoding: .utf8)!print(statusCode)print(datastring)case let .failure(error) :print(error)}}

可以看到，最后返回的形式为字符串，不方便使用，所以需要进一步进行封装，将其转换为对象

使用RxSwift框架请求网络

//rxSwift 方式
provider.rx.request(.sheets(size: 10)).debug("Request").subscribe { event inswitch event {case let .success(response) :print("hello ")let data = response.datalet statusCode = response.statusCodelet datastring = String(data: data,encoding: .utf8)!print(statusCode)print(datastring)if let r = SheetListResponse.deserialize(from: datastring){print(r.status)print(r.data.data[0].title!)}case let .failure(error) :print(error)}}.disposed(by: rx.disposeBag) //释放相关资源，防止内存泄露

使用框架解析JSON数据

使用第三方库HandyJSON

根据给出的JSON格式，建立相关的类即可

然后把字符串转换成相对应的格式即可

if let r = SheetListResponse.deserialize(from: datastring)

封装自动解析JSON功能

对Observable进行拓展

// MARK: - 扩展Observable
extension Observable{/// 将字符串解析为对象////// - Parameter type: 要转为的类/// - Returns: 转换后的观察者对象public func mapObject<T:HandyJSON>(_ type:T.Type) -> Observable<T> {map { data in//将参数尝试转为字符串guard let dataString = data as? String else {//data不能转为字符串throw IxueaError.objectMapping}guard let result = type.deserialize(from: dataString) else{throw IxueaError.objectMapping}//解析成功//返回解析后的对象return result}}
}

在 Swift 中，map 是一种高阶函数，通常用于对集合（如数组、字典、可选值等）中的元素进行转换或映射。在你的代码中，map 用于将某个数据转换为期望的类型。

map 的基本作用：

map 会对序列中的每个元素执行一个闭包，然后返回一个新序列，其中每个元素都经过闭包的处理。

let numbers = [1, 2, 3]
let doubledNumbers = numbers.map { $0 * 2 }
// doubledNumbers == [2, 4, 6]

在这个例子中，map 会遍历 numbers 数组中的每个元素，并将每个元素乘以 2，然后返回一个新的数组。

代码中 map 的使用：

代码中使用 map 似乎是在处理一些数据转换，具体是将某种类型的数据（data）尝试转为字符串类型，并解析成目标类型对象。详细讲解如下：

map { data in// 将参数尝试转为字符串guard let dataString = data as? String else {// data 不能转为字符串throw IxueaError.objectMapping}guard let result = type.deserialize(from: dataString) else {throw IxueaError.objectMapping}// 解析成功// 返回解析后的对象return result
}

分解讲解：

​ 1. map { data in … }

​ • map 会对集合中的每个元素执行闭包中的代码，并返回一个新集合。这里的闭包是 data in { … }，它接受集合中的每个元素作为输入（在这里是 data）。

​ • data 可能是一个原始数据，可以是任何类型，但在此代码中，它最终被尝试转换为 String 类型。

​ 2. guard let dataString = data as? String else { throw IxueaError.objectMapping }

​ • 使用 guard let 尝试将 data 转换为 String 类型。如果转换失败（即 data 不是一个字符串），则会跳转到 else 语句，抛出错误（IxueaError.objectMapping），中断当前的操作并退出。

​ • guard let 语句是一种早期退出的方式，用来简化条件判断并在条件不满足时处理错误。

​ 3. guard let result = type.deserialize(from: dataString) else { throw IxueaError.objectMapping }

​ • 假设 type 是一个类型，它提供了 deserialize(from:) 方法，用来将 dataString 字符串解析成目标类型的对象。

​ • 如果解析失败（即 deserialize 返回 nil），同样会抛出一个错误。deserialize 可能返回一个 nil，表示无法从字符串中成功解析出对象。

​ 4. return result

​ • 如果 data 成功转换为字符串，并且字符串成功被解析为目标类型的对象，最终的 result 会被返回。这个 result 就是经过 map 处理后得到的新元素。

总结：

​ • map：遍历集合中的每个元素，并应用闭包中的代码，返回转换后的新集合。

​ • guard：用于提前退出函数，如果条件不成立则抛出错误（throw IxueaError.objectMapping）。

​ • deserialize：将字符串解析成目标类型，如果失败则抛出错误。

代码的核心目的是将原始数据转换为字符串，然后再将字符串解析为目标类型对象。如果过程中有任何失败的地方（如类型转换失败或解析失败），都会抛出错误并停止处理。

对网络部分进行封装

为了解决JSON中相同类型对复用，所以将一些公共部分对类型写成一个类去继承，这样就避免了对于每一个JSON格式都需要再进行定义该类型。

同理，我们不可能对于每一个JSON去创建一个对应的类，所以使用范型，定义一些公共部分，每次传入该JSON应该属于什么类型即可。即定义了详情网络解析类，解析列表网络请求类

对Observable拓展moya网络相关功能

//
//  ObservableMoyaExtension.swift
//  对Observable拓展moya网络相关功能
//
//  Created by Unlimited_z on 2025/2/16.
//import Foundation
import HandyJSON
import Moya
import RxSwiftpublic enum IxueaError : Swift.Error {case objectMapping
}// MARK: - 扩展Observable
extension Observable{/// 将字符串解析为对象////// - Parameter type: 要转为的类/// - Returns: 转换后的观察者对象public func mapObject<T:HandyJSON>(_ type:T.Type) -> Observable<T> {map { data in//将参数尝试转为字符串guard let dataString = data as? String else {//data不能转为字符串throw IxueaError.objectMapping}guard let result = type.deserialize(from: dataString) else{throw IxueaError.objectMapping}//解析成功//返回解析后的对象return result}}
}//http网络请求观察者
public class HttpObserver<Element>:ObserverType{/// ObserverType协议中用到了泛型E/// 所以说子类中就要指定E这个泛型/// 不然就会报错public typealias E = Elementpublic typealias successCallback = ((E)-> Void)/// 请求成功回调var success:successCallback/// 请求失败回调var error:((BaseResponse?,Error?)-> Bool)?var controller:BaseLogicController?/// 构造方法////// - Parameters:///   - onSuccess: 请求成功的回调///   - onError: 请求失败的回调init(_ success:@escaping successCallback,_ error: ((BaseResponse?,Error?)-> Bool)?) {self.success = successself.error = error}/// 当RxSwift框架里面发送了事件回调////// - Parameter event: <#event description#>public func on(_ event: Event<Element>) {switch event {case .next(let data):
//            print("HttpObserver next \(data)")//将值尝试转为BaseResponselet baseResponse = data as? BaseResponseif baseResponse?.status != 0 {//状态码不等于0//表示请求出错了handlerResponse(baseResponse:baseResponse)} else {//请求正常success(data)}case .error(let error)://请求失败
//            print("HttpObserver error:\(error)")handlerResponse(error:error)case .completed://请求完成
//            print("HttpObserver completed")break}}/// 尝试处理错误网络请求////// - Parameters:///   - baseResponse: 请求返回的对象///   - error: 错误信息func handlerResponse(baseResponse:BaseResponse?=nil,error:Error?=nil) {if self.error != nil && self.error!(baseResponse,error) {//回调失败block//返回true，父类不自动处理错误//子类需要关闭loading，当前也可以父类关闭//暴露给子类的原因是，有些场景会用到//例如：请求失败后，在调用一个接口，如果中途关闭了//用户能看到多次显示loading，体验没那么好} else {//自动处理错误ExceptionHandleUtil.handlerResponse(baseResponse,error)}}}// MARK: - 扩展ObservableType
// 目的是添加两个自定义监听方法
// 一个是只观察请求成功的方法
// 一个既可以观察请求成功也可以观察请求失败
extension ObservableType{/// 观察成功和失败事件////// - Parameter onSuccess: <#onSuccess description#>/// - Returns: <#return value description#>func subscribe(_ success:@escaping ((Element)-> Void),_ error: @escaping ((BaseResponse?,Error?)-> Bool)) -> Disposable {//创建一个Disposablelet disposable = Disposables.create()//创建一个HttpObserverlet observer = HttpObserver<Element>(success,error)//创建并返回一个Disposablesreturn Disposables.create(self.asObservable().subscribe(observer),disposable)}/// 观察成功的事件////// - Parameter onSuccess: <#onSuccess description#>/// - Returns: <#return value description#>func subscribeSuccess(_ controller:BaseLogicController?=nil, _ success:@escaping ((Element)-> Void) ) -> Disposable {let disposable = Disposables.create()let observer = HttpObserver<Element>(success,nil)return Disposables.create(self.asObservable().subscribe(observer),disposable)}
}

可以理解为，对第三方库的重写或是封装

这段代码的核心目的是将 Moya 网络请求的响应封装在 RxSwift 的 Observable 中，并提供更灵活的网络请求错误处理和数据绑定机制。

1. mapObject 扩展

public func mapObject<T:HandyJSON>(_ type:T.Type) -> Observable<T> {map { data inguard let dataString = data as? String else {throw IxueaError.objectMapping}guard let result = type.deserialize(from: dataString) else{throw IxueaError.objectMapping}return result}
}

作用：

​ • mapObject 是对 Observable 的扩展，用于将网络请求的结果（假设是 JSON 格式的字符串）转换为一个指定类型（如 User 或其他符合 HandyJSON 的对象）。

​ • 它会将原始的 data 转换为字符串，并通过 HandyJSON 库来解析为对象。

​ • 如果转换失败，会抛出 IxueaError.objectMapping 错误。

调用顺序：

​ 1. 你在 Observable 中调用 mapObject，传入目标类型 T。

​ 2. 通过 map 操作符对响应数据进行处理，把响应的 JSON 字符串解析为指定类型的对象。

2. HttpObserver 类

public class HttpObserver<Element>: ObserverType {public typealias E = Elementvar success: (E) -> Voidvar error: ((BaseResponse?, Error?) -> Bool)?public init(_ success: @escaping (E) -> Void, _ error: ((BaseResponse?, Error?) -> Bool)?) {self.success = successself.error = error}public func on(_ event: Event<Element>) {switch event {case .next(let data):let baseResponse = data as? BaseResponseif baseResponse?.status != 0 {handlerResponse(baseResponse: baseResponse)} else {success(data)}case .error(let error):handlerResponse(error: error)case .completed:break}}func handlerResponse(baseResponse: BaseResponse? = nil, error: Error? = nil) {if self.error != nil && self.error!(baseResponse, error) {// custom error handling} else {ExceptionHandleUtil.handlerResponse(baseResponse, error)}}
}

作用：

​ • HttpObserver 是 ObserverType 的实现，它处理 Observable 发出的事件。

​ • on 方法根据收到的事件类型（next、error、completed）来执行相应的处理：

​ • next：如果请求成功（状态码 status 为 0），则调用 success 回调；如果请求失败（状态码非 0），则调用 handlerResponse 处理错误。

​ • error：请求失败，调用 handlerResponse。

​ • completed：请求完成，什么都不做。

​ • handlerResponse 根据具体情况调用 ExceptionHandleUtil.handlerResponse 来处理错误。

调用顺序：

​ 1. HttpObserver 被用来观察 Observable 发送的事件（例如网络请求的结果）。

​ 2. 当 Observable 发出 next 事件时，HttpObserver 会检查响应的状态码并决定是否调用 success 回调或处理错误。

​ 3. 如果有错误，handlerResponse 会被调用，根据情况执行自定义的错误处理。

3. ObservableType 扩展

extension ObservableType {func subscribe(_ success: @escaping ((Element) -> Void), _ error: @escaping ((BaseResponse?, Error?) -> Bool)) -> Disposable {let disposable = Disposables.create()let observer = HttpObserver<Element>(success, error)return Disposables.create(self.asObservable().subscribe(observer), disposable)}func subscribeSuccess(_ success: @escaping ((Element) -> Void)) -> Disposable {let disposable = Disposables.create()let observer = HttpObserver<Element>(success, nil)return Disposables.create(self.asObservable().subscribe(observer), disposable)}
}

作用：

​ • 这里对 ObservableType 进行了扩展，添加了自定义的 subscribe 和 subscribeSuccess 方法：

​ • subscribe：这个方法接收成功和失败的回调，并将它们传给 HttpObserver 处理。

​ • subscribeSuccess：只关心请求成功的回调，不处理失败情况。这个方法的 error 参数为 nil。

调用顺序：

​ 1. 外部通过 subscribe 或 subscribeSuccess 方法订阅 Observable。

​ 2. 这些方法内部会创建一个 HttpObserver 并将它绑定到 Observable 上。

​ 3. 当 Observable 发出事件时（例如 next、error、completed），HttpObserver 会接收到这些事件并执行相应的回调。

4. 外部调用顺序

假设你在外部调用了以下代码：

provider.rx.request(.getUserInfo(userId: "123")).asObservable().mapObject(User.self).subscribe { event inswitch event {case .next(let data):print("User Info: \(data)")case .error(let error):print("Request failed: \(error)")case .completed:print("Completed")}}.disposed(by: disposeBag)

调用流程：

​ 1. provider.rx.request(.getUserInfo(userId: “123”)) 发起网络请求，返回一个 Observable。

​ 2. asObservable() 将 Single 转换为 Observable。

​ 3. mapObject(User.self) 将响应的 JSON 字符串转换为 User 对象。

​ 4. subscribe 方法订阅 Observable，并传入一个闭包来处理 next、error 和 completed 事件。

​ • 如果请求成功，next 事件会被触发，data 会是一个 User 对象。

​ • 如果请求失败，error 事件会被触发，error 参数为错误信息。

​ • completed 事件会在请求完成时触发。

5. 内存管理

.disposed(by: disposeBag)

​ • disposeBag 用于管理订阅的生命周期，确保在视图控制器销毁时取消订阅，防止内存泄漏。

总结

​ • 外部代码通过 provider.rx.request() 发起请求，接着通过 mapObject 转换响应数据。

​ • subscribe 方法将请求的成功和失败回调传递给 HttpObserver，并处理事件。

​ • HttpObserver 根据响应的 status 来决定调用 success 或处理错误。

​ • 内部错误处理通过 handlerResponse 实现，允许开发者自定义错误处理逻辑。