C++ REST图片下载

本文作者原创，首发在本博客；CSDN 上的同名文章已标注为转载并回链到本页：https://blog.csdn.net/qq_30220519/article/details/139896564

GitHub - microsoft/cpprestsdk: The C++ REST SDK is a Microsoft project for cloud-based client-server communication in native code using a modern asynchronous C++ API design. This project aims to help C++ developers connect to and interact with services.

handler.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
//hander.h
#ifndef HANDLER_H
#define HANDLER_H
#include <iostream>
#include "stdafx.h"
//#include "../dbms/include/Dbms.h"
#include <cpprest/http_client.h>
#include <cpprest/filestream.h>
#include <cpprest/http_listener.h>              // HTTP server
#include <cpprest/json.h>                       // JSON library
#include <cpprest/uri.h>                        // URI library
#include <cpprest/ws_client.h>                  // WebSocket client
#include <cpprest/containerstream.h>            // Async streams backed by STL containers
#include <cpprest/interopstream.h>              // Bridges for integrating Async streams with STL and WinRT streams
#include <cpprest/rawptrstream.h>               // Async streams backed by raw pointer to memory
#include <cpprest/producerconsumerstream.h>     // Async streams for producer consumer scenarios

using namespace std;
using namespace web;
using namespace http;
using namespace utility;
using namespace http::experimental::listener;


class handler
{
public:
	handler();
	handler(utility::string_t url);
	virtual ~handler();

	pplx::task<void>open() { return m_listener.open(); }
	pplx::task<void>close() { return m_listener.close(); }

protected:

private:
	void handle_get(http_request message);
	void handle_put(http_request message);
	void handle_post(http_request message);
	void handle_delete(http_request message);
	void handle_error(pplx::task<void>& t);
	http_listener m_listener;
};

#endif // HANDLER_H

handler.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
//hander.cpp
#include "stdafx.h"
#include "handler.h"

handler::handler()
{
    //ctor
}
handler::handler(utility::string_t url) :m_listener(url)
{
    m_listener.support(methods::GET, std::bind(&handler::handle_get, this, std::placeholders::_1));
    m_listener.support(methods::PUT, std::bind(&handler::handle_put, this, std::placeholders::_1));
    m_listener.support(methods::POST, std::bind(&handler::handle_post, this, std::placeholders::_1));
    m_listener.support(methods::DEL, std::bind(&handler::handle_delete, this, std::placeholders::_1));

}
handler::~handler()
{
    //dtor
}

void handler::handle_error(pplx::task<void>& t)
{
    try
    {
        t.get();
    }
    catch (...)
    {
        // Ignore the error, Log it if a logger is available
    }
}


//
// Get Request 
//
void handler::handle_get(http_request message)
{
    ucout << message.to_string() << endl;

    auto paths = http::uri::split_path(http::uri::decode(message.relative_uri().path()));

    message.relative_uri().path();
    //Dbms* d  = new Dbms();
    //d->connect();

    concurrency::streams::fstream::open_istream(U("static/index.html"), std::ios::in).then([=](concurrency::streams::istream is)
    {
        message.reply(status_codes::OK, is, U("text/html"))
            .then([](pplx::task<void> t)
        {
            try {
                t.get();
            }
            catch (...) {
                //
            }
        });
    }).then([=](pplx::task<void>t)
    {
        try {
            t.get();
        }
        catch (...) {
            message.reply(status_codes::InternalError, U("INTERNAL ERROR "));
        }
    });

    return;

};

//
// A POST request
//
void handler::handle_post(http_request message)
{
    ucout << message.to_string() << endl;


    message.reply(status_codes::OK, message.to_string());
    return;
};

//
// A DELETE request
//
void handler::handle_delete(http_request message)
{
    ucout << message.to_string() << endl;

    wstring rep = U("WRITE YOUR OWN DELETE OPERATION");
    message.reply(status_codes::OK, rep);
    return;
};


//
// A PUT request 
//
void handler::handle_put(http_request message)
{
    ucout << message.to_string() << endl;
    wstring rep = U("WRITE YOUR OWN PUT OPERATION");
    message.reply(status_codes::OK, rep);
    return;
};

 example.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
