简单的客户端服务器(多线程)基于json通信

最新推荐文章于 2023-04-26 09:00:00 发布
最新推荐文章于 2023-04-26 09:00:00 发布
阅读量658 收藏 3
点赞数
分类专栏： Linux c/c++ c++进阶 文章标签： json 服务器 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57283958/article/details/128621109
版权

这是一个客户端和服务器通信的小项目，小编自己手写了一个json工具，测试比jsoncpp，protobuf "效率更高"（浅拷贝），改写成深拷贝效率会急剧下降（小编能力有限，知识点（多线程，json，c++11(万能模板，完美转发，包装器等)，网络套接字）

改进：后序可以引进多线程，epoll模型（反应堆）或者引入负载均衡（并发数量大的情况），Json API更加完善。

Json/json.h

#pragma once
#include <string>
#include <vector>
#include <map>
#include <sstream>
#include <fstream>
#include <unordered_map>
using namespace std;

namespace yazi
{
    namespace json
    {
        class Json
        {
        public:
            typedef std::vector<Json>::iterator iterator;
            iterator begin()
            {
                return _vaule._array->begin();
            }
            iterator end()
            {
                return _vaule._array->end();
            }
            enum Type
            {
                json_null = 0,
                json_bool,
                json_int,
                json_double,
                json_string,
                json_array,
                json_object
            };
            Json();
            Json(bool vaule);
            Json(int vaule);
            Json(double vaule);
            Json(const char* vaule);
            Json(const std::string& vaule);
            Json(Type type);
            Json(const Json& other);

            operator bool();
            operator int();
            operator double();
            operator string();
            Json& operator[](int index);
            Json& operator[](const char* key);
            Json& operator[](const std::string& key);
            void operator=(const Json& other);
            bool operator==(const Json& other);
            bool operator!=(const Json& other);
            //Json& operator*();
            void append(const Json& other);
            size_t size() const;
            string str()const;
            void copy(const Json& other);
            void clear();
            bool isNull()const { return _type == json_null; }
            bool isBool()const { return _type == json_bool; }
            bool isInt()const { return _type == json_int; }
            bool isDouble()const { return _type == json_double; }
            bool isString()const { return _type == json_string; }
            bool isArray()const { return _type == json_array; }
            bool isObject()const { return _type == json_object; }

            bool asBool() const;
            int asInt()const;
            double asDouble()const;
            std::string asString()const;


            bool has(int index);
            bool has(const char* key);
            bool has(const std::string& key);


            void remove(int index);
            void remove(const char* key);
            void remove(const std::string& key);


            void parse(const std::string& str);
        private: 
            union Vaule
            {
                bool _bool;
                int _int;
                double _double;
                std::string* _string;
                std::vector<Json>* _array;
                std::map<std::string, Json>* _object;
            };
            Type _type;
            Vaule _vaule;
        };
    }
}

json/json.cc

#include "json.h"
#include "parser.h"
using namespace yazi::json;

Json::Json() : _type(json_null)
{
}
Json::Json(bool vaule) : _type(json_bool)
{
    _vaule._bool = vaule;
}
Json::Json(int vaule) : _type(json_int)
{
    _vaule._int = vaule;
}
Json::Json(double vaule) : _type(json_double)
{
    _vaule._double = vaule;
}
Json::Json(const char* vaule) : _type(json_string)
{
    _vaule._string = new std::string(vaule);
}
Json::Json(const std::string& vaule) : _type(json_string)
{
    _vaule._string = new std::string(vaule);
}
Json::Json(Type type) : _type(type)
{
    switch (_type)
    {
    case json_null:
        break;
    case json_bool:
        _vaule._bool = false;
        break;
    case json_int:
        _vaule._int = 0;
        break;
    case json_double:
        _vaule._double = 0.0;
        break;
    case json_string:
        _vaule._string = new std::string("");
        break;
    case json_array:
        _vaule._array = new std::vector<Json>();
        break;
    case json_object:
        _vaule._object = new std::map<std::string, Json>();
        break;
    default:
        break;
    }
}
Json::Json(const Json& other)
{
    copy(other);
}

Json::operator bool()
{
    if (_type != json_bool)
    {
        throw new logic_error("type error,not bool vaule");
    }
    return _vaule._bool;
}
Json::operator int()
{
    if (_type != json_int)
    {
        throw new logic_error("type error,not int vaule");
    }
    return _vaule._int;
}
Json::operator double()
{
    if (_type != json_double)
    {
        throw new logic_error("type error,not double vaule");
    }
    return _vaule._double;
}
Json::operator string()
{
    if (_type != json_string)
    {
        throw new logic_error("type error,not  string vaule");
    }
    return *(_vaule._string);
}

