reactor实现http服务器

已于 2022-02-25 13:13:42 修改
阅读量819 收藏 5
点赞数
分类专栏： Linux server 文章标签： http 服务器 网络 后端 reactor
于 2022-02-11 14:48:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/congchp/article/details/122880497
版权

如何在reactor的基础上实现业务？就是怎么利用reactor做服务器，并实现服务器的业务。

本文基于reactor，实现简单的http协议封装。只是为了说明reactor如何做业务，真正的http服务器业务逻辑是很复杂的。

服务器网络这一层，如nginx、redis，核心是epoll，实现使用的是reactor。

http协议封装与reactor的关系

reactor包含内容

  • reactor_run，event loop，通过epoll进行io检测；

  • accept_cb，处理网络连接；

  • recv_cb 接收客户端http请求

  • send_cb 发送http响应

应用层什么场景使用accept_cb?

  1. 对特定ip的访问进行限制；
  2. 负载均衡的功能，就是将请求转发到哪台服务器进行处理。

如果http服务器没有特殊的需求，是不需要修改reactor中的accept_cb的。

如何在reactor基础上实现http

http使用的是reqeust-reply的模型进行通讯，客户端发送http请求，服务器处理请求并返回应答。http的传输层是基于TCP的。

http的tcp链接的生命周期：

  1. accept_cb
  2. recv_cb
  3. send_cb

对于服务器，首先需要使用recv_cb接收http数据，通过拆包粘包得到一帧完整的http数据；之后对http数据进行解析处理；最后通过send_cb向客户端发送response。

实现简单的response

先实现一个最简单的response，对于所有http请求，直接回复一个response，内容是一段html。返回给客户端后，浏览器可以直接显示。只在send_cb中调用发送数据就可以了。

img

int http_response(struct ntyevent *ev) {

	if (ev == NULL) return -1;
	memset(ev->buffer, 0, BUFFER_LENGTH);
	
	const char *html = "<html><head><title>hello http</title></head><body><H1>Cong</H1></body></html>\r\n\r\n";
						  	   
	ev->length = sprintf(ev->buffer, 
		"HTTP/1.1 200 OK\r\n\
		 Date: Sun, 30 Jan 2022 05:55:32 GMT\r\n\
		 Content-Type: text/html;charset=UTF-8\r\n\
		 Content-Length: 81\r\n\r\n%s", 
		 html);

	return ev->length;
}

int send_cb(int fd, int events, void *arg) {

	struct ntyreactor *reactor = (struct ntyreactor*)arg;
	struct ntyevent *ev = ntyreactor_idx(reactor, fd);

	http_response(ev);
	//
	int len = send(fd, ev->buffer, ev->length, 0);
	if (len > 0) {
		printf("send[fd=%d], [%d]%s\n", fd, len, ev->buffer);

		nty_event_del(reactor->epfd, ev);
		nty_event_set(ev, fd, recv_cb, reactor);
		nty_event_add(reactor->epfd, EPOLLIN, ev);
		
	} else {

		close(ev->fd);

		nty_event_del(reactor->epfd, ev);
		printf("send[fd=%d] error %s\n", fd, strerror(errno));

	}

	return len;
}

HTTP响应由四个部分组成，分别是：状态行、消息报头、空行和响应正文。

img

http get请求实现

实现http get请求获取静态资源。

客户端发送一个HTTP 请求到服务器的请求消息包括以下格式：请求行（ request line ）、请求头部（ header ）、空行和请求数据四个部分组成，下图给出了请求报文的一般格式。

img

读请求行

需要对http请求进行解析，判断请求类型(GET、POST等)，获取资源(uri)

img

int http_request(struct ntyevent *ev) {

	// GET, POST
	char linebuf[1024] = {0};
	int idx = readline(ev->buffer, 0, linebuf);

	if (strstr(linebuf, "GET")) {
		ev->method = HTTP_METHOD_GET;

		//uri
		int i = 0;
		while (linebuf[sizeof("GET ") + i] != ' ') i++;
		linebuf[sizeof("GET ")+i] = '\0';

		sprintf(ev->resource, "./%s/%s", HTTP_WEBSERVER_HTML_ROOT, linebuf+sizeof("GET "));
		
	} else if (strstr(linebuf, "POST")) {

	}

}

