Javascript Angular 4/5如何实现基于优先级的Http请求队列

在拦截器中尝试

import { Injectable } from '@angular/core';
import { HttpEvent, HttpInterceptor, HttpHandler, HttpRequest } from '@angular/common/http';

import { Observable } from 'rxjs/Observable';
import { finalize } from 'rxjs/operators';

@Injectable()
export class HttpRequestsInterceptor implements HttpInterceptor {

    requestQueue = [];
    reqCount: number = 0;
    reqFlag: boolean = false;
    prevCount: number = 0;
    obsIntrReq: any;

    intercept(req: HttpRequest<any>, next: HttpHandler):
        Observable<HttpEvent<any>> {
        this.prevCount++;
        if (this.prevCount >= 4) {
            this.requestQueue.push(req);
            this.obsIntrReq = Observable.interval(1000).do(() => {
                if (this.reqFlag) {                    
                    this.requestQueue.splice(0, 1);
                    return next.handle(this.requestQueue[0]);
                }
            })
                .switchMap(() => this.intervalPreviewChecking(this.reqCount, this.requestQueue.length))
                .subscribe(() => { });
        } else {
            return next.handle(req).pipe(
                finalize(() => {
                    this.prevCount--;
                })
            );
        }

    }

    intervalPreviewChecking(rCount, requestQueueLength) {
        if (requestQueueLength == 0) {
            this.prevCount = 0;
            this.reqFlag = false;
            this.obsIntrReq.unsubscribe();
            return this.obsIntrReq = null;
        }
        if (this.prevCount < 4) {
            this.reqFlag = true;
            return Observable.of(true);
        }
        this.reqFlag = false;
        return Observable.of(false);
    }
}

从'@angular/core'导入{Injectable}；
从'@angular/common/http'导入{HttpEvent，HttpInterceptor，HttpHandler，HttpRequest}；
从“rxjs/Observable”导入{Observable}；
从“rxjs/operators”导入{finalize}；
@可注射（）
导出类HttpRequestsInterceptor实现HttpInterceptor{
requestQueue=[]；
reqCount:number=0；
reqFlag:boolean=false；
prevCount：数字=0；
obsIntrReq：任何；
拦截（请求：HttpRequest，下一步：HttpHandler）：
可观察{
这个.prevCount++；
如果（this.prevCount>=4）{
这个.requestQueue.push（req）；
this.obsintreq=可观测的.interval（1000）.do（（）=>{
如果（this.reqFlag）{
this.requestQueue.splice（0,1）；
返回next.handle（this.requestQueue[0]）；
}
})
.switchMap（（）=>this.intervalPreviewChecking（this.reqCount，this.requestQueue.length））
.subscribe（（）=>{}）；
}否则{
返回next.handle（req.pipe）(
完成（（）=>{
这是伯爵；
})
);
}
}
间隔预览检查（rCount、requestQueueLength）{
如果（requestQueueLength==0）{
这个.prevCount=0；
this.reqFlag=false；
此.obsIntrReq.unsubscribe（）；
返回this.obsIntrReq=null；
}
如果（此.prevCount<4）{
this.reqFlag=true；
可观察的返回（真）；
}
this.reqFlag=false；
可观察到的返回（错误）；
}
}

每次HTTP调用都会调用拦截器

如果我必须对我的呼叫进行优先级排序，我不会在拦截器中这样做，而是在我的功能中这样做

我就是这样做的（顺序=请求的优先级）

---

嗨，谢谢你的回复。。实际上，我想将我的请求排队，一次只发送4个请求，其余的请求应该在队列中。一旦4中的一个请求完成，队列中基于优先级的下一个请求应该被发送。因此，基本上，您会拒绝用户3次的请求，然后您会遵守他的请求吗？为什么？在我的例子中，我有一个叫做预览的功能，它可以将HTML转换成pdf，用户可以提出多个请求。但当用户提出更多请求时，我的登录ping请求落在队列的最后一个，从而导致用户注销。

const calls: {order: number, call: any}[] = [];

calls.push({order: 0, call: this.myService.makeCall(0) });
calls.push({order: 1, call: this.myService.makeCall(1) });
// etc. 

const orderedCalls = calls.sort((a, b) => a.order - b.order).map(call => call.call);

Observable.forkJoin(orderedCalls);