Json& Json::operator[](int index)
{
    if (_type != json_array)
    {
        clear();
        _type = json_array;
        _vaule._array = new std::vector<Json>();
    }
    // if(index < 0)
    // {
    //     throw new logic_error("array[] index < 0");
    // }
    size_t size = (_vaule._array)->size();
    if (index >= size) // 扩容
    {
        for (size_t i = size; i <= index; ++i)
        {
            (_vaule._array)->push_back(Json());
        }
    }
    return (_vaule._array)->at(index);
}
Json& Json::operator[](const char* key)
{
    std::string name(key);
    return (*(this))[name];
}
Json& Json::operator[](const std::string& key)
{
    if (_type != json_object)
    {
        clear();
        _type = json_object;
        _vaule._object = new std::map<std::string, Json>();
    }
    return (*(_vaule._object))[key];
}
void Json::operator=(const Json& other)
{
    clear();
    copy(other);
}
void Json::append(const Json& other)
{
    if (_type != json_array)
    {
        _type = json_array;
        _vaule._array = new std::vector<Json>();
    }
    (_vaule._array)->push_back(other);
}
size_t Json::size() const
{
    if (_type != json_array)
    {
        throw new logic_error("type error,not array vaule");
    }
    return (_vaule._array)->size();
}
string Json::str() const
{
    std::stringstream ss;
    switch (_type)
    {
    case json_null:
        ss << "null";
        break;
    case json_bool:
        if (_vaule._bool)
        {
            ss << "true";
        }
        else
        {
            ss << "false";
        }
        break;
    case json_int:
        ss << _vaule._int;
        break;
    case json_double:
        ss << _vaule._double;
        break;
    case json_string:
        ss << '\"' << *(_vaule._string) << '\"';
        break;
    case json_array:
    {
        ss << '[';
        for (auto it = (_vaule._array)->begin(); it != (_vaule._array)->end(); ++it)
        {
            if (it != (_vaule._array)->begin())
            {
                ss << ',';
            }
            ss << it->str();
        }
        ss << ']';
        break;
    }
    case json_object:
    {
        ss << '{';
        for (auto it = (_vaule._object)->begin(); it != (_vaule._object)->end(); ++it)
        {
            if (it != (_vaule._object)->begin())
            {
                ss << ',';
            }
            ss << '\"' << it->first << '\"' << ':' << it->second.str();
        }
        ss << '}';
        break;
    }
    default:
        break;
    }
    return ss.str();
}
void Json::copy(const Json& other)
{
    _type = other._type;
    switch (_type)
    {
    case json_null:
        break;
    case json_bool:
        _vaule._bool = other._vaule._bool;
        break;
    case json_int:
        _vaule._int = other._vaule._int;
        break;
    case json_double:
        _vaule._double = other._vaule._double;
        break;
    case json_string:
        _vaule._string = other._vaule._string;
        break;
    case json_array:
        _vaule._array = other._vaule._array;
        break;
    case json_object:
        _vaule._object = other._vaule._object;
        break;
    default:
        break;
    }
}
void Json::clear()
{
    switch (_type)
    {
    case json_null:
        break;
    case json_bool:
        _vaule._bool = false;
        break;
    case json_int:
        _vaule._int = 0;
        break;
    case json_double:
        _vaule._double = 0.0;
        break;
    case json_string:
        delete _vaule._string;
        break;
    case json_array:
    {
        for (auto it = _vaule._array->begin(); it != _vaule._array->end(); ++it)
        {
            it->clear();
        }
        delete _vaule._array;
        break;
    }
    case json_object:
    {
        for (auto it = _vaule._object->begin(); it != _vaule._object->end(); ++it)
        {
            (it->second).clear();
        }
        delete _vaule._object;
        break;
    }
    default:
        break;
    }
    _type = json_null;
}

