在Swift中使用AWSTask对象的正确方法是什么?

问题描述

您好，谢谢您的宝贵时间.

Hello and thanks in advance for your time.

在我的代码中，我向AWSSQS发出各种请求，所有请求均返回AWSTask.我发现使用这些AWSTask对象非常困难，同时还尝试将特定于AWS的所有逻辑都放在一个类中，这样，如果需要，我可以轻松地切换到其他云服务.

In my code I am making various requests to AWSSQS which all return AWSTask. I have found working with these AWSTask objects to be very difficult while also trying to keep all the logic specific to AWS in a single class so I can easily switch to a different cloud service if need be.

理想情况下，我想做的是以串行方式异步执行一系列AWS任务.通常，我只是将任务添加到自定义串行调度队列中，但是由于AWSTask对象本身是异步任务，所以我不能这样做.

Ideally, what I would like to do is execute a series of AWS tasks asynchronously in a serial fashion. Normally I would just add tasks to a custom Serial Dispatch Queue but since The AWSTask objects are themselves asynchronous tasks, I can't do that.

这是一个简单的示例，它说明了我遇到的问题.它没有任何现实世界的目的，但是可以很好地说明问题.在下面，我有创建SQS队列，将消息发送到SQS队列，从SQS队列接收消息以及删除SQS队列的代码.假设我想以串行，异步的方式完成这四件事.换句话说，我要确保上一个任务成功之后再尝试下一个任务.

Here is a simple example that illustrates the problem I am having. It doesn't have any real world purpose but it does a good job illustrating the problem. Below, I have code to create a SQS queue, send a message to a SQS queue, receive a message from an SQS queue, and delete a SQS queue. Let's say I want to do those four things in a serial, asynchronous fashion. In other words, I want to make sure the previous task succeeded before attempting the next task.

ViewController

ViewController

DispatchQueue.global(qos: DispatchQoS.QoSClass.userInitiated).async {
        awsClass.runTest()
        DispatchQueue.main.async {
            print("Test Finished")
        }
    }

AwsClass

public func createQueue(){
    guard let createQueueRequest = AWSSQSCreateQueueRequest() else{fatalError()}

    createQueueRequest.queueName = "TestQueue"

    sqs.createQueue(createQueueRequest).continueWith(block: {(task) -> AnyObject? in
        if task.error != nil {
            print(task.error!)
        }
        else if task.result != nil {
            self.queueUrl = task.result!.queueUrl!
            print("created queue at: \(self.queueUrl!)")
        }
        return nil
    })
}

public func deleteQueue(){
    if queueUrl != nil {
        guard let deleteQueueRequest = AWSSQSDeleteQueueRequest() else{fatalError()}

        deleteQueueRequest.queueUrl = queueUrl

        sqs.deleteQueue(deleteQueueRequest).continueWith(block: {(task) -> AnyObject? in
            if task.error != nil {
                print(task.error!)
            }
            else if task.result != nil {
                print("queue sucessfully deleted from \(self.queueUrl!)")
                self.queueUrl = nil
            }
            return nil
        })
    }
    else{
        print("Queue has already been deleted")
    }
}

public func sendMessage(messageData: String, toConnectId: String) {
    guard let sendMessageRequest = AWSSQSSendMessageRequest() else{fatalError()}
    sendMessageRequest.queueUrl = toConnectId
    sendMessageRequest.delaySeconds = 0
    sendMessageRequest.messageBody = messageData
    sqs.sendMessage(sendMessageRequest).continueWith(block: {(task) -> AnyObject? in
        if task.error != nil {
            print(task.error!)
        }
        else if task.result != nil {
            print("successfully sent message to \(toConnectId)")
        }
        return nil
    })
}

public func receiveMessage(){
    guard let receiveMessageRequest = AWSSQSReceiveMessageRequest() else{fatalError()}
    receiveMessageRequest.queueUrl = self.queueUrl
    receiveMessageRequest.maxNumberOfMessages = 1

    sqs.receiveMessage(receiveMessageRequest).continueWith(block: {(task) -> AnyObject? in
        if task.error != nil {
            print(task.error!)
        }
        else if task.result != nil {
            let message = (task.result?.messages?.first)!
            print("successfully received message with body:  \(message.body ?? "failed")")
        }
        return nil
    })
}

public func runTest(){
    let mySerialQueue = DispatchQueue(label: "mySerialQueue")
    mySerialQueue.sync {
        self.createQueue()
    }
    mySerialQueue.sync {
        self.sendMessage(messageData: "test", toConnectId: "https://someUrl")
    }
    mySerialQueue.sync {
        self.receiveMessage()
    }
    mySerialQueue.sync {
        self.deleteQueue()
    }
}

由于AWSTasks与完成函数是异步的，因此代码会快速进行所有四个调用，然后在这些任务完成时立即调用完成函数.相反，我希望第一个任务的完成功能在下一个任务开始之前完成.

Since the AWSTasks are asynchronous with completion functions, the code quickly makes all four calls and then the completion functions are called whenever those tasks finish. Instead I want the completion function of the first task to finish before the next task begins.

推荐答案

AWSTask对象旨在链接"在一起.可以在这里找到文档: http://docs.aws.amazon. com/mobile/sdkforios/developerguide/awstask.html

The AWSTask objects are meant to be "chained" together.Documentation can be found here: http://docs.aws.amazon.com/mobile/sdkforios/developerguide/awstask.html

这里有个小例子:

sqs.createQueue(/* parameters */).continueWithSuccess(block: {(task) -> Void in
    // Success
    return sqs.sendMessage(/* parameters */)
}).continueWithSuccess(block: {(task) -> Void in
    // Success
    return sqs.receiveMessage(/* parameters */)
}).continueWithSuccess(block: {(task) -> Void in
    // Success
    return sqs.deleteQueue(/* parameters */)
})

这篇关于在Swift中使用AWSTask对象的正确方法是什么?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！