在读取http请求头的时候，需要注意，http是以\r\n对每一行进行分隔的，第一行就是请求行，里面有请求类型(GET、POST)、uri、协议版本等。

img

自定义协议，如何界定包的完整性：

  1. 使用分隔符，比如http使用\r\n；
  2. 协议头中加包的长度。

http response

根据上面的uri找到静态资源，并准备好response状态行和消息头。

img

发送不同类型的静态资源的时候，可以使用相应的Content-Type。

发送response

img

mmap

发送静态资源文件的时候，需要先将文件读入内存，再将内存中的数据send到相应的网络fd。通过使用sendfile完成文件的发送，不再需要两步操作。

sendfile使用mmap

零拷贝，使用的是mmap方式，本质是DMA的方式，不需要CPU参与。普通copy，从磁盘copy数据到内存，需要CPU的move指令。

在进程中有一块区域叫内存分配区，当调用mmap的时候，会把文件映射到对应的区域，操作文件就跟操作内存一样。

完整代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <arpa/inet.h>

#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <time.h>

#include <sys/stat.h>
#include <sys/sendfile.h>



#define BUFFER_LENGTH		4096
#define MAX_EPOLL_EVENTS	1024
#define SERVER_PORT			9105
#define PORT_COUNT			1



#define HTTP_WEBSERVER_HTML_ROOT	"html"


#define HTTP_METHOD_GET		0
#define HTTP_METHOD_POST	1

typedef int NCALLBACK(int ,int, void*);

struct ntyevent {
	int fd;
	int events;
	void *arg;
	int (*callback)(int fd, int events, void *arg);
	
	int status;
	char buffer[BUFFER_LENGTH];
	int length;
	long last_active;

	// http param
	int method; //
	char resource[BUFFER_LENGTH];
	int ret_code;
	
	
};

struct eventblock {

	struct eventblock *next;
	struct ntyevent *events;
	
};

struct ntyreactor {
	int epfd;
	int blkcnt;
	struct eventblock *evblk; //fd --> 100w
};


int recv_cb(int fd, int events, void *arg);
int send_cb(int fd, int events, void *arg);
struct ntyevent *ntyreactor_idx(struct ntyreactor *reactor, int sockfd);


void nty_event_set(struct ntyevent *ev, int fd, NCALLBACK callback, void *arg) {

	ev->fd = fd;
	ev->callback = callback;
	ev->events = 0;
	ev->arg = arg;
	ev->last_active = time(NULL);

	return ;
	
}


int nty_event_add(int epfd, int events, struct ntyevent *ev) {

	struct epoll_event ep_ev = {0, {0}};
	ep_ev.data.ptr = ev;
	ep_ev.events = ev->events = events;

	int op;
	if (ev->status == 1) {
		op = EPOLL_CTL_MOD;
	} else {
		op = EPOLL_CTL_ADD;
		ev->status = 1;
	}

	if (epoll_ctl(epfd, op, ev->fd, &ep_ev) < 0) {
		printf("event add failed [fd=%d], events[%d]\n", ev->fd, events);
		return -1;
	}

	return 0;
}

int nty_event_del(int epfd, struct ntyevent *ev) {

	struct epoll_event ep_ev = {0, {0}};

	if (ev->status != 1) {
		return -1;
	}

	ep_ev.data.ptr = ev;
	ev->status = 0;
	epoll_ctl(epfd, EPOLL_CTL_DEL, ev->fd, &ep_ev);

	return 0;
}


int readline(char *allbuf, int idx, char *linebuf) {

	int len = strlen(allbuf);

	for(;idx < len;idx ++) {
		if (allbuf[idx] == '\r' && allbuf[idx+1] == '\n') {
			return idx+2;
		} else {
			*(linebuf++) = allbuf[idx];
		}
	}

	return -1;
}

