thrift文件编写

1.thrift的数据类型。（这里主要为翻译官方文档）

　　a. 基本数据类型

　　　　1) boolean型，值为true或false

　　　　2) byte型，值为单字节字母

　　　　3) i16型，值长度为16位的integer带符号数字.

　　　　4) i32型，值长度为32位的integer带符号数字.

　　　　5) i64型，值长度为64位的integer带符号数字.

　　　　6) double型，值长度为64的浮点数.

　　　　7) string型，字符串或者binary数据。

　　b. 结构体

　　　　有点类似c的结构体。不怎么懂c的同学可以理解为不带方法的类，只有属性而已。

　　　　型如：

　　　　

struct Work {

1: i32 num1 = 0,

2: i32 num2,

3: Operation op,

4: optional string comment,

}

 

　　c. 容器

　　　　1) list类型。

　　　　　　指一组有序元素的集合，类似于java的ArrayList类。

　　　　

typedef i32 MyInteger

MyInteger a;

struct hello{

    list<MyInteger> d; }

指hello结构体中含有一个list类型的数据，且里面的元素都必须是a数据类型的MyInteger数据类型的数据，主要这里的typedef起一个别名的作用。

　　　　2) set类型

　　　　　　一个不可重复的排序元素的集合，类似java的hashset,python的set.使用同list

　　　　3) map<type1,type2>类型。

　　　　　　使用如：

map<string,string> MAPCONSTANT = {'hello':'world', 'goodnight':'moon'}

　　　　4) 枚举类型

 

2. 服务

　　有了数据结构，那么就该对数据进行操作。thrift这里所说的服务，不可能针对我们自己的业务逻辑，而是指的是服务端从端口读取数据，客户端传入数据的一套方法。

service <服务名>{

     <返回类型> <方法名>（参数） throws <异常>

}

3. 实践：

根据前面所说数据类型和结构体，编写如下thrift文件，名为 test.thrift

i32 a;

i32 b;

string c;

list<string> d;

map<string, string> e = {"hello" : "world", "dd" : "ee"};



struct f{

    1:a,

    2:b,

    3:c=2,

    4:d="ceshi",

    5:e,

}



service Hello{

    f get_f(1:f gg) throws (Exception, e)

}

以上代码使用thrift的标准命令(thrift.exe -gen py test.thrift)是不成功,因为语法还是不正确！

修改

1.常量量如a,b,c,d, e要使用const修饰。

2. 如果都使用了const修饰，但有;号，还是不成功，尽管有的人说thrift对；不敏感，那还是估计看版本的，这里我使用的是最新的0.8版本。也就是说，如果你是一个java或者php程序员，请注意没有"；"

3. 静态变量请赋值，如const i32 a = "helloworld"

4. 结构体内部的属性请指定参数类型，因为结构体内部属性和外部的静态属性没有任何关系。

5. 异常之间没有“，”分割，以空格代替

6. Exception类型请定义。

7. throws参数也要指定是第几个参数

好了，修改后的thrift脚本变为

const i32 a = 1

const i32 b = 2

const string c = "helloworld"

const list<string> d = "test"

const map<string, string> e = {"hello" : "world", "dd" : "ee"}



struct f{

    1:i32 a,

    2:i32 b,

    3:string c,

    4:list<string> d=["ceshi"],

    5:map<string,string> e = {"hello":"world"},

}

exception Exception{

    1:i32 what;

    2:string where;

}

service Hello{

    f get_f(1:f gg) throws (1:Exception e)

}

稍微有那么一点像生产环境了，生成代码结构：

我们可以让这个随便编写的脚本为我们完成一点点功能，比如get_f让他对结构体f的对象gg的各种值计算，当然生成环境也可以集成数据库了。

 

那么现在需要几个数据通信接口了。

1. 读取数据：readMessageBegin()

　　(fname, mtype, rseqid) = self._iprot.readMessageBegin()

