my simplest kv db

最简单的kv db

最基本的网络连接 使用STL map存储key value 作为多线程互斥的简单例子。

以后有机会逐步优化添加功能

1增加ASIO 异步通讯

2优化存储空间 传递指针 避免过多的拷贝操作

3优化代码结构

4优化全局锁 操作map时候 锁定部分区域而不是锁全局 。(思路在之前博客有提过多线程查找大量数据加锁的速度降低)

效果图：

部分代码

 #include "NetWork.h"
 #include "Handler.h"
 #include <thread>

 void DEF::NetWorkClass::work() {
     try {
         while () {
             std::shared_ptr<boost::asio::ip::tcp::socket> psocket =
                 std::make_shared<boost::asio::ip::tcp::socket>(*pio_service_);
             pacceptor_->accept(*psocket);
             std::thread t = std::thread(DEF::Handler, psocket);
             t.detach();
         }
     }
     catch (std::exception& e) {
         std::cerr << __FUNCTION__ << " " <<
             e.what() << std::endl;
     }
     return;
 }

NetWork.cpp

#pragma once
#include "PreHead.h"
#include <boost/asio.hpp>
#include <memory>
#include <iostream>

using boost::asio::ip::tcp;

NAMESPACEBEGIN(DEF)

class NetWorkClass {
public:
    NetWorkClass(short port):port_(port),pacceptor_ (nullptr), pio_service_(nullptr){}
    bool Init() {
        bool b = false;
        pio_service_ = std::make_shared<boost::asio::io_service>();
        if (nullptr == pio_service_) {
            std::cerr << __FUNCTION__ << " make io_service() error!" << std::endl;
            return b;
        }
        pacceptor_ = std::make_shared<tcp::acceptor>(*pio_service_,
            tcp::endpoint(tcp::v4(), port_));
        if (nullptr == pio_service_) {
            std::cerr << __FUNCTION__ << " make acceptor() error!" << std::endl;
            return b;
        }

        b = true;
        return b;
    }

    void work();

private:
    short port_;
    std::shared_ptr<tcp::acceptor> pacceptor_;
    std::shared_ptr<boost::asio::io_service> pio_service_;
};

NAMESPACEEND

NetWork.h

 #pragma once
 #include "PreHead.h"
 #include <memory>
 #include <iostream>
 #include <boost/asio.hpp>

 NAMESPACEBEGIN(DEF)

 bool Handler(std::shared_ptr<boost::asio::ip::tcp::socket> psocket);

 struct Item {
     std::string command_;
     std::string key_;
     std::string value_;
     std::string result_;
 };

 class ParseRecvString {
 public:
     static void TestSplitBySpace();
     static std::vector<std::string> SplitBySpace(const std::string& recvStr) {
         std::vector<std::string> vecStr;
         size_t begPos = recvStr.find_first_not_of(' ');
         size_t endPos = recvStr.find_first_of(' ', begPos+);
         while (begPos != std::string::npos) {
             endPos = recvStr.find_first_of(' ', begPos);
             if (endPos != std::string::npos){
                 vecStr.push_back(recvStr.substr(begPos, endPos - begPos));
                 begPos = recvStr.find_first_not_of(' ', endPos + );
             }
             else {
                 vecStr.push_back(recvStr.substr(begPos));
                 begPos = endPos;
             }
         }

         return vecStr;
     }

 private:
 };

 class CommandHandler {
 public:
     CommandHandler(const std::vector<std::string>& command) :command_(command) {}

 private:
     std::vector<std::string> command_;
 };

 class Session {
 public:
     Session(std::shared_ptr<boost::asio::ip::tcp::socket> psocket): psocket_(psocket){}
     Session(const Session& s) = delete;
     Session operator=(const Session& s) = delete;
     bool LoopHandle();
 private:
     void SetFunc(const std::vector<std::string>& vecStr, Item& item);
     void GetFunc(const std::vector<std::string>& vecStr, Item& item);
     void AppendFunc(const std::vector<std::string>& vecStr, Item& item);
     void PreAppendFunc(const std::vector<std::string>& vecStr, Item& item);
     void DeleteFunc(const std::vector<std::string>& vecStr, Item& item);
     void DispatchCommand(const std::vector<std::string>& vecStr, Item& item);
     bool ParseRecvData(char* recvData,size_t len,Item& item);
     std::shared_ptr<boost::asio::ip::tcp::socket> psocket_;
 };

 NAMESPACEEND

Handler.h

#include "Handler.h"
#include "DbStored.h"
#include <iostream>
#include <string>

extern DEF::DBStored g_dbStored;

bool DEF::Handler(std::shared_ptr<boost::asio::ip::tcp::socket> psocket) {
    bool b = false;
    Session s(psocket);
    b = s.LoopHandle();

    return b;
}
bool DEF::Session::ParseRecvData(char* recvData, size_t len, Item& item) {
    bool b = false;
    recvData[len] = '\0';
    std::string recvstr(recvData);
    std::vector<std::string> vecStr = ParseRecvString::SplitBySpace(recvstr);
    DispatchCommand(vecStr,item);

    return b;
}

