初识Thrift 及 Thrift示例

Myth丶恋晨 2024-04-17 17:28 77阅读 0赞

##### 简介 #####

Thrift是一个轻量级、语言无关的软件栈，它具有一套为RPC通信生成代码的机制

支持不同语言， 但是thrift文档资料比较少， 官网上也不是很详细`http://thrift.apache.org/tutorial/`

thrift拥有一套独立的网络栈， 大致分为：

1.  Transport 传输层（基于tcp， http等）
    
    提供的方法例如：
    
     *  open
     *  close
     *  read
     *  write
     *  flush

也提供了ServerTransport，主要用于服务端

1.  Protocol协议层， 实现数据的表示协议， 例如json， xml等， 对transport数据加解码
    
    Thrift的Protocol是面向流设计的，
2.  Processor 处理层
    
    封装了从输入流读取数据和从输出流写数据的能力
    
        interface TProcessor { 
            bool process(TProtocol in, TProtocol out) throws TException
        }
3.  Server 服务
    
    实现调用方法， 例如线程等

支持的类型：

bool: A boolean value (true or false)
    byte: An 8-bit signed integer
    i16: A 16-bit signed integer
    i32: A 32-bit signed integer
    i64: A 64-bit signed integer
    double: A 64-bit floating point number
    string: A text string encoded using UTF-8 encoding
    
    也支持：
    list
    set
    map

--------------------

###### 安装： ######

`yum -y install automake libtool flex bison pkgconfig gcc-c++ boost-devel libevent-devel zlib-devel python-devel ruby-devel openssl-devel`

下载并编译安装：

wget  http://mirror.bit.edu.cn/apache/thrift/0.12.0/thrift-0.12.0.tar.gz
    
     tar -zxvf thrift-0.12.0.tar.gz 
     cd thrift-0.12.0
    
     ./configure --with-boost=/usr/local
     make -j24 
     make install

安装完成后查看版本：

#  thrift  -version
    Thrift version 0.12.0

安装python thrift

pip install thrift

添加thrift IDL定义

vi add.thrift
    
    namespace py calculator
    
    service Calculator{
        i32 add(1: i32 a, 2:i32 b),
    }

##### 编译： #####

thrift --gen <语言> filename  
thrift --gen py add.thrift 转换编译文件

#
    #thrift --gen py add.thrift
    #ll
    total 4
    -rw-r--r-- 1 root root 81 Aug 20 17:41 add.thrift
    drwxr-xr-x 3 root root 41 Aug 20 17:42 gen-py

##### 服务端ser.py #####

import glob
    import sys
    
    sys.path.append('gen-py')
    from calculator import Calculator
    
    from thrift.transport import TSocket
    from thrift.transport import TTransport
    from thrift.protocol import TBinaryProtocol
    from thrift.server import TServer
    
    
    class CalculatorHandler:
        def __init__(self):
            self.log = {}
    
        def add(self, n1, n2):
            print('add(%d,%d)' % (n1, n2))
            return n1 + n2
    
    
    if __name__ == "__main__":
        handler = CalculatorHandler()
        processor = Calculator.Processor(handler)
        transport = TSocket.TServerSocket(host='127.0.0.1', port=9090)
        tfactory = TTransport.TBufferedTransportFactory()
        pfactory = TBinaryProtocol.TBinaryProtocolFactory()
        server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
        print('Starting the server...')
        server.serve()
        print('done.')

##### 客户端： #####

import sys
    import glob
    
    sys.path.append('gen-py')
    
    from calculator import Calculator
    
    from thrift import Thrift
    from thrift.transport import TSocket
    from thrift.transport import TTransport
    from thrift.protocol import TBinaryProtocol
    
    
    def main():
        transport = TSocket.TSocket('localhost', 9090)
        transport = TTransport.TBufferedTransport(transport)
        protocol = TBinaryProtocol.TBinaryProtocol(transport)
        client = Calculator.Client(protocol)
        transport.open()
        sum = client.add(1, 1)
        print(sum)
    
    
    if __name__ == '__main__':
        main()

输出：

服务端：

$ python ser.py 
    Starting the server...
    
    add(1,1)
    add(1,1)
    add(1,1)
    add(1,1)

客户端：

$ python cli.py 
    2
    $ python cli.py 
    2

--------------------

官网示例：

tutorial.thrift

