正文8：Http协议、Restful、异步http请求简单了解（未完善http相关信息，但是异步请求代码已经完成10/07）

于 2021-10-08 02:02:36 发布
阅读量181 收藏 1
点赞数
分类专栏： 服务器开发专栏 文章标签： http restful
谢白羽专属
本文链接：https://blog.csdn.net/weixin_43679037/article/details/120643676
版权

文章目录

1.http知识(待补充)

HTTP Content-type判断返回数据的类型：图片、视频还是文字形式
静态资源都是get
200代表http请求成功

2.异步怎么设计？

异步设计步骤(适用dns\http\redis\mysql等)

1）初始化异步操作的上下文(上下文就是环境)
  • 结构体如下
//上下文
struct async_context
{
	pthread_t threadid;		//线程id
	int epfd;				//套接字
};
a.创建线程

默认线程分配8M空间

b.epoll_create
c.代码

在这里插入图片描述

2）异步上下文的销毁
a.pthread_cancel
b.close
c.代码

在这里插入图片描述

3）commit提交请求
  • commit的参数列表：

①上下文epoll，表示加入到哪个epoll
②发送哪个服务器
③访问服务器的哪个资源
④返回结果怎么处理，处理函数

a.准备socket
b.connect
c.protocal
d.send
e.epoll_ctl(add , epollfd)把准备的io加入epoll里面
4）callback回调函数
a.epoll_wait()检测io有没有数据，有数据就开始读
b.recv()

3.同步http代码

  • 代码作用解释及效果展示

代码作用：
该代码会发送http请求，然后打印数据，效果如下
在这里插入图片描述

  • 代码
编译指令  gcc sync_http.c  -o  sync_http
./sync_http

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include <unistd.h>
#include <time.h>
#include <fcntl.h>
#include <errno.h>
 
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>       /* close */
#include <netdb.h> 
 
#include <sys/epoll.h>
#include <pthread.h>
 
 
#define HTTP_VERSION    "HTTP/1.1"
#define USER_AGENT      "User-Agent: Mozilla/5.0 (Windows NT 5.1; rv:10.0.2) Gecko/20100101 Firefox/10.0.2\r\n"
#define ENCODE_TYPE     "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n"
#define CONNECTION_TYPE "Connection: close\r\n"
 
 
 
#define BUFFER_SIZE     4096
 

 //传入网络地址转成字符串传出
char *host_to_ip(const char *hostname) {

    //获取主机的地址，现在是有新的函数，这个函数已经过期了
    struct hostent *host_entry = gethostbyname(hostname); //gethostbyname_r / getaddrinfo
    if (host_entry) {
        //将网络地址换成字符串的格式
        return inet_ntoa(*(struct in_addr*)*host_entry->h_addr_list);
    } else {
        return NULL;
    }
}

//创建一个套接字
int http_create_socket( char *ip) {
 
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
 
    struct sockaddr_in sin = {0};
    sin.sin_addr.s_addr = inet_addr(ip);
    sin.sin_port = htons(80);               //主机字节序转网络字节序
    sin.sin_family = AF_INET;
 
    if (-1 == connect(sockfd, (struct sockaddr*)&sin, sizeof(struct sockaddr_in))) {
        return -1;
    }
 
    fcntl(sockfd, F_SETFL, O_NONBLOCK);
 
    return sockfd;
 
}
 

//将数据(HTTP请求头)发送出去，发给服务器
char *http_send_request(int sockfd, const char *hostname, const char *resource) {
 
    char buffer[BUFFER_SIZE] = {0};
     
    int len = sprintf(buffer, 
"GET %s %s\r\n\
Host: %s\r\n\
%s\r\n\
\r\n",
         resource, HTTP_VERSION,
         hostname,
         CONNECTION_TYPE
         );
    printf("request buffer:%s\n", buffer);
    send(sockfd, buffer, strlen(buffer), 0);
 
    struct timeval tv;
    tv.tv_sec = 5;
    tv.tv_usec = 0;
 
    fd_set fdread;
    FD_ZERO(&fdread);
    FD_SET(sockfd, &fdread);
 
    char *result = malloc(sizeof(int));
    result[0] = '\0';
 
    while (1) {
 
        int selection = select(sockfd+1, &fdread, NULL, NULL, &tv);
        if (!selection || !(FD_ISSET(sockfd, &fdread))) {
            break;
        } else {
            len = recv(sockfd, buffer, BUFFER_SIZE, 0);
            if (len == 0) break;
 
            result = realloc(result, (strlen(result) + len + 1) * sizeof(char));
            strncat(result, buffer, len);
        }
    }
 
    return result;
 
}
 
 
int http_client_commit(const char *hostname, const char *resource) {
    //1.获得ip
    char *ip = host_to_ip(hostname);

    //2.创建套接字，获得套接字
    int sockfd = http_create_socket(ip);

    //3.给服务器发送数据
    char *content =  http_send_request(sockfd, hostname, resource);
    if (content == NULL) {
        printf("have no data\n");
    }

    //4.打印出来数据
    puts(content);
    close(sockfd);
    free(content);

    return 0;
}


