boost::asio TCP socket聊天室扩展（消息对象从json对象获取信息及将消息对象转成json对象）

本文链接：https://blog.csdn.net/qianlima210210/article/details/104830485


#ifndef CHAT_MESSAGE_HPP
#define CHAT_MESSAGE_HPP

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <cassert>
#include "structHeader.hpp"

class chat_message
{
public:
    enum { header_length = sizeof(Header) };
    enum { max_body_length = 512 };

chat_message()
{
}

const char* data() const
{
    return data_;
}

char* data()
{
    return data_;
}

size_t length() const
{
    return header_length + m_header.bodySize;
}

const char* body() const
{
    return data_ + header_length;
}

char* body()
{
    return data_ + header_length;
}

int type(){
    return m_header.type;
}

size_t body_length() const
{
    return m_header.bodySize;
}

void setMessage(int messageType, const void *buffer, size_t bufferSize){
    assert(bufferSize <= max_body_length);
    m_header.bodySize = (int)bufferSize;
    m_header.type = messageType;
    std::memcpy(body(), buffer, bufferSize);
    std::memcpy(data(), &m_header, header_length);
}
    
void setMessage(int messageType, const std::string& buffer){
    setMessage(messageType, buffer.data(), buffer.size());
}

bool decode_header()
{
    std::memcpy(&m_header, data(), header_length);
    if (m_header.bodySize > max_body_length) {
        std::cout << "body size " << m_header.bodySize << " " << m_header.type << std::endl;
        return false;
    }
    
    return true;
}

private:
    char data_[header_length + max_body_length];
    Header m_header;
};

#endif // CHAT_MESSAGE_HPP

//
//  chat_message.cpp
//  ServerOfChat
//
//  Created by ma qianli on 2020/3/4.
//  Copyright © 2020 qianli. All rights reserved.
//

#include "chat_message.hpp"

///

//
//  JsonObject.hpp
//  ClientOfChat
//
//  Created by ma qianli on 2020/3/12.
//  Copyright © 2020 qianli. All rights reserved.
//

#ifndef JsonObject_hpp
#define JsonObject_hpp

#include <stdio.h>
#include <sstream>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/json_parser.hpp>
#include <string>

using ptree = boost::property_tree::ptree;
inline std::string ptreeToJsonString(const ptree& tree){
    std::stringstream ss;
    boost::property_tree::write_json(ss, tree, false);
    return ss.str();
}

#endif /* JsonObject_hpp */

//
//  JsonObject.cpp
//  ClientOfChat
//
//  Created by ma qianli on 2020/3/12.
//  Copyright © 2020 qianli. All rights reserved.
//

#include "JsonObject.hpp"

///

//
//  SerilizationObject.hpp
//  ClientOfChat
//
//  Created by ma qianli on 2020/3/11.
//  Copyright © 2020 qianli. All rights reserved.
//

#ifndef SerilizationObject_hpp
#define SerilizationObject_hpp

#include <stdio.h>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>

class SBindName {
    friend class boost::serialization::access;
    template <class Archive>
    void serialize(Archive &ar, const unsigned int version){
        ar & m_bindName;
    }
    std::string m_bindName;
public:
    SBindName(std::string name):m_bindName(std::move(name)){}
    SBindName(){}
    const std::string& bindName()const{
        return m_bindName;
    }
};

class SChatInfo {
    friend class boost::serialization::access;
    template <class Archive>
    void serialize(Archive &ar, const unsigned int version){
        ar & m_chatInformation;
    }
    std::string m_chatInformation;
    
public:
    SChatInfo(std::string info):m_chatInformation(std::move(info)){}
    SChatInfo(){}
    const std::string& chatInformation()const{
        return m_chatInformation;
    }
};

class SRoomInfo {
    friend class boost::serialization::access;
    template <class Archive>
    void serialize(Archive &ar, const unsigned int version){
        ar & m_bind;
        ar & m_chat;
    }
    