// example.cpp : Defines the entry point for the console application.
//
#include <iostream>
#include "stdafx.h"
#include "handler.h"
#include <cpprest/http_client.h>
#include <cpprest/filestream.h>
#include <cpprest/http_listener.h>              // HTTP server
#include <cpprest/json.h>                       // JSON library
#include <cpprest/uri.h>                        // URI library
#include <cpprest/ws_client.h>                  // WebSocket client
#include <cpprest/containerstream.h>            // Async streams backed by STL containers
#include <cpprest/interopstream.h>              // Bridges for integrating Async streams with STL and WinRT streams
#include <cpprest/rawptrstream.h>               // Async streams backed by raw pointer to memory
#include <cpprest/producerconsumerstream.h>     // Async streams for producer consumer scenarios

using namespace std;
using namespace web;
using namespace http;
using namespace utility;
using namespace http::experimental::listener;




std::unique_ptr<handler> g_httpHandler;

void on_initialize(const string_t& address)
{


	uri_builder uri(address);


	auto addr = uri.to_uri().to_string();
	g_httpHandler = std::unique_ptr<handler>(new handler(addr));
	g_httpHandler->open().wait();

	ucout << utility::string_t(U("Listening for requests at: ")) << addr << std::endl;

	return;
}

void on_shutdown()
{
	g_httpHandler->close().wait();
	return;
}

#ifdef _WIN32
int wmain(int argc, wchar_t *argv[])
#else
int main(int argc, char *argv[])
#endif
{
	utility::string_t port = U("34568");
	if (argc == 2)
	{
		port = argv[1];
	}

	utility::string_t address = U("http://127.0.0.1:");
	address.append(port);

	on_initialize(address);
	std::cout << "Press ENTER to exit." << std::endl;

	std::string line;
	std::getline(std::cin, line);

	on_shutdown();
	return 0;
}

图片下载

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
// crawlerImg.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
//#include <cpprest/http_client.h>
//#include <cpprest/filestream.h>
//
//using namespace utility;                    // Common utilities like string conversions
//using namespace web;                        // Common features like URIs.
//using namespace web::http;                  // Common HTTP functionality
//using namespace web::http::client;          // HTTP client features
//using namespace concurrency::streams;       // Asynchronous streams
//
//int main(int argc, char* argv[])
//{
//	auto fileStream = std::make_shared<ostream>();
//
//	// Open stream to output file.
//	pplx::task<void> requestTask = fstream::open_ostream(U("results.html")).then([=](ostream outFile)
//	{
//		*fileStream = outFile;
//
//		// Create http_client to send the request.
//		http_client client(U("http://www.bing.com/"));
//
//		// Build request URI and start the request.
//		uri_builder builder(U("/search"));
//		builder.append_query(U("q"), U("cpprestsdk github"));
//		return client.request(methods::GET, builder.to_string());
//	})
//
//		// Handle response headers arriving.
//		.then([=](http_response response)
//	{
//		printf("Received response status code:%u\n", response.status_code());
//
//		// Write response body into the file.
//		return response.body().read_to_end(fileStream->streambuf());
//	})
//
//		// Close the file stream.
//		.then([=](size_t)
//	{
//		return fileStream->close();
//	});
//
//	// Wait for all the outstanding I/O to complete and handle any exceptions
//	try
//	{
//		requestTask.wait();
//	}
//	catch (const std::exception &e)
//	{
//		printf("Error exception:%s\n", e.what());
//	}
//

	//同步方式
	//auto fileStream = std::make_shared<ostream>();
	//ostream outFile = fstream::open_ostream(U("results.html")).get();
	//*fileStream = outFile;

	//// Create http_client to send the request.
	//http_client client(U("http://www.bing.com/"));

	//// Build request URI and start the request.
	//uri_builder builder(U("/search"));
	//builder.append_query(U("q"), U("cpprestsdk github"));
	//http_response response = client.request(methods::GET, builder.to_string()).get();
	//// Write response body into the file.
	//response.body().read_to_end(fileStream->streambuf()).get();
	//fileStream->close().get();
//	return 0;
//}

//访问一个网站并将该内容保存在results.html里面，这里用到了微软自家的PPL并行计算库


#include <iostream>
#include <string>
#include <vector>
#include <fstream>
#include <memory>
#include <regex>
#include <cpprest/http_client.h>
#include <cpprest/filestream.h>
#include <cpprest/containerstream.h>