bool Json::operator==(const Json& other) //浅拷贝(效率)
{
    if (_type != other._type)
    {
        return false;
    }
    switch (_type)
    {
    case json_null:
        return true;
    case json_bool:
        return _vaule._bool == other._vaule._bool;
    case json_int:
        return _vaule._int == other._vaule._int;
    case json_double:
        return _vaule._double == other._vaule._double;
    case json_string:
        return *(_vaule._string) == *(other._vaule._string);
    case json_array:
    {
       /*if(_vaule._array->size() != other._vaule._array->size())
       {
           return false;
       }
       for (size_t i = 0; i < _vaule._array->size(); ++i)
       {
           if ((*(_vaule._array))[i] != (* (other._vaule._array))[i])
           {
               return false;
           }
       }
       return true;*/
        return _vaule._array == other._vaule._array;
    }
    case json_object:
    {
        return _vaule._object == other._vaule._object;
    }
    default:
        break;
    }
    return false;
}
bool Json::operator!=(const Json& other)
{
    return !(*this == other);
}
bool Json::asBool() const
{
    if (_type != json_bool)
    {
        throw new std::logic_error("type error,not bool vaule");
    }
    return _vaule._bool;
}
int Json::asInt()const
{
    if (_type != json_int)
    {
        throw new std::logic_error("type error,not int vaule");
    }
    return _vaule._int;
}
double Json::asDouble()const
{
    if (_type != json_double)
    {
        throw new std::logic_error("type error,not double vaule");
    }
    return _vaule._double;
}
std::string Json::asString()const
{
    if (_type != json_string)
    {
        throw new std::logic_error("type error,not string vaule");
    }
    return *(_vaule._string);
}
bool Json::has(int index)
{
    if (_type != json_array)
    {
        return false;
    }
    int size = static_cast<int>((_vaule._array)->size());
    return (index >= 0 && index < size);
}
bool Json::has(const char* key)
{
    string name(key);
    return has(name);
}
bool Json::has(const std::string& key)
{
    if (_type != json_object)
    {
        return false;
    }
    return (_vaule._object)->find(key) != (_vaule._object)->end();
}

void Json::remove(int index)
{
    if (_type != json_array)
    {
        return;
    }
    int size = static_cast<int>((_vaule._array)->size());
    if (index < 0 || index >= size)
    {
        return;
    }
    (_vaule._array)->at(index).clear();
    (_vaule._array)->erase((_vaule._array)->begin() + index);
}
void Json::remove(const char* key)
{
    string name(key);
    return remove(name);
}
void Json::remove(const std::string& key)
{
    auto it = (_vaule._object)->find(key);
    if (it == (_vaule._object)->end())
    {
        return;
    }
    (*(_vaule._object))[key].clear();
    (_vaule._object)->erase(key);
}

void Json::parse(const std::string& str)
{
    Parser p;
    p.load(str);
    *this = p.parse();
}

json/parser.h

#pragma once
#include "json.h"
#include <string>
#include <regex>
namespace yazi
{
    namespace json
    {
        class Parser
        {
        public:
            Parser();
            void load(const std::string& str);
            Json parse();
        private:
            void skip_white_space();
            char get_next_token();
            Json parse_null();
            Json parse_bool();
            Json parse_number();
            std::string parse_string();
            Json parse_array();
            Json parse_object();
        private:
            std::string _str;
            int _index;
        };
    }
}

json.parser.cc