    SBindName m_bind;
    SChatInfo m_chat;
    
public:
    SRoomInfo(){}
    SRoomInfo(std::string name, std::string info):
    m_bind(std::move(name)), m_chat(std::move(info)){}
    
    const std::string& bindName()const{
        return m_bind.bindName();
    }
    
    const std::string& chatInformation()const{
        return m_chat.chatInformation();
    }
};


#endif /* SerilizationObject_hpp */

//
//  SerilizationObject.cpp
//  ClientOfChat
//
//  Created by ma qianli on 2020/3/11.
//  Copyright © 2020 qianli. All rights reserved.
//

#include "SerilizationObject.hpp"



//
//  structHeader.hpp
//  ServerOfChat
//
//  Created by ma qianli on 2020/3/11.
//  Copyright © 2020 qianli. All rights reserved.
//

#ifndef structHeader_hpp
#define structHeader_hpp

#include <stdio.h>
#include <string>

struct Header {
    int bodySize;
    int type;
};

//client send
struct BindName {
    char name[32];
    int nameLen;
};
//client send
struct ChatInformation {
    char information[256];
    int infolen;
};
//server send
struct RoomInformation {
    BindName name;
    ChatInformation chat;
};

bool parseMessage(const std::string& input, int *type, std::string& outbuffer);
bool parseMessage2(const std::string& input, int *type, std::string& outbuffer);
bool parseMessage3(const std::string& input, int *type, std::string& outbuffer);


#endif /* structHeader_hpp */

//
//  structHeader.cpp
//  ServerOfChat
//
//  Created by ma qianli on 2020/3/11.
//  Copyright © 2020 qianli. All rights reserved.
//

#include "structHeader.hpp"
#include "SerilizationObject.hpp"
#include "JsonObject.hpp"
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <sstream>

//cmd messagebody
bool parseMessage(const std::string& input, int *type, std::string& outbuffer){
    
    auto pos = input.find_first_of(" ");
    if (pos == std::string::npos) {
        return false;
    }
    if (pos == 0) {
        return false;
    }
    
    auto cmd = input.substr(0, pos);//[)
    if (cmd == "BindName") {
        std::string name = input.substr(pos + 1);
        if (name.size() > 32) {
            return false;
        }
        
        if (type) {
            *type = 1;
        }
        
        BindName bindName;
        bindName.nameLen = (int)name.size();
        std::memcpy(&bindName, name.data(), name.size());
        //std::strcpy(bindName.name, name.c_str());
        auto buffer = (char*)(&bindName);
        outbuffer.assign(buffer, sizeof(bindName));
        return true;
        
    }else if (cmd == "Chat"){
        std::string chat = input.substr(pos + 1);
        if (chat.size() > 256) {
            return false;
        }
        
        if (type) {
            *type = 2;
        }
        
        ChatInformation chatInfo;
        chatInfo.infolen = (int)chat.size();
        std::memcpy(&chatInfo, chat.data(), chat.size());
        auto buffer = (char*)(&chatInfo);
        outbuffer.assign(buffer, sizeof(chatInfo));
        
        return true;
    }
    
    return false;
}

template <typename T>
std::string serialize(const T &obj){
    std::stringstream ss;
    boost::archive::text_oarchive oa(ss);
    oa & obj;//归档到ss中
    return ss.str();
}

bool parseMessage2(const std::string& input, int *type, std::string& outbuffer){
    
    auto pos = input.find_first_of(" ");
    if (pos == std::string::npos) {
        return false;
    }
    if (pos == 0) {
        return false;
    }
    
    auto cmd = input.substr(0, pos);//[)
    if (cmd == "BindName") {
        std::string name = input.substr(pos + 1);
        if (name.size() > 32) {
            return false;
        }
        
        if (type) {
            *type = 1;
        }
        
        outbuffer = serialize(SBindName(std::move(name)));
        return true;
        
    }else if (cmd == "Chat"){
        std::string chat = input.substr(pos + 1);
        if (chat.size() > 256) {
            return false;
        }
        
        if (type) {
            *type = 2;
        }
        outbuffer = serialize(SChatInfo(std::move(chat)));
        
        return true;
    }
    
    return false;
    
}

