Thrift Server nodejs Client C# ---学习笔记

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/gzy11/article/details/78287486

Thrift中使用Nodejs作为服务端，C#作为客户端。

1、nodejs中回调在Thrift中的处理，没仔细看文档栽了。郁闷了一会。

2、nodejs支持的模式比较少，对接的时候C#示列代码如下：

.thrift文件如下

service UsersOrderServer{
  //建立索引
  void CreateIndex(),
  //更新用户订单数
  void UpdataUserOrderCount(1:string mobile),
  //获取所有城市(包含保险公司是否可以投保)
  string GetOrderCount(1:string mobile),
  
}

C# 客户端核心代码

需要使用Thrift nugget包最新版的即可。

 using (TBufferedTransport transport = new TBufferedTransport(new TSocket(SERVERIP, SERVERPORT)))
            {
                try
                {
                    transport.Open();
                    //协议要和服务端一致
                    //TTransport _transport = new TFramedTransport(new TSocket(SERVERIP, 3000));
                    TProtocol protocol = new TBinaryProtocol(transport);
                                      
                    UsersOrderServer.Client client = new UsersOrderServer.Client(protocol);
                    String result = client.GetOrderCount("17510000001");
                                     
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.StackTrace);
                }
                finally{
                    transport.Close();
                }
            }

Nodejs的服务端代码： typescript编写

import { ThriftHelper } from '../common/ThriftHelper';
var CityService = require('../gen-nodejs/CityService');
import * as UsersOrderServer from '../gen-nodejs/UsersOrderServer.js';
import { RPC } from "./RPC/RPC";

/**
 * 业务实现 服务端
 * 
 * @export
 * @class ThriftServer
 */
export class ThriftServer {

    public start(port: number) {
        let thriftHelper = new ThriftHelper();
        let rpc = new RPC();
        thriftHelper._server = thriftHelper.createServer(UsersOrderServer, {
            CreateIndex: rpc.create_index.bind(rpc),
            UpdataUserOrderCount: rpc.updata_userorder_count.bind(rpc),
            GetOrderCount: rpc.get_orderCount_rpc.bind(rpc)/*function(n1:any, result:any) {
                console.log("add(", n1, ",",  ")");
                result(null, n1);
              }*/,
        })
        thriftHelper._server.listen(port);
    }
}

RPC

var dbHelper = require("../../Common/MSdbHelper");
import * as redis from "redis";
import { BaseRedis } from "../../Common/RedisClient";
import * as config from '../../config';



export class RPC {
    public _client: redis.RedisClient;
    constructor() {
        // let baseRedis: BaseRedis = new BaseRedis(appConfig.redis.port, appConfig.redis.host, appConfig.redis.db);
        this._client = new BaseRedis(config.redis.port, config.redis.host, config.redis.db)._client;
    }

    /**
     * 索引初始化
     * 
     * @memberof RPC
     */
    public init() {
        this.create_index();
        /*this.get_orderCount("657567", (result: any) => {
            console.log("result:" + result);
        })*/
    }


    /**
     * 建立索引
     * 
     * @memberof RPC
     */
    public create_index(): void {
        let sql = "with aa as (select UserID, COUNT(1) count from Insurance_Order where UserID>0  group by  UserID )  select  u.Mobile,aa.count  from InsuranceUserExtend u, aa where u.UserID=aa.UserID ";
        dbHelper.querySql(sql, "", (err: any, result: any) => {
            for (let i in result) {
                //console.log(result[i].Mobile + ":" + result[i].count);
                this.create_mobile_index(result[i]);
            }
        });
        //this.updata_userorder_count("111");
    }

    /**
     * 建立用户mobile索引
     * 
     * @memberof RPC
     */
    private create_mobile_index(data: any) {
        let key = "baoxian:user:mobile:" + data.Mobile.toString();
        //console.log("用户" + key + ":" + data.count);
        this._client.set(key, data.count);
        /*for (var index = 0; index < 1000; index++) {
            this._client.incr(key);
        }*/

    }
    /**
     * 更新updata_userorder_count
     * 
     * @memberof RPC
     */
    public updata_userorder_count(mobile: string) {
        let key = "baoxian:user:mobile:" + mobile;//77777;
        this._client.exists(key, (error, num) => {
            if (error == null) {
                if (num == 0) {
                    this._client.set(key, "0");
                } else if (num == 1) {
                    this._client.incr(key);
                }
                console.log(mobile + ":" + num);
            }
        })
    }

    /**
     * RPC-专用获取order count数量
     * 
     * @param {string} moblie 
     * @param {*} result 
     * @memberof RPC
     */
    public get_orderCount_rpc(moblie: string, result: any) {

        this.get_orderCount(moblie, (count: string) => {
            //console.log(moblie + ":" + count);
            result(null, count);
        });

        //console.log("sdfsdf:" + result);
        //return result;
    }

    /**
     * 获取order count数量
     * 
     * @param {string} mobile 
     * @param {(count: string) => void} callback 
     * @memberof RPC
     */

    public get_orderCount(mobile: string, callback: (count: string) => void) {
        let key = "baoxian:user:mobile:" + mobile;//77777;
        this._client.exists(key, (error, num) => {
            if (error == null) {
                if (num == 0) {
                    callback("0");
                } else if (num == 1) {
                    this._client.get(key, (error, value) => {
                        if (value) {
                            //console.log("get:" + value)
                            callback(value);
                        } else {
                            callback("0");
                        }
                    });
                }
            } else {
                callback("0");
            }
        })
    }
}

BaseThrift 