// 请求并解析url
bool get_result(const std::string& url, const std::string& pattern, std::vector<std::string>& vec)
{
	try
	{
		web::http::client::http_client client(web::uri(utility::conversions::to_string_t(url)));
		web::http::http_response response = client.request(web::http::methods::GET).get();

		concurrency::streams::stringstreambuf buffer;
		response.body().read_to_end(buffer).get();
		std::string& str = buffer.collection();

		// 使用C++11提供的正则表达式库
		std::regex r(pattern);
		for (std::sregex_iterator iter(str.begin(), str.end(), r), end; iter != end; ++iter)
		{
			std::cout << iter->str() << std::endl;
			vec.emplace_back(iter->str());
		}
	}
	catch (std::exception& e)
	{
		std::cout << "Exception: " << e.what() << std::endl;
		return false;
	}

	return true;
}

// 获取图片
bool get_result(const std::string& url, std::string& picture)
{
	try
	{
		web::http::client::http_client client(web::uri(utility::conversions::to_string_t(url)));
		web::http::http_response response = client.request(web::http::methods::GET).get();

		concurrency::streams::stringstreambuf buffer;
		response.body().read_to_end(buffer).get();
		picture = buffer.collection();
	}
	catch (std::exception& e)
	{
		std::cout << "Exception: " << e.what() << std::endl;
		return false;
	}

	return true;
}

// 保存图片
bool write_to_file(const std::string& file_path, const std::string& data)
{
	try
	{
		std::ofstream file;
		file.open(file_path, std::ios::out | std::ios::binary);
		if (!file.good())
		{
			return false;
		}
		file.write(data.c_str(), data.size());
		file.close();
	}
	catch (std::exception& e)
	{
		std::cout << "Exception: " << e.what() << std::endl;
		return false;
	}

	return true;
}

int main()
{
	// [1] 请求每一页，将子页面的url保存在sub_url_vec里面
	std::vector<std::string> sub_url_vec;
	std::string pattern = "/desk/[0-9]+.htm";
	for (int i = 1; i <= 32; ++i)
	{
		// 创意主题
		std::string url = "http://www.51ztzj.com/dbizhi/category_27_" + std::to_string(i) + ".htm#content_anchor";
		std::cout << "Start get " << i << " page, url: " << url << std::endl;
		// 请求并解析url
		if (!get_result(url, pattern, sub_url_vec))
		{
			std::cout << "Get " << i << " page failed" << std::endl;
		}
	}

	// 最终的图片url：http://img.51ztzj.com//upload/image/20130220/2013022014_670x419.jpg
	// [2] 将子页面的图片url解析出来放入picture_url_vec
	std::vector<std::string> picture_url_vec;
	pattern = "http://img.51ztzj.com//upload/image/.+/.+_670x419.jpg";
	for (std::size_t i = 0; i < sub_url_vec.size(); ++i)
	{
		std::string url = "http://www.51ztzj.com" + sub_url_vec[i];
		std::cout << "Start get " << i + 1 << " sub page, url: " << url << std::endl;
		// 请求并解析url
		if (!get_result(url, pattern, picture_url_vec))
		{
			std::cout << "Get " << i + 1 << " sub page failed" << std::endl;
		}
	}

	// [3] 最后遍历picture_url_vec，然后一个一个的下载图片
	for (std::size_t i = 0; i < picture_url_vec.size(); ++i)
	{
		std::cout << "Start download " << i + 1 << " picture, url: " << picture_url_vec[i] << std::endl;
		std::string picture;
		// 获取图片
		if (!get_result(picture_url_vec[i], picture))
		{
			std::cout << "Download " << i + 1 << " picture failed" << std::endl;
		}

		std::string file_path = "./download/" + std::to_string(i) + ".jpg";
		// 保存图片
		if (!write_to_file(file_path, picture))
		{
			std::cout << "Write to file failed: " << i + 1 << std::endl;
		}
	}

	return 0;
}

Microsoft Cpp Rest SDK编译与使用 - 简书 

创作不易，小小的支持一下吧！

赏

谢谢你请我吃糖果

支付宝

扫一扫，分享到微信

微信分享二维码
× 文章目录
  1. 1. 创作不易，小小的支持一下吧！

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家