bool parseMessage3(const std::string& input, int *type, std::string& outbuffer){
    
      auto pos = input.find_first_of(" ");
      if (pos == std::string::npos) {
          return false;
      }
      if (pos == 0) {
          return false;
      }
      
      auto cmd = input.substr(0, pos);//[)
      if (cmd == "BindName") {
          std::string name = input.substr(pos + 1);
          if (name.size() > 32) {
              return false;
          }
          
          if (type) {
              *type = 1;
          }
          
          ptree tree;
          tree.put("name", name);
          outbuffer = ptreeToJsonString(tree);
          
          return true;
          
      }else if (cmd == "Chat"){
          std::string chat = input.substr(pos + 1);
          if (chat.size() > 256) {
              return false;
          }
          
          if (type) {
              *type = 2;
          }
          
          ptree tree;
          tree.put("information", chat);
          outbuffer = ptreeToJsonString(tree);
          
          return true;
      }
      
      return false;
      
}

/

//下面服务端main.cpp

#include <deque>
#include <iostream>
#include <list>
#include <set>
#include <memory>
#include <boost/asio.hpp>
#include "chat_message.hpp"
#include "SerilizationObject.hpp"
#include "JsonObject.hpp"

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

//----------------------------------------------------------------------

using chat_message_queue = std::deque<chat_message>;

//----------------------------------------------------------------------

class chat_participant
{
public:
  virtual ~chat_participant() {}
  virtual void deliver(const chat_message& msg) = 0;
};

using chat_participant_ptr = std::shared_ptr<chat_participant> ;

//----------------------------------------------------------------------

class chat_room
{
public:
  void join(chat_participant_ptr participant)
  {
    participants_.insert(participant);
      for (const auto& msg : recent_msgs_) {
          participant->deliver(msg);
      }
  }

  void leave(chat_participant_ptr participant)
  {
    participants_.erase(participant);
  }

  void deliver(const chat_message& msg)
  {
    recent_msgs_.push_back(msg);
    while (recent_msgs_.size() > max_recent_msgs)
      recent_msgs_.pop_front();

      for (auto& participant : participants_) {
          participant->deliver(msg);
      }
  }

private:
  std::set<chat_participant_ptr> participants_;
  enum { max_recent_msgs = 100 };
  chat_message_queue recent_msgs_;
};

//----------------------------------------------------------------------

