我在执行 https 请求时遇到问题,如果请求没有任何错误,我永远不会收到消息,这是一个命令行工具应用程序,我有一个允许 http 请求的 plist,我总是看到完成块。
typealias escHandler = ( URLResponse?, Data? ) -> Void
func getRequest(url : URL, _ handler : @escaping escHandler){
let session = URLSession.shared
var request = URLRequest(url:url)
request.cachePolicy = .reloadIgnoringLocalCacheData
request.httpMethod = "GET"
let task = session.dataTask(with: url ){ (data,response,error) in
handler(response,data)
}
task.resume()
}
func startOp(action : @escaping () -> Void) -> BlockOperation{
let exOp = BlockOperation(block: action)
exOp.completionBlock = {
print("Finished")
}
return exOp
}
for sUrl in textFile.components(separatedBy: "\n"){
let url = URL(string: sUrl)!
let queu = startOp {
getRequest(url: url){ response, data in
print("REACHED")
}
}
operationQueue.addOperation(queu)
operationQueue.waitUntilAllOperationsAreFinished()
一个问题是您的操作只是启动请求,但由于请求是异步执行的,因此操作会立即完成,而不是真正等待请求完成。在异步请求完成之前,您不想完成操作。
如果您想使用操作队列执行此操作,技巧是您必须子类化
Operation
并为 isExecuting
和 isFinished
执行必要的 KVO。然后,您可以在开始请求时更改 isExecuting
,在完成请求时更改 isFinished
,并使用两者关联的 KVO。这些都在并发编程指南:定义自定义操作对象中进行了概述,特别是在配置并发执行的操作部分。 (请注意,本指南有点过时(它指的是 isConcurrent
属性,已被替换为 isAsynchronous
;它重点关注 Objective-C;等等),但它向您介绍了这些问题。
无论如何,这是一个抽象类,我用它来封装所有这些愚蠢的异步操作:
/// Asynchronous Operation base class
///
/// This class performs all of the necessary KVO notifications of `isFinished` and
/// `isExecuting` for a concurrent `Operation` subclass. So, to developer
/// a concurrent `Operation` subclass, you instead subclass this class, in which the subclass must:
///
/// - must override `main()` with the tasks that initiate the asynchronous task;
///
/// - must call `finish()` function when the asynchronous task is done;
///
/// - optionally, periodically check `self.cancelled` status, performing any clean-up
/// necessary and then ensuring that `finish()` is called; or
/// override `cancel` method, calling `super.cancel()` and then cleaning-up
/// and ensuring `finish()` is called.
public class AsynchronousOperation: Operation {
override public var isAsynchronous: Bool { true }
private let lock = NSLock()
private var _executing: Bool = false
override private(set) public var isExecuting: Bool {
get {
lock.withLock { _executing }
}
set {
willChangeValue(forKey: #keyPath(isExecuting))
lock.withLock { _executing = newValue }
didChangeValue(forKey: #keyPath(isExecuting))
}
}
private var _finished: Bool = false
override private(set) public var isFinished: Bool {
get {
lock.withLock { _finished }
}
set {
willChangeValue(forKey: #keyPath(isFinished))
lock.withLock { _finished = newValue }
didChangeValue(forKey: #keyPath(isFinished))
}
}
/// Complete the operation
///
/// This will result in the appropriate KVN of isFinished and isExecuting
public func finish() {
if isExecuting {
isExecuting = false
isFinished = true
}
}
override public func start() {
if isCancelled {
isFinished = true
return
}
isExecuting = true
main()
}
}
然后,我可以创建一个使用它的
NetworkOperation
:
class NetworkOperation: AsynchronousOperation {
var task: URLSessionTask!
init(session: URLSession, url: URL, requestCompletionHandler: @escaping (Data?, URLResponse?, Error?) -> ()) {
super.init()
task = session.dataTask(with: url) { data, response, error in
requestCompletionHandler(data, response, error)
self.finish()
}
}
override func main() {
task.resume()
}
override func cancel() {
task.cancel()
super.cancel()
}
}
无论如何,完成此操作后,我现在可以为网络请求创建操作,例如:
let queue = OperationQueue()
queue.name = "com.domain.app.network"
let url = URL(string: "http://...")!
let operation = NetworkOperation(session: .shared, url: url) { data, response, error in
guard let data = data, error == nil else {
print("\(error)")
return
}
let string = String(data: data, encoding: .utf8)
print("\(string)")
// do something with `data` here
}
let operation2 = BlockOperation {
print("done")
}
operation2.addDependency(operation)
queue.addOperations([operation, operation2], waitUntilFinished: false) // if you're using command line app, you'd might use `true` for `waitUntilFinished`, but with standard Cocoa apps, you generally would not
注意,在上面的示例中,我添加了第二个操作,仅打印一些内容,使其依赖于第一个操作,以说明第一个操作在网络请求完成后才完成。
显然,您通常不会使用原始示例中的
waitUntilAllOperationsAreFinished
,也不会使用我示例中的 waitUntilFinished
的 addOperations
选项。但因为您正在处理一个命令行应用程序,并且在这些请求完成之前您不想退出,所以这种模式是可以接受的。 (我提到这一点只是为了让未来的读者对随意使用waitUntilFinished
感到惊讶,这通常是不可取的。)