void DEF::Session::SetFunc(const std::vector<std::string>& vecStr, Item& item) {
    assert(vecStr.size() >= );
    bool b = g_dbStored.InsertDBWithLock(vecStr[], vecStr[]);
    item.key_ = vecStr[];
    item.value_ = vecStr[];
    if (b) {
        item.result_ = "STORED";
    }
    else {
        item.result_ = "STORED_FAILED";
    }
    return ;
}

void DEF::Session::GetFunc(const std::vector<std::string>& vecStr, Item& item) {
    assert(vecStr.size() >= );
    std::string getVal;
    bool b = g_dbStored.GetFromDbWithLock(vecStr[], getVal);
    item.key_ = vecStr[];
    item.value_ = getVal;
    if (b) {
        item.result_ = getVal;
    }
    else {
        item.result_ = "GET_FAILED";
    }
    return ;
}

void DEF::Session::AppendFunc(const std::vector<std::string>& vecStr, Item& item) {
    assert();

    return ;
}

void DEF::Session::PreAppendFunc(const std::vector<std::string>& vecStr, Item& item) {
    assert();

    return ;
}

void DEF::Session::DeleteFunc(const std::vector<std::string>& vecStr, Item& item) {

    return ;
}

void DEF::Session::DispatchCommand(const std::vector<std::string>& vecStr, Item& item)
{
    std::string s = vecStr[];
    std::string result;
    transform(s.begin(), s.end(), s.begin(), tolower);
    //可使用MAP 进行命令分发
    if (s == "set") {
        item.command_ = "set";
        SetFunc(vecStr, item);
    }
    else if (s == "get") {
        item.command_ = "get";
        GetFunc(vecStr, item);
    }
    else if (s == "append") {
        item.command_ = "append";
        AppendFunc(vecStr, item);
    }
    else if (s == "preappend") {
        item.command_ = "preappend";
        PreAppendFunc(vecStr, item);
    }
    else if (s == "del") {
        item.command_ = "del";
        DeleteFunc(vecStr, item);
    }
    else {
        item.result_ = "ERROR_COMMAND";
    }

    return;
}

void DEF::ParseRecvString::TestSplitBySpace()
{
    std::string s1 = " set   ";
    std::string s2 = " set";
    std::string s3 = "set";
    std::string s4 = "set ";
    std::string s5 = " set   mykey myvalue";
    std::string s6 = " set   mykey myvalue ";
    std::string s7 = " set   mykey   myvalue ";
    std::string s8 = "set mykey myvalue";

    std::vector<std::string> vs;

    vs = DEF::ParseRecvString::SplitBySpace(s1);
    assert(vs.size() ==  && vs[] == "set");
    vs.clear();
    vs = DEF::ParseRecvString::SplitBySpace(s2);
    assert(vs.size() ==  && vs[] == "set");
    vs.clear();
    vs = DEF::ParseRecvString::SplitBySpace(s3);
    assert(vs.size() ==  && vs[] == "set");
    vs.clear();
    vs = DEF::ParseRecvString::SplitBySpace(s4);
    assert(vs.size() ==  && vs[] == "set");
    vs.clear();
    vs = DEF::ParseRecvString::SplitBySpace(s5);
    assert(vs.size() ==  && vs[] == "set" && vs[] == "mykey" && vs[] == "myvalue");
    vs.clear();
    vs = DEF::ParseRecvString::SplitBySpace(s6);
    assert(vs.size() ==  && vs[] == "set" && vs[] == "mykey" && vs[] == "myvalue");
    vs.clear();
    vs = DEF::ParseRecvString::SplitBySpace(s7);
    assert(vs.size() ==  && vs[] == "set" && vs[] == "mykey" && vs[] == "myvalue");
    vs.clear();
    vs = DEF::ParseRecvString::SplitBySpace(s8);
    assert(vs.size() ==  && vs[] == "set" && vs[] == "mykey" && vs[] == "myvalue");
    vs.clear();
}

bool DEF::Session::LoopHandle() {
    bool b = false;
    if (psocket_ == nullptr)
        return b;
    char recvData[];
    try {
        while () {
            boost::system::error_code error;
            size_t len = psocket_->read_some(boost::asio::buffer(recvData,), error);
            if (error == boost::asio::error::eof) {
                return (b = true);
            }
            else if (error) {
                throw boost::system::system_error(error);
            }
            Item item;
            b = ParseRecvData(recvData, len,item);
            len = psocket_->write_some(boost::asio::buffer(item.result_.c_str(),item.result_.size()),
                error);
            if (error) {
                throw boost::system::system_error(error);
            }
        }
    }
    catch (std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
    return b;
}

Handler.cpp