#include "parser.h"
using namespace yazi::json;
Parser::Parser() : _str(""), _index(0)
{
}
void Parser::load(const std::string& str)
{
    _str = str;
    _index = 0;
}
Json Parser::parse()
{
    char ch = get_next_token();
    switch (ch)
    {
    case 'n':
        --_index;
        return parse_null();
    case 't':
    case 'f':
        --_index;
        return parse_bool();
    case '-':
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
        --_index;
        return parse_number();
    case '"':
        return Json(parse_string());
    case '[':
        return parse_array();
    case '{':
        return parse_object();
    default:
        break;
    }
    throw new std::logic_error("unexpected char");
}
void Parser::skip_white_space()
{
    while (_str[_index] == ' ' || _str[_index] == '\n' || _str[_index] == '\r' || _str[_index] == '\t')
    {
        ++_index;
    }
}
char Parser::get_next_token()
{
    skip_white_space();
    return _str[_index++];
}
Json Parser::parse_null()
{
    if (_str.compare(_index, 4, "null") == 0)
    {
        _index += 4;
        return Json();
    }
    throw new std::logic_error("parse null error");
}
Json Parser::parse_bool()
{
    if (_str.compare(_index, 4, "true") == 0)
    {
        _index += 4;
        return Json(true);
    }
    else if (_str.compare(_index, 5, "false") == 0)
    {
        _index += 5;
        return Json(false);
    }
    else
    {
        throw new std::logic_error("parse bool error");
    }
}
Json Parser::parse_number()
{
    int pos = _index;
    if (_str[_index] == '-')
    {
        ++_index;
    }
    if (isdigit(_str[_index]) == 0)
    {
        throw new std::logic_error("parse number error");
    }
    while (isdigit(_str[_index]) != 0)
    {
        ++_index;
    }
    if (_str[_index] != '.')
    {
        int i = std::atoi(_str.c_str() + pos);
        return Json(std::move(i));
    }
    if (isdigit(_str[++_index]) == 0)
    {
        throw new std::logic_error("parse number error");
    }
    while (isdigit(_str[_index]) != 0)
    {
        ++_index;
    }
    double f = std::atof(_str.c_str() + pos);
    return Json(std::move(f));
}
std::string Parser::parse_string()
{
    std::string out;
    while (true)
    {
        char ch = _str[_index++];
        if (ch == '"')
        {
            break;
        }
        if (ch == '\\')
        {
            ch = _str[_index++];
            switch (ch)
            {
            case '\n':
                out += '\n';
                break;
            case '\r':
                out += '\r';
                break;
            case '\t':
                out += '\t';
                break;
            case '\b':
                out += '\b';
                break;
            case '\f':
                out += '\f';
                break;
            case '"':
                out += "\\\"";
                break;
            case '\\':
                out += "\\\\";
                break;
            case 'u':
                out += "\\u";
                for (int i = 0; i < 4; ++i)
                {
                    out += _str[_index++];
                }
                break;
            default:
                break;
            }
        }
        else
        {
            out += ch;
        }
    }
    return std::move(out);
}
Json Parser::parse_array()
{
    Json arr(Json::json_array);
    char ch = get_next_token();
    if (ch == ']')
    {
        return arr;
    }
    --_index;
    while (true)
    {
        arr.append(parse());   //递归解析
        ch = get_next_token();
        if (ch == ']')
        {
            break;
        }
        if (ch != ',')
        {
            throw new std::logic_error("parse array error");
        }
        //++_index;//ERROR
    }
    return arr;
}
Json Parser::parse_object()
{
    Json obj(Json::json_object);
    char ch = get_next_token();
    if(ch == '}')
    {
        return obj;
    }
    --_index;
    while(true)
    {
        ch = get_next_token();
        if(ch != '"')
        {
            throw new std::logic_error("parse object error");
        }
        std::string key = parse_string();
        ch = get_next_token();
        if(ch != ':')
        {
            throw new std::logic_error("parse object error");
        }
        obj[key] = parse();
        ch = get_next_token();
        if(ch == '}')
        {
            break;
        }
        if(ch != ',')
        {
            throw new std::logic_error("parse object error");
        }
        //++_index;//ERROR
    }
    return obj;
}

tcp_socket.hpp

#pragma once
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <string>
#include <cassert>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include "./json/json.h"
#include "./json/parser.h"
using namespace yazi::json;
typedef struct sockaddr sockaddr;
typedef struct sockaddr_in sockaddr_in;
#define CHECK_RET(exp) \
    if (!(exp))        \
    {                  \
        return false;  \
    }