struct http_request {
    char *hostname;
    char *resource;
};
 

struct http_request reqs[] = {
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=beijing&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=changsha&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=shenzhen&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=shanghai&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=tianjin&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=wuhan&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=hefei&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=hangzhou&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=nanjing&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=jinan&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=taiyuan&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=wuxi&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=suzhou&language=zh-Hans&unit=c" },
};
 

struct async_context {
    pthread_t threadid;
    int epfd;
};

#define HOSTNAME_LENGTH     1024
#define ASYNC_CLIENT_NUM    1024

struct ep_arg {
    int sockfd;
    char hostname[HOSTNAME_LENGTH];
    async_result_cb cb;
};

typedef void (*async_result_cb)(const char *hostname, const char *result);

void *http_async_client_callback(void *arg) {

    struct async_context *ctx = (struct async_context*)arg;
    int epfd = ctx->epfd;

    while (1) {

        struct epoll_event events[]
        int nready = epoll_wait(epfd, events, ASYNC_CLIENT_NUM, -1);

        int i = 0;
        for (i = 0;i < nready;i ++) {
            
            struct ep_arg *data = (struct ep_arg*)events[i].data.ptr;
            int sockfd = data->sockfd;

            recv();

            epoll_ctl(epfd, EPOLL_CTL_DEL, sockfd, NULL);

            close(sockfd);
            free(data);

        }

    }

}


struct async_context* http_async_client_init(void) {

    struct async_context *ctx = (struct async_context*)malloc(sizeof(struct async_context));
    if (!ctx) {
        return NULL;
    }

    ctx->epfd = epoll_create(1);

    int ret = pthread_create(&ctx->threadid, NULL, http_async_client_callback, ctx); //创建的线程
    if (ret) {
        perror("pthread_create");
        close(ctx->epfd);
        free(ctx);
        return NULL;
    }
    usleep(1);

    return ctx;
    
}

struct http_async_client_uninit(struct async_context *ctx) {

    pthread_cancel(ctx->threadid);
    //pthread_join(ctx->threadid, &ctx);

    close(ctx->epfd);

    free(ctx);

}

//
int http_async_client_commit(struct async_context *ctx, const char *hostname, const char *resource, async_result_cb cb) {

    char buffer[BUFFER_SIZE] = {0};
     
    int len = sprintf(buffer, 
"GET %s %s\r\n\
Host: %s\r\n\
%s\r\n\
\r\n",
         resource, HTTP_VERSION,
         hostname,
         CONNECTION_TYPE
         );
    printf("request buffer:%s\n", buffer);


    char *ip = host_to_ip(hostname);
 
    int sockfd = http_create_socket(ip);
    send(sockfd, buffer, strlen(buffer), 0);


    struct ep_arg *eparg = (struct ep_arg*)malloc(sizeof(struct ep_arg));
    if (!eparg) {
        return NULL;
    }
    struct epoll_event ev;
    ev.data.ptr = eparg;
    ev.events = EPOLLIN;

    epoll_ctl(ctx->epfd, sockfd, EPOLL_CTL_ADD, &ev);

 


    return result;

}

 
int main(int argc, char *argv[]) {

     
    int count = sizeof(reqs) / sizeof(reqs[0]);
    int i = 0;
    for (i = 0;i < count;i ++) {
        http_client_commit(reqs[i].hostname, reqs[i].resource);
    }

 
    return 0;
}