class chat_session
  : public chat_participant,
    public std::enable_shared_from_this<chat_session>
{
public:
  chat_session(tcp::socket socket, chat_room& room)
    : socket_(std::move(socket)),
      room_(room)
  {
  }

  tcp::socket& socket()
  {
    return socket_;
  }

  void start()
  {
    room_.join(shared_from_this());      
      do_read_header();
  }

  void deliver(const chat_message& msg)
  {
    bool write_in_progress = !write_msgs_.empty();
    write_msgs_.push_back(msg);
    if (!write_in_progress)
    {
        do_write();
    }
  }
    void do_read_header(){
        auto self(shared_from_this());
        boost::asio::async_read(socket_,
                                boost::asio::buffer(read_msg_.data(), chat_message::header_length),
                                [this, self](boost::system::error_code ec, std::size_t length){
            if (!ec && read_msg_.decode_header()) {
                do_read_body();
            }else{
                room_.leave(shared_from_this());
            }
        });
    }
    

    void do_read_body(){
        auto self(shared_from_this());
        boost::asio::async_read(socket_,
                                boost::asio::buffer(read_msg_.body(),read_msg_.body_length()),
                                [this, self](boost::system::error_code ec, std::size_t length){
            if (!ec) {
                //room_.deliver(read_msg_);
                handleMessage();
                do_read_header();
            } else {
                room_.leave(shared_from_this());
            }
        });
    }
    
    ptree toPtree(){
        ptree obj;
	std::string buffer = std::string(read_msg_.body(), read_msg_.body_length());
	std::stringstream ss(buffer);
	boost::property_tree::read_json(ss, obj);//从流读取到对象(这里的对象，有点像NSObject中NSArray、NSDictionary对象)
	return obj;
    }
    
    void handleMessage(){
        if (read_msg_.type() == 1) {
            auto nameTree = toPtree();
            m_name = nameTree.get<std::string>("name");
	    std::cout << "shoudaoname " << m_name << std::endl;
            
        }else if (read_msg_.type() == 2){
            auto chat = toPtree();
            m_chatInformation = chat.get<std::string>("information");
	    std::cout << "information " << m_chatInformation << std::endl;  
            
            auto rinfo = buildRoomInfo();
            chat_message msg;
            msg.setMessage(3, rinfo);
            room_.deliver(msg);
        }
    }
    
    std::string buildRoomInfo()const{
        ptree tree;
        tree.put("name", m_name);
        tree.put("information", m_chatInformation);
        return ptreeToJsonString(tree);
    }
    
    void do_write(){
        auto self(shared_from_this());
        boost::asio::async_write(socket_,
                                 boost::asio::buffer(write_msgs_.front().data(), write_msgs_.front().length()),
                                 [this, self](boost::system::error_code ec, std::size_t length){
            if (!ec) {
                write_msgs_.pop_front();
                if (!write_msgs_.empty()) {
                    do_write();
                }
            } else {
                room_.leave(shared_from_this());
            }
        });
    }

private:
    std::string m_name;
    std::string m_chatInformation;
  tcp::socket socket_;
  chat_room& room_;
  chat_message read_msg_;
  chat_message_queue write_msgs_;
};

typedef boost::shared_ptr<chat_session> chat_session_ptr;

//----------------------------------------------------------------------

class chat_server
{
public:
  chat_server(boost::asio::io_service& io_service,
      const tcp::endpoint& endpoint)
    : socket_(io_service),
      acceptor_(io_service, endpoint)
  {
      do_accept();
  }
    
    void do_accept(){
        acceptor_.async_accept(socket_, [this](boost::system::error_code ec){
            if (!ec) {
                std::make_shared<chat_session>(std::move(socket_), room_)->start();
            }
            
            do_accept();
        });
    }

private:
  tcp::socket socket_;
  tcp::acceptor acceptor_;
  chat_room room_;
};

typedef boost::shared_ptr<chat_server> chat_server_ptr;
typedef std::list<chat_server_ptr> chat_server_list;

//----------------------------------------------------------------------

int main(int argc, char* argv[])
{
  try
  {
    if (argc < 2)
    {
      std::cerr << "Usage: chat_server <port> [<port> ...]\n";
      return 1;
    }

    boost::asio::io_service io_service;
      
      std::list<chat_server*> servers;
      for (int i = 1; i < argc; ++i) {
          tcp::endpoint endpoint(tcp::v4(), std::atoi(argv[i]));
          servers.push_back(new chat_server(io_service, endpoint));
      }

    io_service.run();
  }
  catch (std::exception& e)
  {
    std::cerr << "Exception: " << e.what() << "\n";
  }

  return 0;
}

/

//下面客户端main.cpp
#include <cstdlib>
#include <deque>
#include <iostream>
#include <thread>
#include <boost/asio.hpp>
                                                                        
#include "chat_message.hpp"
#include "SerilizationObject.hpp"
#include "JsonObject.hpp"
                     
using boost::asio::ip::tcp;
                     
using chat_message_queue = std::deque<chat_message>;
                     
class chat_client{
    boost::asio::io_service &m_io_service;
    tcp::socket m_socket;
    chat_message m_read_msg;
    chat_message_queue m_write_msgs;
public:
    chat_client(boost::asio::io_service &io_service,
                tcp::resolver::iterator endpoint_iterator):
    m_io_service(io_service), m_socket(io_service){
        do_connect(endpoint_iterator);
    }
                     
