我们平常的网络请求基本步骤
1 发送Request
2 接受 Response
3 json转model (我目前是有这一步的)

1 不利用三方框架的Rx网络层

在实际生产过程中，我们都会使用第三方的网络框架。但为了学习基本流程，我们最好还是实现自己的一套简易框架。

1.1 对URLSession 进行Rx扩展，让他用它Rx的功能

创建URLSession+Rx文件

func response(request: URLRequest) -> Observable<(HTTPURLResponse, Data)> {
        return Observable.create { observable in
            let task = self.base.dataTask(with: request) { (data, response, error) in
                //处理数据
                if let error = error {
                    observable.onError(error)
                    return
                }

                observable.onNext((response as! HTTPURLResponse, data!))
                observable.onCompleted()
            }
            task.resume()
            return Disposables.create(with: task.cancel)
        }
    }

我们拆分来看一下

func response(request: URLRequest) -> Observable<(HTTPURLResponse, Data)> {
        return Observable.create { observable in
      //请求
            return Disposables.create()
        }
    }

这几乎是rx扩展的基本样式，中间加上URLSesson的请求 和 请求之后发送 错误 或者完成信号就可以了。
我们来看一下成果

let request = URLRequest.init(url: URL.init(string: "")!)
let response = URLSession.shared.rx.response(request: request)

response.subscribe(onNext: { (response, data) in
            //数据处理
 }).addDisposableTo(bag)

数据处理这部分也挺恶心了，也应该封装起来
通常数据处理 我们先处理data -> json ,之后json ->model. 事实上 不是所有的VC需要的数据都是model.所以 我们要暴露json 和model 2个接口。供调用者选用

在处理数据之前要确定数据是否有效，根据返回的状态码来判断，
筛选出正常返回的数据

func data(request: URLRequest) -> Observable<Data> {
        return response(request: request).map { (response, data) in
            if 200..<300 ~= response.statusCode {
                return data
            } else {
                throw URLSessionError.failed
            }

        }
    }

json

func json(request: URLRequest) -> Observable<[String: Any]> {
        return data(request: request).map{ data  in
            let json = try JSONSerialization.jsonObject(with: data, options: .allowFragments) as? [String: Any]

            return json!
        }
    }

model
转化model 这一步 这里我没有自己用原生实现，Swift不支持运行时（不包含继承NSObject的类）这里偷偷的用一下三方吧ObjectMapper(用法 后面介绍)

func model<T: Mappable>(request: URLRequest, model: T.Type) -> Observable<T> {
        return json(request: request).map{ json in
            let object = Mapper<T>().map(JSONObject: json["data"])
            return object!
        }
    }

这里的转model 在实际情况下会出现许多问题。举个例子
商品列表 商品详情
商品详情是单纯的model
商品列表是 model的数组,所以根据不同情况可能还需要一个ModelArray的方法。和model的一样，就不在重复了。
我们到VM中看看我们的战果

let request = URLRequest.init(url: URL.init(string: "")!)
let response = URLSession.shared.rx.model(request: request, model: GoodsDetailModel.self)

response.subscribe(onNext: { model in
            //数据处理
        }).addDisposableTo(bag)

这样我们一个基本的rx 的网络层基本完成了。如果要使用可以放在一个NetWorkingService类 。避免于vm大量的耦合。具体封装方法 就看大家的想法啦。是集约型 还是 分散型，都看自己的喜好了

2 RxMoya

在生产中，强烈推荐RxMoya真的大而全。
这边我们简单的介绍使用方法
首先确定配置文件创建XXAPI.Swift
我随便写一个了

enum GoodsAPI {
    case goodsDetail(goodsID: String)
}

extension GoodsAPI: TargetType {
    var parameterEncoding: ParameterEncoding {
        return URLEncoding.default
    }

    var task: Task {
        return .request
    }

    var path: String {
        return ""
    }

    var base: String {
        return ""
    }

    var baseURL: URL {
        return URL.init(string: base)!
    }

    var parameters: [String: Any]? {
        switch self {
        case .goodsDetail(let id):
            return []
        default:
            return nil
        }
    }

    var method: Moya.Method {
        return .post
    }

    var sampleData: Data {
        return "".data(using: .utf8)!
    }



}

遵循TargetType 实现基本配置
然后在VM中调用

let service = RxMoyaProvider<GoodsAPI>()

    var goodsDetailModel: Observable<GoodsDetailModel> {
        return self.service.request(.goodsDetail(goodsID: "10133")).mapObject(GoodsDetailModel.self)
    }

这样就可以让VM中的model暴露给VC使用了。简单方便

=========
介绍下ObjectMapper的使用
1 遵循 Mappable协议
2 实现协议方法 init 和 mapping
这里的mapping 一定要写映射关系，毕竟没有运行时这种东西了。
注意的是如果返回的Int类型，你用String 是无法接受的（很难受）

struct GoodsDetailModel: Mappable {
    var goodsID: Int?
    var goodsInfo: String?
    var goodsName: String?
    var introduction: String?
    var label: String?
    var tag: String?
    var goodsPic: String?
    var xPrice: String?
    var yPrice: String?
    var number: Int?
    var batchNO: String?
    var activityGoods: Bool?

    init?(map: Map) {

    }

    mutating func mapping(map: Map) {
        goodsID <- map["goodsID"]
        goodsInfo <- map["goodsInfo"]
        goodsName <- map["goodsName"]
        introduction <- map["introduction"]
        label <- map["label"]
        tag <- map["tag"]
        goodsPic <- map["goodsPic"]
        xPrice <- map["xPrice"]
        yPrice <- map["yPrice"]
        number <- map["number"]
        batchNO <- map["batchNO"]
        activityGoods <- map["activityGoods"]
    }

}