/*
     * Licensed to the Apache Software Foundation (ASF) under one
     * or more contributor license agreements. See the NOTICE file
     * distributed with this work for additional information
     * regarding copyright ownership. The ASF licenses this file
     * to you under the Apache License, Version 2.0 (the
     * "License"); you may not use this file except in compliance
     * with the License. You may obtain a copy of the License at
     *
     *   http://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing,
     * software distributed under the License is distributed on an
     * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
     * KIND, either express or implied. See the License for the
     * specific language governing permissions and limitations
     * under the License.
     */
    
    # Thrift Tutorial
    # Mark Slee (mcslee@facebook.com)
    #
    # This file aims to teach you how to use Thrift, in a .thrift file. Neato. The
    # first thing to notice is that .thrift files support standard shell comments.
    # This lets you make your thrift file executable and include your Thrift build
    # step on the top line. And you can place comments like this anywhere you like.
    #
    # Before running this file, you will need to have installed the thrift compiler
    # into /usr/local/bin.
    
    /**
     * The first thing to know about are types. The available types in Thrift are:
     *
     *  bool        Boolean, one byte
     *  i8 (byte)   Signed 8-bit integer
     *  i16         Signed 16-bit integer
     *  i32         Signed 32-bit integer
     *  i64         Signed 64-bit integer
     *  double      64-bit floating point value
     *  string      String
     *  binary      Blob (byte array)
     *  map<t1,t2>  Map from one type to another
     *  list<t1>    Ordered list of one type
     *  set<t1>     Set of unique elements of one type
     *
     * Did you also notice that Thrift supports C style comments?
     */
    
    // Just in case you were wondering... yes. We support simple C comments too.
    
    /**
     * Thrift files can reference other Thrift files to include common struct
     * and service definitions. These are found using the current path, or by
     * searching relative to any paths specified with the -I compiler flag.
     *
     * Included objects are accessed using the name of the .thrift file as a
     * prefix. i.e. shared.SharedObject
     */
    include "shared.thrift"
    
    /**
     * Thrift files can namespace, package, or prefix their output in various
     * target languages.
     */
    
    /**
    *namespace cl tutorial
    *namespace cpp tutorial
    *namespace d tutorial
    *namespace dart tutorial
    *namespace java tutorial
    *namespace php tutorial
    *namespace perl tutorial
    *namespace haxe tutorial
    *namespace netcore tutorial
    *namespace netstd tutorial
    */
    namespace py tutorial
    
    /**
     * Thrift lets you do typedefs to get pretty names for your types. Standard
     * C style here.
     */
    typedef i32 MyInteger
    
    /**
     * Thrift also lets you define constants for use across languages. Complex
     * types and structs are specified using JSON notation.
     */
    const i32 INT32CONSTANT = 9853
    const map<string,string> MAPCONSTANT = {'hello':'world', 'goodnight':'moon'}
    
    /**
     * You can define enums, which are just 32 bit integers. Values are optional
     * and start at 1 if not supplied, C style again.
     */
    enum Operation {
      ADD = 1,
      SUBTRACT = 2,
      MULTIPLY = 3,
      DIVIDE = 4
    }
    
    /**
     * Structs are the basic complex data structures. They are comprised of fields
     * which each have an integer identifier, a type, a symbolic name, and an
     * optional default value.
     *
     * Fields can be declared "optional", which ensures they will not be included
     * in the serialized output if they aren't set.  Note that this requires some
     * manual management in some languages.
     */
    struct Work {
      1: i32 num1 = 0,
      2: i32 num2,
      3: Operation op,
      4: optional string comment,
    }
    
    /**
     * Structs can also be exceptions, if they are nasty.
     */
    exception InvalidOperation {
      1: i32 whatOp,
      2: string why
    }
    
    /**
     * Ahh, now onto the cool part, defining a service. Services just need a name
     * and can optionally inherit from another service using the extends keyword.
     */
    service Calculator extends shared.SharedService {
    
      /**
       * A method definition looks like C code. It has a return type, arguments,
       * and optionally a list of exceptions that it may throw. Note that argument
       * lists and exception lists are specified using the exact same syntax as
       * field lists in struct or exception definitions.
       */
    
       void ping(),
    
       i32 add(1:i32 num1, 2:i32 num2),
    
       i32 calculate(1:i32 logid, 2:Work w) throws (1:InvalidOperation ouch),
    
       /**
        * This method has a oneway modifier. That means the client only makes
        * a request and does not listen for any response at all. Oneway methods
        * must be void.
        */
       oneway void zip()
    
    }
    
    /**
     * That just about covers the basics. Take a look in the test/ folder for more
     * detailed examples. After you run this file, your generated code shows up
     * in folders with names gen-<language>. The generated code isn't too scary
     * to look at. It even has pretty indentation.
     */

shared.thrift

编译：

thrift -r --gen py tutorial.thrift

服务端：