int http_request(struct ntyevent *ev) {

	// GET, POST
	char linebuf[1024] = {0};
	int idx = readline(ev->buffer, 0, linebuf);

	if (strstr(linebuf, "GET")) {
		ev->method = HTTP_METHOD_GET;

		//uri
		int i = 0;
		while (linebuf[sizeof("GET ") + i] != ' ') i++;
		linebuf[sizeof("GET ")+i] = '\0';

		sprintf(ev->resource, "./%s/%s", HTTP_WEBSERVER_HTML_ROOT, linebuf+sizeof("GET "));
		
	} else if (strstr(linebuf, "POST")) {

	}

}

int recv_cb(int fd, int events, void *arg) {

	struct ntyreactor *reactor = (struct ntyreactor*)arg;
	struct ntyevent *ev = ntyreactor_idx(reactor, fd);

	int len = recv(fd, ev->buffer, BUFFER_LENGTH, 0); // 
	
	if (len > 0) {
		
		ev->length = len;
		ev->buffer[len] = '\0';

		printf("C[%d]:%s\n", fd, ev->buffer); //http

		http_request(ev);

		//send();
		
		nty_event_del(reactor->epfd, ev);
		nty_event_set(ev, fd, send_cb, reactor);
		nty_event_add(reactor->epfd, EPOLLOUT, ev);
		
		
	} else if (len == 0) {

		nty_event_del(reactor->epfd, ev);
		close(ev->fd);
		//printf("[fd=%d] pos[%ld], closed\n", fd, ev-reactor->events);
		 
	} else {

		nty_event_del(reactor->epfd, ev);
		close(ev->fd);
		printf("recv[fd=%d] error[%d]:%s\n", fd, errno, strerror(errno));
		
	}

	return len;
}


int http_response(struct ntyevent *ev) {

	if (ev == NULL) return -1;
	memset(ev->buffer, 0, BUFFER_LENGTH);
#if 0
	const char *html = "<html><head><title>hello http</title></head><body><H1>Cong</H1></body></html>\r\n\r\n";
						  	   
	ev->length = sprintf(ev->buffer, 
		"HTTP/1.1 200 OK\r\n\
		 Date: Thu, 11 Nov 2021 12:28:52 GMT\r\n\
		 Content-Type: text/html;charset=ISO-8859-1\r\n\
		 Content-Length: 83\r\n\r\n%s", 
		 html);
	
#else

	printf("resource: %s\n", ev->resource);

	int filefd = open(ev->resource, O_RDONLY);
	if (filefd == -1) { // return 404

		ev->ret_code = 404;
		ev->length = sprintf(ev->buffer, 
			"HTTP/1.1 404 Not Found\r\n"
		 	"Date: Thu, 11 Nov 2021 12:28:52 GMT\r\n"
		 	"Content-Type: text/html;charset=ISO-8859-1\r\n"
			"Content-Length: 85\r\n\r\n"
		 	"<html><head><title>404 Not Found</title></head><body><H1>404</H1></body></html>\r\n\r\n" );

	} else {


		struct stat stat_buf;
		fstat(filefd, &stat_buf);
		close(filefd);

		if (S_ISDIR(stat_buf.st_mode)) {

			
			ev->ret_code = 404;
			ev->length = sprintf(ev->buffer, 
				"HTTP/1.1 404 Not Found\r\n"
				"Date: Sun, 30 Jan 2022 05:55:32 GMT\r\n"
				"Content-Type: text/html;charset=ISO-8859-1\r\n"
				"Content-Length: 85\r\n\r\n"
				"<html><head><title>404 Not Found</title></head><body><H1>404</H1></body></html>\r\n\r\n" );

		} else if (S_ISREG(stat_buf.st_mode)) {

			ev->ret_code = 200;

			ev->length = sprintf(ev->buffer, 
				"HTTP/1.1 200 OK\r\n"
			 	"Date: Sun, 30 Jan 2022 05:55:32 GMT\r\n"
			 	// "Content-Type: text/html;charset=ISO-8859-1\r\n"
                // "Content-Type: application/pdf\r\n"
                "Content-Type: image/jpeg\r\n"
				"Content-Length: %ld\r\n\r\n", 
			 		stat_buf.st_size );
		}

	}

#endif
	return ev->length;
}

