TarsCPP 快速入门

创建服务

运行tars脚本

  1. /usr/local/tars/cpp/script/create_tars_server.sh [App] [Server] [Servant]

本例中执行：/usr/local/tars/cpp/script/create_tars_server.sh TestApp HelloServer Hello

命令执行后，会在当前目录的TestApp/HelloServer/ 目录下，生成下面文件：

  1. HelloServer.h HelloServer.cpp Hello.tars HelloImp.h HelloImp.cpp makefile

这些文件，已经包含了最基本的服务框架和默认测试接口实现。

tars接口文件

定义tars接口文件的语法和使用，参见tars_tup.md。

如下：

Hello.tars：

  1. module TestApp
  2. {
  4. interface Hello
  5. {
  6.     int test();
  7. };
  9. };

采用tars2cpp工具自动生成c++文件：/usr/local/tars/cpp/tools/tars2cpp hello.tars会生成hello.h文件，里面包含客户端和服务端的代码。

HelloImp是Servant的接口实现类

实现服务定义的tars件中的接口，如下：

HelloImp.h

  1. #ifndef _HelloImp_H_
  2. #define _HelloImp_H_
  4. #include "servant/Application.h"
  5. #include "Hello.h"
  7. /**
  8.  * HelloImp继承hello.h中定义的Hello对象
  9.  *
  10.  */
  11. class HelloImp : public TestApp::Hello
  12. {
  13. public:
  14.     /**
  15.      *
  16.      */
  17.     virtual ~HelloImp() {}
  19.     /**
  20.      * 初始化，Hello的虚拟函数，HelloImp初始化时调用
  21.      */
  22.     virtual void initialize();
  24.     /**
  25.      * 析构，Hello的虚拟函数，服务析构HelloImp退出时调用
  26.      */
  27.     virtual void destroy();
  29.     /**
  30.      * 实现tars文件中定义的test接口
  31.      */
  32.     virtual int test(tars::TarsCurrentPtr current) { return 0;};
  34. };
  35. /////////////////////////////////////////////////////
  36. #endif

HelloImp.cpp:

  1. #include "HelloImp.h"
  2. #include "servant/Application.h"
  4. using namespace std;
  6. //////////////////////////////////////////////////////
  7. void HelloImp::initialize()
  8. {
  9.     //initialize servant here:
  10.     //...
  11. }
  13. //////////////////////////////////////////////////////
  14. void HelloImp::destroy()
  15. {
  16.     //destroy servant here:
  17.     //...
  18. }

HelloServer是服务的实现类

如下:

HelloServer.h:

  1. #ifndef _HelloServer_H_
  2. #define _HelloServer_H_
  4. #include <iostream>
  5. #include "servant/Application.h"
  7. using namespace tars;
  9. /**
  10.  * HelloServer继承框架的Application类
  11.  **/
  12. class HelloServer : public Application
  13. {
  14. public:
  15.     /**
  16.      *
  17.      **/
  18.     virtual ~HelloServer() {};
  20.     /**
  21.      * 服务的初始化接口
  22.      **/
  23.     virtual void initialize();
  25.     /**
  26.      * 服务退出时的清理接口
  27.      **/
  28.     virtual void destroyApp();
  29. };
  31. extern HelloServer g_app;
  33. ////////////////////////////////////////////
  34. #endif

HelloServer.cpp

  1. #include "HelloServer.h"
  2. #include "HelloImp.h"
  4. using namespace std;
  6. HelloServer g_app;
  8. /////////////////////////////////////////////////////////////////
  9. void
  10. HelloServer::initialize()
  11. {
  12.     //initialize application here:
  14.     //添加Servant接口实现类HelloImp与路由Obj绑定关系
  15.     addServant<HelloImp>(ServerConfig::Application + "." + ServerConfig::ServerName + ".HelloObj");
  16. }
  17. /////////////////////////////////////////////////////////////////
  18. void
  19. HelloServer::destroyApp()
  20. {
  21.     //destroy application here:
  22.     //...
  23. }
  24. /////////////////////////////////////////////////////////////////
  25. int
  26. main(int argc, char* argv[])
  27. {
  28.     try
  29.     {
  30.         g_app.main(argc, argv);
  31.         g_app.waitForShutdown();
  32.     }
  33.     catch (std::exception& e)
  34.     {
  35.         cerr << "std::exception:" << e.what() << std::endl;
  36.     }
  37.     catch (...)
  38.     {
  39.         cerr << "unknown exception." << std::endl;
  40.     }
  41.     return -1;
  42. }
  43. /////////////////////////////////////////////////////////////////

服务编译

进入代码目录,首先做

  1. make cleanall
  2. make    
  3. make tar

扩展功能

Tars框架提供了接口定义语言的功能，可以在tars文件中，增加一下接口和方法，扩展服务的功能。

可以修改由create_tars_server.sh生成的tars文件，以下3个接口方法中，test是默认生成的，testHello是新增加的接口。

  1. module TestApp
  2. {
  4. interface Hello
  5. {
  6.     int test();
  7.     int testHello(string sReq, out string sRsp);
  8. };
  10. };

使用/usr/local/tars/cpp/tools/tars2cpp hello.tars,重新生成hello.h。

