swift对Moya的一些功能封装

柔情痞子 提交于 2020-08-16 07:11:07

项目开发中的接口比较多,在使用moya时会使用多个类,为避免一些代买的重复书写,做了一些封装处理,网络使用Alamofire,数据解析使用Moya-ObjectMapper

  • 首先是对返回数据统一处理的模型
import ObjectMapper
import Moya

class ResponseModel: NSObject,Mappable {
    
    /// 返回码
    var code:Int = 0
    /// 信息
    var message:String = ""
    /// 数据
    var data:Any?
    
    override init() {super.init()}
    
    init(_ code: Int, message:String, data:Any? = nil) {
        self.code = code
        self.message = message
        self.data = data
    }
    
    class func success(_ data:Any) ->ResponseModel{
        return ResponseModel(200, message: "SUCCESS", data: data)
    }
    
    class func faild(_ message:String? = "FAILD") ->ResponseModel{
        return ResponseModel(400, message: message ?? "FAILD", data: nil)
    }
    
    required init?(map: Map) {}
    
    func mapping(map: Map) {
        code <- map["code"]
        message <- map["message"]
        data <- map["data"]
    }
}
  • 然后是对返回数据的统一 处理工具
import Moya

class NetWorkManager {
    
    /// 处理成功的返回结果
    static func getResponse(_ success:Moya.Response) ->ResponseModel {
        var responseModel:ResponseModel = ResponseModel()
        do {
            responseModel =  try success.mapObject(ResponseModel.self)
        }catch{
            responseModel.code = 200
            responseModel.message = "无法解析网络返回数据"
        }
        //TODO: 根据各自业务需求,可对一些返回结果做出特殊处理😅
        if responseModel.code == 200 ,responseModel.message == "SUCCESS",responseModel.data == nil {
            responseModel.message = "没有更多了"
        }
        return responseModel
    }
    
    /// 处理失败的返回结果
    static func getResponse(_ error:MoyaError) ->ResponseModel {
        let responseModel:ResponseModel = ResponseModel()
        responseModel.code = 500
        responseModel.message = error.errorDescription ?? "网络访问出错"
        return responseModel
    }

