tars源码分析之6

最新推荐文章于 2022-07-17 23:44:17 发布
最新推荐文章于 2022-07-17 23:44:17 发布
阅读量369 收藏 1
点赞数 3
分类专栏： S1: C/C++ s2: tarsC++ 文章标签： 网络协议 网络 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stpeace/article/details/125591181
版权

喜欢网络编程的同学，千万不要错过tars中关于socket的部分，来看看客户端操作。

真的是非常经典，看看send/recv吧，写得真是严密：

#include <cerrno>
#include <iostream>
#include "util/tc_clientsocket.h"
#include "util/tc_epoller.h"
#include "util/tc_common.h"

namespace tars
{
TC_Endpoint::TC_Endpoint()
{
    _host = "0.0.0.0";
    _port = 0;
    _timeout = 3000;
    _type = TCP;
    _grid = 0;
    _qos = 0;
    _weight = -1;
    _weighttype = 0;
    _authType = 0;
}

void TC_Endpoint::init(const string& host, int port, int timeout, int type, int grid, int qos, int weight, unsigned int weighttype, int authType)
{
    _host = host;
    _port = port;
    _timeout = timeout;
    _type = type;
    _grid = grid;
    _qos = qos;
    if (weighttype == 0)
    {
        _weight = -1;
        _weighttype = 0;
    }
    else
    {
        if (weight == -1)
        {
            weight = 100;
        }
        _weight = (weight > 100 ? 100 : weight);
        _weighttype = weighttype;
    }

    _authType = authType;
}

void TC_Endpoint::parse(const string &str)
{
    _grid = 0;
    _qos = 0;
    _weight = -1;
    _weighttype = 0;
    _authType = 0;

    const string delim = " \t\n\r";

    string::size_type beg;
    string::size_type end = 0;

    beg = str.find_first_not_of(delim, end);
    if(beg == string::npos)
    {
        throw TC_EndpointParse_Exception("TC_Endpoint::parse error : " + str);
    }

    end = str.find_first_of(delim, beg);
    if(end == string::npos)
    {
        end = str.length();
    }

    string desc = str.substr(beg, end - beg);
    if(desc == "tcp")
    {
        _type = TCP;
    }
    else if (desc == "ssl")
    {
        _type = SSL;
    }
    else if(desc == "udp")
    {
        _type = UDP;
    }
    else
    {
        throw TC_EndpointParse_Exception("TC_Endpoint::parse tcp or udp or ssl error : " + str);
    }

    desc = str.substr(end);
    end  = 0;
    while(true)
    {
        beg = desc.find_first_not_of(delim, end);
        if(beg == string::npos)
        {
            break;
        }

        end = desc.find_first_of(delim, beg);
        if(end == string::npos)
        {
            end = desc.length();
        }

        string option = desc.substr(beg, end - beg);
        if(option.length() != 2 || option[0] != '-')
        {
            throw TC_EndpointParse_Exception("TC_Endpoint::parse error : " + str);
        }

        string argument;
        string::size_type argumentBeg = desc.find_first_not_of(delim, end);
        if(argumentBeg != string::npos && desc[argumentBeg] != '-')
        {
            beg = argumentBeg;
            end = desc.find_first_of(delim, beg);
            if(end == string::npos)
            {
                end = desc.length();
            }
            argument = desc.substr(beg, end - beg);
        }

        switch(option[1])
        {
            case 'h':
            {
                if(argument.empty())
                {
                    throw TC_EndpointParse_Exception("TC_Endpoint::parse -h error : " + str);
                }
                const_cast<string&>(_host) = argument;
                break;
            }
            case 'p':
            {
                istringstream p(argument);
                if(!(p >> const_cast<int&>(_port)) || !p.eof() || _port < 0 || _port > 65535)
                {
                    throw TC_EndpointParse_Exception("TC_Endpoint::parse -p error : " + str);
                }
                break;
            }
            case 't':
            {
                istringstream t(argument);
                if(!(t >> const_cast<int&>(_timeout)) || !t.eof())
                {
                    throw TC_EndpointParse_Exception("TC_Endpoint::parse -t error : " + str);
                }
                break;
            }
            case 'g':
            {
                istringstream t(argument);
                if(!(t >> const_cast<int&>(_grid)) || !t.eof())
                {
                    throw TC_EndpointParse_Exception("TC_Endpoint::parse -g error : " + str);
                }
                break;
            }
            case 'q':
            {
                istringstream t(argument);
                if(!(t >> const_cast<int&>(_qos)) || !t.eof())
                {
                    throw TC_EndpointParse_Exception("TC_Endpoint::parse -q error : " + str);
                }
                break;
            }
            case 'w':
            {
                istringstream t(argument);
                if(!(t >> const_cast<int&>(_weight)) || !t.eof())
                {
                    throw TC_EndpointParse_Exception("TC_Endpoint::parse -w error : " + str);
                }
                break;
            }
            case 'v':
            {
                istringstream t(argument);
                if(!(t >> const_cast<unsigned int&>(_weighttype)) || !t.eof())
                {
                    throw TC_EndpointParse_Exception("TC_Endpoint::parse -v error : " + str);
                }
                break;
            }
            // auth type
            case 'e':
            {
                istringstream p(argument);
                if (!(p >> const_cast<int&>(_authType)) || !p.eof() || _authType < 0 || _authType > 1)
                {
                    throw TC_EndpointParse_Exception("TC_Endpoint::parse -e error : " + str);
                }
                break;
            }
            default:
            {
                ///throw TC_EndpointParse_Exception("TC_Endpoint::parse error : " + str);
            }
        }
    }

    if(_weighttype != 0)
    {
        if(_weight == -1)
        {
            _weight = 100;
        }

        _weight = (_weight > 100 ? 100 : _weight);
    }

    if(_host.empty())
    {
        throw TC_EndpointParse_Exception("TC_Endpoint::parse error : host must not be empty: " + str);
    }
    else if(_host == "*")
    {
        const_cast<string&>(_host) = "0.0.0.0";
    }

    if (_authType < 0)
        _authType = 0;
    else if (_authType > 0)
        _authType = 1;
}

/*************************************TC_TCPClient**************************************/

#define LEN_MAXRECV 8196

int TC_TCPClient::checkSocket()
{
    if(!_socket.isValid())
    {
        try
        {
            if(_port == 0)
            {
                _socket.createSocket(SOCK_STREAM, AF_LOCAL);
            }
            else
            {
                _socket.createSocket(SOCK_STREAM, AF_INET);

            }

            //设置非阻塞模式
            _socket.setblock(false);

            try
            {
                if(_port == 0)
                {
                    _socket.connect(_ip.c_str());
                }
                else
                {
                    _socket.connect(_ip, _port);
                }
            }
            catch(TC_SocketConnect_Exception &ex)
            {
                if(errno != EINPROGRESS)
                {
                    _socket.close();
                    return EM_CONNECT;
                }
            }

            if(errno != EINPROGRESS)
            {
                _socket.close();
                return EM_CONNECT;
            }

            TC_Epoller epoller(false);
            epoller.create(1);
            epoller.add(_socket.getfd(), 0, EPOLLOUT);
            int iRetCode = epoller.wait(_timeout);
            if (iRetCode < 0)
            {
                _socket.close();
                return EM_SELECT;
            }
            else if (iRetCode == 0)
            {
                _socket.close();
                return EM_TIMEOUT;
            }
            else
            {
                for(int i = 0; i < iRetCode; ++i)
                {
                    const epoll_event& ev = epoller.get(i);
                    if (ev.events & EPOLLERR || ev.events & EPOLLHUP)
                    {
                        _socket.close();
                        return EM_CONNECT;
                    }
                    else
                    {
                        int iVal = 0;
                        socklen_t iLen = static_cast<socklen_t>(sizeof(int));
                        if (::getsockopt(_socket.getfd(), SOL_SOCKET, SO_ERROR, reinterpret_cast<char*>(&iVal), &iLen) == -1 || iVal)
                        {
                            _socket.close();
                            return EM_CONNECT;
                        }
                    }
                }
            }

            //设置为阻塞模式
            _socket.setblock(true);
        }
        catch(TC_Socket_Exception &ex)
        {
            _socket.close();
            return EM_SOCKET;
        }
    }
    return EM_SUCCESS;
}

int TC_TCPClient::send(const char *sSendBuffer, size_t iSendLen)
{
    int iRet = checkSocket();
    if(iRet < 0)
    {
        return iRet;
    }

    iRet = _socket.send(sSendBuffer, iSendLen);
    if(iRet < 0)
    {
        _socket.close();
        return EM_SEND;
    }

    return EM_SUCCESS;
}

int TC_TCPClient::recv(char *sRecvBuffer, size_t &iRecvLen)
{
    int iRet = checkSocket();
    if(iRet < 0)
    {
        return iRet;
    }

    TC_Epoller epoller(false);
    epoller.create(1);
    epoller.add(_socket.getfd(), 0, EPOLLIN);

    int iRetCode = epoller.wait(_timeout);
    if (iRetCode < 0)
    {
        _socket.close();
        return EM_SELECT;
    }
    else if (iRetCode == 0)
    {
        _socket.close();
        return EM_TIMEOUT;
    }

    epoll_event ev  = epoller.get(0);
    if(ev.events & EPOLLIN)
    {
        int iLen = _socket.recv((void*)sRecvBuffer, iRecvLen);
        if (iLen < 0)
        {
            _socket.close();
            return EM_RECV;
        }
        else if (iLen == 0)
        {
            _socket.close();
            return EM_CLOSE;
        }

        iRecvLen = iLen;
        return EM_SUCCESS;
    }
    else
    {
        _socket.close();
    }

    return EM_SELECT;
}

int TC_TCPClient::recvBySep(string &sRecvBuffer, const string &sSep)
{
    sRecvBuffer.clear();

    int iRet = checkSocket();
    if(iRet < 0)
    {
        return iRet;
    }

    TC_Epoller epoller(false);
    epoller.create(1);
    epoller.add(_socket.getfd(), 0, EPOLLIN);

    while(true)
    {
        int iRetCode = epoller.wait(_timeout);
        if (iRetCode < 0)
        {
            _socket.close();
            return EM_SELECT;
        }
        else if (iRetCode == 0)
        {
            _socket.close();
            return EM_TIMEOUT;
        }

        epoll_event ev  = epoller.get(0);
        if(ev.events & EPOLLIN)
        {
            char buffer[LEN_MAXRECV] = "\0";

            int len = _socket.recv((void*)&buffer, sizeof(buffer));
            if (len < 0)
            {
                _socket.close();
                return EM_RECV;
            }
            else if (len == 0)
            {
                _socket.close();
                return EM_CLOSE;
            }

            sRecvBuffer.append(buffer, len);

            if(sRecvBuffer.length() >= sSep.length() 
               && sRecvBuffer.compare(sRecvBuffer.length() - sSep.length(), sSep.length(), sSep) == 0)
            {
                break;
            }
        }
    }

    return EM_SUCCESS;
}

int TC_TCPClient::recvAll(string &sRecvBuffer)
{
    sRecvBuffer.clear();

    int iRet = checkSocket();
    if(iRet < 0)
    {
        return iRet;
    }

    TC_Epoller epoller(false);
    epoller.create(1);
    epoller.add(_socket.getfd(), 0, EPOLLIN);

    while(true)
    {
        int iRetCode = epoller.wait(_timeout);
        if (iRetCode < 0)
        {
            _socket.close();
            return EM_SELECT;
        }
        else if (iRetCode == 0)
        {
            _socket.close();
            return EM_TIMEOUT;
        }

        epoll_event ev  = epoller.get(0);
        if(ev.events & EPOLLIN)
        {
            char sTmpBuffer[LEN_MAXRECV] = "\0";

            int len = _socket.recv((void*)sTmpBuffer, LEN_MAXRECV);
            if (len < 0)
            {
                _socket.close();
                return EM_RECV;
            }
            else if (len == 0)
            {
                _socket.close();
                return EM_SUCCESS;
            }

            sRecvBuffer.append(sTmpBuffer, len);
        }
        else
        {
            _socket.close();
            return EM_SELECT;
        }
    }

    return EM_SUCCESS;
}

int TC_TCPClient::recvLength(char *sRecvBuffer, size_t iRecvLen)
{
    int iRet = checkSocket();
    if(iRet < 0)
    {
        return iRet;
    }

    size_t iRecvLeft = iRecvLen;
    iRecvLen = 0;

    TC_Epoller epoller(false);
    epoller.create(1);
    epoller.add(_socket.getfd(), 0, EPOLLIN);

    while(iRecvLeft != 0)
    {
        int iRetCode = epoller.wait(_timeout);
        if (iRetCode < 0)
        {
            _socket.close();
            return EM_SELECT;
        }
        else if (iRetCode == 0)
        {
            _socket.close();
            return EM_TIMEOUT;
        }

        epoll_event ev  = epoller.get(0);
        if(ev.events & EPOLLIN)
        {
            int len = _socket.recv((void*)(sRecvBuffer + iRecvLen), iRecvLeft);
            if (len < 0)
            {
                _socket.close();
                return EM_RECV;
            }
            else if (len == 0)
            {
                _socket.close();
                return EM_CLOSE;
            }

            iRecvLeft -= len;
            iRecvLen += len;
        }
        else
        {
            _socket.close();
            return EM_SELECT;
        }
    }

    return EM_SUCCESS;
}

int TC_TCPClient::sendRecv(const char* sSendBuffer, size_t iSendLen, char *sRecvBuffer, size_t &iRecvLen)
{
    int iRet = send(sSendBuffer, iSendLen);
    if(iRet != EM_SUCCESS)
    {
        return iRet;
    }

    return recv(sRecvBuffer, iRecvLen);
}

int TC_TCPClient::sendRecvBySep(const char* sSendBuffer, size_t iSendLen, string &sRecvBuffer, const string &sSep)
{
    int iRet = send(sSendBuffer, iSendLen);
    if(iRet != EM_SUCCESS)
    {
        return iRet;
    }

    return recvBySep(sRecvBuffer, sSep);
}

int TC_TCPClient::sendRecvLine(const char* sSendBuffer, size_t iSendLen, string &sRecvBuffer)
{
    return sendRecvBySep(sSendBuffer, iSendLen, sRecvBuffer, "\r\n");
}


int TC_TCPClient::sendRecvAll(const char* sSendBuffer, size_t iSendLen, string &sRecvBuffer)
{
    int iRet = send(sSendBuffer, iSendLen);
    if(iRet != EM_SUCCESS)
    {
        return iRet;
    }

    return recvAll(sRecvBuffer);
}

/*************************************TC_UDPClient**************************************/

int TC_UDPClient::checkSocket()
{
    if(!_socket.isValid())
    {
        try
        {
            if(_port == 0)
            {
                _socket.createSocket(SOCK_DGRAM, AF_LOCAL);
            }
            else
            {
                _socket.createSocket(SOCK_DGRAM, AF_INET);
            }
        }
        catch(TC_Socket_Exception &ex)
        {
            _socket.close();
            return EM_SOCKET;
        }

        try
        {
            if(_port == 0)
            {
                _socket.connect(_ip.c_str());
                if(_port == 0)
                {
                    _socket.bind(_ip.c_str());
                }
            }
            else
            {
                _socket.connect(_ip, _port);
            }
        }
        catch(TC_SocketConnect_Exception &ex)
        {
            _socket.close();
            return EM_CONNECT;
        }
        catch(TC_Socket_Exception &ex)
        {
            _socket.close();
            return EM_SOCKET;
        }
    }
    return EM_SUCCESS;
}

int TC_UDPClient::send(const char *sSendBuffer, size_t iSendLen)
{
    int iRet = checkSocket();
    if(iRet < 0)
    {
        return iRet;
    }

    iRet = _socket.send(sSendBuffer, iSendLen);
    if(iRet <0 )
    {
        return EM_SEND;
    }

    return EM_SUCCESS;
}

int TC_UDPClient::recv(char *sRecvBuffer, size_t &iRecvLen)
{
    string sTmpIp;
    uint16_t iTmpPort;

    return recv(sRecvBuffer, iRecvLen, sTmpIp, iTmpPort);
}

int TC_UDPClient::recv(char *sRecvBuffer, size_t &iRecvLen, string &sRemoteIp, uint16_t &iRemotePort)
{
    int iRet = checkSocket();
    if(iRet < 0)
    {
        return iRet;
    }

    TC_Epoller epoller(false);
    epoller.create(1);
    epoller.add(_socket.getfd(), 0, EPOLLIN);
    int iRetCode = epoller.wait(_timeout);
    if (iRetCode < 0)
    {
        return EM_SELECT;
    }
    else if (iRetCode == 0)
    {
        return EM_TIMEOUT;
    }

    epoll_event ev  = epoller.get(0);
    if(ev.events & EPOLLIN)
    {
        iRet = _socket.recvfrom(sRecvBuffer, iRecvLen, sRemoteIp, iRemotePort);
        if(iRet <0 )
        {
            return EM_SEND;
        }

        iRecvLen = iRet;
        return EM_SUCCESS;
    }

    return EM_SELECT;
}

int TC_UDPClient::sendRecv(const char *sSendBuffer, size_t iSendLen, char *sRecvBuffer, size_t &iRecvLen)
{
    int iRet = send(sSendBuffer, iSendLen);
    if(iRet != EM_SUCCESS)
    {
        return iRet;
    }

    return recv(sRecvBuffer, iRecvLen);
}

int TC_UDPClient::sendRecv(const char *sSendBuffer, size_t iSendLen, char *sRecvBuffer, size_t &iRecvLen, string &sRemoteIp, uint16_t &iRemotePort)
{
    int iRet = send(sSendBuffer, iSendLen);
    if(iRet != EM_SUCCESS)
    {
        return iRet;
    }

    return recv(sRecvBuffer, iRecvLen, sRemoteIp, iRemotePort);
}

}