4.异步http代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include <unistd.h>
#include <time.h>
#include <fcntl.h>
#include <errno.h>
 
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>       /* close */
#include <netdb.h> 
 
#include <sys/epoll.h>
#include <pthread.h>
 
 
#define HTTP_VERSION    "HTTP/1.1"
#define USER_AGENT      "User-Agent: Mozilla/5.0 (Windows NT 5.1; rv:10.0.2) Gecko/20100101 Firefox/10.0.2\r\n"
#define ENCODE_TYPE     "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n"
#define CONNECTION_TYPE "Connection: close\r\n"
 
 
 
#define BUFFER_SIZE     4096
 
//传入网络地址转成字符串传出
char *host_to_ip(const char *hostname) {
    //gethostbyname线程不安全，也就是说有全局变量
    //获取主机的地址，现在是有新的函数，这个函数已经过期了
    struct hostent *host_entry = gethostbyname(hostname);//gethostbyname_r线程安全，但只解决ipv4,ipv6还得靠getaddrinfo
    if (host_entry) {
        //将网络地址换成字符串的格式
        return inet_ntoa(*(struct in_addr*)*host_entry->h_addr_list);
    } else {
        return NULL;
    }
}
 
int http_create_socket( char *ip) {
 
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
 
    struct sockaddr_in sin = {0};
    sin.sin_addr.s_addr = inet_addr(ip);
    sin.sin_port = htons(80);
    sin.sin_family = AF_INET;
 
    if (-1 == connect(sockfd, (struct sockaddr*)&sin, sizeof(struct sockaddr_in))) {
        return -1;
    }
 
    fcntl(sockfd, F_SETFL, O_NONBLOCK);
 
    return sockfd;
 
}
 
 
char *http_send_request(int sockfd, const char *hostname, const char *resource) {
 
    char buffer[BUFFER_SIZE] = {0};
     
    int len = sprintf(buffer, 
"GET %s %s\r\n\
Host: %s\r\n\
%s\r\n\
\r\n",
         resource, HTTP_VERSION,
         hostname,
         CONNECTION_TYPE
         );
    printf("==33333333333333333333333==\n");
    printf("request buffer:%s\n", buffer);
    send(sockfd, buffer, strlen(buffer), 0);
    printf("==44444444444444444444444==\n");
 
    struct timeval tv;
    tv.tv_sec = 5;
    tv.tv_usec = 0;
 
    fd_set fdread;
    FD_ZERO(&fdread);
    FD_SET(sockfd, &fdread);
 
    char *result = malloc(sizeof(int));
    result[0] = '\0';
 
    while (1) {
 
        int selection = select(sockfd+1, &fdread, NULL, NULL, &tv);
        if (!selection || !(FD_ISSET(sockfd, &fdread))) {
            break;
        } else {
            len = recv(sockfd, buffer, BUFFER_SIZE, 0);
            if (len == 0) break;
 
            result = realloc(result, (strlen(result) + len + 1) * sizeof(char));
            strncat(result, buffer, len);
        }
    }
 
    return result;
 
}
 
 
int http_client_commit(const char *hostname, const char *resource) {
    char *ip = host_to_ip(hostname);
 
    int sockfd = http_create_socket(ip);
 
    char *content =  http_send_request(sockfd, hostname, resource);
    if (content == NULL) {
        printf("have no data\n");
    }
 
    puts(content);
    close(sockfd);
    free(content);

    return 0;
}
 
 
#define ASYNC_CLIENT_NUM        1024
#define HOSTNAME_LENGTH         128

//回调函数参数，参数一表示是哪个服务器返回的，参数二表示返回的结果是什么
typedef void (*async_result_cb)(const char *hostname, const char *result);
 
 
struct ep_arg {
    int sockfd;                             //
    char hostname[HOSTNAME_LENGTH];         //
    async_result_cb cb;                     //回调函数
};
 
 
struct async_context {
    int epfd;
    pthread_t thread_id;
};
 
struct http_request {
    char *hostname;
    char *resource;
};
 