import * as thrift from "thrift";
import { ThriftEvent } from "../Enum/ThriftEvent";
export class BaseThrift {
    public _server: thrift.ThriftServer;
    
    public _clientConnection: thrift.ClientConnection;


    protected _clientConnection_event_Open_callback?: (error: Error) => void;
    protected _clientConnection_event_Close_callback?: (error: Error) => void;
    protected _clientConnection_event_Error_callback?: (error: Error) => void;
    protected _clientConnection_event_Message_callback?: (message: any) => void;



    constructor(generatedService?: any, serviceMethods?: any) {
        if (generatedService) {
            if (serviceMethods) {
                this._server = thrift.createServer(generatedService, serviceMethods);
            }
        }
    }

    /**
     * 创建服务端
     * 
     * @param {*} generatedService 
     * @param {*} serviceMethods 
     * @returns {thrift.ThriftServer} 
     * @memberof BaseThrift
     */
    public createServer(generatedService: any, serviceMethods: any): thrift.ThriftServer {
        return thrift.createServer(generatedService, serviceMethods);
    }

    /**
     * 创建客户端
     * 
     * @param {*} generatedService 
     * @param {{}} connection 
     * @returns {*} 
     * @memberof BaseThrift
     */
    public createClient(generatedService: any, connection: {}): any{
        return thrift.createClient(generatedService, connection);
    }

    /**
     * 创建 Connection 并加监听
     * 
     * @param {string} ip 
     * @param {number} port 
     * @memberof BaseThrift
     */
    public createConnection(ip: string, port: number) {
        this._clientConnection = thrift.createConnection(ip, port);
        this.addClientConnectionListener();
    }

    /**
     * 添加 Connection 监听
     * 
     * @memberof BaseThrift
     */
    public addClientConnectionListener() {
        this.addClientConnectionOpenListener(ThriftEvent.OPEN);
        this.addClientConnectionCloseListener(ThriftEvent.CLOSE);
        this.addClientConnectionErrorListener(ThriftEvent.ERROR);
        this.addClientConnectionMessageListener(ThriftEvent.MESSAGE);
    }

    /**
     * 添加open的监听
     * 
     * @param {ThriftEvent.OPEN} event 
     * @param {(error: Error) => void} [callback] 
     * @memberof BaseThrift
     */
    public addClientConnectionOpenListener(event: ThriftEvent.OPEN, callback?: (error: Error) => void) {
        this._clientConnection_event_Open_callback = callback;
        this._clientConnection.on(event, this.listenOpenHandle.bind(this));
    }

    /**
     * 添加close的监听
     * 
     * @param {ThriftEvent.CLOSE} event 
     * @param {(error: Error) => void} [callback] 
     * @memberof BaseThrift
     */
    public addClientConnectionCloseListener(event: ThriftEvent.CLOSE, callback?: (error: Error) => void) {
        this._clientConnection_event_Close_callback = callback;
        this._clientConnection.on(event, this.listenCloseHandle.bind(this));
    }


    /**
     * 添加Error的监听
     * 
     * @param {ThriftEvent.ERROR} event 
     * @param {(error: Error) => void} [callback] 
     * @memberof BaseThrift
     */
    public addClientConnectionErrorListener(event: ThriftEvent.ERROR, callback?: (error: Error) => void) {
        this._clientConnection_event_Error_callback = callback;
        this._clientConnection.on(event, this.listenErrorHandle.bind(this));
    }

    /**
     * 添加Message的监听
     * 
     * @param {ThriftEvent.MESSAGE} event 
     * @param {(error: Error) => void} [callback] 
     * @memberof BaseThrift
     */
    public addClientConnectionMessageListener(event: ThriftEvent.MESSAGE, callback?: (error: Error) => void) {
        this._clientConnection_event_Message_callback = callback;
        this._clientConnection.on(event, this.listenMessageHandle.bind(this));
    }

    /**
     * _clientConnection open的回调
     * 
     * @protected
     * @param {Error} error 
     * @memberof BaseThrift
     */
    protected listenOpenHandle(error: Error): void {
        if (this._clientConnection_event_Open_callback)
            this._clientConnection_event_Open_callback(error);
        console.log("thrift open error:" + error);
        //throw error;his
    }


    /**
     * _clientConnection close的回调
     * 
     * @protected
     * @param {Error} error 
     * @memberof BaseThrift
     */
    protected listenCloseHandle(error: Error): void {
        if (this._clientConnection_event_Close_callback)
            this._clientConnection_event_Close_callback(error);
        console.log("thrift close error:" + error);
    }


    /**
     * _clientConnection error的回调
     * 
     * @protected
     * @param {Error} error 
     * @memberof BaseThrift
     */
    protected listenErrorHandle(error: Error): void {
        if (this._clientConnection_event_Error_callback)
            this._clientConnection_event_Error_callback(error);
        console.log("thrift error error:" + error);
    }

    /**
     * _clientConnection Message的回调
     * 
     * @protected
     * @param {Error} error 
     * @memberof BaseThrift
     */
    protected listenMessageHandle(message: any): void {
        if (this._clientConnection_event_Message_callback)
            this._clientConnection_event_Message_callback(message);
        console.log("thrift message:" + message);
    }

    //public addListener(event: string, listener: (...args: any[]) => void): void;
    //addListener(event: string, listener: (...args: any[]) => void): this;
    //addListener(event: "close", listener: () => void): this;
    /*export interface ClientConnection {
        on(event: ConnexionEvent, callback: (...args: any[]) => void): void;
    }*/
}