Quando você usa robôs de negociação quantitativa de moeda digital, quando há vários robôs rodando em um servidor, se você visitar diferentes exchanges, o problema não é sério neste momento, e não haverá problema de frequência de solicitação de API. Se você precisar ter vários robôs rodando ao mesmo tempo, e todos eles estão visitando a mesma troca com o mesmo par de negociação estratégia de negociação quantitativa. Neste momento, haverá alguns problemas de limitação de frequência de solicitação de API. Então, como resolver o problema da interface de acesso multi-robô com o menor número de servidores?

Podemos implementar um robô de transferência de cotações de mercado, e acessar a interface de troca para obter cotações de mercado e outros dados só podem ser preenchidos por este robô.

Exemplo de robô de encaminhamento de citações

Ele é responsável apenas por acessar a interface de cotação do mercado de câmbio para obter dados e fornecer cotações de mercado para outros robôs.

import _thread
import threading
import json
import math
from http.server import HTTPServer, BaseHTTPRequestHandler
from urllib.parse import parse_qs, urlparse

Records = None
lock = threading.RLock()
Counter = {}

def url2Dict(url):
    query = urlparse(url).query  
    params = parse_qs(query)  
    result = {key: params[key][0] for key in params}  
    return result

class Provider(BaseHTTPRequestHandler):
    def do_GET(self):
        global Records, lock, Counter
        try:
            self.send_response(200)
            self.send_header("Content-type", "application/json")
            self.end_headers()

            dictParam = url2Dict(self.path)
            # Log("The service receives the request, self.path:", self.path, "query parameter:", dictParam)
            lock.acquire()
            # Recording
            if dictParam["robotId"] not in Counter:
                Counter[dictParam["robotId"]] = {"NumberOfRequests" : 0}
            Counter[dictParam["robotId"]]["NumberOfRequests"] += 1
            lock.release()
            
            # Write data response
            self.wfile.write(json.dumps(Records).encode())
        except BaseException as e:
            Log("Provider do_GET error, e:", e)


def createServer(host):
    try:
        server = HTTPServer(host, Provider)
        Log("Starting server, listen at: %s:%s" % host)
        server.serve_forever()
    except BaseException as e:
        Log("createServer error, e:", e)
        raise Exception("stop")

def main():
    global Records, Counter
    LogReset(1)
    try:
        # _thread.start_new_thread(createServer, (("localhost", 9090), ))         # local computer test
        _thread.start_new_thread(createServer, (("0.0.0.0", 9090), ))             # Test on VPS server
        Log("Start service", "#FF0000")
    except BaseException as e:
        Log("Failed to start service!")
        Log("Error message:", e)
        raise Exception("stop")
    while True:
        r = exchange.GetRecords()
        if not r :
            Log("K-line market quotation failed", "#FF0000")
            continue
        else :
            Records = r
        # Counter
        tbl = {
            "type" : "table", 
            "title" : "Statistics", 
            "cols" : ["ID of the robot requesting data", "Number of requests"], 
            "rows" : [], 
        }
        for k in Counter:
            tbl["rows"].append([k, Counter[k]["NumberOfRequests"]])
        LogStatus(_D(), "Data collection!", "\n", "`" + json.dumps(tbl) + "`")
        Sleep(500)

Código de estratégia do robô de dados solicitados

O robô que solicita dados é um robô de estratégia de negociação, mas nós o usamos para testes. Nós apenas escrevemos os dados solicitados (dados de linha K) e desenhamos os dados. Você pode escrevê-los em JavaScript. Para desenhar uma imagem, você precisa verificar a biblioteca de desenho de linha. Pesquise e copie esta biblioteca de classes no Strategy Square. Depois de copiar, você pode selecioná-lo na coluna de referência do modelo na página de edição de estratégia.

var FuncGetRecords = exchange.GetRecords
exchange.GetRecords = function() {
    // You can fill in the IP address of the device where the "quote forwarding robot" is located xxx.xxx.xxx.xxx
    var ret = HttpQuery("http://xxx.xxx.xxx.xxx:9090?robotId=" + _G())  
    var records = null
    try {
        records = JSON.parse(ret)
    } catch(e) {
        Log(e)
        records = null
    }
    return records 
}

function main(){
    LogReset(1)
    while(1) {
        var records = exchange.GetRecords()
        LogStatus(_D(), "Robot ID:", _G())
        if (!records) {
            Log("Failed to get data!", "#FF0000")
            Sleep(1000)
            continue
        }
        Log(records)
        $.PlotRecords(records, "K")
        Sleep(1000)
    }
}

Operação efetiva

Inicie o robô de transferência de mercado

Iniciar o robô de teste, ID: 206353

Inicie o robô de teste, ID: 206359

Desta forma, três ou mesmo N robôs podem compartilhar os dados da linha K de um determinado par de negociação.