修改HelloImp.h/HelloImp.cpp，实现新的接口代码。

其中HelloImp.h中继承Hello类的testHello方法：

  1. virtual int testHello(const std::string &sReq, std::string &sRsp, tars::TarsCurrentPtr current);

HelloImp.cpp实现testHello方法：

  1. int HelloImp::testHello(const std::string &sReq, std::string &sRsp, tars::TarsCurrentPtr current)
  2. {
  3.     TLOGDEBUG("HelloImp::testHellosReq:"<<sReq<<endl);
  4.     sRsp = sReq;
  5.     return 0;
  6. }

重新make cleanall;make;make tar，会重新生成HelloServer.tgz发布包。

客户端同步/异步调用服务

在开发环境上，创建/home/tarsproto/[APP]/[Server]目录。

例如：/home/tarsproto/TestApp/HelloServer在刚才编写服务器的代码目录下，

执行 make release 这时会在/home/tarsproto/TestApp/HelloServer目录下生成h、tars和mk文件。

这样在有某个服务需要访问HelloServer时，就直接引用HelloServer服务make release的内容，不需要把HelloServer的tars拷贝过来（即代码目录下不需要存放HelloServer的tars文件）。

建立客户端代码目录，如TestHelloClient/。

编写main.cpp，创建实例并调用刚编写的接口函数进行测试。

同步方式：

  1. #include <iostream>
  2. #include "servant/Communicator.h"
  3. #include "Hello.h"
  5. using namespace std;
  6. using namespace TestApp;
  7. using namespace tars;
  9. int main(int argc,char ** argv)
  10. {
  11.     Communicator comm;
  13.     try
  14.     {
  15.         HelloPrx prx;
  16.         comm.stringToProxy("TestApp.HelloServer.HelloObj@tcp -h 10.120.129.226 -p 20001" , prx);
  18.         try
  19.         {
  20.             string sReq("hello world");
  21.             string sRsp("");
  23.             int iRet = prx->testHello(sReq, sRsp);
  24.             cout<<"iRet:"<<iRet<<" sReq:"<<sReq<<" sRsp:"<<sRsp<<endl;
  26.         }
  27.         catch(exception &ex)
  28.         {
  29.             cerr << "ex:" << ex.what() << endl;
  30.         }
  31.         catch(...)
  32.         {
  33.             cerr << "unknown exception." << endl;
  34.         }
  35.     }
  36.     catch(exception& e)
  37.     {
  38.         cerr << "exception:" << e.what() << endl;
  39.     }
  40.     catch (...)
  41.     {
  42.         cerr << "unknown exception." << endl;
  43.     }
  45.     return 0;
  46. }

异步方式

  1. #include <iostream>
  2. #include "servant/Communicator.h"
  3. #include "Hello.h"
  5. using namespace std;
  6. using namespace TestApp;
  7. using namespace tars;
  9. class HelloCallBack : public HelloPrxCallback
  10. {
  11. public:
  12.     HelloCallBack(){}
  14.     virtual ~HelloCallBack(){}
  16.     virtual void callback_testHello(tars::Int32 ret,  const std::string& sRsp)
  17.     {
  18.         cout<<"callback_testHello ret:"<< ret << "|sRsp:" << sRsp <<endl; 
  19.     }
  21.     virtual void callback_testHello_exception(tars::Int32 ret)
  22.     {
  23.         cout<<"callback_testHello_exception ret:"<< ret <<endl;
  24.     }
  25. };
  27. int main(int argc,char ** argv)
  28. {
  29.     Communicator comm;
  31.     try
  32.     {
  33.         HelloPrx prx;
  34.         comm.stringToProxy("TestApp.HelloServer.HelloObj@tcp -h 10.120.129.226 -p 20001" , prx);
  36.         try
  37.         {
  38.             string sReq("hello world");
  39.             HelloPrxCallbackPtr cb = new HelloCallBack();
  40.             prx->async_testHello(cb, sReq);
  41.             cout<<" sReq:"<<sReq<<endl;
  42.         }
  43.         catch(exception &ex)
  44.         {
  45.             cerr<<"ex:"<<ex.what() <<endl;
  46.         }
  47.         catch(...)
  48.         {
  49.             cerr<<"unknown exception."<<endl;
  50.         }
  51.     }
  52.     catch(exception& e)
  53.     {
  54.         cerr<<"exception:"<<e.what() <<endl;
  55.     }
  56.     catch (...)
  57.     {
  58.         cerr<<"unknown exception."<<endl;
  59.     }
  61.     getchar();
  63.     return 0;
  64. }

编写makefile,里面包含刚才通过make release生成的/home/tarsproto/APP/Server目录下的mk文件，如下：

  1. #-----------------------------------------------------------------------
  2. APP         :=TestApp
  3. TARGET      :=TestHelloClient
  4. CONFIG      :=
  5. STRIP_FLAG  := N
  7. INCLUDE     += 
  8. LIB         +=
  9. #-----------------------------------------------------------------------
  10. include /home/tarsproto/TestApp/HelloServer/HelloServer.mk
  11. include /usr/local/tars/cpp/makefile/makefile.tars
  12. #-----------------------------------------------------------------------

make出目标文件，上传到能访问服务器的环境中进行运行测试即