基于Java的Ajax框架之JSON-RPC(二)

最新推荐文章于 2024-03-10 13:55:44 发布
原创 最新推荐文章于 2024-03-10 13:55:44 发布 · 2.3k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#ajax框架 #java #exception #null #function #xmlhttprequest

本文介绍了一种使用 JSON-RPC 协议实现客户端与服务器间交互的方法。通过示例展示了如何配置服务器端 JSONRPCServlet 以及客户端如何通过 JSONRPCBridge 进行调用。具体包括 web.xml 的配置、TipService 类的设计、index.jsp 页面的实现及必要的 JavaScript 脚本。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

接上例：http://blog.youkuaiyun.com/kunshan_shenbin/archive/2008/11/25/3368266.aspx

这次尝试通过映射服务器端JSONRPCServlet，编写处理类来实现和客户端的交互(客户端通过JSONRPCBridge类实现交互)。

代码：

TipService.java

  1. package demo;
  3. import java.io.Serializable;
  5. public class TipService implements Serializable
  6. {
  7.     private static final long serialVersionUID = -276869945037249233L;
  8.     
  9.     private String[][] tips= 
  10.     {
  11.         {"1" , "IBM笔记本电脑，价格有点贵，<br>外观保守，适合稳重型用户。"},
  12.         {"2" , "Dell笔记本电脑，价格适中，<br>兼顾中、低端用户，有更多的<br>选择余地。"},
  13.         {"3" , "SONY笔记本电脑，源自日本，<br>细致工艺，优美的外观都是其<br>卖点，比较贵。"}
  14.     };
  16.     public String getTip(int id)
  17.     {
  18.         for (String[] tip : tips )
  19.         {
  20.             if (tip[0].equals(String.valueOf(id)))
  21.             {
  22.                 return tip[1];
  23.             }
  24.         }
  25.         return null;
  26.     }
  27. }

web.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.     xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee 
  5.     http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
  7.     <servlet>
  8.         <servlet-name>jsonServlet</servlet-name>
  9.         <servlet-class>
  10.             com.metaparadigm.jsonrpc.JSONRPCServlet
  11.         </servlet-class>
  12.     </servlet>
  14.     <!-- 此处的url-pattern可以随便更改，只是JavaScript代码中JSONRpcClient以此地址创建 -->
  15.     <servlet-mapping>
  16.         <servlet-name>jsonServlet</servlet-name>
  17.         <url-pattern>/myjson</url-pattern>
  18.     </servlet-mapping>
  20.     <welcome-file-list>
  21.         <welcome-file>index.jsp</welcome-file>
  22.     </welcome-file-list>
  23.     
  24. </web-app>