//提交一次，往红黑树加一个io
int http_async_client_commit(struct async_context *ctx, const char *hostname, const char *resource, async_result_cb cb) {

    //1.获得IP字符串
    char *ip = host_to_ip(hostname);
    if (ip == NULL) return -1;

    //2.创建socket并设置非阻塞
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
 
    struct sockaddr_in sin = {0};
    sin.sin_addr.s_addr = inet_addr(ip);
    sin.sin_port = htons(80);
    sin.sin_family = AF_INET;
 
    if (-1 == connect(sockfd, (struct sockaddr*)&sin, sizeof(struct sockaddr_in))) {
        return -1;
    }
 
    fcntl(sockfd, F_SETFL, O_NONBLOCK);
 
    char buffer[BUFFER_SIZE] = {0};
     
    int len = sprintf(buffer, 
"GET %s %s\r\n\
Host: %s\r\n\
%s\r\n\
\r\n",
         resource, HTTP_VERSION,
         hostname,
         CONNECTION_TYPE
         );
 
    printf("request buffer:%s\n", buffer);
    int slen = send(sockfd, buffer, strlen(buffer), 0);
 
    //epoll是可以带参数的，传一个结构体参数
    struct ep_arg *eparg = (struct ep_arg*)calloc(1, sizeof(struct ep_arg));
    if (eparg == NULL) return -1;
    eparg->sockfd = sockfd;
    eparg->cb = cb;

    //问题1：epoll为什么是线程安全的？
    //问题2：怎么让服务器知道发给谁？
    //解答①：自定义协议存发送给客户端的相关信息
    //解答②：epoll把参数传过去，epoll存结构体，结构体包括客户端ID及包ID
    struct epoll_event ev;
    ev.data.ptr = eparg;
    ev.events = EPOLLIN;
 
    int ret = epoll_ctl(ctx->epfd, EPOLL_CTL_ADD, sockfd, &ev); 
 
    return ret;
 
}


static void *http_async_client_callback(void *arg) {
 
    struct async_context *ctx = (struct async_context*)arg;
    int epfd = ctx->epfd;
 
    while (1) {
 
        struct epoll_event events[ASYNC_CLIENT_NUM] = {0};
 
        int nready = epoll_wait(epfd, events, ASYNC_CLIENT_NUM, -1);
        if (nready < 0) {
            if (errno == EINTR || errno == EAGAIN) {
                continue;
            } else {
                break;
            }
        } else if (nready == 0) {
            continue;
        }
 
        printf("nready:%d\n", nready);
        int i = 0;
        for (i = 0;i < nready;i ++) {
 
            struct ep_arg *data = (struct ep_arg*)events[i].data.ptr;
            int sockfd = data->sockfd;
             
            char buffer[BUFFER_SIZE] = {0};
            struct sockaddr_in addr;
            size_t addr_len = sizeof(struct sockaddr_in);
            int n = recv(sockfd, buffer, BUFFER_SIZE, 0);
 
            data->cb(data->hostname, buffer); //call cb

            //操作完后把事件清空，删除这个fd
            int ret = epoll_ctl(epfd, EPOLL_CTL_DEL, sockfd, NULL);
            //printf("epoll_ctl DEL --> sockfd:%d\n", sockfd);
 
            close(sockfd); /

            //避免内存泄漏
            free(data);
 
        }
         
    }
 
}

//初始化环境
struct async_context *http_async_client_init(void) {
 
    int epfd = epoll_create(1); // 
    if (epfd < 0) return NULL;
 
    struct async_context *ctx = calloc(1, sizeof(struct async_context));
    if (ctx == NULL) {
        close(epfd);
        return NULL;
    }
    ctx->epfd = epfd;
 
    int ret = pthread_create(&ctx->thread_id, NULL, http_async_client_callback, ctx);//创建子线程
    if (ret) {
        perror("pthread_create");
        return NULL;
    }
    usleep(1);  //加usleep，允许子线程先行，主线程就会让出CPU
 
    return ctx;
 
}
 
int http_async_client_uninit(struct async_context *ctx) {
 
    close(ctx->epfd);
    pthread_cancel(ctx->thread_id);//不用pthread_join是因为这个函数是等待自线程返回的，这里不需要返回子线程的结果

    return 0;
}
 
struct http_request reqs[] = {
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=beijing&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=changsha&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=shenzhen&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=shanghai&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=tianjin&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=wuhan&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=hefei&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=hangzhou&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=nanjing&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=jinan&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=taiyuan&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=wuxi&language=zh-Hans&unit=c" },
    {"api.seniverse.com", "/v3/weather/now.json?key=0pyd8z7jouficcil&location=suzhou&language=zh-Hans&unit=c" },
};
 
 
static void http_async_client_result_callback(const char *hostname, const char *result) {
     
    printf("hostname:%s, result:%s\n\n\n\n", hostname, result);

}
 
 
 
