如何在Inteceptor模式中使用dojo/promise/Promise.cancel()

Question

我期待为特定于应用程序的AJAX控制器实现一个Inteceptor Pattern.

我的应用程序中的任何AJAX请求都会调用Authenticator.request(),它会拦截响应,检查某些状态(例如401,403,503),根据它们执行特定于应用程序的显示功能(如果状态401是,则显示LoginDialog)收到).我的问题源于围绕道场的承诺的混乱.

1. 如何将成功的请求传递回原始调用方法？
2. 当我调用dojo.promise.Promise.cancel()时,我希望链接停止.但是,这只是运行errback函数.这意味着需要在调用函数中的每个errback方法中放置逻辑,以区分已取消的请求与错误.

谁能解释一下如何在这种情况下使用Promise？

提前致谢!

这是我认为我可以做的一个例子......

require(["dojo/request"], function(request){
    auth = { 
        request: function() {
            var promise = request(arguments);

            return promise.always(function (response) {
                console.log("always called", response);
                switch (response.response.status)
                {
                    case 404:
                        console.log(404, response);
                        return "cancelled";
                        break;
                }
            });
        }
    };
});

auth.request('example.json').then(function(text){ console.log('success!', text) }, function(error){
    console.log('error!', error);
});

如果这有助于将来的任何人,这是我最终实现的(基于戴夫的答案)......

require(["dojo/request", "dojo/errors/CancelError"], function(dRequest, CancelError){
    auth = { 
        request: function(url, options) {
            var promise = dRequest(url, options);

            return promise.response.then(
                function (response) {
                    return response;
                },
                function (error) {
                    var error,
                        cancelError = new CancelError(error.message);
                    cancelError.response = error.response;
                    console.log("error", error, cancelError);

                    switch (error.response.status)
                    {
                        case 404:
                            console.log(404, "canceled");
                            throw cancelError;
                    }
                    throw error;
                }
            );
        },
        cancelTrap: function (errorBack, cancelBack) {
            return function (error) {
                throw (error instanceof CancelError) 
                    ? cancelBack && cancelBack(error) || error 
                    : errorBack && errorBack(error) || error;
            }
        }
    };
});

......它可以像这样使用......

r = auth.request('something.json');
r.then(
    function(text){
        console.log('success! > this', this)
        console.log('success!', text)
        return text;
    }, 
    auth.cancelTrap(
        function (error) {
            console.log('error!', error);
            throw error;
        },
        function (cancelError) {
            console.log('cancelError!', cancelError);
            throw cancelError;
        }
    )
).then(
    function(text){
        console.log('success2!', text)
    }, 
    auth.cancelTrap(
        function (error) {
            console.log('error2!', error);
            throw error;
        },
        function (cancelError) {
            console.log('cancelError2!', cancelError);
            throw cancelError;
        }
    )
);

Answer 1

promises非常强大,我认为你应该尝试理解通过then函数提供的两个执行路径(假设always只是调用then两个params具有相同功能的快捷方式):

promise.then(successCallback, errorCallback)

• 返回一个承诺.
• 在以下情况下,此承诺得到解决(成功)

• successCallback 或 errorCallback返回一个值.使用此值解析promise,或者如果此值是promise,则使用此promise的解析来解析.

• 在以下情况下,此承诺拒绝(错误)

• successCallback 或 errorCallback都会抛出错误.

此外,如果没有提供errorCallback,如果原始的promise被拒绝(错误),这会冒泡到下一个提供错误处理程序的级别,所以如果我这样做:

promise.then(func1).then(func3).then(finalFunc, errorHandler);
promise.reject(someError);

然后errorHandler调用someError.

这一切意味着,如果你不想在某个级别处理错误,那就不要,让它冒出来并在最高级别实现一个错误处理程序.如果你只想处理某些错误,你可以像这样"包装或陷阱":

promise.then(successFunction, function(error) {
    if(error.code > 400) {
         // do something clever, maybe just send an empty result up the chain
         return []; // goes to successCallbacks!
    } else {
        throw error; // pass it to the next errorHandler
    }
});

最后,结束并尝试回答您的问题:

如何将成功的请求传递回原始调用方法？

您可以简单地return将值传递给下一个successHandler.

当我调用dojo.promise.Promise.cancel()时,我希望链接停止.但是,这只是运行errback函数.这意味着需要在调用函数中的每个errback方法中放置逻辑,以区分已取消的请求与错误.

不幸的是,你不允许停止链接,承诺旨在强有力地传递到完成.但是,您可以不在每个交叉点放置一个错误,只在您真正需要时添加一个,并且您的解决方案应该非常干净.