    /// 获取请求头
    ///
    /// - Parameter token: 是否包含token
    /// - Returns: <#return value description#>
    static func getHeaders(_ token:Bool? = true) ->[String:String] {
        var result:[String:String] = ["Content-type" : "application/json"]
        if token! {
            result["Token"] = "这里写用户的token"
        }
        return result
    }
}

 

  • 再对MoyaProvider进行扩展
    import Moya
    import Alamofire
    
    extension MoyaProvider {
        
        static func custom(
            endpointClosure: @escaping Moya.MoyaProvider<Target>.EndpointClosure = HZJMoyaTool<Target>.endpointClosure,
            requestClosure: @escaping Moya.MoyaProvider<Target>.RequestClosure = HZJMoyaTool<Target>.requestResultClosure,
            stubClosure: @escaping Moya.MoyaProvider<Target>.StubClosure = HZJMoyaTool<Target>.stubClosure,
            callbackQueue: DispatchQueue? = nil,
            session: Moya.Session = HZJMoyaTool<Target>.session(),
            plugins: [Moya.PluginType] = HZJMoyaTool<Target>.authPlugins(),
            trackInflights: Bool = false) -> MoyaProvider{
            return MoyaProvider.init(endpointClosure: endpointClosure, requestClosure: requestClosure, stubClosure: stubClosure, callbackQueue: callbackQueue, session: session, plugins: plugins, trackInflights: trackInflights)
        }
    
        func hzj_Request(_ target: Target, callbackQueue: DispatchQueue? = .none, progress: ProgressBlock? = .none, finishBlock:@escaping ((ResponseModel)->Void)) {
            self.request(target, callbackQueue: callbackQueue, progress: progress) { (result) in
                switch result {
                case let .success(response):
                    finishBlock(NetWorkManager.getResponse(response))
                case let .failure(error):
                    finishBlock(NetWorkManager.getResponse(error))
                }
            }
        }
    }

     

  • 其中的HZJMoyaTool类,其中的具体内容,大家应根据自己的项目而定
    struct HZJMoyaTool<Target: TargetType> {
        
        static func endpointClosure(for target: Target) -> Endpoint {
            let url = target.baseURL.appendingPathComponent(target.path).absoluteString
            let endpoint = Endpoint(url: url, sampleResponseClosure: {.networkResponse(200,target.sampleData)}, method: target.method, task: target.task, httpHeaderFields: target.headers)
    //            endpoint.adding(newHTTPHeaderFields:["Content-Type" : "application/x-www-form-urlencoded","ECP-COOKIE" : ""])
            return endpoint
        }
        
        static func requestResultClosure(for endpoint: Endpoint, closure: MoyaProvider<Target>.RequestResultClosure) {
            do {
                var urlRequest = try endpoint.urlRequest()
                urlRequest.timeoutInterval = 60//设置网络超时时间
    //            urlRequest.cachePolicy = .returnCacheDataElseLoad
                closure(.success(urlRequest))
            } catch MoyaError.requestMapping(let url) {
                closure(.failure(MoyaError.requestMapping(url)))
            } catch MoyaError.parameterEncoding(let error) {
                closure(.failure(MoyaError.parameterEncoding(error)))
            } catch {
                closure(.failure(MoyaError.underlying(error, nil)))
            }
        }
        
        static func stubClosure(_: Target) -> Moya.StubBehavior {
    //        return Moya.StubBehavior.immediate//使用sampleData中返回的测试数据
            return Moya.StubBehavior.never
        }
        
        static func session() -> Session {
            let defaultSession = MoyaProvider<Target>.defaultAlamofireSession()
    //        let configuration = URLSessionConfiguration.default
    //        configuration.headers = defaultSession.sessionConfiguration.headers
    //        configuration.httpAdditionalHeaders = defaultSession.sessionConfiguration.httpAdditionalHeaders
            let configuration = defaultSession.sessionConfiguration
            if let path: String = Bundle.main.path(forResource: "xxx", ofType: "cer") {
                ///添加证书
                do {
                    let certificationData = try Data(contentsOf: URL(fileURLWithPath: path)) as CFData
                    if let certificate = SecCertificateCreateWithData(nil, certificationData){
                        let certificates: [SecCertificate] = [certificate]
                        let policies: [String: ServerTrustEvaluating] = ["domain": PinnedCertificatesTrustEvaluator(certificates: certificates, acceptSelfSignedCertificates: true, performDefaultValidation: true, validateHost: true)]
                        let manager = ServerTrustManager(allHostsMustBeEvaluated: false, evaluators: policies)
                        return Session(configuration: configuration, serverTrustManager: manager)
                    }
                } catch {
                    return Session(configuration: configuration)
                }
            }
            return Session(configuration: configuration)
        }
        
        static func authPlugins() -> [Moya.PluginType] {
            return []
    //        return [AccessTokenPlugin{_ in User.shared.token}]
        }
    }
    

     

  • 最后再举个使用例子吧 
    import Moya
    
    let LoginLogManager = MoyaProvider<LoginLogAPI>.custom()
    
    enum LoginLogAPI {
        ///添加登录日志(type:0-web 1-app)
        case addLoginLog(type:Int)
    }
    
    extension LoginLogAPI:TargetType {
        var baseURL: URL {
            return URL(string: AppRootApi + "/api/appHtLoginLog/")!
        }
        
        var path: String {
            switch self {
            case .addLoginLog(type: _):
                return "addLoginLog"
            }
        }
        
        var method: Moya.Method {
            switch self {
            default:
                return .post
            }
        }
        
        var sampleData: Data {
            return "{}".data(using: String.Encoding.utf8)!
        }
        
        var task: Task {
            var params:[String:Any] = [:]
            switch self {
            case .addLoginLog(type: let type):
                params["type"] = type
                return .requestCompositeParameters(bodyParameters: [:], bodyEncoding: URLEncoding.httpBody, urlParameters: params)
            }
        }
        
        var headers: [String : String]? {
            switch self {
            default:
                return NetWorkManager.getHeaders(true)
            }
        }
    }

    使用接口就这样

        func test() {
            LoginLogManager.hzj_Request(.addLoginLog(type: 1)) { [weak self](responseModel) in
                guard let strongSelf = self else { return }
                if responseModel.code == 200 {
                    print("成功")
                }else{
                    print("失败")
                }
            }
        }

     

大概就这样,以上都是一些统一的处理,若要有一些特殊的接口,大家就只用自己弄了

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!