涛歌依旧
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Tars源码分析---TC_EpollServer
Swartz2015的专栏
06-15 1755
前言 架构 IO_Thread Pool Handler Pool Adapter 总结 前言 这个系列的文章主要分析腾讯的开源RPC框架Tars。Tars除了提供RPC服务之外，还配套了一整套的运营管理平台。它同时支持C++，java等多种编程语言。本系列主要是分析tars的cpp部分实现，涉及的版本是github上最近release的1.40版。主要是在源...
tars源码解析二
killer0128的专栏
08-19 1772
tars源码解析二 准备知识 这节准备解析下tars的网络层和协议转换的源码，为了更好的理解这节，需要具备java网络层知识，主要是nio和Reactor模式。 nio的知识可以参考这个系列的文章 http://www.iteye.com/magazines/132-Java-NIO 这里简单说下Nio的概念，在bio模式下，因为socket读取数据是阻塞的，所以导致整个...
tars源码分析之11
认知 行动 坚持
07-10 785
time provider函数，来看一下，用了单例模式：
tars源码解析1--服务端启动
samll leaf
02-02 1113
tars源码解析1-服务段启动1. 服务如何启动1.12. 服务如何注册到注册中心 首先本例子是来自，TarsJava/examples/quickstart-server/ 新建一个启动类App.java package com.qq.tars.quickstart.server; /** * @author : yesheng * @Description : * @Date : 20...
tars源码漫谈第15篇------tc_clientsocket.h/tc_clientsocket.cpp（socket的客户端操作封装）
认知 行动 坚持
04-01 5144
很多时候，要朝对端发请求， 那么你需要的是tc_clientsocket.h/tc_clientsocket.cpp. 之前说过， 在tars中， 几乎没看到select/poll, 因为epoll遮挡了它们的光芒， 虽然在client端编程中完全可以用select/poll. 在tc_clientsocket.h中有#include "util/tc_http.h"， 但没有...
Tars框架线程TC_Thread的使用
未来之歌
02-20 1027
开源库Tars，本文参考官方示例对封装的线程TC_Thread进行实践。 封装类 TestThread 头文件： #pragma once #include "../../tars/util/include/util/tc_thread.h" using namespace tars; namespace lesliefishtest { class TestThread : publ...
tars
03-15
6. **Tars开发流程** - **服务定义**：使用Tars模板语言编写服务接口。 - **服务生成**：通过Tars编译工具生成服务的客户端和服务端代码。 - **服务实现**：在服务端实现接口，客户端通过代理调用服务。 - **...
laravel-tars:Laravel的Tars驱动程序
04-11
Laravel Tars Driver中文版描述Tars driver for laravel.Laravel集成微服务治理框架Tars功能支持服务打包支持Laravel/Lumen原生开发支持TarsConfig支持TarsLog支持网关注册下线支持请求开始(laravel.tars.requesting...
tars 资料安装包
07-01
【Tars资料安装包】是针对Tars框架的一份综合资源集合，包含了多个关键组件的安装包，旨在帮助用户快速搭建和部署Tars服务。Tars是一个基于微服务架构的高性能、可扩展的服务框架，广泛应用于分布式系统开发。在这个...
腾讯开源框架tars
07-02
Tars是腾讯从2008年到今天一直在使用的后台逻辑层的统一应用框架TAF（Total Application Framework），目前支持C++,Java,PHP,Nodejs语言。该框架为用户提供了涉及到开发、运维、以及测试的一整套解决方案，帮助一个...
TarsWeb:TARS项目仪表板
04-28
tars Web管理平台的高效运行是腾讯自2008年以来一直使用的后台逻辑层的统一应用程序框架TAF（总应用程序框架）的开源版本，目前支持C ++，Java，go，nodejs和PHP。 该框架为用户提供了一整套与开发，操作和维护以及...
Tars框架线程池TC_ThreadPool的使用--执行lambda形式任务task
未来之歌
02-23 909
线程池是我们在开发多线程程序中几乎是必不可少的一部分。 今天实践一下Tars框架的线程池TC_ThreadPool，本例采用一个lambda函数作为线程执行的任务，源码如下： #pragma once #include "../../tars/util/include/util/tc_thread_pool.h" #include &lt;iostream&gt; #include &lt;se...
Tars源码分析---智能指针的实现
Swartz2015的专栏
06-25 1038
前言 TC_AutoPtr TC_HandleBaseT 构造函数 赋值重载 析构函数 小结 TC_ScopedPtr TC_SharedPtr tc_shared_count_base tc_shared_count_impl_p tc_shared_count_impl_pd TC_EnableSharedFromThis 构造函数 赋值重载 总结 前言...
tars framework 源码解读(一) 总述
weixin_30333885的博客
09-25 752
tars framework源码 其实分两块。 一块是tarscpp 这块的代码跟外面的tarscpp貌似是一毛一样的。这块代码实现了一个服务的基础lib 一块是framework基础服务代码实现。这些服务撑起来整个tars系统的框架功能。直接用Introduction.zh.md中的图来说明一下吧。 整体架构的拓扑图主要分为2个部分：服务节点与公共框架节点。服务节...
Tars-Java客户端源码分析
vivo互联网技术
05-08 407
Tars是基于名字服务使用Tars协议的RPC开发框架，配套一个服务治理平台，帮助开发者快速构建一个分布式应用。其中Tars客户端支持C++，Java，Go等语言，方便各个语言程序互相进行高性能RPC调用。本文将介绍Tars-Java客户端设计理念，方便开发人员理解其设计原理。
微服务开源框架TARS的RPC源码解析 之 初识TARS C++客户端
TARSFoundation的博客
07-08 2822
微服务开源框架TARS的RPC源码解析 之 初识TARS C++客户端什么是TARS初识客户端CommunicatorServantProxy与ServantProxyFactoryCommunicatorEpollObjectProxy与ObjectProxyFactory初始化代码1. 执行stringToProxy2.执行Communicator的初始化函数3.尝试获取ServantProxy4.获取ObjectProxy5.建立ObjectProxy与AdapterProxy的关系6.继续完成Ser
tars源码漫谈第13篇------tc_gzip.h/tc_gzip.cpp（gzip编解码）
认知 行动 坚持
04-01 5029
      gzip是一种压缩/解压缩算法（无损）， 可以针对字符串/二进制流/文件等， 看了下源码， 利用到了基础的zlib库， 具体代码也就百来行， 可以参考tc_gzip.h/tc_gzip.cpp.  在tc_gzip.h中， 可以看到C++的类中类定义。 来写个简单的demo看下：#include &lt;iostream&gt; using namespace std; struct...
tars源码分析之9
认知 行动 坚持
07-03 294
动态运行时的类怎么定义，也很直观了：
tars源码分析之23
认知 行动 坚持
07-17 959
红黑树，来了：
springboot集成tars
最新发布
04-11
Spring Boot是一个用于创建独立的、基于Spring的应用程序的框架，而Tars是一个高性能、高可用的微服务框架。将Spring Boot与Tars集成可以实现快速开发和部署微服务应用。 要实现Spring Boot集成Tars，可以按照以下步骤进行操作： 1. 添加依赖：在Spring Boot项目的pom.xml文件中添加Tars相关的依赖，包括tars-spring-boot-starter和tars-spring-boot-starter-actuator。 2. 配置Tars服务：在application.properties或application.yml文件中配置Tars服务的相关信息，包括服务名称、端口号、协议等。 3. 编写Tars接口：创建一个接口，并使用@TarsServant注解标记该接口为Tars服务接口。在接口中定义需要暴露给外部调用的方法。 4. 实现Tars接口：创建一个实现类，并使用@TarsServantImpl注解标记该类为Tars服务接口的实现类。在实现类中实现接口定义的方法。 5. 启动应用程序：编写一个启动类，并使用@SpringBootApplication注解标记该类为Spring Boot应用程序的入口。在启动类中添加@EnableTarsServer注解，启用Tars服务。 6. 部署应用程序：将打包好的应用程序部署到Tars平台上，通过Tars平台管理界面进行配置和发布。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值