class TcpSocket
{
public:
    TcpSocket() : fd_(-1) {}
    TcpSocket(int fd) : fd_(fd) {}
    bool Socket()
    {
        fd_ = socket(AF_INET, SOCK_STREAM, 0);
        if (fd_ < 0)
        {
            perror("socket");
            return false;
        }
        printf("open fd = %d\n", fd_);
        return true;
    }
    bool Close() const
    {
        close(fd_);
        printf("close fd = %d\n", fd_);
        return true;
    }
    bool Bind(const std::string &ip, uint16_t port) const
    {
        sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        addr.sin_port = htons(port);
        int ret = bind(fd_, (sockaddr *)&addr, sizeof(addr));
        if (ret < 0)
        {
            perror("bind");
            return false;
        }
        return true;
    }
    bool Listen(int num) const
    {
        int ret = listen(fd_, num);
        if (ret < 0)
        {
            perror("listen");
            return false;
        }
        return true;
    }
    bool Accept(TcpSocket *peer, std::string *ip = NULL, uint16_t *port = NULL) const
    {
        sockaddr_in peer_addr;
        socklen_t len = sizeof(peer_addr);
        int new_sock = accept(fd_, (sockaddr *)&peer_addr, &len);
        if (new_sock < 0)
        {
            perror("accept");
            return false;
        }
        printf("accept fd = %d\n", new_sock);
        peer->fd_ = new_sock;
        if (ip != NULL)
        {
            *ip = inet_ntoa(peer_addr.sin_addr);
        }
        if (port != NULL)
        {
            *port = ntohs(peer_addr.sin_port);
        }
        return true;
    }
    bool Recv(std::string *buf) const
    {
        buf->clear();
        char tmp[1024 * 10] = {0};
        // [注意!] 这里的读并不算很严谨, 因为一次 recv 并不能保证把所有的数据都全部读完
        // 参考 man 手册 MSG_WAITALL 节.
        ssize_t read_size = recv(fd_, tmp, sizeof(tmp), 0);
        if (read_size < 0)
        {
            perror("recv");
            return false;
        }
        if (read_size == 0)
        {
            return false;
        }
        buf->assign(tmp, read_size);
        return true;
    }
    bool Recv(Json* result) const
    {
        result->clear();
        char tmp[1024 * 10] = {0};
        ssize_t read_size = recv(fd_, tmp, sizeof(tmp), 0);
        if (read_size < 0)
        {
            perror("recv");
            return false;
        }
        if (read_size == 0)
        {
            return false;
        }
        std::string name(tmp);
        (*result).parse(name);
        return true;
    }
    bool Send(const std::string &buf) const
    {
        ssize_t write_size = send(fd_, buf.data(), buf.size(), 0);
        if (write_size < 0)
        {
            perror("send");
            return false;
        }
        return true;
    }
    bool Send(const Json &vaule) const
    {
        ssize_t write_size = send(fd_, vaule.str().data(), vaule.str().size(), 0);
        if (write_size < 0)
        {
            perror("send");
            return false;
        }
        return true;
    }
    bool Connect(const std::string &ip, uint16_t port) const
    {
        sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        addr.sin_port = htons(port);
        int ret = connect(fd_, (sockaddr *)&addr, sizeof(addr));
        if (ret < 0)
        {
            perror("connect");
            return false;
        }
        return true;
    }
    int GetFd() const
    {
        return fd_;
    }

private:
    int fd_;
};

tcp_client.hpp        

#pragma once
#include "tcp_socket.hpp"
class TcpClient
{
public:
    TcpClient(const std::string &ip, uint16_t port) : ip_(ip), port_(port)
    {
        // [注意!!] 需要先创建好 socket
        sock_.Socket();
    }
    ~TcpClient()
    {
        sock_.Close();
    }
    bool Connect()
    {
        return sock_.Connect(ip_, port_);
    }
    bool Recv(std::string *buf)
    {
        return sock_.Recv(buf);
    }
    bool Recv(Json* result)
    {
        return sock_.Recv(result);
    }
    bool Send(const std::string &buf)
    {
        return sock_.Send(buf);
    }
    bool Send(const Json& vaule)
    {
        return sock_.Send(vaule);
    }
private:
    TcpSocket sock_;
    std::string ip_;
    uint16_t port_;
};

tcp_server.hpp

#pragma once
#include <functional>
#include <pthread.h>
#include "tcp_socket.hpp"
typedef std::function<void(const std::string &, std::string *)> Handler;
struct ThreadArg
{
    TcpSocket new_sock;
    std::string ip;
    uint16_t port;
    Handler handler;
};
class TcpThreadServer
{
public:
    TcpThreadServer(const std::string &ip, uint16_t port) : ip_(ip), port_(port)
    {
    }
    bool Start(Handler handler)
    {
        // 1. 创建 socket;
        CHECK_RET(listen_sock_.Socket());
        // 2. 绑定端口号
        CHECK_RET(listen_sock_.Bind(ip_, port_));
        // 3. 进行监听
        CHECK_RET(listen_sock_.Listen(5));
        // 4. 进入循环
        for (;;)
        {
            // 5. 进行 accept
            ThreadArg *arg = new ThreadArg();
            arg->handler = handler;
            bool ret = listen_sock_.Accept(&arg->new_sock, &arg->ip, &arg->port);
            if (!ret)
            {
                continue;
            }
            printf("[client %s:%d] connect\n", arg->ip.c_str(), arg->port);
            // 6. 创建新的线程完成具体操作
            pthread_t tid;
            pthread_create(&tid, NULL, ThreadEntry, arg);
            pthread_detach(tid);
        }
        return true;
    }
    // 这里的成员函数为啥非得是 static?
    static void *ThreadEntry(void *arg)
    {
        // C++ 的四种类型转换都是什么?
        ThreadArg *p = reinterpret_cast<ThreadArg *>(arg);
        ProcessConnect(p);
        // 一定要记得释放内存!!! 也要记得关闭文件描述符
        p->new_sock.Close();
        delete p;
        return NULL;
    }
    // 处理单次连接. 这个函数也得是 static
    static void ProcessConnect(ThreadArg *arg)
    {
        // 1. 循环进行读写
        for (;;)
        {
            std::string req;
            // 2. 读取请求
            bool ret = arg->new_sock.Recv(&req);
            if (!ret)
            {
                printf("[client %s:%d] disconnected!\n", arg->ip.c_str(), arg->port);
                break;
            }
            std::string resp;
            // 3. 根据请求计算响应
            arg->handler(req, &resp);
            // 4. 发送响应
            arg->new_sock.Send(resp);
            printf("[client %s:%d] req: %s, resp: %s\n", arg->ip.c_str(),
                   arg->port, req.c_str(), resp.c_str());
        }
    }

private:
    TcpSocket listen_sock_;
    std::string ip_;
    uint16_t port_;
};

 dict_client.cc