int send_cb(int fd, int events, void *arg) {

	struct ntyreactor *reactor = (struct ntyreactor*)arg;
	struct ntyevent *ev = ntyreactor_idx(reactor, fd);

	http_response(ev);
	//
	int len = send(fd, ev->buffer, ev->length, 0);
	if (len > 0) { // http header和body分两次发送
		printf("send[fd=%d], [%d]%s\n", fd, len, ev->buffer);

		if (ev->ret_code == 200) {
			int filefd = open(ev->resource, O_RDONLY);
			struct stat stat_buf;
			fstat(filefd, &stat_buf);
            // sendfile使用mmap
			sendfile(fd, filefd, NULL, stat_buf.st_size);
			close(filefd);
		}
		

		nty_event_del(reactor->epfd, ev);
		nty_event_set(ev, fd, recv_cb, reactor);
		nty_event_add(reactor->epfd, EPOLLIN, ev);
		
	} else {

		close(ev->fd);

		nty_event_del(reactor->epfd, ev);
		printf("send[fd=%d] error %s\n", fd, strerror(errno));

	}

	return len;
}

int accept_cb(int fd, int events, void *arg) {

	struct ntyreactor *reactor = (struct ntyreactor*)arg;
	if (reactor == NULL) return -1;

	struct sockaddr_in client_addr;
	socklen_t len = sizeof(client_addr);

	int clientfd;

	if ((clientfd = accept(fd, (struct sockaddr*)&client_addr, &len)) == -1) {
		if (errno != EAGAIN && errno != EINTR) {
			
		}
		printf("accept: %s\n", strerror(errno));
		return -1;
	}

	

	int flag = 0;
	if ((flag = fcntl(clientfd, F_SETFL, O_NONBLOCK)) < 0) {
		printf("%s: fcntl nonblocking failed, %d\n", __func__, MAX_EPOLL_EVENTS);
		return -1;
	}

	struct ntyevent *event = ntyreactor_idx(reactor, clientfd);
	
	nty_event_set(event, clientfd, recv_cb, reactor);
	nty_event_add(reactor->epfd, EPOLLIN, event);

	
	printf("new connect [%s:%d], pos[%d]\n", 
		inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port), clientfd);

	return 0;

}

int init_sock(short port) {

	int fd = socket(AF_INET, SOCK_STREAM, 0);
	fcntl(fd, F_SETFL, O_NONBLOCK);

	struct sockaddr_in server_addr;
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	server_addr.sin_port = htons(port);

	bind(fd, (struct sockaddr*)&server_addr, sizeof(server_addr));

	if (listen(fd, 20) < 0) {
		printf("listen failed : %s\n", strerror(errno));
	}

	return fd;
}


int ntyreactor_alloc(struct ntyreactor *reactor) {

	if (reactor == NULL) return -1;
	if (reactor->evblk == NULL) return -1;

	struct eventblock *blk = reactor->evblk;
	while (blk->next != NULL) {
		blk = blk->next;
	}

	struct ntyevent *evs = (struct ntyevent*)malloc((MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));
	if (evs == NULL) {
		printf("ntyreactor_alloc ntyevents failed\n");
		return -2;
	}
	memset(evs, 0, (MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));

	struct eventblock *block = (struct eventblock *)malloc(sizeof(struct eventblock));
	if (block == NULL) {
		printf("ntyreactor_alloc eventblock failed\n");
		return -2;
	}
	memset(block, 0, sizeof(struct eventblock));

	block->events = evs;
	block->next = NULL;

	blk->next = block;
	reactor->blkcnt ++; //

	return 0;
}

struct ntyevent *ntyreactor_idx(struct ntyreactor *reactor, int sockfd) {

	int blkidx = sockfd / MAX_EPOLL_EVENTS;

	while (blkidx >= reactor->blkcnt) {
		ntyreactor_alloc(reactor);
	}

	int i = 0;
	struct eventblock *blk = reactor->evblk;
	while(i ++ < blkidx && blk != NULL) {
		blk = blk->next;
	}

	return &blk->events[sockfd % MAX_EPOLL_EVENTS];
}