int main(int argc, char *argv[]) {

//同步
#if 0
     
    int count = sizeof(reqs) / sizeof(reqs[0]);
    int i = 0;
    for (i = 0;i < count;i ++) {
        http_client_commit(reqs[i].hostname, reqs[i].resource);
    }
     
#else
//异步
    //1.初始化环境
    struct async_context *ctx = http_async_client_init();
    if (ctx == NULL) return -1;

    //2.提交请求
    int count = sizeof(reqs) / sizeof(reqs[0]);
    int i = 0;
    for (i = 0;i < count;i ++) {
        http_async_client_commit(ctx, reqs[i].hostname, reqs[i].resource, http_async_client_result_callback);
    }
 
 
    getchar();
#endif
 
}
谢白羽
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Restful http第三方接口实现，异步http请求
Aaron.无剑
09-21 1363
1 http协议教程 http协议(超文本传输协议)是因特网上应用最为广泛的一种网络传输协议，所有的www文件都必须遵守这个标准。https是一个基于tcp/ip通信协议来传递数据(html文件，图片文件，查询结构等) 2 http工作原理 http协议工作于客户端-服务器架构上。流浪器作为http客户端通过url向http服务器即web服务器发送所有请求。 Web服务器有：apache服务器，IIS服务器等。web服务器根据接受到的请求后，向客户端发送响应信息。 http默认端口号80，也可以改为8080
如何异步的处理restful服务（基础）
巡山小妖008
04-29 1355
如何异步的处理restful服务（基础） 1、使用Runnable 2、使用DeferredResult 3、异步处理的一些配置 正常请求方式 package com.nxz.controller; import lombok.extern.slf4j.Slf4j; import org.springframework.web.bind.annotati...
Restful异步
08-14 620
Restful异步 REST服务与异步： https://www.zybuluo.com/feuyeux/note/115766 posted @ 2018-08-14 22:10 笨笨的阿龙索 阅读(...) 评论(...) 编辑 收藏 ...
RESTful API设计基础知识
weixin_58029845的博客
08-25 1304
本篇主要内容是对《RESTfulWebServices》书中内容的精要摘录。笔者用几个月的时间研读此书，将书中内容进行梳理和注解，在此基础上总结了RESTful API设计基础知识。 本文从以下四个方面进行阐述： 1. REST与Web 2. 面向资源的架构：极限面向对象 3. ROA设计：URI设计 4. 深入理解：可寻址性、无状态性、统一接口、连通性
HTTP 的简单应答方式
Pichairen
08-02 655
请求方式： 【数据来自127.0.0.1:38470】 GET / HTTP/1.1 Host: 127.0.0.1:8089 User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:58.0) Gecko/20100101 Firefox/58.0 Accept: text/html,application/xhtml+xml,appli...
ansible-api：Ansible的RESTful HTTP Api
01-31
runner作为中间件0.2.6自适应ansible 2.6.4并添加异步模式0.2.2优化日志0.2.1优化日志并允许在同一主机中使用mutil-instance 0.2.0支持websocket，删除insible中入侵的代码结构图如何安装[准备工作] python版本> = ...
artax：基于AmpPHP异步HTTP1.1客户端
02-02
产品特点异步请求完整的单线程并发合并持久性保持活动连接透明地跟随重定向解码压缩的实体主体公开标题和消息数据流实体实体以进行大量传输的内存管理支持所有标准和自定义HTTP方法动词简化HTTP表单提交实施默认安全...
shiro-guice-async-webapp:使用 Apache Shiro 1.2.3、JBoss RestEasy 3 和 Google Guice 3 的 RESTful Web 服务，支持异步 HTTP 请求处理
07-01
shiro-guice-async-webapp 使用 Apache Shiro 1.2.3、JBoss RestEasy 3 和 Google Guice 3 和异步 HTTP 请求处理支持构建 RESTful Web 服务的示例项目。包含的依赖项Servlet 3.1.0 ( ) JBoss RestEasy 3.0.9.Final ...
WebApiClient：基于HttpClient的开源项目。 您只需要定义c＃接口并修改相关功能即可异步调用远程http接口的客户端库。
02-03
WebApiClientCore 的netcore版本，集高级高可扩展性于一体的声明式http客户端库，特别适用于微服务的restful资源请求，也适用于各种畸形的http接口请求。努吉特包名描述努吉特WebApiClientCore基础包 ...
HTTPKit:一个简单且轻量级的用于Objective-C的异步HTTP库
05-21
HTTPKit HTTPKit是一个非常简单的轻量级基于块的异步Objective-C库，用于发出HTTP请求。 非常适合使用RESTful API。将HTTPKit添加到您的项目下载或将存储库作为git子模块添加到git跟踪的项目中。 在Xcode中打开您的...
超详细的HTTP协议
weixin_45141313的博客
06-26 915
文章目录HTTP协议是什么？HTTP协议格式请求行请求方法URL协议版本HTTP0.9HTTP1.0HTTP1.1长连接管道机制分块传输HTTP2.0响应行头部Cookie与SessionCookieSessionCookie与Session的区别空行正文简单的http服务器的搭建输入URL后发生了什么 HTTP协议是什么？ HTTP：超文本传输协议。HTTP 协议和 TCP/IP 协议族内的其他众多的协议相同， 用于客户端和服务器之间的通信。请求访问文本或图像等资源的一端称为客户端， 而提供资源响应的.
Spring之在客户端访问RESTful业务
热门推荐
luccs624061082的专栏
11-07 1万+
 RestTemplate 是客户端访问RESTful
