精华内容
下载资源
问答
  • ##jsonrpc.js JSON RPC 客户端在 javascript 中的实现 ##用法 创建客户端对象 var client = new JSONRPC ( { host : "localhost:3001" } ) ; 其他可用选项 host : rpc host transport: used transport , ...
  • Atitit.js javascriptrpc框架选型.pdf
  • javascriptRPC。 得到它 npm i js-obj-rpc 在Node.js中 直接要求包装。 var RPC = require ( 'js-obj-rpc' ) ; 在浏览器中 npm i --dev npm run build 然后使用dist目录中的脚本 < script src =" ***/dist/...
  • 在配置好基本环境之后,运行npm run rpc,生成调用的 proxy 文件时提示以下错误: 这个是阿里文档没有提到了一个坑: 必须在package.json文件最外层添加,这个egg-int工具并不会帮建这个。 egg: { framework: sofa...
  • Atitit.js javascriptrpc框架选型 1. Dwr1 2. 使用AJAXRPC1 2.2. 数据类型映射表1 3. json-rpc轻量级远程调用协议介绍及使用2 3.1. 2.3、JavaScript客户端调用示例2 3.2. 2.4、直接GET请求进行调用2...

    Atitit.js javascriptrpc框架选型

     

    1. Dwr1

    2. 使用AJAXRPC1

    2.2. 数据类型映射表1

    3. json-rpc轻量级远程调用协议介绍及使用2

    3.1. 2.3、JavaScript客户端调用示例2

    3.2. 2.4、直接GET请求进行调用2

    4. atiri3

     

     

    1. Dwr

    Dwr要自己一个method挑选了,麻烦的..

     

     

    2. 使用AJAXRPC

    在调用RPC方法时,如果没有传递回调函数,则是同步调用;如果传递回调函数,则是异步调用。

    2.1.1.1. 同步调用

    2.1. 数据类型映射表

    AJAXRPC支持基本数据类型、自定义类,不支持泛型。

    Javascript

    Java

    .Net

    Php

    说明

    Number

    Short,short
    Integer,int
    Long,long
    Float,float
    Double,double

    short,Int16
    int,Int32
    long,Int64
    float
    Double,double

    Integer
    Float
    Double

    数字类型之间没有严格的界限,可以任意转换

    Boolean

    Boolean,boolean

    Boolean,bool

    Boolean

     

    String

    String

    String,string

    String

     

    Date

    Date

    DateTime

    String

    日期字符串”Y-m-d\TH:i:s“格式,php需要额外处理

    Object

    HashMap,Map

    Hashtable,IDictionary

    Object

     

    Array

    ArrayList,List

    ArrayList,IList

    Array

     

    null

    null

    null

    NULL

     

    AjaxRPC开发者知不知道静态方法和实例方法的差别?!! 
    静态方法在内存始终都有一份拷贝,也就意味着内存始终被耗用,无法释放,同时静态方法不利于调试

     

    作者::  ★(attilax)>>>   绰号:老哇的爪子  全名::Attilax Akbar Al Rapanui 阿提拉克斯 阿克巴 阿尔 拉帕努伊  汉字名:艾龙,  EMAIL:1466519819@qq.com

    转载请注明来源: http://blog.csdn.net/attilax

     

    3. json-rpc轻量级远程调用协议介绍及使用

    这个项目能够帮助开发人员利用Java编程语言轻松实现JSON-RPC远程调用

     

    json-rpc协议非常简单,发起远程调用时向服务端传输数据格式如下:

       { "method": "sayHello", "params": ["Hello JSON-RPC"], "id": 1}

     

    3.1. 2.3、JavaScript客户端调用示例

    基于jsonrpcjs的JavaScript客户端调用示例:

    var rpc = new jsonrpc.JsonRpc('http://127.0.0.1:8080/index.json');

    rpc.call('getSystemProperties'function(result){

    alert(result);

    });

     

    3.2. 2.4、直接GET请求进行调用

    无需任何客户端,只需手工拼接参数进行远程调用,请求URL如下:

    http://127.0.0.1:8080/index.json?method=getSystemProperties&id=3325235235235¶ms=JTViJTVk

    参数说明:

    method : 方法名

    params :调用参数,json的数组格式[], 将参数需先进行url编码,再进行base64编码

    id : 调用标识符,任意值

     

     

    4. atiri

    转载于:https://www.cnblogs.com/attilax/p/5963317.html

    展开全文
  • thrift rpc js使用

    千次阅读 2018-12-07 11:04:37
    一、thrift js使用方式 使用thrift js时,PRotocol需要使用TJSONPRotocol/TBinaryProtocol协议,Thrift.Protocol对应的是TJSONPRotocol。Transport需要使用TXHRTransport/TWebSocketTransport通道,Thrift.Transport...

    一、thrift js使用方式
    使用thrift js时,PRotocol需要使用TJSONPRotocol/TBinaryProtocol协议,Thrift.Protocol对应的是TJSONPRotocol。Transport需要使用TXHRTransport/TWebSocketTransport通道,Thrift.Transport对应的是TXHRTransport。
    thrift-0.10.0源代码中的js代码在thrift-0.10.0\lib\js目录中。test目录下的src目录是java程序,test.html是测试页面。
    thrift js使用场景:
    Node.js JavaScript 服务端(Node.js本身支持http协议),thrift js客户端
    java或vertx等服务端(需要支持http协议),thrift js客户端

    二、实例
    1、书写test.thrift接口,使用thrift-0.10.0.exe生成java、js的数据结构和代理类。
    2、java程序
    2.1、java程序中,实现Iface接口方法。
    2.2、java服务器程序
    Httpd.java

    package www.junchen.com;
    
    import java.io.File;
    import java.io.IOException;
    import java.io.InterruptedIOException;
    import java.io.OutputStream;
    import java.io.OutputStreamWriter;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.net.URLDecoder;
    import java.util.Collection;
    import java.util.Iterator;
    import java.util.Locale;
    
    import org.apache.http.ConnectionClosedException;
    import org.apache.http.HttpEntity;
    import org.apache.http.HttpEntityEnclosingRequest;
    import org.apache.http.HttpException;
    import org.apache.http.HttpRequest;
    import org.apache.http.HttpResponse;
    import org.apache.http.HttpServerConnection;
    import org.apache.http.HttpStatus;
    import org.apache.http.MethodNotSupportedException;
    import org.apache.http.entity.ContentProducer;
    import org.apache.http.entity.EntityTemplate;
    import org.apache.http.entity.FileEntity;
    import org.apache.http.impl.DefaultHttpResponseFactory;
    import org.apache.http.impl.DefaultHttpServerConnection;
    import org.apache.http.impl.NoConnectionReuseStrategy;
    import org.apache.http.params.BasicHttpParams;
    import org.apache.http.params.CoreConnectionPNames;
    import org.apache.http.params.CoreProtocolPNames;
    import org.apache.http.params.HttpParams;
    import org.apache.http.protocol.BasicHttpContext;
    import org.apache.http.protocol.BasicHttpProcessor;
    import org.apache.http.protocol.HttpContext;
    import org.apache.http.protocol.HttpProcessor;
    import org.apache.http.protocol.HttpRequestHandler;
    import org.apache.http.protocol.HttpRequestHandlerRegistry;
    import org.apache.http.protocol.HttpService;
    import org.apache.http.util.EntityUtils;
    import org.apache.thrift.TProcessor;
    import org.apache.thrift.protocol.TJSONProtocol;
    import org.apache.thrift.protocol.TProtocol;
    import org.apache.thrift.transport.TMemoryBuffer;
    
    import eu.medsea.mimeutil.MimeType;
    import eu.medsea.mimeutil.MimeUtil2;
    import eu.medsea.mimeutil.detector.ExtensionMimeDetector;
    
    public class Httpd {
    
    	/**
    	 * @param args
    	 * @throws IOException 
    	 */
    	public static void main(String[] args) throws IOException {
    		// TODO Auto-generated method stub
            if (args.length < 1) {
                System.err.println("Please specify document root directory");
                System.exit(1);
            }
            Thread t = new RequestListenerThread(9090, args[0]);
            t.setDaemon(false);
            t.start();
    	}
    
        static class HttpFileHandler implements HttpRequestHandler {
    
            private final String docRoot;
    
            public HttpFileHandler(final String docRoot) {
                super();
                this.docRoot = docRoot;
            }
    
            public void handle(final HttpRequest request, final HttpResponse response, final HttpContext context) throws HttpException, IOException {
    
                String method = request.getRequestLine().getMethod().toUpperCase(Locale.ENGLISH);
                if (!method.equals("GET") && !method.equals("HEAD") && !method.equals("POST")) {
                    throw new MethodNotSupportedException(method + " method not supported");
                }
                String target = request.getRequestLine().getUri();
    
                if (request instanceof HttpEntityEnclosingRequest && target.equals("/service")) {
                    HttpEntity entity = ((HttpEntityEnclosingRequest) request).getEntity();
                    byte[] entityContent = EntityUtils.toByteArray(entity);
                    System.out.println("Incoming content: " + new String(entityContent));
                    
                    final String output = this.thriftRequest(entityContent);
                    
                    System.out.println("Outgoing content: "+output);
                    ContentProducer producer = new ContentProducer() {
    
    					@Override
    					public void writeTo(OutputStream outstream) throws IOException {
    						// TODO Auto-generated method stub
                            OutputStreamWriter writer = new OutputStreamWriter(outstream, "UTF-8");
                            writer.write(output);
                            writer.flush();
    					}
                    };
                    EntityTemplate body = new EntityTemplate(producer);
                    body.setContentType("text/html; charset=UTF-8");
                    response.setEntity(body);
                } else {
                    if(target.indexOf("?") != -1) {
                     target = target.substring(1, target.indexOf("?"));
                    }
    
                    final File file = new File(this.docRoot, URLDecoder.decode(target, "UTF-8"));
    
                    if (!file.exists()) {
    
                        response.setStatusCode(HttpStatus.SC_NOT_FOUND);
                        EntityTemplate body = new EntityTemplate(new ContentProducer() {
    
                            public void writeTo(final OutputStream outstream) throws IOException {
                                OutputStreamWriter writer = new OutputStreamWriter(outstream, "UTF-8");
                                writer.write("<html><body><h1>");
                                writer.write("File ");
                                writer.write(file.getPath());
                                writer.write(" not found");
                                writer.write("</h1></body></html>");
                                writer.flush();
                            }
    
                        });
                        body.setContentType("text/html; charset=UTF-8");
                        response.setEntity(body);
                        System.out.println("File " + file.getPath() + " not found");
    
                    } else if (!file.canRead() || file.isDirectory()) {
    
                        response.setStatusCode(HttpStatus.SC_FORBIDDEN);
                        EntityTemplate body = new EntityTemplate(new ContentProducer() {
    
                            public void writeTo(final OutputStream outstream) throws IOException {
                                OutputStreamWriter writer = new OutputStreamWriter(outstream, "UTF-8");
                                writer.write("<html><body><h1>");
                                writer.write("Access denied");
                                writer.write("</h1></body></html>");
                                writer.flush();
                            }
    
                        });
                        body.setContentType("text/html; charset=UTF-8");
                        response.setEntity(body);
                        System.out.println("Cannot read file " + file.getPath());
    
                    } else {
    
                        String mimeType = "application/octet-stream";
                        MimeUtil2 mimeUtil = new MimeUtil2();
                        synchronized (this) {
                            mimeUtil.registerMimeDetector(ExtensionMimeDetector.class.getName());
                        }
                        Collection<MimeType> collection = mimeUtil.getMimeTypes(file);
                        Iterator<MimeType> iterator = collection.iterator();
                        while(iterator.hasNext()) {
                            MimeType mt = iterator.next();
                            mimeType =  mt.getMediaType() + "/" + mt.getSubType();
                            break;
                        }
    
                        response.setStatusCode(HttpStatus.SC_OK);
                        FileEntity body = new FileEntity(file, mimeType);
                        response.addHeader("Content-Type", mimeType);
                        response.setEntity(body);
                        System.out.println("Serving file " + file.getPath());
    
                    }
                }
            }
            
            private String thriftRequest(byte[] input){
                try{
                
                    //Input
                    TMemoryBuffer inbuffer = new TMemoryBuffer(input.length);           
                    inbuffer.write(input);              
                    TProtocol  inprotocol   = new TJSONProtocol(inbuffer);                   
                    
                    //Output
                    TMemoryBuffer outbuffer = new TMemoryBuffer(100);           
                    TProtocol outprotocol   = new TJSONProtocol(outbuffer);
                    
                    TProcessor processor = new Test.Processor(new TestImpl());      
                    processor.process(inprotocol, outprotocol);
                    
                    byte[] output = new byte[outbuffer.length()];
                    outbuffer.readAll(output, 0, output.length);
                
                    return new String(output,"UTF-8");
                }catch(Throwable t){
                    return "Error:"+t.getMessage();
                }
                 
                         
            }
            
        }
    
        static class RequestListenerThread extends Thread {
    
            private final ServerSocket serversocket;
            private final HttpParams params;
            private final HttpService httpService;
            private final String docroot;
    
            public RequestListenerThread(int port, final String docroot) throws IOException {
            	this.docroot = docroot;
                this.serversocket = new ServerSocket(port);
                this.params = new BasicHttpParams();
                this.params.setIntParameter(CoreConnectionPNames.SO_TIMEOUT, 1000).setIntParameter(CoreConnectionPNames.SOCKET_BUFFER_SIZE, 8 * 1024)
                        .setBooleanParameter(CoreConnectionPNames.STALE_CONNECTION_CHECK, false).setBooleanParameter(CoreConnectionPNames.TCP_NODELAY, true)
                        .setParameter(CoreProtocolPNames.ORIGIN_SERVER, "HttpComponents/1.1");
    
                // Set up the HTTP protocol processor
                HttpProcessor httpproc = new BasicHttpProcessor();
    
                // Set up request handlers
                HttpRequestHandlerRegistry reqistry = new HttpRequestHandlerRegistry();
                reqistry.register("*", new HttpFileHandler(docroot));
    
                // Set up the HTTP service
                this.httpService = new HttpService(httpproc, new NoConnectionReuseStrategy(), new DefaultHttpResponseFactory());
                this.httpService.setParams(this.params);
                this.httpService.setHandlerResolver(reqistry);
            }
    
            public void run() {
                System.out.println("Listening on port " + this.serversocket.getLocalPort());
                System.out.println("Point your browser to http://localhost:9090/thrift-web-test/test.html");
                
                while (!Thread.interrupted()) {
                    try {
                        // Set up HTTP connection
                        Socket socket = this.serversocket.accept();
                        DefaultHttpServerConnection conn = new DefaultHttpServerConnection();
                        System.out.println("Incoming connection from " + socket.getInetAddress());
                        conn.bind(socket, this.params);
    
                        // Start worker thread
                        Thread t = new WorkerThread(this.httpService, conn);
                        t.setDaemon(true);
                        t.start();
                    } catch (InterruptedIOException ex) {
                        break;
                    } catch (IOException e) {
                        System.err.println("I/O error initialising connection thread: " + e.getMessage());
                        break;
                    }
                }
            }
        }
    
        static class WorkerThread extends Thread {
    
            private final HttpService httpservice;
            private final HttpServerConnection conn;
    
            public WorkerThread(final HttpService httpservice, final HttpServerConnection conn) {
                super();
                this.httpservice = httpservice;
                this.conn = conn;
            }
    
            public void run() {
                System.out.println("New connection thread");
                HttpContext context = new BasicHttpContext(null);
                try {
                    while (!Thread.interrupted() && this.conn.isOpen()) {
                        this.httpservice.handleRequest(this.conn, context);
                    }
                } catch (ConnectionClosedException ex) {
                    System.err.println("Client closed connection");
                } catch (IOException ex) {
                    System.err.println("I/O error: " + ex.getMessage());
                } catch (HttpException ex) {
                    System.err.println("Unrecoverable HTTP protocol violation: " + ex.getMessage());
                } finally {
                    try {
                        this.conn.shutdown();
                    } catch (IOException ignore) {
                    }
                }
            }
    
        }
    }

    上面程序依赖于thrift-0.10.0代码和一些jar包。如下图:

    3、html页面
    test.html

     <!DOCTYPE html>
        <html lang="en">
          <head>
            <meta charset="utf-8">
            <title>Hello Thrift</title>
          </head>
          <body>
            number1: <input type="text" id="number1">
            number2: <input type="text" id="number2">
            result: <input type="text" id="result">
            <input type="button" id="add" value="add" >
            <div id="output"></div>
      
            <script src="thrift.js"></script>
            <script src="gen-js/test_types.js"></script>
            <script src="gen-js/Test.js"></script>
            <script>
              (function() {
                //var transport = new Thrift.Transport("http://localhost:9090/service");
                var transport = new Thrift.Transport("/service");
                var protocol  = new Thrift.TJSONProtocol(transport);
                var client    = new TestClient(protocol);
                var number1 = document.getElementById("number1");
                var number2 = document.getElementById("number2");
                var resultElement = document.getElementById("result");
                var outputElement = document.getElementById("output");
                document.getElementById("add").addEventListener("click", function(){
                    client.add(number1.value,number2.value, function(result) {
                      outputElement.innerHTML = result;
                      resultElement.value = result;
                    });
                  });
              })();
            </script>
          </body>
        </html>

    注意:
    1)、将web页面,包含thrift.js等资源文件拷贝到一个目录下。
    2)、执行java程序时,需要指定对应的web页面的根目录,比如d:
    3)、跨域问题,将web页面放到java程序配置的程序目录中。
    完整代码下载

    展开全文
  • Display your Spotify status as a Discord Rich Presence using the RPC API
  • simple-jsonrpc-js 客户端和服务器。 支持websocket和http。 完全支持JSON-RPC 2.0(包括自动递增的请求ID) 最初由创建。 () ( )编写的一些更新 浏览器快速入门 为了在浏览器中使用,您可以从CDNSwift将其...
  • javascriptRPC

    2019-07-28 06:18:18
    NULL 博文链接:https://zhaoshijie.iteye.com/blog/786259
  • 跨域 JavaScript 的 XML-RPC 库。 基于 Carlos Eduardo Goncalves 最初编写的 Mimic JS 库; 许可证见下文。 为 XML-RPC 提供易于使用的面向对象的接口。 将对象透明地转换为 JS 文字是实用的(例如 String('abc'...
  • Node中使用RPC

    2021-09-25 16:41:40
    使用第三方组件:pomelo-rpc-ws Demo下载 启动服务端: #进入server目录,执行命令: node app 如下图: 启动客户端: #进入client目录,执行命令: node app 如下图:

    使用第三方组件:pomelo-rpc-ws

    代码下载


    启动服务端:

    #进入server目录,执行命令:

    node app

    如下图:

    启动客户端:

    #进入client目录,执行命令:

    node app

    如下图:

    展开全文
  • SOFARPC 是蚂蚁金服开源的一个高可扩展性、高性能、生产级的 Java RPC 框架,提供了丰富的模型抽象和可扩展接口,包括过滤器、路由、负载均衡等等,致力于简化应用之间的 RPC 调用,为应用提供方便透明、稳定高效的...

    一、前言

    SOFARPC 是蚂蚁金服开源的一个高可扩展性、高性能、生产级的 Java RPC 框架,提供了丰富的模型抽象和可扩展接口,包括过滤器、路由、负载均衡等等,致力于简化应用之间的 RPC 调用,为应用提供方便透明、稳定高效的点对点远程服务调用方案。

    egg.js作为一个成熟的开源项目,清晰的定义了从配置、路由、扩展、中间件到控制器、定时任务等各个 Web 应用研发过程中一些最基础的概念,这样不同团队的开发者使用框架写出来的代码风格会更一致,接手老项目的上手成本也会更低。

    本文将简单介绍egg.js和sofa(Java)的相互作用,利用sofarpc的开源,展现一个初步的node.js RPC 解决方案。

    二、RPC介绍

    RPC (Remote Procedure Call) 即 远程过程调用,就是像调用本地的函数一样去调用远程的函数。简单讲,就是本地调用的逻辑处理的过程放在的远程的机器上,而不是本地服务代理来处理。

    其实 HTTP 也可以实现远程调用的效果,那么 HTTP 与 RPC 到底是什么关系呢?有什么区别呢?

    经过了解,我们发现RPC 和 HTTP 其实是不在同一个层级的概念。

    (一)RPC与HTTP区别

    RPC 通常所讲是一个框架

    结合上图,阿里对RPC开源RPC框架sofa优点的解读,我们了解到,RPC 也可以基于 HTTP 实现,如上图 GRPC ,就是 google 基于 HTTP2.0协议,RPC 也可以基于 TCP,Sockets实现。

    gRPC is a modern open source high performance RPC framework that can run in any environment. It can efficiently connect services in and across data centers with pluggable support for load balancing, tracing, health checking and authentication. It is also applicable in last mile of distributed computing to connect devices, mobile applications and browsers to backend services.

    而 HTTP(HyperText Transfer Protocol) 是基于 TCP 的实现的超文本传输协议,HTTP 是无状态协议;最初用于浏览器与服务器的通信,后来广泛用于各个服务间的通信。

    RPC远程过程调用RPC框架可以的通信过程可以使用各种通信协议(如 HTTP,TCP以及各种自定义协议)实现。

    简单来说,成熟的rpc库相对http容器,更多的是封装了“服务发现”,"负载均衡",“熔断降级”一类面向服务的高级特性,rpc框架是面向服务的更高级的封装。如果把一个http servlet容器上封装一层服务发现和函数代理调用,那它就已经可以做一个rpc框架了。
    所以为什么要用rpc调用?因为良好的rpc调用是面向服务的封装,针对服务的可用性和效率等都做了优化。单纯使用http调用则缺少了这些特性。

    这里可以关注知乎了解更多:既然有 HTTP 请求,为什么还要用 RPC 调用?

    三、Nodejs有哪些比较流行的 RPC 框架?

    1. grpc —— grpc.io, 这个是国外比较流行的,有 google 背书,支持多语言,听说使用的公司也比较多,看上去是比较成熟的框架。
    2. sofa —— tech.antfin.com/sofa 这个是国内阿里开源的,目前阿里开源的 Eggjs 框架也开源了基于 sofa 的最佳实践。
    3. DUBBO —— 阿里开源的 java RPC 框架

    四、实践

    基于“Eggjs 和 SOFA 的跨语言互调” 我们尝试了 Eggjs 下的 rpc 调用。

    (一)zookeeper介绍

    回到最初看 RPC 的原理, Client 端没有向 Server 端发起通信,而是需要Client Stub 和 Server Stub的桥接,完成 Client 和 Server 的通信; 问题来了:

    1. Client Stub 和 Server Stub的桥接过程中如何找到对应的 Server?(服务地址储存
    2. Server 接收到请求后,Client如何接收处理结果?(服务状态感知

    Zookeeper 在此实现的框架上的作用就是解决上面两个问题,详情可参考:ketao1989.github.io/2016/12/10/…

    对比起 http 服务里面,我们有一个配套的支撑基础组件叫做DNS,其根据域名找到某几个外网ip地址。然后,请求打到网站内部,一般首先到nginx群,nginx也会根据url规则找到配置好的一组ip地址,此外,nginx根据healthcheck来检查http服务是否可用。

    Zookeeper 在解决服务地址储存的所做事情就如DNS和 nginx一样。 接下来主要从 “node服务 ——> Java 服务“ 和 “ Java 服务 ——> node服务” (使用sofa调用)来尝试

    1. 配置

    • 通过 egg-init 初始化项目脚手架,选择 simple 模板,接下来根据实际情况填写必要信息。
    $ egg-init
    
    ? Please select a boilerplate type (Use arrow keys)
     ──────────────
    ❯ simple - Simple egg app boilerplate
     ts - Simple egg && typescript app boilerplate
     empty - Empty egg app boilerplate
     plugin - egg plugin boilerplate
     framework - egg framework boilerplate   
    复制代码
    • 进入生成好的项目目录,并安装依赖

    • 安装 egg-sofa-rpc 插件和 egg-rpc-generator 工具
      $ npm i egg-sofa-rpc --save
      $ npm i egg-rpc-generator --save-dev

    • 配置 package.json 的 scripts 节点,增加一个命令 "rpc": "egg-rpc-generator"

    {
     "scripts": {
       "dev": "egg-bin dev",
       "rpc": "egg-rpc-generator"
     }
    }
    复制代码

    补充下在阿里的文档没有提到的一点:必须在package.json文件最外层添加,这个egg-int工具并不会帮建这个。

    "egg": {
       "framework": "sofa-node"
     }
    复制代码
    • 配置 config/plugin.js 开启 egg-sofa-rpc 插件
    // config/plugin.js
    
    exports.sofaRpc = {
    enable: true,
    package: 'egg-sofa-rpc',
    };
    复制代码
    • config/config.default.js 配置zookeeper
    // config/config.default.js
    'use strict';
    
    exports.sofaRpc = {
    registry: {
      address: '127.0.0.1:2181', // zk 地址指向本地 2181 端口
    },
    };
    复制代码

    2.配置接口

    ProtoService.proto

    syntax = "proto3";
    
    package com.alipay.sofa.rpc.protobuf;
    option java_multiple_files = true; // 可选
    option java_outer_classname = "ProtoServiceModels"; // 可选
    
    service ProtoService {
        rpc echoObj (EchoRequest) returns (EchoResponse) {}
    }
    
    message EchoRequest {
        string name = 1;
        Group group = 2;
    }
    
    message EchoResponse {
        int32 code = 1;
        string message = 2;
    }
    
    enum Group {
        A = 0;
        B = 1;
    }
    复制代码

    上面这个 ProtoService.proto 文件定义了一个服务:实际上就是需要调用 Java 项目中com.alipay.sofa.rpc.protobuf.ProtoService,它有一个叫 echoObj 的方法,入口参数类型是 EchoRequest,返回值类型是 EchoResponse。

    该 Java 项目在此 Eggjs RPC Example

    (二)protobuf

    1.protobuf 是什么?

    Protocol buffers 是一种语言中立,平台无关,可扩展的序列化数据的格式,可用于通信协议,数据存储等。 Protocol buffers 在序列化数据方面,它是灵活的,高效的。相比于 XML 来说,Protocol buffers 更加小巧,更加快速,更加简单。一旦定义了要处理的数据的数据结构之后,就可以利用 Protocol buffers 的代码生成工具生成相关的代码。甚至可以在无需重新部署程序的情况下更新数据结构。只需使用 Protobuf 对数据结构进行一次描述,即可利用各种不同语言或从各种不同数据流中对你的结构化数据轻松读写。 它很适合做数据存储或 RPC数据交换格式。可用于通讯协议、数据存储等领域的语言无关、平台无关、可扩展的序列化结构数据格式。目前提供了 C++、Java、Python 三种语言的 API。

    protobuf在数据序列化的应用有以下几方面:

    • 在 config/proxy.js 中配置要调用的服务信息:
        'use strict';
        
        module.exports = {
          services: [{
            appName: 'sofarpc',
            api: {
              ProtoService: 'com.alipay.sofa.rpc.protobuf.ProtoService',
            },
          }],
        };
    复制代码
    • 在根目录下运行 npm run rpc,生成调用的 proxy 文:
        $ npm run rpc
        > rpc-demo@1.0.0 rpc /egg-rpc-demo
        > egg-rpc-generator
        [EggRpcGenerator] framework: /egg-rpc-demo/node_modules/egg, baseDir: /egg-rpc-demo
        [ProtoRPCPlugin] found "com.alipay.sofa.rpc.protobuf.ProtoService" in proto file
        [ProtoRPCPlugin] save all proto info into "/egg-rpc-demo/run/proto.json"
    复制代码

    2.Egg-sofa-generator

    SOFARPC 插件是为 egg 提供调用和发布 RPC 服务的能力,该插件提供调用其他系统暴露的 SOFARPC 接口的能力。
    那么这个插件如何应用在实际项目? 实际上就是生成了app/proxy/ProtoService.js - 调用服务的代理文件。

        // Don't modified this file, it's auto created by egg-rpc-generator
        
        'use strict';
        
        const path = require('path');
        
        /* eslint-disable */
        /* istanbul ignore next */
        module.exports = app => {
          const consumer = app.sofaRpcClient.createConsumer({
            interfaceName: 'com.alipay.sofa.rpc.protobuf.ProtoService',
            targetAppName: 'sofarpc',
            version: '1.0',
            group: 'SOFA',
            proxyName: 'ProtoService',
            responseTimeout: 3000,
          });
        
          if (!consumer) {
            // `app.config['sofarpc.rpc.service.enable'] = false` will disable this consumer
            return;
          }
        
          app.beforeStart(async() => {
            await consumer.ready();
          });
        
          class ProtoService extends app.Proxy {
            constructor(ctx) {
              super(ctx, consumer);
            }
        
            async echoObj(req) {
              return await consumer.invoke('echoObj', [ req ], { 
                ctx: this.ctx,
            codecType: 'protobuf',                        
              });
            }
          }
        
          return ProtoService;
        };
        /* eslint-enable */
    复制代码

    如何调用该方法呢?

    • 在路由里通过 ctx.proxy去调用
        // app/controller/home.js
        'use strict';
        
        const Controller = require('egg').Controller;
        
        class HomeController extends Controller {
          async index() {
            const { ctx } = this;
            const res = await ctx.proxy.protoService.echoObj({
              name: 'gxcsoccer',
            group: 'A',
            });
            ctx.body = res;
          }
        }
        
        module.exports = HomeController;
    复制代码
        npm run dev
    复制代码

    调试结果方面,调用接口之后如下图所示:

    五、小结

    伴随 SOFARPC的开源,sofa-bolt-node 和 sofa-rpc-node 两个 Nodejs RPC 基础模块也逐步完善。本文主要将Eggjs 和 SOFA(Java)连通,尝试去提供EGG.js中RPC的一些引用。node社区不断完善,未来node.js在RPC中的尝试也可以越来越多。

    六、参考文献

    转载于:https://juejin.im/post/5cf11991e51d45590a445ae4

    展开全文
  • 客户端库,用于连接JavaScript中的Sirius Core RPC。 开始使用 siriusd-rpc.js运行在,可以通过安装: npm install siriusd-rpc 例子 var run = function ( ) { var siriuscore = require ( 'siriuscore-lib' ) ; ...
  • 客户端库,用于连接JavaScript中的Divi Core RPC。 开始使用 divid-rpc.js运行在,可以通过安装: npm install divid-rpc 例子 var run = function ( ) { var bitcore = require ( 'bitcore' ) ; var RpcClient...
  • 使用带有 json-rpc 的主干 js 库而不是本机 REST 实现的插件 此插件不再积极维护,将合并 PR,但不会解决进一步的问题。 可以在此处找到更新(并积极维护)的插件: 构建状态、项目页面、带注释的源代码和测试 ...
  • Js-RPC微博登陆案例

    2021-07-31 14:22:20
    Js逆向时,我们本地可以和浏览器以服务端和客户端的形式通过websocket协议进行RPC通信,这样可以直接调用浏览器中的一些函数方法,不必去在意函数具体的执行逻辑,可以省去大量的逆向调试时间。 在RPC中,发出请求...
  • sample-js-rpc 是一个轻量级的 json-rpc 框架,整个框架类只有 5 个示例代码:@Service @Lazy(false) public class DemoWebServiceImpl implements DemoWebService {  @Override  public String say...
  • Node.js Eggjs和RPC框架的结合实践方案 使用egg-sofa-rpc模块搭建服务端和客户端。 本文将简单介绍RPC,以及通过Eggjs框架搭建RPC客户端和服务端。 过程遇到的问题记录在这:[Node.js Eggjs使用RPC模块 egg-sofa-rpc...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,310
精华内容 15,324
关键字:

js使用rpc