VisualStudio2015下利用boost::asio实现客户端和服务器端的连接及文本信息发送

1.主要实现本地文本信息传送

//服务端
#include <hl/version_check/boost_impl.h>
#include <hl/net_driver.h>
#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include <boost/make_shared.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/coroutine.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <iostream>

class server
{
public:
	class tcp_connection : public boost::enable_shared_from_this<tcp_connection>
	{
	public:

		boost::asio::ip::tcp::socket& socket()              //获取套接字
		{
			return _socket;
		}

		void start()
		{
			//const char text[] = "HTTP/1.1 200 OK\r\nContent-length:2\r\n\r\nok";  //  HTTP/1.1：协议为Http，版本是1.1
			boost::asio::async_write(_socket, boost::asio::buffer("1", 1),
				boost::bind(&tcp_connection::handle_write, shared_from_this(), _1, _2));//两个占位符的实际传入的值是什么？
		}

		tcp_connection(boost::asio::io_service& ios) : _socket(ios)
		{
		}

	private:

		char buffer[1024];
		void handle_write(const boost::system::error_code& e, size_t s)
		{
			if (e)
			{
				std::cout << e.message() << std::endl;
			}
			else
			{
	
				memset(buffer, 0, 1024);
				boost::asio::async_read(_socket, boost::asio::buffer(buffer, 1), boost::bind(&tcp_connection::handle_read, shared_from_this(), _1, _2));//每次接收一个字符并存在buffer中,调用handle_read

			}
		}

		void handle_read(const boost::system::error_code& e, size_t s)
		{
			if (e)
			{
				std::cout << e.message() << std::endl;
			}
			else
			{
				std::cout <<"server recv:"<< buffer << "\n";   //把接收到的字符打印出来
			}

			ho::thread::sleep(1000); //休息1秒
			boost::asio::async_write(_socket, boost::asio::buffer("1", 1),
			boost::bind(&tcp_connection::handle_write, shared_from_this(), _1, _2));//每次发送一个'1',调用handle_write

		}


		boost::asio::ip::tcp::socket _socket;
	};


	class tcp_server : public boost::asio::coroutine, public boost::enable_shared_from_this<tcp_server>
	{
	private:
		boost::asio::io_service &_ios;
		boost::shared_ptr<boost::asio::ip::tcp::acceptor> _acceptor;
		boost::shared_ptr<tcp_connection> _conn;

	public:
		tcp_server(boost::asio::io_service& ios) : _ios(ios)
		{

		}

		void go()
		{
			_ios.post(boost::bind(&tcp_server::go_internal, shared_from_this()));
		}
#include <boost/asio/yield.hpp>
		void go_internal()
		{

			reenter(this)
			{
				_acceptor = boost::make_shared<boost::asio::ip::tcp::acceptor>(_ios, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), 10086));//10086为端口号
				for (;;)
				{
					_conn = boost::make_shared<tcp_connection>(_ios);
					yield _acceptor->async_accept(_conn->socket(), boost::bind(&tcp_server::go_internal, shared_from_this()));
					_conn->start();
				}
			}
		}
#include <boost/asio/unyield.hpp>
	};

};
struct __TEST_ASIO;
typedef ho::net_service2<__TEST_ASIO> test_asio_service;


void main()
{
	boost::make_shared<server::tcp_server>(test_asio_service::get_io_service())->go(); //开启服务器
	for (;;)
	{
		ho::thread::sleep(1000);
	}
}

#include <hl/version_check/boost_impl.h>
#include <hl/net_driver.h>
#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include <boost/make_shared.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/coroutine.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <iostream>

//客户端
class client
{
public:
	client(boost::asio::io_service& io_service,
		const std::string& server, const std::string& path)
		: resolver_(io_service),
		socket_(io_service)
	{
		boost::asio::ip::tcp::resolver::query query(server, "10086");//10086为端口号
		resolver_.async_resolve(query,
			boost::bind(&client::handle_resolve, this,
				boost::asio::placeholders::error,
				boost::asio::placeholders::iterator));
	}

private:
	char _buffer[1024];

	void handle_resolve(const boost::system::error_code& err,
		boost::asio::ip::tcp::resolver::iterator endpoint_iterator)
	{
		if (!err)
		{
			// Attempt a connection to each endpoint in the list until we
			// successfully establish a connection.
			boost::asio::async_connect(socket_, endpoint_iterator,
				boost::bind(&client::handle_connect, this,
					boost::asio::placeholders::error));
		}
		else
		{
			std::cout << "Error: " << err.message() << "\n";
		}
	}

	void handle_connect(const boost::system::error_code& err)
	{
		if (!err)
		{
			boost::asio::async_read(socket_, boost::asio::buffer(_buffer, 1),
				boost::bind(&client::handle_read, this, _1, _2));
		}
		else
		{
			std::cout << "Error: " << err.message() << "\n";
		}
	}

	void handle_read(const boost::system::error_code& err, size_t s)
	{
		if (!err)
		{
			std::cout  << " client recv:"  << _buffer << "\n";

			boost::asio::async_write(socket_, boost::asio::buffer("2", 1), boost::bind(&client::handle_write, this, _1, _2));

		}
		else
		{
			std::cout << "Error: " << err.message() << "\n";
		}
	}

	void handle_write(const boost::system::error_code& err, size_t s)
	{
		if (!err)
		{
			memset(_buffer, 0, 1024);
			boost::asio::async_read(socket_, boost::asio::buffer(_buffer, 1),
				boost::bind(&client::handle_read, this, _1, _2));

		}
		else
		{
			std::cout << "Error: " << err.message() << "\n";
		}
	}


	boost::asio::ip::tcp::resolver resolver_;
	boost::asio::ip::tcp::socket socket_;
	boost::asio::streambuf request_;
	boost::asio::streambuf response_;
};

void main()
{

	boost::asio::io_service io_service;                //开启客户端 
	client c(io_service, "127.0.0.1", "");
	io_service.run();

}