【go语言之thrift协议一】

thrift 相对于grpc而言，可能用的不是特别多，但是也是有一定的知名度，废话不多说，直接看一下实现。
首先就是安装，对于mac系统来说，直接就是

brew install thrift

当输入thrift --version 显示版本说明安装成功.

这里的示例代码是基于官方的示例去做的，地址是 官方示例。

这一篇文件主要介绍的是thrift的文件，以后生成对应的go的代码

thrift文件

然后和protobuf，先写proto文件，然后生成不同语言的文件一样，thrift是以thrift的文件作为后缀，然后使用thrift命令来去生成不同语言的文件。
这里看一下官方的示例

shared.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.
 */

/**
 * This Thrift file can be included by other Thrift files that want to share
 * these definitions.
 */

namespace cl shared
namespace cpp shared
namespace d share // "shared" would collide with the eponymous D keyword.
namespace dart shared
namespace java shared
namespace perl shared
namespace php shared
namespace haxe shared
namespace netstd shared


struct SharedStruct {
   
  1: i32 key
  2: string value
}

service SharedService {
   
  SharedStruct getStruct(1: i32 key)
}

首先这里定义了一个shared.thrift的文件，然后这里是定义了namespace，然后是SharedStruct这个结构体，这个里面定义了两个成员，第一个是key，属性是int32。然后就是value，属性是string。
然后就是SharedService。这个就是需要实现的方法，在golang中就是interface，在java中就是abstract。
接下来看一下生成的go文件

SharedStruct

type SharedStruct struct {
   
	Key   int32  `thrift:"key,1" db:"key" json:"key"`
	Value string `thrift:"value,2" db:"value" json:"value"`
}

func NewSharedStruct() *SharedStruct {
   
	return &SharedStruct{
   }
}

func (p *SharedStruct) GetKey() int32 {
   
	return p.Key
}

func (p *SharedStruct) GetValue() string {
   
	return p.Value
}
func (p *SharedStruct) Read(ctx context.Context, iprot thrift.TProtocol) error {
   
	if _, err := iprot.ReadStructBegin(ctx); err != nil {
   
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
   
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
		if err != nil {
   
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
   
			break
		}
		switch fieldId {
   
		case 1:
			if fieldTypeId == thrift.I32 {
   
				if err := p.ReadField1(ctx, iprot); err != nil {
   
					return err
				}
			} else {
   
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
   
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRING {
   
				if err := p.ReadField2(ctx, iprot); err != nil {
   
					return err
				}
			} else {
   
				if err := iprot.Skip(ctx, fieldTypeId); err != nil {
   
					return err
				}
			}
		default:
			if err := iprot.Skip(ctx, fieldTypeId); err != nil {
   
				return err
			}
		}
		if err := iprot.ReadFieldEnd(ctx); err != nil {
   
			return err
		}
	}
	if err := iprot.ReadStructEnd(ctx); err != nil {
   
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *SharedStruct) ReadField1(ctx context.Context, iprot thrift.TProtocol) error {
   
	if v, err := iprot.ReadI32(ctx); err != nil {
   
		return thrift.PrependError("error reading field 1: ", err)
	} else {
   
		p.Key = v
	}
	return nil
}

func (p *SharedStruct) ReadField2(ctx context.Context, iprot thrift.TProtocol) error {
   
	if v, err := iprot.ReadString(ctx); err != nil {
   
		return thrift.PrependError("error reading field 2: ", err)
	} else {
   
		p.Value = v
	}
	return nil
}

func (p *SharedStruct) Write(ctx context.Context, oprot thrift.TProtocol) error {
   
	if err := oprot.WriteStructBegin(ctx, "SharedStruct"); err != nil {
   
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
   
		if err := p.writeField1(ctx, oprot); err != nil {
   
			return err
		}
		if err := p.writeField2(ctx, oprot); err != nil {
   
			return err
		}
	}
	if err := oprot.WriteFieldStop(ctx); err != nil {
   
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(ctx); err != nil {
   
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *SharedStruct) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) {
   
	if err := oprot.WriteFieldBegin(ctx, "key", thrift.I32, 1); err != nil {
   
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err)
	}
	if err := oprot.WriteI32(ctx, int32(p.Key)); err != nil {
   
		return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(ctx); err != nil {
   
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p