    void write(const chat_message &msg){
        //让lambda在m_io_service的run所在线程执行（类似于OC中的performSelector: onThread: withObject: waitUntilDone: modes:）
        m_io_service.post([this, msg](){
            bool write_in_progress = !m_write_msgs.empty();
            m_write_msgs.push_back(msg);
                                                                                                                              
            if (!write_in_progress) {
                do_write();
            }
        });
    }
    
    void close(){
        m_io_service.post([this](){
            m_socket.close();
        });
    }
    
    void do_connect(tcp::resolver::iterator endpoint_iterator){
        boost::asio::async_connect(m_socket, endpoint_iterator,
                                   [this](boost::system::error_code ec, tcp::resolver::iterator it){
            if (!ec) {
                do_read_header();
            }
        });
    }
    
    void do_read_header(){
        boost::asio::async_read(m_socket,
                                boost::asio::buffer(m_read_msg.data(), chat_message::header_length),
                                [this](boost::system::error_code ec, std::size_t lenght){
            if (!ec && m_read_msg.decode_header()) {
                do_read_body();
            }else{
                m_socket.close();
            }
        });
    }
    
    void do_read_body(){
        boost::asio::async_read(m_socket,
                                boost::asio::buffer(m_read_msg.body(), m_read_msg.body_length()),
                                [this](boost::system::error_code ec, std::size_t length){
            if (!ec) {
                if (m_read_msg.type() == 3) {
                    
                    std::stringstream ss(std::string(m_read_msg.body(), m_read_msg.body() +
                                                     m_read_msg.body_length()));
                    std::cout << "receive from server: " << ss.str() << std::endl;
                    ptree tree;
                    boost::property_tree::read_json(ss, tree);//从流中读取到tree
                    std::cout << "client: '";
                    std::cout << tree.get<std::string>("name");
                    std::cout << "' says '";
                    std::cout << tree.get<std::string>("information");
                    std::cout << "'" << std::endl;
                    
                }
                
                //继续读取下一条信息的头
                do_read_header();
                
            }else{
                m_socket.close();
            }
        });
    }
    
    void do_write(){
        boost::asio::async_write(m_socket,                                 boost::asio::buffer(m_write_msgs.front().data(), m_write_msgs.front().length()),
                                 [this](boost::system::error_code ec, std::size_t length){
            if (!ec) {
                m_write_msgs.pop_front();
                if (!m_write_msgs.empty()) {
                    do_write();
                }
            }else{
                m_socket.close();
            }
        });
    }
    
};

int main(int argc, const char * argv[]) {
    
    try {
        if (argc != 3) {
            std::cerr << "Usage: chat_client <host> <port>\n";
            return 1;
        }

        boost::asio::io_service io_service;
        tcp::resolver resolver(io_service);
        auto endpoint_iterator = resolver.resolve({argv[1], argv[2]});
        chat_client c(io_service, endpoint_iterator);

        std::thread t([&io_service](){
            io_service.run();//这样，与io_service绑定的事件源的回调均在子线程上执行（这里指的是boost::asio::async_xxx中的lambda函数）。
        });

        char line[chat_message::max_body_length + 1] = "";
        while (std::cin.getline(line, chat_message::max_body_length + 1)) {
            chat_message msg;
            auto type = 0;
            std::string input(line, line + std::strlen(line));
            std::string output;
            if (parseMessage3(input, &type, output)) {
                msg.setMessage(type, output.data(), output.size());
                c.write(msg);
                std::cout << "write message for server" << output.size() << std::endl;
            }
        }

        c.close();
        //这里必须close，否则子线程中run不会退出，
        //因为boost::asio::async_read事件源一直注册在io_service中.
        t.join();

    } catch (std::exception &e) {
        std::cerr << e.what() << std::endl;
    }
    
    return 0;
}