接口定义语言idl——thrift

thritf

thrift是facebook开元的接口定义语言IDL(Interface Definition Languge),用于进行跨语言的接口定义从而实现不同语言之间的远程通讯。

不同的开发语言使用idl定义接口都会生成其本身的语法接口,idl忽略的语言的差异从而实现了远程调用。每个idl都有自己独特的语言法和工具,用于将自身代码生成其他语言的代码。

thrift、protobuf也提供了自己的工具将该语法编译成Java,python,Go等语言的代码,同时生成的代码中有构建server端与client端的方法,通过方法方法构建server服务器与client客户端,那么任意server和cliet都能通讯。

thrift的核心原理是序列化和反序列化,序列化就是将数据转化为字节流,反序列化就是将字节流恢复为数据。


namespace java demo

struct addStore{
    1:i32 id
    2:string storeName
    3:i32 type
    4:string uuid
    5:string identitionTime
    6:string createAt
    7:i32 status
}


struct delete{
    1:i32 id
}

struct update{
    1:i32 id
    2:string storeName
    3:i32 type
    4:string uuid
    5:string identitionTime
    6:string createAt
    7:i32 status
}

struct getStore{
    1:i32 id
    2:string storeName
    3:i32 type
    4:string uuid
    5:string identitionTime
    6:string createAt
    7:i32 status
}

service storeInterface{
    i32 addStore(1:addStore req)
    i32 delete(1:delete req)
    i32 update(1:update req)
    listgetStore(1:i32 id 2:string uuid)
}


上述使用thrift定义了storeInterface接口,其中需要注意的是namespace声明了生成的语言为java。

thrift生成工具为thrift,如下所示:

接口定义语言idl——thrift_第1张图片

kitex -module kitexdemo ./demo.thrift

需要注意的是namespace必须是要生成语言的表示,后一位是文件夹名
接口定义语言idl——thrift_第2张图片

thrift -r --gen java demo.thrift

在这里插入图片描述

-r表示递归生成,--gen java表示生成Java代码,该命令会生成一个gen-java目录存放生成的代码。

在这里插入图片描述

thrift命令默认是在当前文件下生成,也可以使用-o来指定目录,-out更多命令使用thrift -help查看。

将生成的源码移到maven构建的源码目录,如下

在这里插入图片描述
打开文件发现全是报错

接口定义语言idl——thrift_第3张图片
报错原因是在生成代码时只生成了源码而没有引入包,源码中import关键字都没有出现。解决方案也很简单查询thrift生成源码是需要哪些工具包,在maven中引入然后刷新pom文件即可。

https://mvnrepository.com
接口定义语言idl——thrift_第4张图片接口定义语言idl——thrift_第5张图片

也可以直接在idea中操作,鼠标点击红色报错Add Maven Dependency

接口定义语言idl——thrift_第6张图片

Java实现

使用命令行只生成了代码和测设包名,要实际应用到maven中还需要改包名和引入依赖,如下

  1. 目录分层

接口定义语言idl——thrift_第7张图片

  1. 引包引依赖

接口定义语言idl——thrift_第8张图片

生成的源码和thrift定义的是一致的,那么实现接口,启动client和server端即可。如下:

 public interface Iface {

   public int addStore(addStoreReq req) throws org.apache.thrift.TException;

   public int deleteStore(deleteStoreReq req) throws org.apache.thrift.TException;

   public int updateStore(updateStoreReq req) throws org.apache.thrift.TException;

   public java.util.List<getStoreReq> getStore(int id, java.lang.String uuid) throws org.apache.thrift.TException;

 }

上述是服务端源码,首先要继承改接口,然后在实现接口方法:

package org.example.demo_test;

import org.apache.thrift.TException;
import org.example.demo.model.addStoreReq;
import org.example.demo.model.deleteStoreReq;
import org.example.demo.model.getStoreReq;
import org.example.demo.model.updateStoreReq;
import org.example.demo.storeInterface;

import java.util.List;

public class serverImpl implements storeInterface.Iface {
    @Override
    public int addStore(addStoreReq req) throws TException {
        System.out.println("you add a store data");
        return 0;
    }