#include "tcp_client.hpp"
#include <iostream>
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        printf("Usage ./dict_client [ip] [port]\n");
        return 1;
    }
    TcpClient client(argv[1], atoi(argv[2]));
    bool ret = client.Connect();
    if (!ret)
    {
        return 1;
    }
    // for (;;)
    // {
    //     std::cout << "请输入要查询的单词:" << std::endl;
    //     std::string word;
    //     std::cin >> word;
    //     if (!std::cin)
    //     {
    //         break;
    //     }
    //     client.Send(word);
    //     std::string result;
    //     client.Recv(&result);
    //     std::cout << result << std::endl;
    // }
    for (;;)  //客户端创建json串发往服务器
    {
        std::cout << "请输入你的协议:" << std::endl;
        // const std::string& str = "{\"a\":true,\"b\":{\"a\":true,\"b\":[1, \"a\", 3, null, -1.2345, true, false, \"hello world\"],\"c\":123,\"4\":\"hello world\"},\"c\":123,\"4\":\"hello world\"}";
        // Json v;
        // v.parse(str);
        // std::cout << v.str() << std::endl;
        // client.Send(v.str());
        Json arr;
        arr[1] = true;
        arr[2] = 123;
        arr[3] = 1.23;
        arr[4] = "hello";
        Json obj;
        obj["bool"] = true;
        obj["int"] = 123;
        obj["double"] = 1.23;
        obj["arr"] = arr;
        std::cout << obj.str() << std::endl;
        client.Send(obj);
        obj.clear();

        Json result;
        // client.Recv(result);
        // std::string result;
        client.Recv(&result);
        std::cout << result.str() << std::endl;
    }
    return 0;
}

dict_server.cc

#include <unordered_map>
#include "tcp_server.hpp"
#include "./json/json.h"
#include "./json/parser.h"
std::unordered_map<std::string, std::string> g_dict;
// void Translate(const std::string &req, std::string *resp)
// {
//     auto it = g_dict.find(req);
//     if (it == g_dict.end())
//     {
//         *resp = "未找到";
//         return;
//     }
//     *resp = it->second;
//     return;
// }
void Translate(const std::string &req, std::string *resp)
{
    // auto it = g_dict.find(req);
    // if (it == g_dict.end())
    // {
    //     *resp = "未找到";
    //     return;
    // }
    // *resp = it->second;
    // return;

    Json vaule;
    vaule.parse(req);
    if(vaule["bool"])
    {
        Json obj;
        //收到Json串这里可以有服务器自己处理业务
        //obj["服务器"] = "收到了";
        Json arr;
        arr[0] = "服务器收到客户端的数据了";
        arr[1] = "服务器发往客户端的协议为:932";
        arr[2] = 932;
        obj["服务器"] = arr;
        *resp = obj.str();
        obj.clear();
    }
    vaule.clear();
}
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        printf("Usage ./dict_server [ip] [port]\n");
        return 1;
    }
    // 1. 初始化词典
    //g_dict.insert(std::make_pair("hello", "你好"));
    //g_dict.insert(std::make_pair("world", "世界"));
    //g_dict.insert(std::make_pair("bit", "贼NB"));
    // 2. 启动服务器
    TcpThreadServer server(argv[1], atoi(argv[2]));
    server.Start(Translate);
    return 0;
}