int ntyreactor_init(struct ntyreactor *reactor) {

	if (reactor == NULL) return -1;
	memset(reactor, 0, sizeof(struct ntyreactor));

	reactor->epfd = epoll_create(1);
	if (reactor->epfd <= 0) {
		printf("create epfd in %s err %s\n", __func__, strerror(errno));
		return -2;
	}

	struct ntyevent *evs = (struct ntyevent*)malloc((MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));
	if (evs == NULL) {
		printf("ntyreactor_alloc ntyevents failed\n");
		return -2;
	}
	memset(evs, 0, (MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));

	struct eventblock *block = (struct eventblock *)malloc(sizeof(struct eventblock));
	if (block == NULL) {
		printf("ntyreactor_alloc eventblock failed\n");
		return -2;
	}
	memset(block, 0, sizeof(struct eventblock));

	block->events = evs;
	block->next = NULL;

	reactor->evblk = block;
	reactor->blkcnt = 1;

	return 0;
}

int ntyreactor_destory(struct ntyreactor *reactor) {

	close(reactor->epfd);
	//free(reactor->events);

	struct eventblock *blk = reactor->evblk;
	struct eventblock *blk_next = NULL;

	while (blk != NULL) {

		blk_next = blk->next;

		free(blk->events);
		free(blk);

		blk = blk_next;

	}
	
	return 0;
}



int ntyreactor_addlistener(struct ntyreactor *reactor, int sockfd, NCALLBACK *acceptor) {

	if (reactor == NULL) return -1;
	if (reactor->evblk == NULL) return -1;

	//reactor->evblk->events[sockfd];
	struct ntyevent *event = ntyreactor_idx(reactor, sockfd);

	nty_event_set(event, sockfd, acceptor, reactor);
	nty_event_add(reactor->epfd, EPOLLIN, event);

	return 0;
}



int ntyreactor_run(struct ntyreactor *reactor) {
	if (reactor == NULL) return -1;
	if (reactor->epfd < 0) return -1;
	if (reactor->evblk == NULL) return -1;
	
	struct epoll_event events[MAX_EPOLL_EVENTS+1];
	
	int checkpos = 0, i;

	while (1) {
/*
		long now = time(NULL);
		for (i = 0;i < 100;i ++, checkpos ++) {
			if (checkpos == MAX_EPOLL_EVENTS) {
				checkpos = 0;
			}

			if (reactor->events[checkpos].status != 1) {
				continue;
			}

			long duration = now - reactor->events[checkpos].last_active;

			if (duration >= 60) {
				close(reactor->events[checkpos].fd);
				printf("[fd=%d] timeout\n", reactor->events[checkpos].fd);
				nty_event_del(reactor->epfd, &reactor->events[checkpos]);
			}
		}
*/

		int nready = epoll_wait(reactor->epfd, events, MAX_EPOLL_EVENTS, 1000);
		if (nready < 0) {
			printf("epoll_wait error, exit\n");
			continue;
		}

		for (i = 0;i < nready;i ++) {

			struct ntyevent *ev = (struct ntyevent*)events[i].data.ptr;

			if ((events[i].events & EPOLLIN) && (ev->events & EPOLLIN)) {
				ev->callback(ev->fd, events[i].events, ev->arg);
			}
			if ((events[i].events & EPOLLOUT) && (ev->events & EPOLLOUT)) {
				ev->callback(ev->fd, events[i].events, ev->arg);
			}
			
		}

	}
}

// 3, 6w, 1, 100 == 
// <remoteip, remoteport, localip, localport>
int main(int argc, char *argv[]) {

	unsigned short port = SERVER_PORT; // listen 8888
	if (argc == 2) {
		port = atoi(argv[1]);
	}
	struct ntyreactor *reactor = (struct ntyreactor*)malloc(sizeof(struct ntyreactor));
	ntyreactor_init(reactor);

	int i = 0;
	int sockfds[PORT_COUNT] = {0};
	for (i = 0;i < PORT_COUNT;i ++) {
		sockfds[i] = init_sock(port+i);
		ntyreactor_addlistener(reactor, sockfds[i], accept_cb);
	}

	//dup2(sockfd, STDIN);
	
	
	ntyreactor_run(reactor);

	ntyreactor_destory(reactor);

	for (i = 0;i < PORT_COUNT;i ++) {
		close(sockfds[i]);
	}

	free(reactor);

	return 0;
}
nts[i].events, ev->arg);
			}
			
		}

	}
}