    @Override
    public int deleteStore(deleteStoreReq req) throws TException {
        System.out.println("you delete a store data");
        return 0;
    }

    @Override
    public int updateStore(updateStoreReq req) throws TException {
        System.out.println("you update a store data");
        return 0;
    }

    @Override
    public List<getStoreReq> getStore(int id, String uuid) throws TException {
        System.out.println("show store lists");
        return null;
    }
}


方法已经实现接下来就是会数据传输了,原理可以看https://www.cnblogs.com/jpfss/p/10881220.html

thrift实现rpc大致分为三个过程,首先业务层代码的数据映射到idl的定义的同名接口中(内存复用);然后对映射过来的数据序列化操作,序列化协议是TProtocol ;最后实现数据流的传输,协议是TTransport

接口定义语言idl——thrift_第9张图片

还有一点需要明白的是rpc传输和http传输过程类似,都是需要一个持续的非阻塞进程来响应客户端请求。

参考感谢作者!

服务端与客户端代码代码如下:

  • server
package org.example.demo_test;


import org.apache.thrift.TProcessorFactory;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.server.THsHaServer;
import org.apache.thrift.server.TSaslNonblockingServer;
import org.apache.thrift.server.TServer;
import org.apache.thrift.transport.TNonblockingServerSocket;
import org.apache.thrift.transport.TServerSocket;

import org.apache.thrift.transport.TTransportException;
import org.apache.thrift.transport.layered.TFramedTransport;
import org.example.demo.storeInterface;

public class server {
    public static void main(String[] args) throws TTransportException {

        //设置服务器端口  TNonblockingServerSocket-非堵塞服务模型
        TNonblockingServerSocket serverSocket = new TNonblockingServerSocket(8899);
        //参数设置
        THsHaServer.Args arg = new THsHaServer.Args(serverSocket).minWorkerThreads(2).maxWorkerThreads(4);
        //处理器
        storeInterface.Processor<storeInterfaceImpl> processor = new storeInterface.Processor<>(new storeInterfaceImpl());
        arg.protocolFactory(new TCompactProtocol.Factory());
        arg.transportFactory(new TFramedTransport.Factory());
        arg.processorFactory(new TProcessorFactory(processor));

        TServer server = new THsHaServer(arg);
        System.out.println("Thrift 服务端启动成功");
        server.serve();

    }
}

  • client
package org.example.demo_test;
import org.apache.thrift.TException;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.protocol.TProtocol;
import org.apache.thrift.transport.TSocket;
import org.apache.thrift.transport.TTransport;
import org.apache.thrift.transport.TTransportException;
import org.apache.thrift.transport.layered.TFramedTransport;
import org.example.demo.model.addStoreReq;
import org.example.demo.model.deleteStoreReq;
import org.example.demo.model.getStoreReq;
import org.example.demo.storeInterface;

import java.util.List;

public class client {
    public static void main(String[] args) throws TException {
        TTransport transport = new TFramedTransport(new TSocket("localhost", 9000), 600);
        TProtocol protocol = new TCompactProtocol(transport);
        storeInterface.Client client = new storeInterface.Client(protocol);
        deleteStoreReq deleteStoreReq = new deleteStoreReq(1);
        transport.open();
        // 接口方法
        client.deleteStore(deleteStoreReq);
        List<getStoreReq> store = client.getStore(1, "333");
        System.out.println(store);
        return ;
    }
}

demo地址:https://gitee.com/fireapproval/daxu/tree/master/thrift-demo

Go实现

thrift文件和上述一直,生成Go源码:thrift -r -gen go demo.thrift。若对命令不熟悉通过thrift -help查看 。

  1. 初始目录(仅包含thrift文件)

接口定义语言idl——thrift_第10张图片
再次之前首先要确保安装了thrift插件,thrift -version

接口定义语言idl——thrift_第11张图片
若未安装可参考如下步骤:

  1. 下载thrifthttps://archive.apache.org/dist/thrift/
  2. 系统高级设置配置环境变量(Linux修改配置文件即可)

thrift -r -out ./ --gen go demo.thrift

在这里插入图片描述
该命令生成了构建rpc的全部源码,如demo文件夹