　　从端口读取请求流，获取3个值。

　　readMessageEnd() 读取数据结束。

2. readStructBegin() 开始读取结构体

　　readStructEnd() 读取结构体结束

3. readFieldBegin() 读取属性开始

　　readFieldEnd()

4. readMapBegin()读取map开始

　　readMapEnd()读取map结束。

这里的数据接口还有很多，不一一列举，因为我们在实际使用thrift的时候，只要不类似于修改thrift源码的操作，都不需要关心这些具体的数据操作。

 

接下来我们做客户端和服务端的操作，同时在服务端进行具体业务的处理。

 

1. 编写借口类.

　　

import sys

sys.path.append("../gen-py")

from cc import Hello



from cc import ttypes



class My_Handler(Hello.Iface):



    def get_f(self, gg):

        #对对象gg进行梳理

        gg.a = gg.a + gg.b

        gg.b = gg.a - gg.b

        return gg

官方事例的CalculatorHandler是不继承Iface的，而我这里采用继承Hello.Iface,并没有别的深意，是表示一定要有我们定义thrift文件的get_f方法。假如我们的逻辑更加复杂，handler处理里有数据库操作等等，继承不继承Iface都是可以的。

官方的handler(部分):

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

接下来要对这个handler要对这个hander进行处理：

import sys

sys.path.append("../gen-py")

from cc import Hello



from cc import ttypes



class My_Handler(Hello.Iface):



    def get_f(self, gg):

        #对对象gg进行梳理

        gg.a = gg.a + gg.b

        gg.b = gg.a - gg.b

        return gg



handler = My_Handler()

process = Hello.Processor(handler)

from thrift.transport.TSocket import TServerSocket

server = TServerSocket(host="localhost", port = 9090)

from thrift.transport.TTransport import TBufferedTransportFactory

tfactory = TBufferedTransportFactory()

from thrift.protocol.TBinaryProtocol import TBinaryProtocolFactory

bfactory = TBinaryProtocolFactory()



from thrift.server.TServer import  TSimpleServer

servers = TSimpleServer(process, server, tfactory, bfactory)

print "starting the server..."

servers.serve()

print "done..."

直接上代码了。注意，这里的TServerSocket一定要指定,因为官方的类初始化时host赋初值居然写的none,等于没有写麽。

class TServerSocket(TSocketBase, TServerTransportBase):

  """Socket implementation of TServerTransport base."""



  def __init__(self, host=None, port=9090, unix_socket=None):

一个没有host的服务，可以想象会是什么样子，使用netstat -na查看端口：

 TCP    [::]:9090              [::]:0                 LISTENING

就是没有host导致的情况。

一个host定义为localhost的服务，使用netstat -na查看端口：

TCP    127.0.0.1:9090         0.0.0.0:0              LISTENING

 

接下来编写客户端，客户端的编写主要是是实例化Hello.Client对象

__author__ = 'CLTANG'

#! -*- encoding:utf-8 -*-



'''

    客户端

'''



import sys

sys.path.append("../gen-py")

from cc import Hello

from cc import ttypes





from thrift.transport import TSocket

from thrift.transport import TTransport

from thrift.protocol.TBinaryProtocol import TBinaryProtocol

transport = TSocket.TSocket('localhost', 9090)



# Buffering is critical. Raw sockets are very slow

transport = TTransport.TBufferedTransport(transport)



# Wrap in a protocol

protocol = TBinaryProtocol(transport)

client = Hello.Client(protocol)



transport.open()



ff = ttypes.f(a=1,b=2)



results = client.get_f(ff)

print results

transport.close()

执行客户端程序，最终将输出:

f(a=3, c='helloworld', b=1, e={'cc': 'dd', 'ee': 'ff'}, d=['hello', 'world'])

达到了我们最早定义在test.thrift中的service的内容，即传入f类型的实例化对象，调用get_f方法，返回一个经过处理的f类型的实例化对象。