#!/usr/bin/env python
    
    #
    # Licensed to the Apache Software Foundation (ASF) under one
    # or more contributor license agreements. See the NOTICE file
    # distributed with this work for additional information
    # regarding copyright ownership. The ASF licenses this file
    # to you under the Apache License, Version 2.0 (the
    # "License"); you may not use this file except in compliance
    # with the License. You may obtain a copy of the License at
    #
    #   http://www.apache.org/licenses/LICENSE-2.0
    #
    # Unless required by applicable law or agreed to in writing,
    # software distributed under the License is distributed on an
    # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    # KIND, either express or implied. See the License for the
    # specific language governing permissions and limitations
    # under the License.
    #
    
    import glob
    import sys
    
    sys.path.append('gen-py')
    # sys.path.insert(0, glob.glob('../../lib/py/build/lib*')[0])
    
    from tutorial import Calculator
    from tutorial.ttypes import InvalidOperation, Operation
    
    from shared.ttypes import SharedStruct
    
    from thrift.transport import TSocket
    from thrift.transport import TTransport
    from thrift.protocol import TBinaryProtocol
    from thrift.server import TServer
    
    
    class CalculatorHandler:
        def __init__(self):
            self.log = {}
    
        def ping(self):
            print('ping()')
    
        def add(self, n1, n2):
            print('add(%d,%d)' % (n1, n2))
            return n1 + n2
    
        def calculate(self, logid, work):
            print('calculate(%d, %r)' % (logid, work))
    
            if work.op == Operation.ADD:
                val = work.num1 + work.num2
            elif work.op == Operation.SUBTRACT:
                val = work.num1 - work.num2
            elif work.op == Operation.MULTIPLY:
                val = work.num1 * work.num2
            elif work.op == Operation.DIVIDE:
                if work.num2 == 0:
                    x = InvalidOperation()
                    x.whatOp = work.op
                    x.why = 'Cannot divide by 0'
                    raise x
                val = work.num1 / work.num2
            else:
                x = InvalidOperation()
                x.whatOp = work.op
                x.why = 'Invalid operation'
                raise x
    
            log = SharedStruct()
            log.key = logid
            log.value = '%d' % (val)
            self.log[logid] = log
    
            return val
    
        def getStruct(self, key):
            print('getStruct(%d)' % (key))
            return self.log[key]
    
        def zip(self):
            print('zip()')
    
    
    if __name__ == '__main__':
        handler = CalculatorHandler()
        processor = Calculator.Processor(handler)
        transport = TSocket.TServerSocket(host='127.0.0.1', port=9090)
        tfactory = TTransport.TBufferedTransportFactory()
        pfactory = TBinaryProtocol.TBinaryProtocolFactory()
    
        server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
    
        # You could do one of these for a multithreaded server
        # server = TServer.TThreadedServer(
        #     processor, transport, tfactory, pfactory)
        # server = TServer.TThreadPoolServer(
        #     processor, transport, tfactory, pfactory)
    
        print('Starting the server...')
        server.serve()
        print('done.')

客户端：

#!/usr/bin/env python
    
    #
    # Licensed to the Apache Software Foundation (ASF) under one
    # or more contributor license agreements. See the NOTICE file
    # distributed with this work for additional information
    # regarding copyright ownership. The ASF licenses this file
    # to you under the Apache License, Version 2.0 (the
    # "License"); you may not use this file except in compliance
    # with the License. You may obtain a copy of the License at
    #
    #   http://www.apache.org/licenses/LICENSE-2.0
    #
    # Unless required by applicable law or agreed to in writing,
    # software distributed under the License is distributed on an
    # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    # KIND, either express or implied. See the License for the
    # specific language governing permissions and limitations
    # under the License.
    #
    
    import sys
    import glob
    
    sys.path.append('gen-py')
    # sys.path.insert(0, glob.glob('../../lib/py/build/lib*')[0])
    
    from tutorial import Calculator
    from tutorial.ttypes import InvalidOperation, Operation, Work
    
    from thrift import Thrift
    from thrift.transport import TSocket
    from thrift.transport import TTransport
    from thrift.protocol import TBinaryProtocol
    
    
    def main():
        # Make socket
        transport = TSocket.TSocket('localhost', 9090)
    
        # Buffering is critical. Raw sockets are very slow
        transport = TTransport.TBufferedTransport(transport)
    
        # Wrap in a protocol
        protocol = TBinaryProtocol.TBinaryProtocol(transport)
    
        # Create a client to use the protocol encoder
        client = Calculator.Client(protocol)
    
        # Connect!
        transport.open()
    
        client.ping()
        print('ping()')
    
        sum_ = client.add(1, 1)
        print('1+1=%d' % sum_)
    
        work = Work()
    
        work.op = Operation.DIVIDE
        work.num1 = 1
        work.num2 = 0
    
        try:
            quotient = client.calculate(1, work)
            print('Whoa? You know how to divide by zero?')
            print('FYI the answer is %d' % quotient)
        except InvalidOperation as e:
            print('InvalidOperation: %r' % e)
    
        work.op = Operation.SUBTRACT
        work.num1 = 15
        work.num2 = 10
    
        diff = client.calculate(1, work)
        print('15-10=%d' % diff)
    
        log = client.getStruct(1)
        print('Check log: %s' % log.value)
    
        # Close!
        transport.close()
    
    
    if __name__ == '__main__':
        try:
            main()
        except Thrift.TException as tx:
            print('%s' % tx.message)

输出：

服务端：

Starting the server...
    
    
    ping()
    add(1,1)
    calculate(1, Work(comment=None, num1=1, num2=0, op=4))
    calculate(1, Work(comment=None, num1=15, num2=10, op=2))
    getStruct(1)

客户端：

ping()
    1+1=2
    InvalidOperation: InvalidOperation(whatOp=4, why=u'Cannot divide by 0')
    15-10=5
    Check log: 5