java中callback回调机制解析
牛奋lch
08-29 1万+
我们首先来看下面一段代码，这段代码是我们使用Jedis封装服务的一个实现： package com.chhliu.myself.redis; import javax.annotation.Resource; import org.springframework.stereotype.Service; import redis.clients.jedis.ShardedJe
callback回调（简单易懂）
我有明珠一颗的博客
08-17 9471
callback回调：http://blog.sina.com.cn/s/blog_5996fcbd0100vn2n.html#commonComment 说得很清楚，然后小白的我就懂了
回调函数
taizitj的专栏
03-04 1891
刚在学习回调函数，从c和java都看了一遍，c的回调可以用信号调用来理解，比较容易，当理解java的时候就比较晦涩，最后在知乎上找了一个非常形象的例子来理解回调函数，记录一下。另外感谢知乎中的桥头堡用户。 编程分为两类：系统编程（system programming）和应用编程（application programming）。所谓系统编程，简单来说，就是编写库；而应用编程就是利用写好的各种库来
Spring中访问Restful接口
真一居士的博客
11-27 1149
目录 Spring中调用Restful接口 RestTemplate 简介 使用 AsyncRestTemplate 简介 使用 注意 Spring中调用Restful接口 RestTemplate 简介 RestTemplate类可用于在应用中调用rest服务，它简化了与http服务的通信方式，统一了RESTful的标准，封装了http链接， 我们只需要传入url及返回...
RESTful API 设计最佳实践
coder 的历程
06-13 1176
背景 目前互联网上充斥着大量的关于RESTful API（为了方便，以后API和RESTful API 一个意思）如何设计的文章，然而却没有一个”万能“的设计标准：如何鉴权？API格式如何？你的API是否应该加入版本信息？当你开始写一个app的时候，特别是后端模型部分已经写完的时候，你不得不殚精竭虑的设计和实现自己app的public API部分。因为一旦发布，对外发布的API将会很难改变。 ...
callback && callback()的理解
Haines
05-17 4940
同义转换 ：if(callback) { callback() }解释：&amp;&amp; 属于布尔值逻辑判断，  False and True ，判断为Faslse。这里面有一个特性，当第一个值为False的时候，就不会去判断第二个值了，而是直接返回False，只有第一值为true的时候，才会继续判断第二个值 。所以这里的 callback &amp;&amp; callback() 的意思就...
怎么看spring boot代码哪里发送了http请求
最新发布
05-25
RestTemplate是Spring提供的一个用于请求RESTful服务的模板类，它可以方便地发送HTTP请求，同时还支持HTTP响应的转换。在代码中，可以通过以下方式创建RestTemplate对象并使用它发送HTTP请求： ``` RestTemplate ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值