Bei der Verwendung von quantitativen Handelsrobotern für digitale Währungen, wenn mehrere Roboter auf einem Server ausgeführt werden, wenn Sie verschiedene Börsen besuchen, ist das Problem zu diesem Zeitpunkt nicht ernst und es wird kein API-Anforderungsfrequenzproblem geben. Wenn Sie mehrere Roboter gleichzeitig ausführen müssen und sie alle die gleiche Börse mit der gleichen Handelspaar-quantitativen Handelsstrategie besuchen. Zu diesem Zeitpunkt wird es einige Probleme mit der API-Anforderungsfrequenzbegrenzung geben. Wie lösen Sie also das Problem der Multi-Robot-Zugriffsschnittstelle mit der geringsten Anzahl von Servern?

Wir können einen Markt-Kotierung Forwarding-Roboter implementieren und auf die Börsenoberfläche zugreifen, um Markt-Kotierungen und andere Daten zu erhalten, die nur von diesem Roboter ausgefüllt werden können.

Beispiel für Robotersendung von Zitaten

Es ist nur für den Zugriff auf die Börsenmarktnotierungsschnittstelle verantwortlich, um Daten zu erhalten und Marktnotierungen an andere Roboter bereitzustellen.

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)

Anforderungsdaten-Roboter-Strategiecode

Der Roboter, der Daten anfordert, ist ein Trading-Strategie-Roboter, aber wir verwenden ihn zum Testen. Wir schreiben nur die angeforderten Daten (K-Line-Daten) und zeichnen die Daten. Sie können sie in JavaScript schreiben. Um ein Bild zu zeichnen, müssen Sie die Line-Drawing-Bibliothek überprüfen. Suchen und kopieren Sie diese Klassenbibliothek in Strategy Square. Nach dem Kopieren können Sie sie in der Template-Referenzspalte auf der Strategiebearbeitungsseite auswählen.

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)
    }
}

Tatsächlicher Betrieb

Starten Sie den Markt-Forwarding-Roboter

Starten Sie den Testroboter, ID: 206353

Starten Sie den Testroboter, ID: 206359

Auf diese Weise können drei oder sogar N Roboter die K-Liniendaten eines bestimmten Handelspaares teilen.