makefile

.PHONY:all
all:dict_client dict_server
dict_client:dict_client.cc ./json/json.cc ./json/parser.cc
dict_client.cc:
	g++ -o $@  $^ -std=c++11
dict_server:dict_server.cc ./json/json.cc ./json/parser.cc
	g++ -o $@ $^  -std=c++11 -lpthread
.PHONY:clean
clean:
	rm -rf dict_client dict_server

测试截图：

 

 

githup地址： 

 基于Josn的网络通信

josn工具

protobuf工具

932我
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JSON数据交互
m0_56183421的博客
06-01 638
JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式，目前使用特别广泛。采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。在 JavaScript 语言中，一切都是对象。因此，任何JavaScript 支持的类型都可以通过 JSON 来表示，例如字符串、数字、对象、数组等。看看他的要求和语法格式：对象表示为键值对，数据由逗
Json 一种轻量级的数据通信格式
quzishen的专栏
11-16 6000
<br />Json是一种基于js的轻量级数据交换格式，独立于特定的语言，其中对于信息的保存使用特殊的符合来实现不同的数据结构。可以构建两种基本数据结构：<br /> <br />1、对象<br />对象的概念类似于面向对象语言中的逻辑，采用 key/value的方式保存数据，同时使用{}包含来表示对象；如：<br /> <br />{name:'quzishen',company:'netease',department:{d1:'hangzhou',d2:'tech',d3:'dir'}}<br /> 
C++实现Socket传输json（UDP形式）
08-17
服务端发送给客户端，服务端有一串字符串，按照分隔符将其分割，并存入json，发给客户端，然后输出。
通信协议jsonrpc
SteveRocket's-Blog
04-26 3032
JSON-RPC是一种轻量级且无状态的远程过程调用（RPC）协议，它使用JSON（JavaScript Object Notation）作为数据格式，并通过HTTP或TCP协议传输数据。它允许客户端和服务器之间进行无状态的通信，从而实现分布式应用程序的远程过程调用。
C++使用json在Linux中实现TCP通信
qq_21197941的博客
06-28 2334
最近在学习使用json格式在Linux中进行tcp通信,以下为学习笔记我使用的第三方库为, 仓库地址为nlohmann/json: JSON for Modern C++ (github.com)的所有代码都保存在单个头文件中，所以要使用,需要在实现文件中包含 json的发送与接收 要发送json格式的数据时需要先将其转换为二进制数据，我使用以下代码实现转换 在接收到json的二进制数据后，再将其转换为json格式 代码实例 我封装了一个用于json与内置数据类型与STL容器转换的类 以下为在客户端与服务端
android服务器和客户端通信《下》
08-04
总的来说，Android客户端与服务器的通信是一个复杂的过程，涉及到网络编程、数据序列化、线程控制等多个方面。开发者需要理解这些基本原理，并根据实际需求选择合适的通信方式和工具。在实际项目中，考虑到性能、...
基于SOCKET编程多人聊天软件HTML+JSON报文
06-24
基于socket实现通信，开启一个端口进行监听，当有用户连接，则建立TCP连接，并且保存连接。建立多线程，当有客户端发送消息则对HTTP报文进行处理，并发送响应报文。传输的消息格式为HTTP,正文采用URL+JSON方式。...
基于TCP通信丢包原因总结(推荐)
08-29
3. 多线程同步问题：多线程同步问题可能导致数据丢失，例如多个线程同时访问同一个资源，可能导致数据丢失。 4. TCP粘包和拆包问题：TCP是一个流协议，一个完整的包可能会被TCP拆分成多个包进行发送，也可能把小的...
Java实现的基于socket通信的实例代码
09-05
在实际应用中，这样的通信可能涉及更复杂的逻辑，如数据的序列化、错误处理、多线程支持等。例如，服务器可能需要处理多个并发的客户端连接，这可以通过在一个单独的线程中处理每个新连接来实现。客户端可能需要发送...
JSON在Android和Web通信中的应用研究.pdf
09-21
在Android客户端应用开发中，JSON不仅用于获取服务器上的数据，还用于向服务器发送用户操作产生的数据，是移动应用与Web服务间通信的重要桥梁。 1. JSON的结构和语法： JSON基于JavaScript的一个子集，主要由对象...
客户端json格式化工具
09-30
json格式化工具，json格式化工具，json格式化工具，json格式化工具
JSON客户端与服务器端生成JSON数据及传递方法
02-24
JSON 即 JavaScript Object Natation，它是一种轻量级的数据交换格式，非常适合于服务器与 JavaScript 的交互。本文将快速讲解 JSON 格式，并通过代码示例演示如何分别在客户端和服务器端进行 JSON 格式数据的处理。 尽管有许多宣传关于 XML 如何拥有跨平台，跨语言的优势，然而，除非应用于 Web Services，否则，在普通的 Web 应用中，开发者经常为 XML 的解析伤透了脑筋，无论是服务器端生成或处理 XML，还是客户端用 JavaScript 解析 XML，都常常导致复杂的代码，极低的开发效率。实际上，对于大多数 Web 应用来说，他们根本不需要复杂的 XML 来传输数据，XML 的扩展性很少具有优势，许多 AJAX 应用甚至直接返回 HTML 片段来构建动态 Web 页面。和返回 XML 并解析它相比，返回 HTML 片段大大降低了系统的复杂性，但同时缺少了一定的灵活性。 现在， JSON 为 Web 应用开发者提供了另一种数据交换格式。让我们来看看 JSON 到底是什么，同 XML 或 HTML 片段相比，JSON 提供了更好的简单性和灵活性。
服务器端与客户端使用Json进行数据交互
HHLee1995的博客
04-17 5884
服务器端： 引入相应的包：json-lib-2.2-jdk15.jar Action：     public String findAll() throws IOException{ List news = newsService.findAll(); //把java 对象列表转换为json对象数组，并转为字符串 JSONArray array = JSONArray.fromOb
json通信协议 java_（63）通信协议之一json
weixin_35940111的博客
02-17 449
1.什么是JSONJSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。它基于JavaScript的一个子集。 JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯(包括C, C++, C#, Java, JavaScript, Perl, Python等)。这些特性使JSON成为理想的数据交换语言。易于人阅读和编写，同时也易于机器解析和...
Json-Server 简单使用
oJuHao12345的专栏
11-07 1004
用于模拟服务端接口数据，可以根据json数据建立一个完整的web服务。一般用在前后端分离后，前端人员可以不依赖API开发，而在本地搭建一个JSON服务，自己产生测试数据。
PLC通过智能网关，实现HTTP协议的POST/GET请求，与服务端JSON格式双向通讯
AutoCtrl的博客
05-07 7702
智能网关IGT-DSER集成了多种PLC的原厂协议，方便实现各种PLC与服务端之间的HTTP协议通讯，通过网关的参数配置软件绑定JSON文件的字段与PLC寄存器地址，配置URL，即可通过POST/GET命令，将JSON文件提交给HTTP的服务端； 如果服务端有返回的JSON，网关进行解析后将数据写入到PLC，实现PLC与HTTP服务端双向通讯。 网关模块详细资料 网关支持多种工作模式：周期模式是按设置的周期时间提交POST请求和解析返回的文件；触发模式可配置一个或多个触发条...
记一次线上故障的排查过程
高性能架构探索
12-21 1107
记录了某次线上进程崩溃的整个排查过程
【ESP32_8266_WiFi (十一)】通过JSON实现物联网数据通讯
K3169的博客
11-14 2127
由于易于解析且量级很轻，JSON成为了常用的物联网信息传输格式之一。 主要学习以下几个知识点： 1. 使用ESP8266来建立物联网服务器，该服务器可以向客户端发送JSON格式响应信息从而实现物联网信息通讯。 2. 使用ESP8266来通过网络向物联网服务器请求JSON信息 3. 使用ESP8266来通过ArduinoJson库解析JSON信息
在线json服务器,json服务器
weixin_36475420的博客
07-31 386
android跟服务器使用json传递数据最近在做项目,使用了json传递数据,把服务器对象转换成json字符串返回,android使用gson包解析json字符串变成对象. 1.服务器代码编写,我这边是在servlet里面 Peronperson=newPerson("张三","男");Peron是自定义...文章ansen_6662016-04-292179浏览量iOS开发网络篇—发送js...
android studio手机app实现客户端与服务器的通信
最新发布
06-06
Android Studio是一种...总之，在实现Android应用程序中客户端与服务器之间的通信时，需要综合考虑多方面因素，选择合适的通信协议和数据传输格式，并采取适当的异常处理和安全措施，以确保程序运行稳定性和数据安全。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值