index.jsp

  1. <%@ page contentType="text/html;charset=utf-8"%>
  2. <jsp:useBean id="JSONRPCBridge" scope="session" class="com.metaparadigm.jsonrpc.JSONRPCBridge" />
  3. <jsp:useBean id="tip" scope="session" class="demo.TipService" />
  4. <% JSONRPCBridge.registerObject("tip", tip); %>
  5. <HTML>
  6. <HEAD>
  7. <TITLE>在线商场</TITLE>
  8. <META http-equiv=Content-Type content="text/html; charset=utf-8">
  9. </HEAD>
  10.     <script type="text/javascript" src="jsonrpc.js"></script>
  11.     <script type="text/javascript" src="tip.js"></script>
  12. <BODY topMargin=20 onLoad="onLoad()">
  13. <h3 align="center">请挑选您想购买的笔记本</h3>
  15. <table width="640" height="208" border="1" align="center" style="border-collapse:collapse">
  16.   <tr>
  17.     <td width="230"><img id="1" src="img/ibm.jpg" onMouseOver="getTip(this.id , event);" onMouseOut="hideTip()"/></td>
  18.     <td width="400">
  19.     <table width="400" border="0" style="font-size:10pt">
  20.        <tr>
  21.         <td><h3 align="center">ThinkPad T60 2007GT1</h3></td>
  22.       </tr>
  23.       <tr>
  24.         <td><strong>处理器: </strong>Intel Core2 Duo(Merom) T7200(2.0G)</td>
  25.       </tr>   
  26.       <tr>
  27.         <td><strong>内存容量: </strong>512M</td>
  28.       </tr>
  29.       <tr>
  30.         <td><strong>硬盘容量: </strong>120G</td>
  31.       </tr>
  32.       <tr>
  33.         <td><strong>屏幕尺寸: </strong>14.1寸</td>
  34.       </tr>
  35.       <tr>
  36.         <td><strong>显示芯片: </strong>独立,ATI Mobility Radeon X1300</td>
  37.       </tr>
  38.       <tr>
  39.         <td><strong>重量: </strong>约2.32Kg</td>
  40.       </tr>
  41.     </table></td>
  42.   </tr>
  43.   <tr>
  44.     <td><img id="2" src="img/dell.jpg"  onMouseOver="getTip(this.id , event);" onMouseOut="hideTip()"/></td>
  45.     <td>
  46.     <table width="400" border="0" style="font-size:10pt">
  47.       <tr>
  48.         <td><h3 align="center">戴尔 Inspiron 6400(N511212)</h3></td>
  49.       </tr>
  50.       <tr>
  51.         <td><strong>处理器: </strong>Intel Core2 Duo(Merom) T5500(1.66G)</td>
  52.       </tr>   
  53.       <tr>
  54.         <td><strong>内存容量: </strong>512M</td>
  55.       </tr>
  56.       <tr>
  57.         <td><strong>硬盘容量: </strong>120G</td>
  58.       </tr>
  59.       <tr>
  60.         <td><strong>屏幕尺寸: </strong>14.1寸</td>
  61.       </tr>
  62.       <tr>
  63.         <td><strong>显示芯片: </strong>独立,ATI Mobility Radeon X1300</td>
  64.       </tr>
  65.       <tr>
  66.         <td><strong>重量: </strong>约2.32Kg</td>
  67.       </tr>
  68.     </table></td>
  69.   </tr>
  70.     <tr>
  71.     <td><img id="3" src="img/sony.jpg"  onMouseOver="getTip(this.id , event);" onMouseOut="hideTip()"/></td>
  72.     <td>
  73.     <table width="400" border="0" style="font-size:10pt">
  74.       <tr>
  75.         <td><h3 align="center">索尼 VGN-AR18CP</h3></td>
  76.       </tr>
  77.       <tr>
  78.         <td><strong>处理器: </strong>Intel Core Duo(Yonah) T2600(2.16G)</td>
  79.       </tr>
  80.       <tr>
  81.         <td><strong>内存容量: </strong>2048M</td>
  82.       </tr>
  83.       <tr>
  84.         <td><strong>硬盘容量: </strong>160G</td>
  85.       </tr>
  86.       <tr>
  87.         <td><strong>屏幕尺寸: </strong>17寸</td>
  88.       </tr>
  89.       <tr>
  90.         <td><strong>显示芯片: </strong>独立,nVidia Geforce Go7600GT</td>
  91.       </tr>
  92.       <tr>
  93.         <td><strong>重量: </strong>约3.8Kg</td>
  94.       </tr> 
  95.     </table>
  96.     </td>
  97.   </tr>
  98. </table>
  99. <div id="tip" style="position:absolute; z-index:100;font-size:10pt;background-color:#eeeeaa;border:1px solid #999999" >
  100. </div>
  101. </BODY>
  102. </HTML>

