Ajax-Webservice-Implementierungscode für domänenübergreifende Aufrufe

Kürzlich stieß Ajax beim Zugriff auf den Webservice auf domänenübergreifende Probleme. Ich habe online nach Informationen gesucht und diese wie folgt zusammengefasst (viele davon wurden von anderen kopiert, die die Zusammenfassung für gut hielten)

<< Verwenden Sie JSON, um Daten zu übertragen, und verlassen Sie sich dabei auf JSONP. Kommen Sie domänenübergreifend>>

Zuerst mein implementierter Code:

Front-End-Code:

$.ajax({
 type: "get",
 url: "http://localhost/Service1.asmx/getElevatorStatusJsonData?jsoncallback=?",
 dataType: "jsonp",
 jsonp: "json",
 data: "",
 success: function (result) {
 var data = eval(result);
 for (var i = 0; i < data.length; i++) {
 alert(data[i].ID + "--" + data[i].Name);
 }
 },
 error: function (a, b, c) {
 alert(c);
 }
 });

Server -seitiger Code:

/// <summary>
/// 获取状态数据信息
/// </summary>
/// <returns></returns>
[WebMethod]
public void getElevatorStatusJsonData()
{
List<List<DeviceInfo>> elevatordatas = new List<List<DeviceInfo>>();
List<SendDicdate> searchList = XmlSerializeHelper.XmlDeserializeFromFile<List<SendDicdate>>(@ConfigUtil.servicePath + ConfigUtil.getConfigByKey("xmlPath") + "查询指令信息.xml", Encoding.UTF8);
foreach (SendDicdate item in searchList)
{
string key = item.portno + "-" + item.bordrate + "-" + item.sendtype;
List<DeviceInfo> deviceInfoList = (List<DeviceInfo>)Context.Cache.Get(key);
elevatordatas.Add(deviceInfoList);
}
 
String result = "";
DataContractJsonSerializer json = new DataContractJsonSerializer(elevatordatas.GetType());
using (MemoryStream stream = new MemoryStream())
{
json.WriteObject(stream, elevatordatas);
result = Encoding.UTF8.GetString(stream.ToArray());
}
String jsoncallback = HttpContext.Current.Request["jsoncallback"];
result = jsoncallback + &#39;(&#39; + result + &#39;)&#39;;
HttpContext.Current.Response.Write(result);
HttpContext.Current.Response.End();
 
}

　c#

　Das Obige ist der Implementierungscode zum Aufrufen des C#-Servers. Die Parameter können unterschiedlich sein, aber die Prinzipien sind gleich

　java:

String callbackFunName = context.Request["callbackparam"];
　　context.Response.Write(callbackFunName + "([ { \"name\":\"John\"}])");

PS: Der JSONP-Parameter des Clients wird verwendet, um Parameter über die URL zu übergeben und den Parameternamen von zu übergeben Der jsonpCallback-Parameter ist etwas verwirrend:

jsonp: " "

jsonpCallback:""

Übrigens: Im Chrome Browser können Sie auch Header-Informationen im Serverkontext festlegen.Response.AddHeader("Access-Control-Allow-Origin" , "*"); um den Zweck domänenübergreifender Anforderungen zu erreichen, ist dies nicht erforderlich Folgende Ajax-Parameter

dataType : "jsonp",
　　jsonp: "callbackparam",
　　jsonpCallback:"jsonpCallback1"

Es können Daten über die normale Ajax-Anforderungsmethode abgerufen werden.

Nachdem ich gelesen habe, was andere erklärt haben, scheint es vernünftig: 1. Ein bekanntes Problem, das normale Dateien direkt anfordert, was zu domänenübergreifendem unbefugtem Zugriff führt . Machen Sie sich keine Sorgen. Es handelt sich um eine statische Seite, einen dynamischen Webdienst oder einen WCF Außerdem wurde festgestellt, dass es beim Aufrufen von js-Dateien auf der Webseite keinen Einfluss darauf hat, ob sie domänenübergreifend sind (Darüber hinaus haben wir festgestellt, dass alle Tags mit dem Attribut „src“ über domänenübergreifende Funktionen verfügen, z. B.

3. Man kann also davon ausgehen, dass es zum jetzigen Zeitpunkt, wenn man die reine Webseite (ActiveX-Steuerung, Server) nutzen möchte, nur eine Möglichkeit gibt, domänenübergreifend auf Daten zuzugreifen (Proxies, Websockets und andere nicht mitgezählt). Methoden, die zu zukünftigem HTML5 gehören), und das heißt, zu versuchen, die Daten in eine js-Formatdatei auf dem Remote-Server zu laden, damit sie vom Client aufgerufen und weiterverarbeitet werden können;

4. Wir wissen zufällig bereits, dass es eine gibt Ein reines Zeichendatenformat namens JSON, das komplexe Daten prägnant beschreiben kann. Was noch besser ist, ist, dass JSON auch nativ von js unterstützt wird, sodass dieses Format fast wie gewünscht auf dem Client verarbeitet werden kann Auf diese Weise ist die Lösung fertig. Der Webclient ruft die dynamisch generierte Datei im JS-Format (normalerweise mit JSON als Suffix) auf dem domänenübergreifenden Server auf, und zwar auf die gleiche Weise wie das aufrufende Skript Der Server generiert dynamisch die vom Client benötigten Daten.

　6. Nachdem der Client die JSON-Datei erfolgreich aufgerufen hat, erhält er auch die benötigten Daten Diese Methode zum Abrufen von Remote-Daten ähnelt AJAX, ist jedoch tatsächlich anders. Um dem Client die Verwendung von Daten zu erleichtern, wird er schrittweise erstellt Übertragungsprotokoll, die Leute nennen es JSONP. Einer der wichtigsten Punkte dieses Protokolls besteht darin, Benutzern die Übergabe eines Rückrufparameters an den Server zu ermöglichen. Wenn der Server dann Daten zurückgibt, verwendet er diesen Rückrufparameter als Funktionsnamen zum Umschließen des JSON Daten, sodass der Client seine eigenen Funktionen anpassen kann, um die zurückgegebenen Daten automatisch zu verarbeiten.

Intelligente Entwickler können sich leicht vorstellen, dass der Aufrufer dies tun wird, solange das vom Server bereitgestellte JS-Skript dynamisch generiert wird Gut. Sie können einen Parameter übergeben, um dem Server mitzuteilen: „Ich möchte einen JS-Code, der die XXX-Funktion aufruft, bitte geben Sie ihn an mich zurück.“ Dann kann der Server das JS-Skript entsprechend den Anforderungen des Clients generieren und antworten >