// 3, 6w, 1, 100 == 
// <remoteip, remoteport, localip, localport>
int main(int argc, char *argv[]) {

	unsigned short port = SERVER_PORT; // listen 8888
	if (argc == 2) {
		port = atoi(argv[1]);
	}
	struct ntyreactor *reactor = (struct ntyreactor*)malloc(sizeof(struct ntyreactor));
	ntyreactor_init(reactor);

	int i = 0;
	int sockfds[PORT_COUNT] = {0};
	for (i = 0;i < PORT_COUNT;i ++) {
		sockfds[i] = init_sock(port+i);
		ntyreactor_addlistener(reactor, sockfds[i], accept_cb);
	}

	//dup2(sockfd, STDIN);
	
	
	ntyreactor_run(reactor);

	ntyreactor_destory(reactor);

	for (i = 0;i < PORT_COUNT;i ++) {
		close(sockfds[i]);
	}

	free(reactor);

	return 0;
}
congchp
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于reactor设计http服务器
kakaka666的博客
08-08 548
主要实现俩部分，一部分是对http头的解析。另一部分是封装http的响应。
reactor-netty-http-1.0.15-API文档-中英对照版.zip
05-03
赠送jar包：reactor-netty-http-1.0.15.jar； 赠送原API文档：reactor-netty-http-1.0.15-javadoc.jar； 赠送源代码：reactor-netty-http-1.0.15-sources.jar； 赠送Maven依赖信息文件：reactor-netty-http-1.0.15.pom； 包含翻译后的API文档：reactor-netty-http-1.0.15-javadoc-API文档-中文(简体)-英语-对照版.zip； Maven坐标：io.projectreactor.netty:reactor-netty-http:1.0.15； 标签：projectreactor、reactor、http、netty、jar包、java、中英对照文档； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。 双语对照，边学技术、边学英语。
深入浅出谈谈网络reactor模式与百万并发
weixin_70084230的博客
08-13 285
网络reactor模式与服务器网络连接百万并发的实现讲解
基于reactor的http服务器
youaremyalllove的博客
01-07 755
本文的http服务器基于的代码实现，只实现很简单的接收get请求，并向客户端发送响应的功能。
一个奇怪的bug，记录一下
Honins的博客
03-28 3642
问题 发请求经过gateway都报500错误。 有两条相关的错误日志 [reactor-http-epoll-4] ERROR o.s.b.a.w.r.error.AbstractErrorWebExceptionHandler - [9667bcf8-59094591] 500 Server Error for HTTP GET "/yyw-pharmacy/verify/captcha?key=852639" java.lang.IllegalArgumentException: a header v
完结13章C++从0实现百万并发Reactor服务器
最新发布
01-29
是否具备高并发、高性能、分布式、事件驱动框架设计能力，是优秀C++中高级工程师的分水岭，我将通过本文带领大家纯手写一个Reactor服务器，让大家可以高效掌握三高框架设计思维，同时让你对C++网络编程、线程、智能...
http服务器的实现.zip
09-15
本教程将深入探讨如何使用C++语言实现一个基本的HTTP服务器。C++是一种强大的、通用的编程语言，它允许低级别的内存操作，使得创建高效且灵活的网络应用成为可能。 首先，我们来理解HTTP（超文本传输协议）的基本...
基于Reactor高并发服务器 c++源码+详细项目说明+sln解决方案.zip
10-26
> 基于`Reactor`的高并发服务器，分为`反应堆模型`，`多线程`，`I/O模型`，`服务器`，`Http请求`和`响应`五部分 【备注】 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本...
cpp-利用C编写的HTTP服务器使用线程池Reactor模式
08-16
1. **源代码文件**：实现HTTP服务器的主要代码，可能包括服务器主程序、线程池类、Reactor类以及其他辅助类。 2. **配置文件**：可能包含服务器的配置信息，如监听端口、最大连接数等。 3. **测试用例**：用于验证...
Java：使用Reactor Netty如何从HttpClient获取响应报文
netyeaxi的专栏
04-12 2371
使用Reactor Netty如何从HttpClient获取响应报文
Java编程方法论-Spring WebFlux篇 Reactor-Netty下HttpServer 的封装
weixin_34409357的博客
02-27 6384
前言 本系列为本人Java编程方法论 响应式解读系列的Webflux部分，现分享出来，前置知识Rxjava2 ，Reactor的相关解读已经录制分享视频，并发布在b站，地址如下: Rxjava源码解读与分享：www.bilibili.com/video/av345… Reactor源码解读与分享：www.bilibili.com/video/av353… NIO源码解读相关视频分享： www.bi...
reactor讲解
changjh1的博客
05-29 1486
本文目录 （本文仅为记录用） 1. 为什么是Reactor模式 2. Reactor模式简介 3. 多线程IO的致命缺陷 4. 单线程Reactor模型 4.1. 什么是单线程Reactor呢？ 4.2. 单线程Reactor的参考代码 4.3. 单线程模式的缺点: 5. 多线程的Reactor 5.1. 基于线程池的改进 5.2. 改进后的完整示意图 5.3. 多线程Reactor的参考代码 6. Reactor持续改进 7. Reactor编程的优点和缺点 7.1. 优点 7.2. 缺点 1..
Linux C epoll实现简单的Reactor模型-http server demo
C++ 开发者的博客
03-27 1313
reactor模型：主要用epoll实现了reactor模型，并简单的实现了http server的demo。 主要知识点：socket编程，reactor模型，I/O多路复用，epoll
reactor-netty中HttpClient对TcpClient的封装
weixin_34074740的博客
02-19 2794
序 本文主要研究一下reactor-netty中HttpClient对TcpClien的封装 maven &lt;dependency&gt; &lt;groupId&gt;io.projectreactor.ipc&lt;/groupId&gt; &lt;artifactId&gt;reactor-netty&lt;/artifactId&gt; &lt;version&g...
Java编程方法论-Spring WebFlux篇 Reactor-Netty下TcpServer的功能实现 1
weixin_34348111的博客
03-04 3746
前言 本系列为本人Java编程方法论 响应式解读系列的Webflux部分，现分享出来，前置知识Rxjava2 ，Reactor的相关解读已经录制分享视频，并发布在b站，地址如下: Rxjava源码解读与分享：https://www.bilibili.com/video/av34537840 Reactor源码解读与分享：https://www.bilibili.com/video/av353269...
简单使用netty搭建一个http服务器
收破烂的小熊猫
11-25 1549
世上无难事,只要肯登攀。——毛泽东 Netty的入门使用 常见的http服务器有Tomcat、jetty等，netty也可以方便的开发一个Http服务器。 想要完整的实现一个高性能、功能完善的http服务器非常的复杂，本文仅为了方便理解 Netty 网络应用开发的基本过程，所以只实现最基本的请求响应的流程： 搭建 HTTP 服务器，配置相关参数并启动。 从浏览器或者终端发起 HTTP 请求。 成功得到服务端的响应结果。 准备工作 先创建一个maven项目，引入netty依赖，这里使用4.1.52...
事件分发器之Reactor模式详细解读
xsjzn的博客
04-20 967
一、网络服务和请求的特点与事件分发器的两种模式： 例如：Web服务、分布式事务 大多数都有相同的基础结构和步骤： 读请求：Read request 解码请求：Decode request 进程服务：Process service 编码回复：Encode reply 回复应答:Send reply 但是各种不同的请求不同在逻辑和每一步的开销 例如： XML parsing, File transfer, Web page generation, computational services, … 典型的服务设
写一个reactor处理http请求的代码
05-15
以下是一个简单的 Reactor 模式的 HTTP 服务器示例代码，使用 C++11 和 Boost.Asio 库实现： ```c++ #include #include using namespace boost::asio; using namespace boost::asio::ip; class HttpRequest { ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值