jsonrpc.js（在json-rpc-java-1.0.1.zip包中可以找到，下载地址：http://oss.metaparadigm.com/jsonrpc/download.html）

  1. /*
  2.  * JSON-RPC JavaScript client
  3.  *
  4.  * $Id: jsonrpc.js,v 1.36.2.3 2006/03/08 15:09:37 mclark Exp $
  5.  *
  6.  * Copyright (c) 2003-2004 Jan-Klaas Kollhof
  7.  * Copyright (c) 2005 Michael Clark, Metaparadigm Pte Ltd
  8.  *
  9.  * This code is based on Jan-Klaas' JavaScript o lait library (jsolait).
  10.  *
  11.  * Licensed under the Apache License, Version 2.0 (the "License");
  12.  * you may not use this file except in compliance with the License.
  13.  * You may obtain a copy of the License at
  14.  *
  15.  *    http://www.apache.org/licenses/LICENSE-2.0
  16.  *
  17.  * Unless required by applicable law or agreed to in writing, software
  18.  * distributed under the License is distributed on an "AS IS" BASIS,
  19.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  20.  * See the License for the specific language governing permissions and
  21.  * limitations under the License.
  22.  *
  23.  */
  26. /* escape a character */
  28. escapeJSONChar =
  29. function escapeJSONChar(c)
  30. {
  31.     if(c == "/"" || c == "//") return "//" + c;
  32.     else if (c == "/b") return "//b";
  33.     else if (c == "/f") return "//f";
  34.     else if (c == "/n") return "//n";
  35.     else if (c == "/r") return "//r";
  36.     else if (c == "/t") return "//t";
  37.     var hex = c.charCodeAt(0).toString(16);
  38.     if(hex.length == 1) return "//u000" + hex;
  39.     else if(hex.length == 2) return "//u00" + hex;
  40.     else if(hex.length == 3) return "//u0" + hex;
  41.     else return "//u" + hex;
  42. };
  45. /* encode a string into JSON format */
  47. escapeJSONString =
  48. function escapeJSONString(s)
  49. {
  50.     /* The following should suffice but Safari's regex is b0rken
  51.        (doesn't support callback substitutions)
  52.        return "/"" + s.replace(/([^/u0020-/u007f]|[///"])/g,
  53.        escapeJSONChar) + "/"";
  54.     */
  56.     /* Rather inefficient way to do it */
  57.     var parts = s.split("");
  58.     for(var i=0; i < parts.length; i++) {
  59.     var c =parts[i];
  60.     if(c == '"' ||
  61.        c == '//' ||
  62.        c.charCodeAt(0) < 32 ||
  63.        c.charCodeAt(0) >= 128)
  64.         parts[i] = escapeJSONChar(parts[i]);
  65.     }
  66.     return "/"" + parts.join("") + "/"";
  67. };
  70. /* Marshall objects to JSON format */
  72. toJSON = function toJSON(o)
  73. {
  74.     if(o == null) {
  75.     return "null";
  76.     } else if(o.constructor == String) {
  77.     return escapeJSONString(o);
  78.     } else if(o.constructor == Number) {
  79.     return o.toString();
  80.     } else if(o.constructor == Boolean) {
  81.     return o.toString();
  82.     } else if(o.constructor == Date) {
  83.     return '{javaClass: "java.util.Date", time: ' + o.valueOf() +'}';
  84.     } else if(o.constructor == Array) {
  85.     var v = [];
  86.     for(var i = 0; i < o.length; i++) v.push(toJSON(o[i]));
  87.     return "[" + v.join(", ") + "]";
  88.     } else {
  89.     var v = [];
  90.     for(attr in o) {
  91.         if(o[attr] == null) v.push("/"" + attr + "/": null");
  92.         else if(typeof o[attr] == "function"); /* skip */
  93.         else v.push(escapeJSONString(attr) + ": " + toJSON(o[attr]));
  94.     }
  95.     return "{" + v.join(", ") + "}";
  96.     }
  97. };
  100. /* JSONRpcClient constructor */
  102. JSONRpcClient =
  103. function JSONRpcClient_ctor(serverURL, user, pass, objectID)
  104. {
  105.     this.serverURL = serverURL;
  106.     this.user = user;
  107.     this.pass = pass;
  108.     this.objectID = objectID;
  110.     /* Add standard methods */
  111.     if(this.objectID) {
  112.     this._addMethods(["listMethods"]);
  113.     var req = this._makeRequest("listMethods", []);
  114.     } else {
  115.     this._addMethods(["system.listMethods"]);
  116.     var req = this._makeRequest("system.listMethods", []);
  117.     }
  118.     var m = this._sendRequest(req);
  119.     this._addMethods(m);
  120. };
  123. /* JSONRpcCLient.Exception */
  125. JSONRpcClient.Exception =
  126. function JSONRpcClient_Exception_ctor(code, message, javaStack)
  127. {
  128.     this.code = code;
  129.     var name;
  130.     if(javaStack) {
  131.     this.javaStack = javaStack;
  132.     var m = javaStack.match(/^([^:]*)/);
  133.     if(m) name = m[0];
  134.     }
  135.     if(name) this.name = name;
  136.     else this.name = "JSONRpcClientException";
  137.     this.message = message;
  138. };
  140. JSONRpcClient.Exception.CODE_REMOTE_EXCEPTION = 490;
  141. JSONRpcClient.Exception.CODE_ERR_CLIENT = 550;
  142. JSONRpcClient.Exception.CODE_ERR_PARSE = 590;
  143. JSONRpcClient.Exception.CODE_ERR_NOMETHOD = 591;
  144. JSONRpcClient.Exception.CODE_ERR_UNMARSHALL = 592;
  145. JSONRpcClient.Exception.CODE_ERR_MARSHALL = 593;
  147. JSONRpcClient.Exception.prototype = new Error();
  149. JSONRpcClient.Exception.prototype.toString =
  150. function JSONRpcClient_Exception_toString(code, msg)
  151. {
  152.     return this.name + ": " + this.message;
  153. };
  156. /* Default top level exception handler */
  158. JSONRpcClient.default_ex_handler =
  159. function JSONRpcClient_default_ex_handler(e) { alert(e); };
  162. /* Client settable variables */
  164. JSONRpcClient.toplevel_ex_handler = JSONRpcClient.default_ex_handler;
  165. JSONRpcClient.profile_async = false;
  166. JSONRpcClient.max_req_active = 1;
  167. JSONRpcClient.requestId = 1;
  170. /* JSONRpcClient implementation */
  172. JSONRpcClient.prototype._createMethod =
  173. function JSONRpcClient_createMethod(methodName)
  174. {
  175.     var fn=function()
  176.     {
  177.     var args = [];
  178.     var callback = null;
  179.     for(var i=0;i<arguments.length;i++) args.push(arguments[i]);
  180.     if(typeof args[0] == "function") callback = args.shift();
  181.     var req = fn.client._makeRequest.call(fn.client, fn.methodName,
  182.                           args, callback);
  183.     if(callback == null) {
  184.         return fn.client._sendRequest.call(fn.client, req);
  185.     } else {
  186.         JSONRpcClient.async_requests.push(req);
  187.         JSONRpcClient.kick_async();
  188.         return req.requestId;
  189.     }
  190.     };
  191.     fn.client = this;
  192.     fn.methodName = methodName;
  193.     return fn;
  194. };
  196. JSONRpcClient.prototype._addMethods =
  197. function JSONRpcClient_addMethods(methodNames)
  198. {
  199.     for(var i=0; i<methodNames.length; i++) {
  200.     var obj = this;
  201.     var names = methodNames[i].split(".");
  202.     for(var n=0; n<names.length-1; n++) {
  203.         var name = names[n];
  204.         if(obj[name]) {
  205.         obj = obj[name];
  206.         } else {
  207.         obj[name]  = new Object();
  208.         obj = obj[name];
  209.         }
  210.     }
  211.     var name = names[names.length-1];
  212.     if(!obj[name]) {
  213.         var method = this._createMethod(methodNames[i]);
  214.         obj[name] = method;
  215.     }
  216.     }
  217. };
  219. JSONRpcClient._getCharsetFromHeaders =
  220. function JSONRpcClient_getCharsetFromHeaders(http)
  221. {
  222.     try {
  223.     var contentType = http.getResponseHeader("Content-type");
  224.     var parts = contentType.split(//s*;/s*/);
  225.     for(var i =0; i < parts.length; i++) {
  226.         if(parts[i].substring(0, 8) == "charset=")
  227.         return parts[i].substring(8, parts[i].length);
  228.     }
  229.     } catch (e) {}
  230.     return "UTF-8"; /* default */
  231. };
  233. /* Async queue globals */
  234. JSONRpcClient.async_requests = [];
  235. JSONRpcClient.async_inflight = {};
  236. JSONRpcClient.async_responses = [];
  237. JSONRpcClient.async_timeout = null;
  238. JSONRpcClient.num_req_active = 0;
  240. JSONRpcClient._async_handler =
  241. function JSONRpcClient_async_handler()
  242. {
  243.     JSONRpcClient.async_timeout = null;
  245.     while(JSONRpcClient.async_responses.length > 0) {
  246.     var res = JSONRpcClient.async_responses.shift();
  247.     if(res.canceled) continue;
  248.     if(res.profile) res.profile.dispatch = new Date();
  249.     try {
  250.         res.cb(res.result, res.ex, res.profile);
  251.     } catch(e) {
  252.         JSONRpcClient.toplevel_ex_handler(e);
  253.     }
  254.     }
  256.     while(JSONRpcClient.async_requests.length > 0 &
  257.       JSONRpcClient.num_req_active < JSONRpcClient.max_req_active) {
  258.     var req = JSONRpcClient.async_requests.shift();
  259.     if(req.canceled) continue;
  260.     req.client._sendRequest.call(req.client, req);
  261.     }
  262. };
  264. JSONRpcClient.kick_async =
  265. function JSONRpcClient_kick_async()
  266. {
  267.     if(JSONRpcClient.async_timeout == null)
  268.     JSONRpcClient.async_timeout =
  269.         setTimeout(JSONRpcClient._async_handler, 0);
  270. };
  272. JSONRpcClient.cancelRequest =
  273. function JSONRpcClient_cancelRequest(requestId)
  274. {
  275.     /* If it is in flight then mark it as canceled in the inflight map
  276.        and the XMLHttpRequest callback will discard the reply. */
  277.     if(JSONRpcClient.async_inflight[requestId]) {
  278.     JSONRpcClient.async_inflight[requestId].canceled = true;
  279.     return true;
  280.     }
  282.     /* If its not in flight yet then we can just mark it as canceled in
  283.        the the request queue and it will get discarded before being sent. */
  284.     for(var i in JSONRpcClient.async_requests) {
  285.     if(JSONRpcClient.async_requests[i].requestId == requestId) {
  286.         JSONRpcClient.async_requests[i].canceled = true;
  287.         return true;
  288.     }
  289.     }
  291.     /* It may have returned from the network and be waiting for its callback
  292.        to be dispatched, so mark it as canceled in the response queue
  293.        and the response will get discarded before calling the callback. */
  294.     for(var i in JSONRpcClient.async_responses) {
  295.     if(JSONRpcClient.async_responses[i].requestId == requestId) {
  296.         JSONRpcClient.async_responses[i].canceled = true;
  297.         return true;
  298.     }
  299.     }
  301.     return false;
  302. };
  304. JSONRpcClient.prototype._makeRequest =
  305. function JSONRpcClient_makeRequest(methodName, args, cb)
  306. {
  307.     var req = {};
  308.     req.client = this;
  309.     req.requestId = JSONRpcClient.requestId++;
  311.     var obj = {};
  312.     obj.id = req.requestId;
  313.     if (this.objectID)
  314.     obj.method = ".obj#" + this.objectID + "." + methodName;
  315.     else
  316.     obj.method = methodName;
  317.     obj.params = args;
  319.     if (cb) req.cb = cb;
  320.     if (JSONRpcClient.profile_async)
  321.     req.profile = { "submit": new Date() };
  322.     req.data = toJSON(obj);
  324.     return req;
  325. };
  327. JSONRpcClient.prototype._sendRequest =
  328. function JSONRpcClient_sendRequest(req)
  329. {
  330.     if(req.profile) req.profile.start = new Date();
  332.     /* Get free http object from the pool */
  333.     var http = JSONRpcClient.poolGetHTTPRequest();
  334.     JSONRpcClient.num_req_active++;
  336.     /* Send the request */
  337.     if (typeof(this.user) == "undefined") {
  338.     http.open("POST", this.serverURL, (req.cb != null));
  339.     } else {
  340.     http.open("POST", this.serverURL, (req.cb != null), this.user, this.pass);
  341.     }
  343.     /* setRequestHeader is missing in Opera 8 Beta */
  344.     try { http.setRequestHeader("Content-type", "text/plain"); } catch(e) {}
  346.     /* Construct call back if we have one */
  347.     if(req.cb) {
  348.     var self = this;
  349.     http.onreadystatechange = function() {
  350.         if(http.readyState == 4) {
  351.         http.onreadystatechange = function () {};
  352.         var res = { "cb": req.cb, "result": null, "ex": null};
  353.         if (req.profile) {
  354.             res.profile = req.profile;
  355.             res.profile.end = new Date();
  356.         }
  357.         try { res.result = self._handleResponse(http); }
  358.         catch(e) { res.ex = e; }
  359.         if(!JSONRpcClient.async_inflight[req.requestId].canceled)
  360.             JSONRpcClient.async_responses.push(res);
  361.         delete JSONRpcClient.async_inflight[req.requestId];
  362.         JSONRpcClient.kick_async();
  363.         }
  364.     };
  365.     } else {
  366.     http.onreadystatechange = function() {};
  367.     }
  369.     JSONRpcClient.async_inflight[req.requestId] = req;
  370.     
  371.     try {
  372.     http.send(req.data);
  373.     } catch(e) {
  374.     JSONRpcClient.poolReturnHTTPRequest(http);
  375.     JSONRpcClient.num_req_active--;
  376.     throw new JSONRpcClient.Exception
  377.         (JSONRpcClient.Exception.CODE_ERR_CLIENT, "Connection failed");
  378.     }
  380.     if(!req.cb) return this._handleResponse(http);
  381. };
  383. JSONRpcClient.prototype._handleResponse =
  384. function JSONRpcClient_handleResponse(http)
  385. {
  386.     /* Get the charset */
  387.     if(!this.charset) {
  388.     this.charset = JSONRpcClient._getCharsetFromHeaders(http);
  389.     }
  391.     /* Get request results */
  392.     var status, statusText, data;
  393.     try {
  394.     status = http.status;
  395.     statusText = http.statusText;
  396.     data = http.responseText;
  397.     } catch(e) {
  398.     JSONRpcClient.poolReturnHTTPRequest(http);
  399.     JSONRpcClient.num_req_active--;
  400.     JSONRpcClient.kick_async();
  401.     throw new JSONRpcClient.Exception
  402.         (JSONRpcClient.Exception.CODE_ERR_CLIENT, "Connection failed");
  403.     }
  405.     /* Return http object to the pool; */
  406.     JSONRpcClient.poolReturnHTTPRequest(http);
  407.     JSONRpcClient.num_req_active--;
  409.     /* Unmarshall the response */
  410.     if(status != 200) {
  411.     throw new JSONRpcClient.Exception(status, statusText);
  412.     }
  413.     var obj;
  414.     try {
  415.     eval("obj = " + data);
  416.     } catch(e) {
  417.     throw new JSONRpcClient.Exception(550, "error parsing result");
  418.     }
  419.     if(obj.error)
  420.     throw new JSONRpcClient.Exception(obj.error.code, obj.error.msg,
  421.                       obj.error.trace);
  422.     var res = obj.result;
  424.     /* Handle CallableProxy */
  425.     if(res && res.objectID && res.JSONRPCType == "CallableReference")
  426.     return new JSONRpcClient(this.serverURL, this.user,
  427.                  this.pass, res.objectID);
  429.     return res;
  430. };
  433. /* XMLHttpRequest wrapper code */
  435. /* XMLHttpRequest pool globals */
  436. JSONRpcClient.http_spare = [];
  437. JSONRpcClient.http_max_spare = 8;
  439. JSONRpcClient.poolGetHTTPRequest =
  440. function JSONRpcClient_pool_getHTTPRequest()
  441. {
  442.     if(JSONRpcClient.http_spare.length > 0) {
  443.     return JSONRpcClient.http_spare.pop();
  444.     }
  445.     return JSONRpcClient.getHTTPRequest();
  446. };
  448. JSONRpcClient.poolReturnHTTPRequest =
  449. function JSONRpcClient_poolReturnHTTPRequest(http)
  450. {
  451.     if(JSONRpcClient.http_spare.length >= JSONRpcClient.http_max_spare)
  452.     delete http;
  453.     else
  454.     JSONRpcClient.http_spare.push(http);
  455. };
  457. JSONRpcClient.msxmlNames = [ "MSXML2.XMLHTTP.5.0",
  458.                  "MSXML2.XMLHTTP.4.0",
  459.                  "MSXML2.XMLHTTP.3.0",
  460.                  "MSXML2.XMLHTTP",
  461.                  "Microsoft.XMLHTTP" ];
  463. JSONRpcClient.getHTTPRequest =
  464. function JSONRpcClient_getHTTPRequest()
  465. {
  466.     /* Mozilla XMLHttpRequest */
  467.     try {
  468.     JSONRpcClient.httpObjectName = "XMLHttpRequest";
  469.     return new XMLHttpRequest();
  470.     } catch(e) {}
  472.     /* Microsoft MSXML ActiveX */
  473.     for (var i=0;i < JSONRpcClient.msxmlNames.length; i++) {
  474.     try {
  475.         JSONRpcClient.httpObjectName = JSONRpcClient.msxmlNames[i];
  476.         return new ActiveXObject(JSONRpcClient.msxmlNames[i]);
  477.     } catch (e) {}
  478.     }
  480.     /* None found */
  481.     JSONRpcClient.httpObjectName = null;
  482.     throw new JSONRpcClient.Exception(0, "Can't create XMLHttpRequest object");
  483. };

tip.js

  1. var jsonrpc;
  2. var tipDiv;
  3. var top;
  4. var left;
  5. function onLoad()
  6. {
  7.     jsonrpc = new JSONRpcClient("myjson");
  8. }
  9. function getTip(id , event)
  10. {
  11.     if (navigator.appName == "Microsoft Internet Explorer")
  12.     {
  13.         left = event.x;
  14.         top = event.y;
  15.     }
  16.     else
  17.     {
  18.         left = event.pageX;
  19.         top = event.pageY;
  20.     }
  21.     tipDiv = document.getElementById("tip");
  22.     jsonrpc.tip.getTip(cb, id);
  23.     tipDiv.style.left = left;
  24.     tipDiv.style.top = top;
  25.     tipDiv.style.display = "";
  26. }
  27. function cb(result, exception)
  28. {
  29.     if(result == null && exception != null)
  30.     {
  31.         alert(exception.message);
  32.     }
  33.     if (result != null && exception == null)
  34.     {
  35.         tipDiv.innerHTML=result;
  36.     }
  37. }
  38. function hideTip()
  39. {
  40.     tipDiv.style.display = "none";
  41. }
使用JSON-RPC-Java完成Ajax交互
IT_Farmer2010的专栏
03-07 4282
JSON-RPC-Java是一个开源Ajax框架，能够让javascript直接调用后台的Java程序。下载地址：http://oss.metaparadigm.com/jsonrpc 注意：构筑工程需要用到jsonrpc-1.0.jar，以及开源包webapps/jsonrpc下jsonrpc.js文件。web.xml文件：jsonServletcom.metapa
ajax jsonrpc包的使用
12-18
在网络上搜到整理的，我用这个ajax jsonrpc包实现了在当前页面判断用户是否存在。
ajax框架--jsonrpc-JSON-RPC框架的使用步骤
www.wushuning.com
04-27 2484
公司框架中集成了jsonrpc框架，所以研究了一下，下面是在讲解公司框架的时候写的一个关于jsonrpc使用流程的一个简单例子   使用步骤 1.在jsp中导入jsonrpc.js 2.导入jsonrpc.jar包 3.配置servlet       JSONRPCServlet  com.metaparadigm.jsonrpc.JSONRPCServlet
ajax－json-rpc处理过程
junctioner的专栏
12-28 1416
在web.xml文件中，可以发现      com.metaparadigm.jsonrpc.JSONRPCServlet    /JSON-RPC  所有的请求提交到这个Servlet后分发处理并做出响应。JSONRPCServlet.java中实现了init()和service()，init() 中只是取了些配置参数作了相关设置；service() 中实现了请求处理；1.从session中创建
基于Java的Ajax框架之JSON-RPC(一)
【昆山人在上海】
11-25 1743
官方主页：http://oss.metaparadigm.com/jsonrpc/先看一个简单的例子：如下图所示建立工程：代码如下：web.xmlxml version="1.0" encoding="UTF-8"?>web-app version="2.4"     xmlns="http://java.sun.com/xml/ns/j2ee"    
AJAX JSON-RPC + MYSQL 数据库登陆和查询操作
zjh0588
08-16 293
第一步: 建立mysql 数据库,创建noteuser表和增加1条信息sql 代码CREATE TABLE `noteuser` (      `userid` int(5) NOT NULL auto_increment,      `username` varchar(16) character set utf8 default NULL,      `password` varchar(16...
JSON-RPC for Java使用说明1
08-04
JSON-RPC for Java是用于Java平台的一个轻量级、零入侵的远程过程调用（RPC）框架，特别适合于AJAX应用中的级联调用。本文档将详细介绍如何在Java项目中使用JSON-RPC，包括引入依赖库、创建服务类、自定义基类以及在...
Java实现的JSON-RPC框架实例解析
JSON-RPC-Java是一个在Java中实现JSON-RPC协议的框架，JSON-RPC是一种轻量级的远程过程调用（RPC）协议，它基于JSON（JavaScript Object Notation）进行数据交换。JSON-RPC允许客户端和服务器通过简单的JSON对象进行...
Java AJAX框架技术详解：DWR、AJAXTags、StrutsAjaxTags、AjaxAnywhere和JSON-RPC-Java
JSON-RPC-Java可运行在Servlet容器中，如Tomcat，也可以运行在JBoss与其他J2EE应用服务器中，因此可以在一个基于JavaScript与DHTML的Web应用程序中利用它来直接调用普遍的Java代码。 这些Java开源AJAX框架和组件...
Java开发中json-rpc的常用jar包
使用jsonrpc4j库，Java开发者可以创建服务端接口，这些接口能够接收JSON-RPC调用，执行相应的Java方法，并返回结果。对于客户端开发，可以使用相同的库来构建需要与服务端通信的代码。通过这种方式，Java开发者可以...
json-rpc.jar 和 jsonrpc.js
03-23
JSON-RPC-Java是一个用Java来实现动态JSON-RPC的框架. 利用它内置的一个轻级量JSON-RPC JavaScripIt客户端,可以让你透明地在JavaScript中调用Java代码。JSON-RPC-Java可运行在Servlet容器中如Tomcat也可以运行在...
JSON-RPC用户手册
05-24
JSON-RPC用户手册
springboot jsonrpc server
10-09
非常适合java springboot好用的jsonrpc服务。 客户端调用： Content-Type：application/json {"id":"1","jsonrpc":"2.0","method":"multiplier","params":[5,8]} 服务端返回：{ "jsonrpc": "2.0", "id": "1", "result": 40 }
基于Java的Ajax框架之JSON-RPC(三)
【昆山人在上海】
11-25 1340
接上例：http://blog.csdn.net/kunshan_shenbin/archive/2008/11/25/3368686.aspx这次讲解一下关于获得集合返回值的方法。如下图所示建立工程：代码如下：Hello.javapackage lee;import java.io.Serializable;import java.util.*;
ajax 技术（jsonrpc buffalo） 与tapestry（5）的简单快速集成使用
lococode
04-10 186
     前几天在项目中需要用到一些ajax 的东西，之前也有用过dwr ，这次想看看其他也些ajax的技术，有什么不同和特殊之处，于是就看了看  jsonrpc 和buffalo ，用起来，突然发现，他们的使用方法，基本上差不多。这里以一个例子做简单的介绍，希望对一些朋友能有所帮助，同时也是对我之前的两篇关于tapestry以及maven的文章的补充（当然，那一系列的文章我还会继续写的）    ...
AJAX RPC
liuleigang1107的专栏
03-27 411
DWR(Direct Web Remoting DWR(Direct Web Remoting)是一个WEB远程调用框架.利用这个框架可以让AJAX开发变得很简单. DWR 是一个开放源码的使用 Apache 许可协议的解决方案，它包含服务器端 Java 库、一个 DWR servlet 以及 JavaScript 库。 虽然 DWR 不是 Java 平台上唯一可用的 Ajax-R...
jsonRPC
weixin_30273763的博客
09-01 126
jsonRPC重新整理： __call php内置函数： 当请求一个对象的方法不存在是会调用此方法： /* *@param string $method 请求方法名称。 *@param array $params 请求方法的参数。 */function __call ($method,$params); server.php(服务器) <?php hea...
jQuery JSONRPC
最新发布
gitblog_00010的博客
03-10 413
jQuery JSONRPC jQuery JSONRPC 是一个轻量级的 JavaScript 库，用于实现 JSON-RPC 协议与服务器进行通信。JSON-RPC 是一种基于 JSON 的远程过程调用（RPC）协议，可以让你轻松地通过 HTTP 请求在客户端和服务器之间交换数据。 项目简介 jQuery JSONRPC 提供了一种简单易用的方式来处理 JSON-RPC 调用，它封装了请求的创...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值