接口定义语言idl——thrift_第12张图片
该文件夹是thrift一键生成的,文件名取决于namespace的命名。

==注意在生成的代码中可能会报错,注意观察如果是引入报包是正常的,因为生成的代码是将其本身的目录作为根目录,而实际上应该以项目目录为根目录,修改一下即可。另外要是生成的代码报错,确定引入包了情况下可能是thrift和go版本差太多了,相应减低版本即可。

接口定义语言idl——thrift_第13张图片
如果在自动生成的代码中某些方法爆红就是版本问题了,在如下的网站找到相近的版本就行了

接口定义语言idl——thrift_第14张图片

在生成的代码中,XXX_XXX-remote是测试代码无关核心功能,xxx_xxx是根据接口IDL的接口命名的。其中核心文件是和namespace命名一样的文件。

在上述的核心文件中存在在thrift文件名称完全一样的接口,该接口就是rpc服务端接口,按照thrift的rpc传输原理,Processer、Protocal、Transport分阶段完成。

接口定义语言idl——thrift_第15张图片

还要实现对服务端接口的重写,实现内存共用。

服务端实现:

package main

import (
	"context"
	"errors"
	"fmt"
	"github.com/apache/thrift/lib/go/thrift"
	"thriftdemo/demo"
)


// 操作对象
type Store struct {}

// 实现服务端接口
// 以下所用到的参数均在thrift生成的很小代码中获取
func (s *Store) AddStore(ctx context.Context, req *demo.AddParam) (_r int32, _err error){
	return 1,errors.New("add store fail")
}

func (s *Store) DeleteStore(ctx context.Context, req *demo.DeleteParam) (_r int32, _err error) {
	return 1,errors.New("delete store fail")
}

func (s *Store) UpdateStore(ctx context.Context, req *demo.UpdateParam) (_r int32, _err error)  {
	return 1,nil
}

func (s Store) GetStore(ctx context.Context, id int32, uuid string) (_r []*demo.GetParam, _err error)  {
	P1 := demo.GetParam{ID: 1,StoreName: "XIAOXU",Type: 1,UUID: "33-55",IdentifyTime: "2023",CreateAt: "2023",Status: 1}
	list :=make([]*demo.GetParam,1)
	list[0]= &P1
	return list,nil
}

//实现rpc服务端
func main(){
	storeTmp := Store{}
	// demo获取thrift传输各个阶段对象
	process := demo.NewStoreInterfaceProcessor(&storeTmp)
	socket, err := thrift.NewTServerSocket(":9000")
	if err  != nil{
		panic(err)
	}
	factory := thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory())
	factoryDefault := thrift.NewTBinaryProtocolFactoryDefault()

	server := thrift.NewTSimpleServer4(process, socket, factory, factoryDefault)
	fmt.Println("rpc服务端启动端口为9000")
	server.Serve()
}


方法的实现类也可以拆分,这里都写在main函数了。

客户端实现:

package main

import (
	"context"
	"fmt"
	"github.com/apache/thrift/lib/go/thrift"
	"log"
	"thriftdemo/demo"
)

func main()  {
	conf := &thrift.TConfiguration{}
	transport := thrift.NewTSocketConf("localhost:9000", conf)
	// 创建客户端协议
	confN := &thrift.TConfiguration{}
	protocolFactory := thrift.NewTBinaryProtocolFactoryConf(confN)

	client := demo.NewStoreInterfaceClientFactory(transport, protocolFactory)

	if err := transport.Open(); err != nil {
		log.Fatalln("Error opening:", "localhost" + ":9000")
	}
	defer transport.Close()


	//d, err := client.GetStore(context.Background(),1,"2233")
	//if err!=nil{
	//
	//}
	d ,err:= client.AddStore(context.Background(),&demo.AddParam{})
	if err != nil{}
	fmt.Println(d)
}

protobuf和thrift一样都是接口定义语言,通过工具生成各个语言的源码,他们的序列化协议不一样,用法都一样。

https://github.com/protocolbuffers/protobuf

https://protobuf.dev/getting-started/

你可能感兴趣的:(微服务,Code,Tools,go,protobuf,thrift)