首页 文章 精选 留言 我的

精选列表

搜索[restful]，共2168篇文章
优秀的个人博客,低调大师

nodejs 搭建 RESTful API 服务器的常用包及其简介

常用包 框架： yarn add express 数据库链接： yarn add sequelize yarn add mysql2 处理 favicon： yarn add serve-favicon 纪录日志： yarn add morgan 生成文档： yarn add --dev apidoc 解析请求参数： yarn add body-parser 设置 HTTP 头(提高安全性)： yarn add helmet 文件变动监控(自动重启)： yarn add --dev nodemon (启动服务器脚本中替换 node 即可) 允许 cors 请求： yarn add cors 压缩数据： yarn add compression 响应时间: yarn add response-time 数据伪造: yarn add faker – 数据验证: yarn add express-validator 进程管理: yarn add --dev pm2 带重启(nodemon用于开发环境)，日志，负载均衡 serve-favicon 优点：把请求 favicon 的记录从日志中去除。缓存 icon 提高性能。使用兼容性最好的 Content-Type。 使用方式： var favicon = require('serve-favicon') app.use(favicon(path.join(__dirname, 'public', 'favicon.ico'))) morgan 使用方式： var morgan = require('morgan') app.use(morgan('combined')) //参数可选 dev tiny 或自定义输出日志格式，详见文档 // 导出日志文件 var express = require('express') var fs = require('fs') var morgan = require('morgan') var path = require('path') var app = express() // create a write stream (in append mode) var accessLogStream = fs.createWriteStream(path.join(__dirname, 'access.log'), {flags: 'a'}) // setup the logger app.use(morgan('combined', {stream: accessLogStream})) body-parser 使用方式： var bodyParser = require('body-parser') // parse application/x-www-form-urlencoded app.use(bodyParser.urlencoded({ extended: false })) //设置 false 使用 querystring 解析，处理 ajax 提交的复杂数据更在行。(true 使用 qs 解析) // parse application/json app.use(bodyParser.json()) apidoc 使用方式: 生成文档命令: apidoc -i routes/ -o doc/( routes 是程序入口，doc 是文档出口) 注释示例： /** * @api {get} /user/:id Read data of a User * @apiVersion 0.3.0 * @apiName GetUser * @apiGroup User * @apiPermission admin * * @apiDescription Compare Verison 0.3.0 with 0.2.0 and you will see the green markers with new items in version 0.3.0 and red markers with removed items since 0.2.0. * * @apiParam {String} id The Users-ID. * * @apiSuccess {String} id The Users-ID. * @apiSuccess {Date} registered Registration Date. * @apiSuccess {Date} name Fullname of the User. * @apiSuccess {String[]} nicknames List of Users nicknames (Array of Strings). * @apiSuccess {Object} profile Profile data (example for an Object) * @apiSuccess {Number} profile.age Users age. * @apiSuccess {String} profile.image Avatar-Image. * @apiSuccess {Object[]} options List of Users options (Array of Objects). * @apiSuccess {String} options.name Option Name. * @apiSuccess {String} options.value Option Value. * * @apiError NoAccessRight Only authenticated Admins can access the data. * @apiError UserNotFound The <code>id</code> of the User was not found. * * @apiErrorExample Response (example): * HTTP/1.1 401 Not Authenticated * { * "error": "NoAccessRight" * } */ helmet var express = require('express') var helmet = require('helmet') var app = express() app.use(helmet()) cors 使用方式： // 允许所有跨域请求 var express = require('express') var cors = require('cors') var app = express() app.use(cors()) // 允许某路由的跨域请求 app.get('/products/:id', cors(), function (req, res, next) { res.json({msg: 'This is CORS-enabled for a Single Route'}) }) // 允许某些域的请求 var whitelist = ['http://example1.com', 'http://example2.com'] var corsOptions = { origin: function (origin, callback) { if (whitelist.indexOf(origin) !== -1) { callback(null, true) } else { callback(new Error('Not allowed by CORS')) } } } app.get('/products/:id', cors(corsOptions), function (req, res, next) { res.json({msg: 'This is CORS-enabled for a whitelisted domain.'}) }) // 允许 GET/POST 以外的请求 app.options('/products/:id', cors()) // enable pre-flight request for DELETE request app.del('/products/:id', cors(), function (req, res, next) { res.json({msg: 'This is CORS-enabled for all origins!'}) }) // 对所有路由允许 app.options('*', cors()) // include before other routes compression 使用方式： var compression = require('compression') var express = require('express') var app = express() app.use(compression({filter: shouldCompress})) function shouldCompress (req, res) { if (req.headers['x-no-compression']) { // don't compress responses with this request header return false } // fallback to standard filter function return compression.filter(req, res) } response-time 使用方式： 该中间件将响应时间写在响应头 X-Response-Time 中 var express = require('express') var responseTime = require('response-time') var app = express() // 统计响应进入该中间件到写完响应头的毫秒数 app.use(responseTime()) express-validator 验证规则 // 初始化 app.use(expressValidator()) // this line must be immediately after any of the bodyParser middlewares! // 检查参数是否符合标准 req.check('testparam', 'Error Message').notEmpty().isInt() // 将参数转化为 req.sanitize('postparam').toBoolean() // 返回验证结果 req.getValidationResult().then(function(result) { // do something with the validation result }) pm2 pm2 start app.js --name="api" # Start application and name it "api" pm2 stop all # Stop all apps pm2 logs # Display logs of all apps pm2 web 后访问 http://localhost:9615/ # 查看系统状态
2017-07-23
优秀的个人博客,低调大师

《Java RESTful Web Service实战》第一章的实现补漏

韩陆，你好你的书，麻烦写的清楚一点，多写一些，也许还能多点稿费。小韩，写书认真一点。第13页上来就用maven命令行创建项目，这就有问题啊，没有pom.xml文件mvn这个命令怎么跑的起来呢？所以正确的过程是这样的：eclipse上创建项目创建的结果是这样的：创建过程，先创建一个maven项目 然后archetypes选择书中指出的jersey-quickstart-grizzly2创建项目之后，实际上会报错默认情况下eclipse创建出来的pom.xml文件中提供的jersey-version的版本是1.20但实际上mavenrepository上提供的最新版也就是1.19.4，所以修改一下正常情况下，创建项目完毕，我们测试一下：首先当然是参考书中的命令行方式，用curl这个命令去执行，这需要首先下载配置curlhttps://curl.haxx.se/windows/配置环境变量现在都准备好了我们先看看这个项目的内容，它都自动帮我们生成了什么：MyResource.java package my.restfulwork.jerseyone; import javax.ws.rs.GET; import javax.ws.rs.Path; import javax.ws.rs.Produces; // The Java class will be hosted at the URI path "/myresource" @Path("/myresource") public class MyResource { // TODO: update the class to suit your needs // The Java method will process HTTP GET requests @GET // The Java method will produce content identified by the MIME Media // type "text/plain" @Produces("text/plain") public String getIt() { return "Got it!"; } } Main.java package my.restfulwork.jerseyone; import com.sun.jersey.api.container.grizzly2.GrizzlyServerFactory; import com.sun.jersey.api.core.PackagesResourceConfig; import com.sun.jersey.api.core.ResourceConfig; import org.glassfish.grizzly.http.server.HttpServer; import javax.ws.rs.core.UriBuilder; import java.io.IOException; import java.net.URI; public class Main { private static int getPort(int defaultPort) { //grab port from environment, otherwise fall back to default port 9998 String httpPort = System.getProperty("jersey.test.port"); if (null != httpPort) { try { return Integer.parseInt(httpPort); } catch (NumberFormatException e) { } } return defaultPort; } private static URI getBaseURI() { return UriBuilder.fromUri("http://localhost/").port(getPort(9998)).build(); } public static final URI BASE_URI = getBaseURI(); protected static HttpServer startServer() throws IOException { ResourceConfig resourceConfig = new PackagesResourceConfig("my.restfulwork.jerseyone"); System.out.println("Starting grizzly2..."); return GrizzlyServerFactory.createHttpServer(BASE_URI, resourceConfig); } public static void main(String[] args) throws IOException { // Grizzly 2 initialization HttpServer httpServer = startServer(); System.out.println(String.format("Jersey app started with WADL available at " + "%sapplication.wadl\nHit enter to stop it...", BASE_URI)); System.in.read(); httpServer.stop(); } } MainTest.java package my.restfulwork.jerseyone; import org.glassfish.grizzly.http.server.HttpServer; import com.sun.jersey.core.header.MediaTypes; import com.sun.jersey.api.client.Client; import com.sun.jersey.api.client.WebResource; import junit.framework.TestCase; public class MainTest extends TestCase { private HttpServer httpServer; private WebResource r; public MainTest(String testName) { super(testName); } @Override protected void setUp() throws Exception { super.setUp(); //start the Grizzly2 web container httpServer = Main.startServer(); // create the client Client c = Client.create(); r = c.resource(Main.BASE_URI); } @Override protected void tearDown() throws Exception { super.tearDown(); httpServer.stop(); } /** * Test to see that the message "Got it!" is sent in the response. */ public void testMyResource() { String responseMsg = r.path("myresource").get(String.class); assertEquals("Got it!", responseMsg); } /** * Test if a WADL document is available at the relative path * "application.wadl". */ public void testApplicationWadl() { String serviceWadl = r.path("application.wadl"). accept(MediaTypes.WADL).get(String.class); assertTrue(serviceWadl.length() > 0); } } 上述三个文件是项目自己生成的java代码我们运行Main.javaconsole中的信息如下所示： 我们使用cmd客户端，执行命令行语句：执行结果，和书中写的一样。
2018-09-10
优秀的个人博客,低调大师

Spring Boot 无侵入式 实现RESTful API接口统一JSON格式返回

前言 现在我们做项目基本上中大型项目都是选择前后端分离，前后端分离已经成了一个趋势了，所以总这样·我们就要和前端约定统一的api 接口返回json 格式， 这样我们需要封装一个统一通用全局 模版api返回格式，下次再写项目时候直接拿来用就可以了 约定JSON格式 一般我们和前端约定json格式是这样的 { "code": 200, "message": "成功", "data": { } } code: 返回状态码 message: 返回信息的描述 data: 返回值 封装java bean 定义状态枚举 package cn.soboys.core.ret; import lombok.Data; import lombok.Getter; /** * @author kenx * @version 1.0 * @date 2021/6/17 15:35 * 响应码枚举，对应HTTP状态码 */ @Getter public enum ResultCode { SUCCESS(200, "成功"),//成功 //FAIL(400, "失败"),//失败 BAD_REQUEST(400, "Bad Request"), UNAUTHORIZED(401, "认证失败"),//未认证 NOT_FOUND(404, "接口不存在"),//接口不存在 INTERNAL_SERVER_ERROR(500, "系统繁忙"),//服务器内部错误 METHOD_NOT_ALLOWED(405,"方法不被允许"), /*参数错误:1001-1999*/ PARAMS_IS_INVALID(1001, "参数无效"), PARAMS_IS_BLANK(1002, "参数为空"); /*用户错误2001-2999*/ private Integer code; private String message; ResultCode(int code, String message) { this.code = code; this.message = message; } } 定义返回状态码，和信息一一对应，我们可以约定xxx～xxx 为什么错误码，防止后期错误码重复，使用混乱不清楚， 定义返回体结果体 package cn.soboys.core.ret; import lombok.Data; import java.io.Serializable; /** * @author kenx * @version 1.0 * @date 2021/6/17 15:47 * 统一API响应结果格式封装 */ @Data public class Result<T> implements Serializable { private static final long serialVersionUID = 6308315887056661996L; private Integer code; private String message; private T data; public Result setResult(ResultCode resultCode) { this.code = resultCode.getCode(); this.message = resultCode.getMessage(); return this; } public Result setResult(ResultCode resultCode,T data) { this.code = resultCode.getCode(); this.message = resultCode.getMessage(); this.setData(data); return this; } } code，和message都从定义的状态枚举中获取 这里有两个需要注意地方我的数据类型T data返回的是泛型类型而不是object类型而且我的结果累实现了Serializable接口 我看到网上有很多返回object,最后返回泛型因为泛型效率要高于object,object需要强制类型转换，还有最后实现了Serializable接口因为通过流bytes传输方式web传输，速率更块 定义返回结果方法 一般业务返回要么是 success成功，要么就是failure失败，所以我们需要单独定义两个返回实体对象方法， package cn.soboys.core.ret; /** * @author kenx * @version 1.0 * @date 2021/6/17 16:30 * 响应结果返回封装 */ public class ResultResponse { private static final String DEFAULT_SUCCESS_MESSAGE = "SUCCESS"; // 只返回状态 public static Result success() { return new Result() .setResult(ResultCode.SUCCESS); } // 成功返回数据 public static Result success(Object data) { return new Result() .setResult(ResultCode.SUCCESS, data); } // 失败 public static Result failure(ResultCode resultCode) { return new Result() .setResult(resultCode); } // 失败 public static Result failure(ResultCode resultCode, Object data) { return new Result() .setResult(resultCode, data); } } 注意这里我定义的是静态工具方法，因为使用构造方法进行创建对象调用太麻烦了, 我们使用静态方法来就直接类调用很方便 这样我们就可以在controller中很方便返回统一api格式了 package cn.soboys.mallapi.controller; import cn.soboys.core.ret.Result; import cn.soboys.core.ret.ResultResponse; import cn.soboys.mallapi.bean.User; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; /** * @author kenx * @version 1.0 * @date 2021/7/2 20:28 */ @RestController //默认全部返回json @RequestMapping("/user") public class UserController { @GetMapping("/list") public Result getUserInfo(){ User u=new User(); u.setUserId("21"); u.setUsername("kenx"); u.setPassword("224r2"); return ResultResponse.success(u); } } 返回结果符合我们预期json格式 但是这个代码还可以优化，不够完善，比如，每次controller中所有的方法的返回必须都是要Result类型，我们想返回其他类型格式怎么半,还有就是不够语义化，其他开发人员看你方法根本就不知道具体返回什么信息 如果改成这个样子就完美了如 @GetMapping("/list") public User getUserInfo() { User u = new User(); u.setUserId("21"); u.setUsername("kenx"); u.setPassword("224r2"); return u; } 其他开发人员一看就知道具体是返回什么数据。但这个格式要怎么去统一出来？ 其实我们可以这么去优化，通过SpringBoot提供的ResponseBodyAdvice进行统一响应处理 自定义注解@ResponseResult来拦截有此controller注解类的代表需要统一返回json格式，没有就安照原来返回 package cn.soboys.core.ret; import java.lang.annotation.*; /** * @author kenx * @version 1.0 * @date 2021/6/17 16:43 * 统一包装接口返回的值 Result */ @Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface ResponseResult { } 定义请求拦截器通过反射获取到有此注解的HandlerMethod设置包装拦截标志 package cn.soboys.core.ret; import org.springframework.web.method.HandlerMethod; import org.springframework.web.servlet.HandlerInterceptor; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.lang.reflect.Method; /** * @author kenx * @version 1.0 * @date 2021/6/17 17:10 * 请求拦截 */ public class ResponseResultInterceptor implements HandlerInterceptor { //标记名称 public static final String RESPONSE_RESULT_ANN = "RESPONSE-RESULT-ANN"; @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { //请求方法 if (handler instanceof HandlerMethod) { final HandlerMethod handlerMethod = (HandlerMethod) handler; final Class<?> clazz = handlerMethod.getBeanType(); final Method method = handlerMethod.getMethod(); //判断是否在对象上加了注解 if (clazz.isAnnotationPresent(ResponseResult.class)) { //设置此请求返回体需要包装，往下传递，在ResponseBodyAdvice接口进行判断 request.setAttribute(RESPONSE_RESULT_ANN, clazz.getAnnotation(ResponseResult.class)); //方法体上是否有注解 } else if (method.isAnnotationPresent(ResponseResult.class)) { //设置此请求返回体需要包装，往下传递，在ResponseBodyAdvice接口进行判断 request.setAttribute(RESPONSE_RESULT_ANN, clazz.getAnnotation(ResponseResult.class)); } } return true; } } 实现ResponseBodyAdvice<Object> 接口自定义json返回解析器根据包装拦截标志判断是否需要自定义返回类型返回类型 package cn.soboys.core.ret; import cn.soboys.core.utils.HttpContextUtil; import com.alibaba.fastjson.JSON; import lombok.extern.slf4j.Slf4j; import org.springframework.core.MethodParameter; import org.springframework.http.MediaType; import org.springframework.http.converter.HttpMessageConverter; import org.springframework.http.server.ServerHttpRequest; import org.springframework.http.server.ServerHttpResponse; import org.springframework.web.bind.annotation.ControllerAdvice; import org.springframework.web.context.request.RequestContextHolder; import org.springframework.web.context.request.ServletRequestAttributes; import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice; import javax.servlet.http.HttpServletRequest; /** * @author kenx * @version 1.0 * @date 2021/6/17 16:47 * 全局统一响应返回体处理 */ @Slf4j @ControllerAdvice public class ResponseResultHandler implements ResponseBodyAdvice<Object> { public static final String RESPONSE_RESULT_ANN = "RESPONSE-RESULT-ANN"; /** * @param methodParameter * @param aClass * @return 此处如果返回false , 则不执行当前Advice的业务 * 是否请求包含了包装注解 标记，没有直接返回不需要重写返回体， */ @Override public boolean supports(MethodParameter methodParameter, Class<? extends HttpMessageConverter<?>> aClass) { HttpServletRequest request = HttpContextUtil.getRequest(); //判断请求是否有包装标志 ResponseResult responseResultAnn = (ResponseResult) request.getAttribute(RESPONSE_RESULT_ANN); return responseResultAnn == null ? false : true; } /** * @param body * @param methodParameter * @param mediaType * @param aClass * @param serverHttpRequest * @param serverHttpResponse * @return 处理响应的具体业务方法 */ @Override public Object beforeBodyWrite(Object body, MethodParameter methodParameter, MediaType mediaType, Class<? extends HttpMessageConverter<?>> aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) { if (body instanceof Result) { return body; } else if (body instanceof String) { return JSON.toJSONString(ResultResponse.success(body)); } else { return ResultResponse.success(body); } } } 注意这里string类型返回要单独json序列化返回一下，不然会报转换异常 这样我们就可以在controler中返回任意类型，了不用每次都必须返回 Result 如 package cn.soboys.mallapi.controller; import cn.soboys.core.ret.ResponseResult; import cn.soboys.core.ret.Result; import cn.soboys.core.ret.ResultResponse; import cn.soboys.mallapi.bean.User; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; /** * @author kenx * @version 1.0 * @date 2021/7/2 20:28 */ @RestController //默认全部返回json @RequestMapping("/user") @ResponseResult public class UserController { @GetMapping("/list") public User getUserInfo() { User u = new User(); u.setUserId("21"); u.setUsername("kenx"); u.setPassword("224r2"); return u; } @GetMapping("/test") public String test() { return "ok"; } @GetMapping("/test2") public Result test1(){ return ResultResponse.success(); } } 这里还有一个问题？正常情况返回成功的话是统一json 格式，但是返回失败，或者异常了，怎么统一返回错误json 格式，sprinboot有自己的错误格式？ 请参考我上一篇，SpringBoot优雅的全局异常处理 扫码关注公众号猿人生了解更多好文
2021-07-05
优秀的个人博客,低调大师

使用Wisdom RESTClient自动化测试RESTful API和生成REST API文档

Wisdom RESTClientsupports automated testing REST API, producing exquisite report, and generating exquisite REST API documentation based on historical cases. Wisdom RESTClient是由个人所开发的一款自动化测试REST API的工具。 它可以自动化测试REST API并生成精美的测试报告，同时基于测试过的历史数据，可以生成精美的REST API文档。 Steps 1. Download JAR:restclient-1.2.jar; 下载JAR包restclient-1.2.jar； 2. InstallJava 1.7or higher version; 使用前请先安装Java 1.7或者更高版本； 3. Double clickrestclient-1.2.jarto launch GUI. 双击restclient-1.2.jar即可运行工具。
2018-03-16
优秀的个人博客,低调大师

gout v0.1.12 版本更新，Go http RESTful 客户端和 benchmark lib

项目地址 https://gitee.com/guonaihong/gout https://github.com/guonaihong/gout 本次更新内容 支持关闭遇到3xx状态码自动重新请求功能 import ( "github.com/guonaihong/gout" ) func main() { // globalWithOpt里面包含连接池, 这是一个全局可复用的对象, 一个进程里面可能只需创建1个 globalWithOpt := gout.NewWithOpt(gout.WithClose3xxJump()) err := globalWithOpt.GET("url").Do() if err != nil { fmt.Printf("err = %v\n" ,err) return } } gout gout 是go写的http 客户端，为提高工作效率而开发 feature 支持设置 GET/PUT/DELETE/PATH/HEAD/OPTIONS 支持设置请求 http header(可传 struct,map,array,slice 等类型) 支持设置 URL query(可传 struct,map,array,slice,string 等类型) 支持设置 json 编码到请求 body 里面(可传struct, map, string, []byte 等类型) 支持设置 xml 编码到请求 body 里面(可传struct, string, []byte 等类型) 支持设置 yaml 编码到请求 body 里面(可传struct, map, string, []byte 等类型) 支持设置 form-data(可传 struct, map, array, slice 等类型) 支持设置 x-www-form-urlencoded(可传 struct,map,array,slice 等类型) 支持设置 io.Reader，uint/uint8/uint16...int/int8...string...[]byte...float32,float64 至请求 body 里面 支持解析响应body里面的json,xml,yaml至结构体里(BindJSON/BindXML/BindYAML) 支持解析响应body的内容至io.Writer, uint/uint8...int/int8...string...[]byte...float32,float64 支持解析响应header至结构体里 支持接口性能benchmark，可控制压测一定次数还是时间，可控制压测频率 支持retry-backoff，可以指定重试条件 支持发送裸http数据包 支持导出curl命令 传入自定义*http.Client 支持请求中间件(https://github.com/antlabs/gout-middleware) 支持设置chunked数据格式发送 等等更多 演示 内容 Installation example quick start API Examples GET POST PUT DELETE PATH HEAD OPTIONS Query Parameters http header Set request header Parsing the response header http body body Set the data to the http request body Parse the response body into a variable json Serialize json to request body Parsed http response body in json format yaml xml form-data x-www-form-urlencoded protobuf callback Set request timeout proxy socks5 cookie context Cancel a sending request unix socket http2 doc debug mode Turn on debug mode Turn off color highlighting in debug mode Custom debug mode trace info benchmark benchmarking a certain number of times benchmarking for a certain time benchmarking at a fixed frequency Custom benchmark functions retry backoff Specify the retry conditions, when equal to a certain http code Specify retry conditions. The default URL cannot be accessed. Use the backup URL import send raw http request export generate curl command Incoming custom * http.Client Using chunked data format Global configuration Insecure skip verify Turn off 3xx status code automatic jump Null values are also serialized set timeout Unique features forward gin data FAQ Installation go get github.com/guonaihong/gout example examples目录下面的例子，都是可以直接跑的。如果觉得运行例子还是不明白用法，可以把你迷惑的地方写出来，然后提issue 运行命令如下 cd _example # GOPROXY 是打开go module代理，可以更快下载模块 # 第一次运行需要加GOPROXY下载模块，模块已安装的直接 go run 01-color-json.go 即可 env GOPROXY=https://goproxy.cn go run 01-color-json.go quick start package main import ( "fmt" "github.com/guonaihong/gout" "time" ) // 用于解析 服务端 返回的http body type RspBody struct { ErrMsg string `json:"errmsg"` ErrCode int `json:"errcode"` Data string `json:"data"` } // 用于解析 服务端 返回的http header type RspHeader struct { Sid string `header:"sid"` Time int `header:"time"` } func main() { rsp := RspBody{} header := RspHeader{} //code := 0 err := gout. // POST请求 POST("127.0.0.1:8080"). // 打开debug模式 Debug(true). // 设置查询字符串 SetQuery(gout.H{"page": 10, "size": 10}). // 设置http header SetHeader(gout.H{"X-IP": "127.0.0.1", "sid": fmt.Sprintf("%x", time.Now().UnixNano())}). // SetJSON设置http body为json // 同类函数有SetBody, SetYAML, SetXML, SetForm, SetWWWForm SetJSON(gout.H{"text": "gout"}). // BindJSON解析返回的body内容 // 同类函数有BindBody, BindYAML, BindXML BindJSON(&rsp). // 解析返回的http header BindHeader(&header). // http code // Code(&code). // 结束函数 Do() // 判断错误 if err != nil { fmt.Printf("send fail:%s\n", err) } } /* > POST /?page=10&size=10 HTTP/1.1 > Sid: 15d9b742ef32c130 > X-Ip: 127.0.0.1 > Content-Type: application/json > { "text": "gout" } */ API examples GET POST PUT DELETE PATH HEAD OPTIONS package main import ( "github.com/guonaihong/gout" ) func main() { url := "https://github.com" // 发送GET方法 gout.GET(url).Do() // 发送POST方法 gout.POST(url).Do() // 发送PUT方法 gout.PUT(url).Do() // 发送DELETE方法 gout.DELETE(url).Do() // 发送PATH方法 gout.PATCH(url).Do() // 发送HEAD方法 gout.HEAD(url).Do() // 发送OPTIONS gout.OPTIONS(url).Do() } Query Parameters SetQuery package main import ( "fmt" "github.com/guonaihong/gout" "time" ) func main() { err := gout. //设置GET请求和url，:8080/test.query是127.0.0.1:8080/test.query的简写 GET(":8080/test.query"). //打开debug模式 Debug(true). //设置查询字符串 SetQuery(gout.H{ "q1": "v1", "q2": 2, "q3": float32(3.14), "q4": 4.56, "q5": time.Now().Unix(), "q6": time.Now().UnixNano(), "q7": time.Now().Format("2006-01-02")}). //结束函数 Do() if err != nil { fmt.Printf("%s\n", err) return } } /* > GET /test.query?q1=v1&q2=2&q3=3.14&q4=4.56&q5=1574081600&q6=1574081600258009213&q7=2019-11-18 HTTP/1.1 > < HTTP/1.1 200 OK < Content-Length: 0 */ SetQuery支持的更多数据类型 http header Set request header package main import ( "fmt" "github.com/guonaihong/gout" "time" ) func main() { err := gout. //设置GET请求和url，:8080/test.header是127.0.0.1:8080/test.header的简写 GET(":8080/test.header"). //设置debug模式 Debug(true). //设置请求http header SetHeader(gout.H{ "h1": "v1", "h2": 2, "h3": float32(3.14), "h4": 4.56, "h5": time.Now().Unix(), "h6": time.Now().UnixNano(), "h7": time.Now().Format("2006-01-02")}). Do() if err != nil { fmt.Printf("%s\n", err) return } } /* > GET /test.header HTTP/1.1 > H2: 2 > H3: 3.14 > H4: 4.56 > H5: 1574081686 > H6: 1574081686471347098 > H7: 2019-11-18 > H1: v1 > < HTTP/1.1 200 OK < Content-Length: 0 */ Parsing the response header package main import ( "fmt" "github.com/guonaihong/gout" "time" ) // 和解析json类似，如要解析http header需设置header tag type rspHeader struct { Total int `header:"total"` Sid string `header:"sid"` Time time.Time `header:"time" time_format:"2006-01-02"` } func main() { rsp := rspHeader{} err := gout. // :8080/test.header是 http://127.0.0.1:8080/test.header的简写 GET(":8080/test.header"). //打开debug模式 Debug(true). //解析请求header至结构体中 BindHeader(&rsp). //结束函数 Do() if err != nil { fmt.Printf("%s\n", err) return } fmt.Printf("rsp header:\n%#v \nTime:%s\n", rsp, rsp.Time) } /* > GET /test.header HTTP/1.1 > < HTTP/1.1 200 OK < Content-Length: 0 < Sid: 1234 < Time: 2019-11-18 < Total: 2048 */ SetHeader和BindHeader支持的更多类型 http body body Set the data to the http request body // SetBody 设置string, []byte等类型数据到http body里面 // SetBody支持的更多数据类型可看下面 package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { err := gout. // 设置POST方法和url POST(":8080/req/body"). //打开debug模式 Debug(true). // 设置非结构化数据到http body里面 // 设置json需使用SetJSON SetBody("send string"). //结束函数 Do() if err != nil { fmt.Printf("%s\n", err) return } } /* > POST /req/body HTTP/1.1 > send string < HTTP/1.1 200 OK < Content-Type: text/plain; charset=utf-8 < Content-Length: 2 */ Parse the response body into a variable // BindBody bind body到string, []byte等类型变量里面 package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { s := "" err := gout. // 设置GET 方法及url GET("www.baidu.com"). // 绑定返回值 BindBody(&s). // 结束函数 Do() if err != nil { fmt.Printf("%s\n", err) return } fmt.Printf("html size = %d\n", len(s)) } 支持的类型有 io.Reader(SetBody 支持) io.Writer(BindBody 支持) int, int8, int16, int32, int64 uint, uint8, uint16, uint32, uint64 string []byte float32, float64 明确不支持的类型有 struct array, slice json Serialize json to request body 更多支持数据类型及用法 package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { err := gout.POST(":8080/colorjson"). //打开debug模式 Debug(true). //设置json到请求body SetJSON( gout.H{ "str": "foo", "num": 100, "bool": false, "null": nil, "array": gout.A{"foo", "bar", "baz"}, "obj": gout.H{"a": 1, "b": 2}, }, ). Do() if err != nil { fmt.Printf("err = %v\n", err) } } /* > POST /colorjson HTTP/1.1 > Content-Type: application/json > { "array": [ "foo", "bar", "baz" ], "bool": false, "null": null, "num": 100, "obj": { "a": 1, "b": 2 }, "str": "foo" } */ Parsed http response body in json format package main import ( "fmt" "github.com/guonaihong/gout" ) type rsp struct { ErrMsg string `json:"errmsg"` ErrCode int `json:"errcode"` } func main() { rsp := rsp{} err := gout. GET(":8080/colorjson"). //打开debug模式 Debug(true). //绑定响应json数据到结构体 BindJSON(&rsp). //结束函数 Do() if err != nil { fmt.Printf("err = %v\n", err) } } yaml SetYAML() 设置请求http body为yaml BindYAML() 解析响应http body里面的yaml到结构体里面 发送yaml到服务端，然后把服务端返回的yaml结果解析到结构体里面 type data struct { Id int `yaml:"id"` Data string `yaml:"data"` } var d1, d2 data var httpCode int err := gout.POST(":8080/test.yaml").SetYAML(&d1).BindYAML(&d2).Code(&httpCode).Do() if err != nil || httpCode != 200{ fmt.Printf("send fail:%s\n", err) } xml SetXML() 设置请求http body为xml BindXML() 解析响应http body里面的xml到结构体里面 发送xml到服务端，然后把服务端返回的xml结果解析到结构体里面 type data struct { Id int `xml:"id"` Data string `xml:"data"` } var d1, d2 data var httpCode int err := gout.POST(":8080/test.xml").SetXML(&d1).BindXML(&d2).Code(&httpCode).Do() if err != nil || httpCode != 200{ fmt.Printf("send fail:%s\n", err) } form-data SetForm() 设置http body 为multipart/form-data格式数据 客户端发送multipart/form-data到服务端,curl用法等同go代码 curl -F mode=A -F text="good" -F voice=@./test.pcm -f voice2=@./test2.pcm url 使用gout.H package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { code := 0 err := gout. POST(":8080/test"). // 打开debug模式 Debug(true). SetForm( gout.H{ "mode": "A", "text": "good", // 从文件里面打开 "voice": gout.FormFile("test.pcm"), "voice2": gout.FormMem("pcm"), }, ). //解析http code，如不关心可以不设置 Code(&code). Do() if err != nil { fmt.Printf("%s\n", err) } if code != 200 { } } /* > POST /test HTTP/1.1 > Content-Type: multipart/form-data; boundary=2b0685e5b98e540f80b247d5e7c1283807aa07e62b827543859a6db765a8 > --2b0685e5b98e540f80b247d5e7c1283807aa07e62b827543859a6db765a8 Content-Disposition: form-data; name="mode" A --2b0685e5b98e540f80b247d5e7c1283807aa07e62b827543859a6db765a8 Content-Disposition: form-data; name="text" good --2b0685e5b98e540f80b247d5e7c1283807aa07e62b827543859a6db765a8 Content-Disposition: form-data; name="voice"; filename="voice" Content-Type: application/octet-stream pcm pcm pcm --2b0685e5b98e540f80b247d5e7c1283807aa07e62b827543859a6db765a8 Content-Disposition: form-data; name="voice2"; filename="voice2" Content-Type: application/octet-stream pcm --2b0685e5b98e540f80b247d5e7c1283807aa07e62b827543859a6db765a8-- < HTTP/1.1 200 OK < Server: gurl-server < Content-Length: 0 */ 使用结构体 type testForm struct { Mode string `form:"mode"` Text string `form:"text"` Voice string `form:"voice" form-file:"true"` //从文件中读取 Voice2 []byte `form:"voice2" form-file:"mem"` //从内存中构造 } type rsp struct{ ErrMsg string `json:"errmsg"` ErrCode int `json:"errcode"` } t := testForm{} r := rsp{} code := 0 err := gout.POST(url).SetForm(&t).ShoudBindJSON(&r).Code(&code).Do() if err != nil { } x-www-form-urlencoded 使用SetWWWForm函数实现发送x-www-form-urlencoded类型数据 package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { code := 0 err := gout. POST(":8080/post"). // 打开debug模式 Debug(true). // 设置x-www-form-urlencoded数据 SetWWWForm( gout.H{ "int": 3, "float64": 3.14, "string": "test-www-Form", }, ). // 关心http code 返回值设置 Code(&code). Do() if err != nil { fmt.Printf("%s\n", err) return } if code != 200 { } } /* > POST /post HTTP/1.1 > Content-Type: application/x-www-form-urlencoded > float64=3.14&int=3&string=test-www-Form < HTTP/1.1 200 OK < Content-Length: 0 < Server: gurl-server */ protobuf SetProtoBuf支持，protobuf序列化后的[]byte，或者生成的protobuf结构体指针 package main import ( "github.com/guonaihong/gout" ) func main() { httpCode := 0 err := GET(":8080/echo"). SetProtoBuf( /* protobuf 生成的结构体，必须传指针类型*/ ). Code(&httpCode). Do() } callback callback主要用在，服务端会返回多种格式body的场景, 比如404返回的是html, 200返回json。 这时候要用Callback挂载多种处理函数，处理不同的数据结构 func main() { r, str404 := Result{}, "" code := 0 err := gout.GET(":8080").Callback(func(c *gout.Context) (err error) { switch c.Code { case 200: //http code为200时，服务端返回的是json 结构 c.BindJSON(&r) case 404: //http code为404时，服务端返回是html 字符串 c.BindBody(&str404) } code = c.Code return nil }).Do() if err != nil { fmt.Printf("err = %s\n", err) return } fmt.Printf("http code = %d, str404(%s) or json result(%v)\n", code, str404, r) } Set request timeout setimeout是request级别的超时方案。相比http.Client级别，更灵活。 package main import ( "fmt" "github.com/guonaihong/gout" "time" ) func main() { err := gout.GET(":8080"). SetTimeout(2 * time.Second). Do() if err != nil { fmt.Printf("err = %v\n", err) } } proxy SetProxy 设置代理服务地址 package main import ( "fmt" "github.com/guonaihong/gout" "log" ) func main() { c := &http.Client{} s := "" err := gout. New(c). GET("www.qq.com"). // 设置proxy服务地址 SetProxy("http://127.0.0.1:7000"). // 绑定返回数据到s里面 BindBody(&s). Do() if err != nil { log.Println(err) return } fmt.Println(s) } socks5 SetSOCKS5 设置socks5地址 package main import ( "fmt" "github.com/guonaihong/gout" "log" "net/http" ) func main() { c := &http.Client{} s := "" err := gout. New(c). GET("www.qq.com"). // 设置proxy服务地址 SetSOCKS5("127.0.0.1:7000"). // 绑定返回数据到s里面 BindBody(&s). Do() if err != nil { log.Println(err) return } fmt.Println(s) } cookie SetCookies设置cookie, 可以设置一个或者多个cookie package main import ( "fmt" "github.com/guonaihong/gout" "net/http" ) func main() { // === 发送多个cookie ==== err := gout. // :8080/cookie是http://127.0.0.1:8080/cookie的简写 GET(":8080/cookie"). //设置debug模式 Debug(true). SetCookies( //设置cookie1 &http.Cookie{ Name: "test1", Value: "test1", }, //设置cookie2 &http.Cookie{ Name: "test2", Value: "test2", }, ). Do() if err != nil { fmt.Println(err) return } // === 发送一个cookie === err = gout. // :8080/cookie/one是http://127.0.0.1:8080/cookie/one的简写 GET(":8080/cookie/one"). //设置debug模式 Debug(true). SetCookies( //设置cookie1 &http.Cookie{ Name: "test3", Value: "test3", }, ). Do() fmt.Println(err) } context WithContext设置context，可以取消http请求 Cancel a sending request package main import ( "context" "github.com/guonaihong/gout" "time" ) func main() { // 声明一个context ctx, cancel := context.WithCancel(context.Background()) //调用cancel可取消http请求 go func() { time.Sleep(time.Second) cancel() }() err := gout. GET("127.0.0.1:8080/cancel"). //设置GET请求以及需要访问的url WithContext(ctx). //设置context, 外层调用cancel函数就可取消这个http请求 Do() if err != nil { } } unix socket UnixSocket可以把http底层通信链路由tcp修改为unix domain socket 下面的例子，会通过domain socket发送http GET请求，http body的内容是hello world package main import ( "fmt" "github.com/guonaihong/gout" "net/http" ) func main() { c := http.Client{} g := gout. New(&c). UnixSocket("/tmp/test.socket") //设置unixsocket文件位置 err := g. GET("http://a/test"). //设置GET请求 SetBody("hello world"). //设置body内容 Do() fmt.Println(err) } http2 doc go 使用https访问http2的服务会自动启用http2协议，这里不需要任何特殊处理 https://http2.golang.org/(bradfitz建的http2测试网址,里面大约有十来个测试地址，下面的例子选了一个) package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { s := "" err := gout. GET("https://http2.golang.org/reqinfo"). //设置GET请求和请求url Debug(true). //打开debug模式，可以看到请求数据和响应数据 SetBody("hello, ###########"). //设置请求body的内容，如果你的请求内容是json格式，需要使用SetJSON函数 BindBody(&s). //解析响应body内容 Do() //结束函数 if err != nil { fmt.Printf("send fail:%s\n", err) } _ = s } debug mode Turn on debug mode 该模式主要方便调试用的，默认开启颜色高亮(如果要关闭颜色高亮，请往下看) func main() { err := gout.POST(":8080/colorjson"). Debug(true). //打开debug模式 SetJSON(gout.H{"str": "foo", "num": 100, "bool": false, "null": nil, "array": gout.A{"foo", "bar", "baz"}, "obj": gout.H{"a": 1, "b": 2}, }).Do() if err != nil { fmt.Printf("err = %v\n", err) } } Turn off color highlighting in debug mode 使用gout.NoColor()传入Debug函数关闭颜色高亮 func main() { err := gout.POST(":8080/colorjson"). Debug(gout.NoColor()). SetJSON(gout.H{"str": "foo", "num": 100, "bool": false, "null": nil, "array": gout.A{"foo", "bar", "baz"}, "obj": gout.H{"a": 1, "b": 2}, }).Do() if err != nil { fmt.Printf("err = %v\n", err) } } Custom debug mode debug 自定义模式，可传递函数。下面演示用环境变量开启debug模式(只有传递IOS_DEBUG环境变量才输出日志) package main import ( "fmt" "github.com/guonaihong/gout" "os" ) func IOSDebug() gout.DebugOpt { return gout.DebugFunc(func(o *gout.DebugOption) { if len(os.Getenv("IOS_DEBUG")) > 0 { o.Debug = true } }) } func main() { s := "" err := gout. GET("127.0.0.1:8080"). // Debug可以支持自定义方法 // 可以实现设置某个环境变量才输出debug信息 // 或者debug信息保存到文件里面，可以看下_example/15-debug-save-file.go Debug(IOSDebug()). SetBody("test hello"). BindBody(&s). Do() fmt.Printf("err = %v\n", err) } // env IOS_DEBUG=true go run customize.go trace info gout.Trace()可输出http各个阶段的耗时，比如dns lookup时间，tcp连接时间等等。可以很方便的做些性能调优。 package main import ( "fmt" "github.com/guonaihong/gout" ) func openDebugTrace() { err := gout.POST(":8080/colorjson"). Debug(gout.Trace()). SetJSON(gout.H{"str": "foo", "num": 100, "bool": false, "null": nil, "array": gout.A{"foo", "bar", "baz"}, "obj": gout.H{"a": 1, "b": 2}, }).Do() if err != nil { fmt.Printf("err = %v\n", err) } } output =================== Trace Info(S): =================== DnsDuration : 0s ConnDuration : 868.623µs TLSDuration : 0s RequestDuration : 376.712µs WaitResponeDuration : 717.008µs ResponseDuration : 76.158µs TotalDuration : 2.13921ms =================== Trace Info(E): =================== benchmark benchmarking a certain number of times 下面的例子，起了20并发。对:8080端口的服务，发送3000次请求进行压测，内容为json结构 package main import ( "fmt" "github.com/guonaihong/gout" ) const ( benchNumber = 30000 benchConcurrent = 20 ) func main() { err := gout. POST(":8080"). //压测本地8080端口 SetJSON(gout.H{"hello": "world"}). //设置请求body内容 Filter(). //打开过滤器 Bench(). //选择bench功能 Concurrent(benchConcurrent). //并发数 Number(benchNumber). //压测次数 Do() if err != nil { fmt.Printf("%v\n", err) } } benchmark-duration 下面的例子，起了20并发。对:8080端口的服务，压测持续时间为10s，内容为json结构 package main import ( "fmt" "github.com/guonaihong/gout" "time" ) const ( benchTime = 10 * time.Second benchConcurrent = 30 ) func main() { err := gout. POST(":8080"). //压测本机8080端口 SetJSON(gout.H{"hello": "world"}). //设置请求body内容 Filter(). //打开过滤器 Bench(). //选择bench功能 Concurrent(benchConcurrent). //并发数 Durations(benchTime). //压测时间 Do() if err != nil { fmt.Printf("%v\n", err) } } benchmark-rate 下面的例子，起了20并发。对:8080端口的服务，压测总次数为3000次，其中每秒发送1000次。内容为json结构 package main import ( "fmt" "github.com/guonaihong/gout" ) const ( benchNumber = 3000 benchConcurrent = 20 ) func main() { err := gout. POST(":8080"). //压测本机8080端口 SetJSON(gout.H{"hello": "world"}). //设置请求body内容 Filter(). //打开过滤器 Bench(). //选择bench功能 Rate(1000). //每秒发1000请求 Concurrent(benchConcurrent). //并发数 Number(benchNumber). //压测次数 Do() if err != nil { fmt.Printf("%v\n", err) } } Custom benchmark functions 自定义压测函数，构造每次不一样的http request数据 package main import ( "fmt" "github.com/google/uuid" "github.com/guonaihong/gout" "github.com/guonaihong/gout/filter" "sync/atomic" ) func main() { i := int32(0) err := filter.NewBench(). Concurrent(30). //开30个go程 Number(30000). //压测30000次 Loop(func(c *gout.Context) error { // 下面的代码，每次生成不一样的http body 用于压测 uid := uuid.New() //生成uuid id := atomic.AddInt32(&i, 1) //生成id, 可以理解为++i，线程安全版本 c.POST(":1234").SetJSON(gout.H{"sid": uid.String(), "appkey": fmt.Sprintf("ak:%d", id), "text": fmt.Sprintf("test text :%d", id)}) return nil }).Do() if err != nil { fmt.Printf("err = %v\n", err) } } retry-backoff retry 功能使用带抖动功能和指数回退的算法实现backoff package main import ( "fmt" "github.com/guonaihong/gout" "time" ) func main() { err := gout.HEAD("127.0.0.1:8080"). Debug(true). //打开debug模式 Filter(). //打开过滤器 Retry(). //打开重试模式 Attempt(5). //最多重试5次 WaitTime(500 * time.Millisecond). //基本等待时间 MaxWaitTime(3 * time.Second). //最长等待时间 Do() if err != nil { fmt.Printf("err = %v\n", err) } } retry conditions httpcode 指定重试条件，这里面的例子是服务端返回的状态码是209进行重试完整代码 package main import ( "fmt" "github.com/guonaihong/gout" "github.com/guonaihong/gout/filter" "time" ) func useRetryFuncCode() { s := "" err := gout.GET(":8080/code").Debug(true).BindBody(&s).F(). Retry().Attempt(3).WaitTime(time.Millisecond * 10).MaxWaitTime(time.Millisecond * 50). Func(func(c *gout.Context) error { if c.Error != nil || c.Code == 209 { return filter.ErrRetry } return nil }).Do() fmt.Printf("err = %v\n", err) } retry conditions backupurl 指定条件进行重试，这里的例子是默认url不能访问，使用backup url进行访问完整代码 package main import ( "fmt" "github.com/guonaihong/gout" "github.com/guonaihong/gout/core" "github.com/guonaihong/gout/filter" "time" ) func useRetryFunc() { // 获取一个没有服务绑定的端口 port := core.GetNoPortExists() s := "" err := gout.GET(":" + port).Debug(true).BindBody(&s).F(). Retry().Attempt(3).WaitTime(time.Millisecond * 10).MaxWaitTime(time.Millisecond * 50). Func(func(c *gout.Context) error { if c.Error != nil { c.SetHost(":1234") //必须是存在的端口 return filter.ErrRetry } return nil }).Do() fmt.Printf("err = %v\n", err) } import send raw http request package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { s := `POST /colorjson HTTP/1.1 Host: 127.0.0.1:8080 User-Agent: Go-http-client/1.1 Content-Length: 97 Content-Type: application/json Accept-Encoding: gzip {"array":["foo","bar","baz"],"bool":false,"null":null,"num":100,"obj":{"a":1,"b":2},"str":"foo"} ` err := gout.NewImport().RawText(s).Debug(true).SetHost(":1234").Do() if err != nil { fmt.Printf("err = %s\n", err) return } } export generate curl command package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { // 1.formdata err := gout.GET(":1234"). SetForm(gout.A{"text", "good", "mode", "A", "voice", gout.FormFile("./t8.go")}). Export().Curl().Do() // output: // curl -X GET -F "text=good" -F "mode=A" -F "voice=@./voice" "http://127.0.0.1:1234" // 2.json body err = gout.GET(":1234"). SetJSON(gout.H{"key1": "val1", "key2": "val2"}). Export().Curl().Do() // output: // curl -X GET -H "Content-Type:application/json" -d "{\"key1\":\"val1\",\"key2\":\"val2\"}" "http://127.0.0.1:1234" fmt.Printf("%v\n", err) } Incoming custom *http.Client 使用New接口即可使用自己的http.Client对象 package main import ( "fmt" "net/http" "github.com/guonaihong/gout" ) func main() { c := &http.Client{} //http.Client里面有fd连接池，如果对这块优化不是太了解，只使用一个实例就行 err := gout.New(c). // New接口可传入http.Client对象 GET("www.qq.com"). Debug(true). Do() if err != nil { fmt.Printf("err = %s\n", err) return } } Using chunked data format 使用Chunked接口, 设置为"Transfer-Encoding: chunked"的数据编码方式 package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { err := gout.POST(":8080"). Chunked(). SetBody("11111111111"). Do() if err != nil { fmt.Printf("err :%v\n", err) } } // 使用nc 起一个tcp服务, 使用上面的代码发起数据观察下结果 // nc -l 8080 Global configuration 这里记录全局配置的方法, 后面所有的全局配置都推荐使用gout.NewWithOpt接口的实现 insecure skip verify 忽略ssl验证, 使用gout.WithInsecureSkipVerify()接口配置该功能, 传入gout.NewWithOpt接口即可生效. import ( "github.com/guonaihong/gout" ) func main() { // globalWithOpt里面包含连接池, 这是一个全局可复用的对象 globalWithOpt := gout.NewWithOpt(gout.WithInsecureSkipVerify()) err := globalWithOpt.GET("url").Do() if err != nil { fmt.Printf("err = %v\n" ,err) return } } Turn off 3xx status code automatic jump golang client库默认遇到301的状态码会自动跳转重新发起新请求, 你希望关闭这种默认形为, 那就使用下面的功能 import ( "github.com/guonaihong/gout" ) func main() { // globalWithOpt里面包含连接池, 这是一个全局可复用的对象, 一个进程里面可能只需创建1个 globalWithOpt := gout.NewWithOpt(gout.WithClose3xxJump()) err := globalWithOpt.GET("url").Do() if err != nil { fmt.Printf("err = %v\n" ,err) return } } Null values are also serialized query := gout.H{ "t": 1296, "callback": "searchresult", "q": "美食", "stype": 1, "pagesize": 100, "pagenum": 1, "imageType": 2, "imageColor": "", "brand": "", "imageSType": "", "fr": 1, "sortFlag": 1, "imageUType": "", "btype": "", "authid": "", "_": 1611822443760, } 调用代码如下： gout.GET(url).Debug(true).SetQuery(query).SetHeader(header).BindBody(&body).Do() 控制台请求信息如下： > GET xxxx?_=1611822443760&callback=searchresult&fr=1&imageType=2&pagenum=1&pagesize=100&q=%E7%BE%8E%E9%A3%9F&sortFlag=1&stype=1&t=1296 HTTP/1.1 默认会删除，authid等空值，使用gout.NotIgnoreEmpty()接口，空value不会删除 set timeout 设置全局超时时间。可以简化一些代码。在使用全局配置默认你已经了解它会带来的一些弊端. package main import ( "fmt" "github.com/guonaihong/gout" "time" ) func main() { gout.SetTimeout(time.Second * 1) err := gout.GET("www.baidu.com").Do() if err != nil { fmt.Printf("err is:%v\n") } } Unique features forward gin data gout 设计之初就考虑到要和gin协同工作的可能性，下面展示如何方便地使用gout转发gin绑定的数据。 package main import ( "github.com/gin-gonic/gin" "github.com/guonaihong/gout" ) type testQuery struct { Size int `query:"size" form:"size"` // query tag是gout设置查询字符串需要的 Page int `query:"page" form:"page"` Ak string `query:"ak" form:"ak"` } //下一个服务节点 func nextSever() { r := gin.Default() r.GET("/query", func(c *gin.Context) { q := testQuery{} err := c.ShouldBindQuery(&q) if err != nil { return } c.JSON(200, q) }) r.Run(":1234") } func main() { go nextSever() r := gin.Default() // 演示把gin绑定到的查询字符串转发到nextServer节点 r.GET("/query", func(c *gin.Context) { q := testQuery{} // 绑定查询字符串 err := c.ShouldBindQuery(&q) if err != nil { return } // 开发转发, 复用gin所用结构体变量q code := 0 // http code err := gout. //发起GET请求 GET("127.0.0.1:1234/query"). //设置查询字符串 SetQuery(q). //关心http server返回的状态码 设置该函数 Code(&code). Do() if err != nil || code != 200 { /* todo Need to handle errors here */ } c.JSON(200, q) }) r.Run() } // http client // curl '127.0.0.1:8080/query?size=10&page=20&ak=test'
2021-06-17
优秀的个人博客,低调大师

gout v0.1.11 版本更新，Go 实现的 http RESTful 和 benchmark lib 库

项目地址: https://github.com/guonaihong/gout https://gitee.com/guonaihong/gout 本次更新 忽略ssl验证, 使用gout.WithInsecureSkipVerify()接口配置该功能, 传入gout.NewWithOpt接口即可生效. import ( "github.com/guonaihong/gout" ) func main() { // globalWithOpt里面包含连接池, 这是一个全局可复用的对象 globalWithOpt := gout.NewWithOpt(gout.WithInsecureSkipVerify()) err := globalWithOpt.GET("url").Do() if err != nil { fmt.Printf("err = %v\n" ,err) return } } 完整文档 gout gout 是go写的http 客户端，为提高工作效率而开发 构架 feature 支持设置 GET/PUT/DELETE/PATH/HEAD/OPTIONS 支持设置请求 http header(可传 struct,map,array,slice 等类型) 支持设置 URL query(可传 struct,map,array,slice,string 等类型) 支持设置 json 编码到请求 body 里面(可传struct, map, string, []byte 等类型) 支持设置 xml 编码到请求 body 里面(可传struct, string, []byte 等类型) 支持设置 yaml 编码到请求 body 里面(可传struct, map, string, []byte 等类型) 支持设置 form-data(可传 struct, map, array, slice 等类型) 支持设置 x-www-form-urlencoded(可传 struct,map,array,slice 等类型) 支持设置 io.Reader，uint/uint8/uint16...int/int8...string...[]byte...float32,float64 至请求 body 里面 支持解析响应body里面的json,xml,yaml至结构体里(BindJSON/BindXML/BindYAML) 支持解析响应body的内容至io.Writer, uint/uint8...int/int8...string...[]byte...float32,float64 支持解析响应header至结构体里 支持接口性能benchmark，可控制压测一定次数还是时间，可控制压测频率 支持retry-backoff，可以指定重试条件 支持发送裸http数据包 支持导出curl命令 传入自定义*http.Client 支持请求中间件(https://github.com/antlabs/gout-middleware) 支持设置chunked数据格式发送 等等更多 演示 内容 Installation example quick start API Examples GET POST PUT DELETE PATH HEAD OPTIONS Query Parameters http header Set request header Parsing the response header http body body Set the data to the http request body Parse the response body into a variable json Serialize json to request body Parsed http response body in json format yaml xml form-data x-www-form-urlencoded protobuf callback Set request timeout proxy socks5 cookie context Cancel a sending request unix socket http2 doc debug mode Turn on debug mode Turn off color highlighting in debug mode Custom debug mode trace info benchmark benchmarking a certain number of times benchmarking for a certain time benchmarking at a fixed frequency Custom benchmark functions retry backoff Specify the retry conditions, when equal to a certain http code Specify retry conditions. The default URL cannot be accessed. Use the backup URL import send raw http request export generate curl command Incoming custom * http.Client Using chunked data format Global configuration Insecure skip verify Null values are also serialized Global set timeout Unique features forward gin data FAQ Installation go get github.com/guonaihong/gout example examples目录下面的例子，都是可以直接跑的。如果觉得运行例子还是不明白用法，可以把你迷惑的地方写出来，然后提issue 运行命令如下 cd _example # GOPROXY 是打开go module代理，可以更快下载模块 # 第一次运行需要加GOPROXY下载模块，模块已安装的直接 go run 01-color-json.go 即可 env GOPROXY=https://goproxy.cn go run 01-color-json.go quick start package main import ( "fmt" "github.com/guonaihong/gout" "time" ) // 用于解析 服务端 返回的http body type RspBody struct { ErrMsg string `json:"errmsg"` ErrCode int `json:"errcode"` Data string `json:"data"` } // 用于解析 服务端 返回的http header type RspHeader struct { Sid string `header:"sid"` Time int `header:"time"` } func main() { rsp := RspBody{} header := RspHeader{} //code := 0 err := gout. // POST请求 POST("127.0.0.1:8080"). // 打开debug模式 Debug(true). // 设置查询字符串 SetQuery(gout.H{"page": 10, "size": 10}). // 设置http header SetHeader(gout.H{"X-IP": "127.0.0.1", "sid": fmt.Sprintf("%x", time.Now().UnixNano())}). // SetJSON设置http body为json // 同类函数有SetBody, SetYAML, SetXML, SetForm, SetWWWForm SetJSON(gout.H{"text": "gout"}). // BindJSON解析返回的body内容 // 同类函数有BindBody, BindYAML, BindXML BindJSON(&rsp). // 解析返回的http header BindHeader(&header). // http code // Code(&code). // 结束函数 Do() // 判断错误 if err != nil { fmt.Printf("send fail:%s\n", err) } } /* > POST /?page=10&size=10 HTTP/1.1 > Sid: 15d9b742ef32c130 > X-Ip: 127.0.0.1 > Content-Type: application/json > { "text": "gout" } */ API examples GET POST PUT DELETE PATH HEAD OPTIONS package main import ( "github.com/guonaihong/gout" ) func main() { url := "https://github.com" // 发送GET方法 gout.GET(url).Do() // 发送POST方法 gout.POST(url).Do() // 发送PUT方法 gout.PUT(url).Do() // 发送DELETE方法 gout.DELETE(url).Do() // 发送PATH方法 gout.PATCH(url).Do() // 发送HEAD方法 gout.HEAD(url).Do() // 发送OPTIONS gout.OPTIONS(url).Do() } Query Parameters SetQuery package main import ( "fmt" "github.com/guonaihong/gout" "time" ) func main() { err := gout. //设置GET请求和url，:8080/test.query是127.0.0.1:8080/test.query的简写 GET(":8080/test.query"). //打开debug模式 Debug(true). //设置查询字符串 SetQuery(gout.H{ "q1": "v1", "q2": 2, "q3": float32(3.14), "q4": 4.56, "q5": time.Now().Unix(), "q6": time.Now().UnixNano(), "q7": time.Now().Format("2006-01-02")}). //结束函数 Do() if err != nil { fmt.Printf("%s\n", err) return } } /* > GET /test.query?q1=v1&q2=2&q3=3.14&q4=4.56&q5=1574081600&q6=1574081600258009213&q7=2019-11-18 HTTP/1.1 > < HTTP/1.1 200 OK < Content-Length: 0 */ SetQuery支持的更多数据类型 http header Set request header package main import ( "fmt" "github.com/guonaihong/gout" "time" ) func main() { err := gout. //设置GET请求和url，:8080/test.header是127.0.0.1:8080/test.header的简写 GET(":8080/test.header"). //设置debug模式 Debug(true). //设置请求http header SetHeader(gout.H{ "h1": "v1", "h2": 2, "h3": float32(3.14), "h4": 4.56, "h5": time.Now().Unix(), "h6": time.Now().UnixNano(), "h7": time.Now().Format("2006-01-02")}). Do() if err != nil { fmt.Printf("%s\n", err) return } } /* > GET /test.header HTTP/1.1 > H2: 2 > H3: 3.14 > H4: 4.56 > H5: 1574081686 > H6: 1574081686471347098 > H7: 2019-11-18 > H1: v1 > < HTTP/1.1 200 OK < Content-Length: 0 */ Parsing the response header package main import ( "fmt" "github.com/guonaihong/gout" "time" ) // 和解析json类似，如要解析http header需设置header tag type rspHeader struct { Total int `header:"total"` Sid string `header:"sid"` Time time.Time `header:"time" time_format:"2006-01-02"` } func main() { rsp := rspHeader{} err := gout. // :8080/test.header是 http://127.0.0.1:8080/test.header的简写 GET(":8080/test.header"). //打开debug模式 Debug(true). //解析请求header至结构体中 BindHeader(&rsp). //结束函数 Do() if err != nil { fmt.Printf("%s\n", err) return } fmt.Printf("rsp header:\n%#v \nTime:%s\n", rsp, rsp.Time) } /* > GET /test.header HTTP/1.1 > < HTTP/1.1 200 OK < Content-Length: 0 < Sid: 1234 < Time: 2019-11-18 < Total: 2048 */ SetHeader和BindHeader支持的更多类型 http body body Set the data to the http request body // SetBody 设置string, []byte等类型数据到http body里面 // SetBody支持的更多数据类型可看下面 package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { err := gout. // 设置POST方法和url POST(":8080/req/body"). //打开debug模式 Debug(true). // 设置非结构化数据到http body里面 // 设置json需使用SetJSON SetBody("send string"). //结束函数 Do() if err != nil { fmt.Printf("%s\n", err) return } } /* > POST /req/body HTTP/1.1 > send string < HTTP/1.1 200 OK < Content-Type: text/plain; charset=utf-8 < Content-Length: 2 */ Parse the response body into a variable // BindBody bind body到string, []byte等类型变量里面 package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { s := "" err := gout. // 设置GET 方法及url GET("www.baidu.com"). // 绑定返回值 BindBody(&s). // 结束函数 Do() if err != nil { fmt.Printf("%s\n", err) return } fmt.Printf("html size = %d\n", len(s)) } 支持的类型有 io.Reader(SetBody 支持) io.Writer(BindBody 支持) int, int8, int16, int32, int64 uint, uint8, uint16, uint32, uint64 string []byte float32, float64 明确不支持的类型有 struct array, slice json Serialize json to request body 更多支持数据类型及用法 package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { err := gout.POST(":8080/colorjson"). //打开debug模式 Debug(true). //设置json到请求body SetJSON( gout.H{ "str": "foo", "num": 100, "bool": false, "null": nil, "array": gout.A{"foo", "bar", "baz"}, "obj": gout.H{"a": 1, "b": 2}, }, ). Do() if err != nil { fmt.Printf("err = %v\n", err) } } /* > POST /colorjson HTTP/1.1 > Content-Type: application/json > { "array": [ "foo", "bar", "baz" ], "bool": false, "null": null, "num": 100, "obj": { "a": 1, "b": 2 }, "str": "foo" } */ Parsed http response body in json format package main import ( "fmt" "github.com/guonaihong/gout" ) type rsp struct { ErrMsg string `json:"errmsg"` ErrCode int `json:"errcode"` } func main() { rsp := rsp{} err := gout. GET(":8080/colorjson"). //打开debug模式 Debug(true). //绑定响应json数据到结构体 BindJSON(&rsp). //结束函数 Do() if err != nil { fmt.Printf("err = %v\n", err) } } yaml SetYAML() 设置请求http body为yaml BindYAML() 解析响应http body里面的yaml到结构体里面 发送yaml到服务端，然后把服务端返回的yaml结果解析到结构体里面 type data struct { Id int `yaml:"id"` Data string `yaml:"data"` } var d1, d2 data var httpCode int err := gout.POST(":8080/test.yaml").SetYAML(&d1).BindYAML(&d2).Code(&httpCode).Do() if err != nil || httpCode != 200{ fmt.Printf("send fail:%s\n", err) } xml SetXML() 设置请求http body为xml BindXML() 解析响应http body里面的xml到结构体里面 发送xml到服务端，然后把服务端返回的xml结果解析到结构体里面 type data struct { Id int `xml:"id"` Data string `xml:"data"` } var d1, d2 data var httpCode int err := gout.POST(":8080/test.xml").SetXML(&d1).BindXML(&d2).Code(&httpCode).Do() if err != nil || httpCode != 200{ fmt.Printf("send fail:%s\n", err) } form-data SetForm() 设置http body 为multipart/form-data格式数据 客户端发送multipart/form-data到服务端,curl用法等同go代码 curl -F mode=A -F text="good" -F voice=@./test.pcm -f voice2=@./test2.pcm url 使用gout.H package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { code := 0 err := gout. POST(":8080/test"). // 打开debug模式 Debug(true). SetForm( gout.H{ "mode": "A", "text": "good", // 从文件里面打开 "voice": gout.FormFile("test.pcm"), "voice2": gout.FormMem("pcm"), }, ). //解析http code，如不关心可以不设置 Code(&code). Do() if err != nil { fmt.Printf("%s\n", err) } if code != 200 { } } /* > POST /test HTTP/1.1 > Content-Type: multipart/form-data; boundary=2b0685e5b98e540f80b247d5e7c1283807aa07e62b827543859a6db765a8 > --2b0685e5b98e540f80b247d5e7c1283807aa07e62b827543859a6db765a8 Content-Disposition: form-data; name="mode" A --2b0685e5b98e540f80b247d5e7c1283807aa07e62b827543859a6db765a8 Content-Disposition: form-data; name="text" good --2b0685e5b98e540f80b247d5e7c1283807aa07e62b827543859a6db765a8 Content-Disposition: form-data; name="voice"; filename="voice" Content-Type: application/octet-stream pcm pcm pcm --2b0685e5b98e540f80b247d5e7c1283807aa07e62b827543859a6db765a8 Content-Disposition: form-data; name="voice2"; filename="voice2" Content-Type: application/octet-stream pcm --2b0685e5b98e540f80b247d5e7c1283807aa07e62b827543859a6db765a8-- < HTTP/1.1 200 OK < Server: gurl-server < Content-Length: 0 */ 使用结构体 type testForm struct { Mode string `form:"mode"` Text string `form:"text"` Voice string `form:"voice" form-file:"true"` //从文件中读取 Voice2 []byte `form:"voice2" form-file:"mem"` //从内存中构造 } type rsp struct{ ErrMsg string `json:"errmsg"` ErrCode int `json:"errcode"` } t := testForm{} r := rsp{} code := 0 err := gout.POST(url).SetForm(&t).ShoudBindJSON(&r).Code(&code).Do() if err != nil { } x-www-form-urlencoded 使用SetWWWForm函数实现发送x-www-form-urlencoded类型数据 package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { code := 0 err := gout. POST(":8080/post"). // 打开debug模式 Debug(true). // 设置x-www-form-urlencoded数据 SetWWWForm( gout.H{ "int": 3, "float64": 3.14, "string": "test-www-Form", }, ). // 关心http code 返回值设置 Code(&code). Do() if err != nil { fmt.Printf("%s\n", err) return } if code != 200 { } } /* > POST /post HTTP/1.1 > Content-Type: application/x-www-form-urlencoded > float64=3.14&int=3&string=test-www-Form < HTTP/1.1 200 OK < Content-Length: 0 < Server: gurl-server */ protobuf SetProtoBuf支持，protobuf序列化后的[]byte，或者生成的protobuf结构体指针 package main import ( "github.com/guonaihong/gout" ) func main() { httpCode := 0 err := GET(":8080/echo"). SetProtoBuf( /* protobuf 生成的结构体，必须传指针类型*/ ). Code(&httpCode). Do() } callback callback主要用在，服务端会返回多种格式body的场景, 比如404返回的是html, 200返回json。 这时候要用Callback挂载多种处理函数，处理不同的数据结构 func main() { r, str404 := Result{}, "" code := 0 err := gout.GET(":8080").Callback(func(c *gout.Context) (err error) { switch c.Code { case 200: //http code为200时，服务端返回的是json 结构 c.BindJSON(&r) case 404: //http code为404时，服务端返回是html 字符串 c.BindBody(&str404) } code = c.Code return nil }).Do() if err != nil { fmt.Printf("err = %s\n", err) return } fmt.Printf("http code = %d, str404(%s) or json result(%v)\n", code, str404, r) } Set request timeout setimeout是request级别的超时方案。相比http.Client级别，更灵活。 package main import ( "fmt" "github.com/guonaihong/gout" "time" ) func main() { err := gout.GET(":8080"). SetTimeout(2 * time.Second). Do() if err != nil { fmt.Printf("err = %v\n", err) } } proxy SetProxy 设置代理服务地址 package main import ( "fmt" "github.com/guonaihong/gout" "log" ) func main() { c := &http.Client{} s := "" err := gout. New(c). GET("www.qq.com"). // 设置proxy服务地址 SetProxy("http://127.0.0.1:7000"). // 绑定返回数据到s里面 BindBody(&s). Do() if err != nil { log.Println(err) return } fmt.Println(s) } socks5 SetSOCKS5 设置socks5地址 package main import ( "fmt" "github.com/guonaihong/gout" "log" "net/http" ) func main() { c := &http.Client{} s := "" err := gout. New(c). GET("www.qq.com"). // 设置proxy服务地址 SetSOCKS5("127.0.0.1:7000"). // 绑定返回数据到s里面 BindBody(&s). Do() if err != nil { log.Println(err) return } fmt.Println(s) } cookie SetCookies设置cookie, 可以设置一个或者多个cookie package main import ( "fmt" "github.com/guonaihong/gout" "net/http" ) func main() { // === 发送多个cookie ==== err := gout. // :8080/cookie是http://127.0.0.1:8080/cookie的简写 GET(":8080/cookie"). //设置debug模式 Debug(true). SetCookies( //设置cookie1 &http.Cookie{ Name: "test1", Value: "test1", }, //设置cookie2 &http.Cookie{ Name: "test2", Value: "test2", }, ). Do() if err != nil { fmt.Println(err) return } // === 发送一个cookie === err = gout. // :8080/cookie/one是http://127.0.0.1:8080/cookie/one的简写 GET(":8080/cookie/one"). //设置debug模式 Debug(true). SetCookies( //设置cookie1 &http.Cookie{ Name: "test3", Value: "test3", }, ). Do() fmt.Println(err) } context WithContext设置context，可以取消http请求 Cancel a sending request package main import ( "context" "github.com/guonaihong/gout" "time" ) func main() { // 声明一个context ctx, cancel := context.WithCancel(context.Background()) //调用cancel可取消http请求 go func() { time.Sleep(time.Second) cancel() }() err := gout. GET("127.0.0.1:8080/cancel"). //设置GET请求以及需要访问的url WithContext(ctx). //设置context, 外层调用cancel函数就可取消这个http请求 Do() if err != nil { } } unix socket UnixSocket可以把http底层通信链路由tcp修改为unix domain socket 下面的例子，会通过domain socket发送http GET请求，http body的内容是hello world package main import ( "fmt" "github.com/guonaihong/gout" "net/http" ) func main() { c := http.Client{} g := gout. New(&c). UnixSocket("/tmp/test.socket") //设置unixsocket文件位置 err := g. GET("http://a/test"). //设置GET请求 SetBody("hello world"). //设置body内容 Do() fmt.Println(err) } http2 doc go 使用https访问http2的服务会自动启用http2协议，这里不需要任何特殊处理 https://http2.golang.org/(bradfitz建的http2测试网址,里面大约有十来个测试地址，下面的例子选了一个) package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { s := "" err := gout. GET("https://http2.golang.org/reqinfo"). //设置GET请求和请求url Debug(true). //打开debug模式，可以看到请求数据和响应数据 SetBody("hello, ###########"). //设置请求body的内容，如果你的请求内容是json格式，需要使用SetJSON函数 BindBody(&s). //解析响应body内容 Do() //结束函数 if err != nil { fmt.Printf("send fail:%s\n", err) } _ = s } debug mode Turn on debug mode 该模式主要方便调试用的，默认开启颜色高亮(如果要关闭颜色高亮，请往下看) func main() { err := gout.POST(":8080/colorjson"). Debug(true). //打开debug模式 SetJSON(gout.H{"str": "foo", "num": 100, "bool": false, "null": nil, "array": gout.A{"foo", "bar", "baz"}, "obj": gout.H{"a": 1, "b": 2}, }).Do() if err != nil { fmt.Printf("err = %v\n", err) } } Turn off color highlighting in debug mode 使用gout.NoColor()传入Debug函数关闭颜色高亮 func main() { err := gout.POST(":8080/colorjson"). Debug(gout.NoColor()). SetJSON(gout.H{"str": "foo", "num": 100, "bool": false, "null": nil, "array": gout.A{"foo", "bar", "baz"}, "obj": gout.H{"a": 1, "b": 2}, }).Do() if err != nil { fmt.Printf("err = %v\n", err) } } Custom debug mode debug 自定义模式，可传递函数。下面演示用环境变量开启debug模式(只有传递IOS_DEBUG环境变量才输出日志) package main import ( "fmt" "github.com/guonaihong/gout" "os" ) func IOSDebug() gout.DebugOpt { return gout.DebugFunc(func(o *gout.DebugOption) { if len(os.Getenv("IOS_DEBUG")) > 0 { o.Debug = true } }) } func main() { s := "" err := gout. GET("127.0.0.1:8080"). // Debug可以支持自定义方法 // 可以实现设置某个环境变量才输出debug信息 // 或者debug信息保存到文件里面，可以看下_example/15-debug-save-file.go Debug(IOSDebug()). SetBody("test hello"). BindBody(&s). Do() fmt.Printf("err = %v\n", err) } // env IOS_DEBUG=true go run customize.go trace info gout.Trace()可输出http各个阶段的耗时，比如dns lookup时间，tcp连接时间等等。可以很方便的做些性能调优。 package main import ( "fmt" "github.com/guonaihong/gout" ) func openDebugTrace() { err := gout.POST(":8080/colorjson"). Debug(gout.Trace()). SetJSON(gout.H{"str": "foo", "num": 100, "bool": false, "null": nil, "array": gout.A{"foo", "bar", "baz"}, "obj": gout.H{"a": 1, "b": 2}, }).Do() if err != nil { fmt.Printf("err = %v\n", err) } } output =================== Trace Info(S): =================== DnsDuration : 0s ConnDuration : 868.623µs TLSDuration : 0s RequestDuration : 376.712µs WaitResponeDuration : 717.008µs ResponseDuration : 76.158µs TotalDuration : 2.13921ms =================== Trace Info(E): =================== benchmark benchmarking a certain number of times 下面的例子，起了20并发。对:8080端口的服务，发送3000次请求进行压测，内容为json结构 package main import ( "fmt" "github.com/guonaihong/gout" ) const ( benchNumber = 30000 benchConcurrent = 20 ) func main() { err := gout. POST(":8080"). //压测本地8080端口 SetJSON(gout.H{"hello": "world"}). //设置请求body内容 Filter(). //打开过滤器 Bench(). //选择bench功能 Concurrent(benchConcurrent). //并发数 Number(benchNumber). //压测次数 Do() if err != nil { fmt.Printf("%v\n", err) } } benchmark-duration 下面的例子，起了20并发。对:8080端口的服务，压测持续时间为10s，内容为json结构 package main import ( "fmt" "github.com/guonaihong/gout" "time" ) const ( benchTime = 10 * time.Second benchConcurrent = 30 ) func main() { err := gout. POST(":8080"). //压测本机8080端口 SetJSON(gout.H{"hello": "world"}). //设置请求body内容 Filter(). //打开过滤器 Bench(). //选择bench功能 Concurrent(benchConcurrent). //并发数 Durations(benchTime). //压测时间 Do() if err != nil { fmt.Printf("%v\n", err) } } benchmark-rate 下面的例子，起了20并发。对:8080端口的服务，压测总次数为3000次，其中每秒发送1000次。内容为json结构 package main import ( "fmt" "github.com/guonaihong/gout" ) const ( benchNumber = 3000 benchConcurrent = 20 ) func main() { err := gout. POST(":8080"). //压测本机8080端口 SetJSON(gout.H{"hello": "world"}). //设置请求body内容 Filter(). //打开过滤器 Bench(). //选择bench功能 Rate(1000). //每秒发1000请求 Concurrent(benchConcurrent). //并发数 Number(benchNumber). //压测次数 Do() if err != nil { fmt.Printf("%v\n", err) } } Custom benchmark functions 自定义压测函数，构造每次不一样的http request数据 package main import ( "fmt" "github.com/google/uuid" "github.com/guonaihong/gout" "github.com/guonaihong/gout/filter" "sync/atomic" ) func main() { i := int32(0) err := filter.NewBench(). Concurrent(30). //开30个go程 Number(30000). //压测30000次 Loop(func(c *gout.Context) error { // 下面的代码，每次生成不一样的http body 用于压测 uid := uuid.New() //生成uuid id := atomic.AddInt32(&i, 1) //生成id, 可以理解为++i，线程安全版本 c.POST(":1234").SetJSON(gout.H{"sid": uid.String(), "appkey": fmt.Sprintf("ak:%d", id), "text": fmt.Sprintf("test text :%d", id)}) return nil }).Do() if err != nil { fmt.Printf("err = %v\n", err) } } retry-backoff retry 功能使用带抖动功能和指数回退的算法实现backoff package main import ( "fmt" "github.com/guonaihong/gout" "time" ) func main() { err := gout.HEAD("127.0.0.1:8080"). Debug(true). //打开debug模式 Filter(). //打开过滤器 Retry(). //打开重试模式 Attempt(5). //最多重试5次 WaitTime(500 * time.Millisecond). //基本等待时间 MaxWaitTime(3 * time.Second). //最长等待时间 Do() if err != nil { fmt.Printf("err = %v\n", err) } } retry conditions httpcode 指定重试条件，这里面的例子是服务端返回的状态码是209进行重试完整代码 package main import ( "fmt" "github.com/guonaihong/gout" "github.com/guonaihong/gout/filter" "time" ) func useRetryFuncCode() { s := "" err := gout.GET(":8080/code").Debug(true).BindBody(&s).F(). Retry().Attempt(3).WaitTime(time.Millisecond * 10).MaxWaitTime(time.Millisecond * 50). Func(func(c *gout.Context) error { if c.Error != nil || c.Code == 209 { return filter.ErrRetry } return nil }).Do() fmt.Printf("err = %v\n", err) } retry conditions backupurl 指定条件进行重试，这里的例子是默认url不能访问，使用backup url进行访问完整代码 package main import ( "fmt" "github.com/guonaihong/gout" "github.com/guonaihong/gout/core" "github.com/guonaihong/gout/filter" "time" ) func useRetryFunc() { // 获取一个没有服务绑定的端口 port := core.GetNoPortExists() s := "" err := gout.GET(":" + port).Debug(true).BindBody(&s).F(). Retry().Attempt(3).WaitTime(time.Millisecond * 10).MaxWaitTime(time.Millisecond * 50). Func(func(c *gout.Context) error { if c.Error != nil { c.SetHost(":1234") //必须是存在的端口 return filter.ErrRetry } return nil }).Do() fmt.Printf("err = %v\n", err) } import send raw http request package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { s := `POST /colorjson HTTP/1.1 Host: 127.0.0.1:8080 User-Agent: Go-http-client/1.1 Content-Length: 97 Content-Type: application/json Accept-Encoding: gzip {"array":["foo","bar","baz"],"bool":false,"null":null,"num":100,"obj":{"a":1,"b":2},"str":"foo"} ` err := gout.NewImport().RawText(s).Debug(true).SetHost(":1234").Do() if err != nil { fmt.Printf("err = %s\n", err) return } } export generate curl command package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { // 1.formdata err := gout.GET(":1234"). SetForm(gout.A{"text", "good", "mode", "A", "voice", gout.FormFile("./t8.go")}). Export().Curl().Do() // output: // curl -X GET -F "text=good" -F "mode=A" -F "voice=@./voice" "http://127.0.0.1:1234" // 2.json body err = gout.GET(":1234"). SetJSON(gout.H{"key1": "val1", "key2": "val2"}). Export().Curl().Do() // output: // curl -X GET -H "Content-Type:application/json" -d "{\"key1\":\"val1\",\"key2\":\"val2\"}" "http://127.0.0.1:1234" fmt.Printf("%v\n", err) } Incoming custom *http.Client 使用New接口即可使用自己的http.Client对象 package main import ( "fmt" "net/http" "github.com/guonaihong/gout" ) func main() { c := &http.Client{} //http.Client里面有fd连接池，如果对这块优化不是太了解，只使用一个实例就行 err := gout.New(c). // New接口可传入http.Client对象 GET("www.qq.com"). Debug(true). Do() if err != nil { fmt.Printf("err = %s\n", err) return } } Using chunked data format 使用Chunked接口, 设置为"Transfer-Encoding: chunked"的数据编码方式 package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { err := gout.POST(":8080"). Chunked(). SetBody("11111111111"). Do() if err != nil { fmt.Printf("err :%v\n", err) } } // 使用nc 起一个tcp服务, 使用上面的代码发起数据观察下结果 // nc -l 8080 Global configuration 这里记录全局配置的方法, 后面所有的全局配置都推荐使用gout.NewWithOpt接口的实现 insecure skip verify 忽略ssl验证, 使用gout.WithInsecureSkipVerify()接口配置该功能, 传入gout.NewWithOpt接口即可生效. import ( "github.com/guonaihong/gout" ) func main() { // globalWithOpt里面包含连接池, 这是一个全局可复用的对象 globalWithOpt := gout.NewWithOpt(gout.WithInsecureSkipVerify()) err := globalWithOpt.GET("url").Do() if err != nil { fmt.Printf("err = %v\n" ,err) return } } Null values are also serialized query := gout.H{ "t": 1296, "callback": "searchresult", "q": "美食", "stype": 1, "pagesize": 100, "pagenum": 1, "imageType": 2, "imageColor": "", "brand": "", "imageSType": "", "fr": 1, "sortFlag": 1, "imageUType": "", "btype": "", "authid": "", "_": 1611822443760, } 调用代码如下： gout.GET(url).Debug(true).SetQuery(query).SetHeader(header).BindBody(&body).Do() 控制台请求信息如下： > GET xxxx?_=1611822443760&callback=searchresult&fr=1&imageType=2&pagenum=1&pagesize=100&q=%E7%BE%8E%E9%A3%9F&sortFlag=1&stype=1&t=1296 HTTP/1.1 默认会删除，authid等空值，使用gout.NotIgnoreEmpty()接口，空value不会删除 global set timeout 设置全局超时时间。可以简化一些代码。在使用全局配置默认你已经了解它会带来的一些弊端. package main import ( "fmt" "github.com/guonaihong/gout" "time" ) func main() { gout.SetTimeout(time.Second * 1) err := gout.GET("www.baidu.com").Do() if err != nil { fmt.Printf("err is:%v\n") } } Unique features forward gin data gout 设计之初就考虑到要和gin协同工作的可能性，下面展示如何方便地使用gout转发gin绑定的数据。 package main import ( "github.com/gin-gonic/gin" "github.com/guonaihong/gout" ) type testQuery struct { Size int `query:"size" form:"size"` // query tag是gout设置查询字符串需要的 Page int `query:"page" form:"page"` Ak string `query:"ak" form:"ak"` } //下一个服务节点 func nextSever() { r := gin.Default() r.GET("/query", func(c *gin.Context) { q := testQuery{} err := c.ShouldBindQuery(&q) if err != nil { return } c.JSON(200, q) }) r.Run(":1234") } func main() { go nextSever() r := gin.Default() // 演示把gin绑定到的查询字符串转发到nextServer节点 r.GET("/query", func(c *gin.Context) { q := testQuery{} // 绑定查询字符串 err := c.ShouldBindQuery(&q) if err != nil { return } // 开发转发, 复用gin所用结构体变量q code := 0 // http code err := gout. //发起GET请求 GET("127.0.0.1:1234/query"). //设置查询字符串 SetQuery(q). //关心http server返回的状态码 设置该函数 Code(&code). Do() if err != nil || code != 200 { /* todo Need to handle errors here */ } c.JSON(200, q) }) r.Run() } // http client // curl '127.0.0.1:8080/query?size=10&page=20&ak=test' FAQ gout benchmark性能如何 下面是与apache ab的性能对比_example/16d-benchmark-vs-ab.go
2021-06-04
优秀的个人博客,低调大师

gout v0.1.10 版本更新,go http RESTful 客户端和 benchmark lib

项目地址: https://gitee.com/guonaihong/gout https://github.com/guonaihong/gout 本次更新内容 新增Chunked()接口, 控制使用chunked数据结构 文档 gout 是go写的http 客户端，为提高工作效率而开发 构架 feature 支持设置 GET/PUT/DELETE/PATH/HEAD/OPTIONS 支持设置请求 http header(可传 struct,map,array,slice 等类型) 支持设置 URL query(可传 struct,map,array,slice,string 等类型) 支持设置 json 编码到请求 body 里面(可传struct, map, string, []byte 等类型) 支持设置 xml 编码到请求 body 里面(可传struct, string, []byte 等类型) 支持设置 yaml 编码到请求 body 里面(可传struct, map, string, []byte 等类型) 支持设置 form-data(可传 struct, map, array, slice 等类型) 支持设置 x-www-form-urlencoded(可传 struct,map,array,slice 等类型) 支持设置 io.Reader，uint/uint8/uint16...int/int8...string...[]byte...float32,float64 至请求 body 里面 支持解析响应body里面的json,xml,yaml至结构体里(BindJSON/BindXML/BindYAML) 支持解析响应body的内容至io.Writer, uint/uint8...int/int8...string...[]byte...float32,float64 支持解析响应header至结构体里 支持接口性能benchmark，可控制压测一定次数还是时间，可控制压测频率 支持retry-backoff，可以指定重试条件 支持发送裸http数据包 支持导出curl命令 传入自定义*http.Client 支持请求中间件(https://github.com/antlabs/gout-middleware) 支持设置chunked数据格式发送 等等更多 演示 内容 Installation example quick start API Examples GET POST PUT DELETE PATH HEAD OPTIONS Query Parameters http header Set request header Parsing the response header http body body Set the data to the http request body Parse the response body into a variable json Serialize json to request body Parsed http response body in json format yaml xml form-data x-www-form-urlencoded protobuf callback Set request timeout proxy socks5 cookie context Cancel a sending request unix socket http2 doc debug mode Turn on debug mode Turn off color highlighting in debug mode Custom debug mode trace info benchmark benchmarking a certain number of times benchmarking for a certain time benchmarking at a fixed frequency Custom benchmark functions retry backoff Specify the retry conditions, when equal to a certain http code Specify retry conditions. The default URL cannot be accessed. Use the backup URL import send raw http request export generate curl command Incoming custom * http.Client Using chunked data format Global configuration Null values are also serialized Global set timeout Unique features forward gin data FAQ Installation go get github.com/guonaihong/gout example examples目录下面的例子，都是可以直接跑的。如果觉得运行例子还是不明白用法，可以把你迷惑的地方写出来，然后提issue 运行命令如下 cd _example # GOPROXY 是打开go module代理，可以更快下载模块 # 第一次运行需要加GOPROXY下载模块，模块已安装的直接 go run 01-color-json.go 即可 env GOPROXY=https://goproxy.cn go run 01-color-json.go quick start package main import ( "fmt" "github.com/guonaihong/gout" "time" ) // 用于解析 服务端 返回的http body type RspBody struct { ErrMsg string `json:"errmsg"` ErrCode int `json:"errcode"` Data string `json:"data"` } // 用于解析 服务端 返回的http header type RspHeader struct { Sid string `header:"sid"` Time int `header:"time"` } func main() { rsp := RspBody{} header := RspHeader{} //code := 0 err := gout. // POST请求 POST("127.0.0.1:8080"). // 打开debug模式 Debug(true). // 设置查询字符串 SetQuery(gout.H{"page": 10, "size": 10}). // 设置http header SetHeader(gout.H{"X-IP": "127.0.0.1", "sid": fmt.Sprintf("%x", time.Now().UnixNano())}). // SetJSON设置http body为json // 同类函数有SetBody, SetYAML, SetXML, SetForm, SetWWWForm SetJSON(gout.H{"text": "gout"}). // BindJSON解析返回的body内容 // 同类函数有BindBody, BindYAML, BindXML BindJSON(&rsp). // 解析返回的http header BindHeader(&header). // http code // Code(&code). // 结束函数 Do() // 判断错误 if err != nil { fmt.Printf("send fail:%s\n", err) } } /* > POST /?page=10&size=10 HTTP/1.1 > Sid: 15d9b742ef32c130 > X-Ip: 127.0.0.1 > Content-Type: application/json > { "text": "gout" } */ API examples GET POST PUT DELETE PATH HEAD OPTIONS package main import ( "github.com/guonaihong/gout" ) func main() { url := "https://github.com" // 发送GET方法 gout.GET(url).Do() // 发送POST方法 gout.POST(url).Do() // 发送PUT方法 gout.PUT(url).Do() // 发送DELETE方法 gout.DELETE(url).Do() // 发送PATH方法 gout.PATCH(url).Do() // 发送HEAD方法 gout.HEAD(url).Do() // 发送OPTIONS gout.OPTIONS(url).Do() } Query Parameters SetQuery package main import ( "fmt" "github.com/guonaihong/gout" "time" ) func main() { err := gout. //设置GET请求和url，:8080/test.query是127.0.0.1:8080/test.query的简写 GET(":8080/test.query"). //打开debug模式 Debug(true). //设置查询字符串 SetQuery(gout.H{ "q1": "v1", "q2": 2, "q3": float32(3.14), "q4": 4.56, "q5": time.Now().Unix(), "q6": time.Now().UnixNano(), "q7": time.Now().Format("2006-01-02")}). //结束函数 Do() if err != nil { fmt.Printf("%s\n", err) return } } /* > GET /test.query?q1=v1&q2=2&q3=3.14&q4=4.56&q5=1574081600&q6=1574081600258009213&q7=2019-11-18 HTTP/1.1 > < HTTP/1.1 200 OK < Content-Length: 0 */ SetQuery支持的更多数据类型 http header Set request header package main import ( "fmt" "github.com/guonaihong/gout" "time" ) func main() { err := gout. //设置GET请求和url，:8080/test.header是127.0.0.1:8080/test.header的简写 GET(":8080/test.header"). //设置debug模式 Debug(true). //设置请求http header SetHeader(gout.H{ "h1": "v1", "h2": 2, "h3": float32(3.14), "h4": 4.56, "h5": time.Now().Unix(), "h6": time.Now().UnixNano(), "h7": time.Now().Format("2006-01-02")}). Do() if err != nil { fmt.Printf("%s\n", err) return } } /* > GET /test.header HTTP/1.1 > H2: 2 > H3: 3.14 > H4: 4.56 > H5: 1574081686 > H6: 1574081686471347098 > H7: 2019-11-18 > H1: v1 > < HTTP/1.1 200 OK < Content-Length: 0 */ Parsing the response header package main import ( "fmt" "github.com/guonaihong/gout" "time" ) // 和解析json类似，如要解析http header需设置header tag type rspHeader struct { Total int `header:"total"` Sid string `header:"sid"` Time time.Time `header:"time" time_format:"2006-01-02"` } func main() { rsp := rspHeader{} err := gout. // :8080/test.header是 http://127.0.0.1:8080/test.header的简写 GET(":8080/test.header"). //打开debug模式 Debug(true). //解析请求header至结构体中 BindHeader(&rsp). //结束函数 Do() if err != nil { fmt.Printf("%s\n", err) return } fmt.Printf("rsp header:\n%#v \nTime:%s\n", rsp, rsp.Time) } /* > GET /test.header HTTP/1.1 > < HTTP/1.1 200 OK < Content-Length: 0 < Sid: 1234 < Time: 2019-11-18 < Total: 2048 */ SetHeader和BindHeader支持的更多类型 http body body Set the data to the http request body // SetBody 设置string, []byte等类型数据到http body里面 // SetBody支持的更多数据类型可看下面 package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { err := gout. // 设置POST方法和url POST(":8080/req/body"). //打开debug模式 Debug(true). // 设置非结构化数据到http body里面 // 设置json需使用SetJSON SetBody("send string"). //结束函数 Do() if err != nil { fmt.Printf("%s\n", err) return } } /* > POST /req/body HTTP/1.1 > send string < HTTP/1.1 200 OK < Content-Type: text/plain; charset=utf-8 < Content-Length: 2 */ Parse the response body into a variable // BindBody bind body到string, []byte等类型变量里面 package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { s := "" err := gout. // 设置GET 方法及url GET("www.baidu.com"). // 绑定返回值 BindBody(&s). // 结束函数 Do() if err != nil { fmt.Printf("%s\n", err) return } fmt.Printf("html size = %d\n", len(s)) } 支持的类型有 io.Reader(SetBody 支持) io.Writer(BindBody 支持) int, int8, int16, int32, int64 uint, uint8, uint16, uint32, uint64 string []byte float32, float64 明确不支持的类型有 struct array, slice json Serialize json to request body 更多支持数据类型及用法 package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { err := gout.POST(":8080/colorjson"). //打开debug模式 Debug(true). //设置json到请求body SetJSON( gout.H{ "str": "foo", "num": 100, "bool": false, "null": nil, "array": gout.A{"foo", "bar", "baz"}, "obj": gout.H{"a": 1, "b": 2}, }, ). Do() if err != nil { fmt.Printf("err = %v\n", err) } } /* > POST /colorjson HTTP/1.1 > Content-Type: application/json > { "array": [ "foo", "bar", "baz" ], "bool": false, "null": null, "num": 100, "obj": { "a": 1, "b": 2 }, "str": "foo" } */ Parsed http response body in json format package main import ( "fmt" "github.com/guonaihong/gout" ) type rsp struct { ErrMsg string `json:"errmsg"` ErrCode int `json:"errcode"` } func main() { rsp := rsp{} err := gout. GET(":8080/colorjson"). //打开debug模式 Debug(true). //绑定响应json数据到结构体 BindJSON(&rsp). //结束函数 Do() if err != nil { fmt.Printf("err = %v\n", err) } } yaml SetYAML() 设置请求http body为yaml BindYAML() 解析响应http body里面的yaml到结构体里面 发送yaml到服务端，然后把服务端返回的yaml结果解析到结构体里面 type data struct { Id int `yaml:"id"` Data string `yaml:"data"` } var d1, d2 data var httpCode int err := gout.POST(":8080/test.yaml").SetYAML(&d1).BindYAML(&d2).Code(&httpCode).Do() if err != nil || httpCode != 200{ fmt.Printf("send fail:%s\n", err) } xml SetXML() 设置请求http body为xml BindXML() 解析响应http body里面的xml到结构体里面 发送xml到服务端，然后把服务端返回的xml结果解析到结构体里面 type data struct { Id int `xml:"id"` Data string `xml:"data"` } var d1, d2 data var httpCode int err := gout.POST(":8080/test.xml").SetXML(&d1).BindXML(&d2).Code(&httpCode).Do() if err != nil || httpCode != 200{ fmt.Printf("send fail:%s\n", err) } form-data SetForm() 设置http body 为multipart/form-data格式数据 客户端发送multipart/form-data到服务端,curl用法等同go代码 curl -F mode=A -F text="good" -F voice=@./test.pcm -f voice2=@./test2.pcm url 使用gout.H package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { code := 0 err := gout. POST(":8080/test"). // 打开debug模式 Debug(true). SetForm( gout.H{ "mode": "A", "text": "good", // 从文件里面打开 "voice": gout.FormFile("test.pcm"), "voice2": gout.FormMem("pcm"), }, ). //解析http code，如不关心可以不设置 Code(&code). Do() if err != nil { fmt.Printf("%s\n", err) } if code != 200 { } } /* > POST /test HTTP/1.1 > Content-Type: multipart/form-data; boundary=2b0685e5b98e540f80b247d5e7c1283807aa07e62b827543859a6db765a8 > --2b0685e5b98e540f80b247d5e7c1283807aa07e62b827543859a6db765a8 Content-Disposition: form-data; name="mode" A --2b0685e5b98e540f80b247d5e7c1283807aa07e62b827543859a6db765a8 Content-Disposition: form-data; name="text" good --2b0685e5b98e540f80b247d5e7c1283807aa07e62b827543859a6db765a8 Content-Disposition: form-data; name="voice"; filename="voice" Content-Type: application/octet-stream pcm pcm pcm --2b0685e5b98e540f80b247d5e7c1283807aa07e62b827543859a6db765a8 Content-Disposition: form-data; name="voice2"; filename="voice2" Content-Type: application/octet-stream pcm --2b0685e5b98e540f80b247d5e7c1283807aa07e62b827543859a6db765a8-- < HTTP/1.1 200 OK < Server: gurl-server < Content-Length: 0 */ 使用结构体 type testForm struct { Mode string `form:"mode"` Text string `form:"text"` Voice string `form:"voice" form-file:"true"` //从文件中读取 Voice2 []byte `form:"voice2" form-file:"mem"` //从内存中构造 } type rsp struct{ ErrMsg string `json:"errmsg"` ErrCode int `json:"errcode"` } t := testForm{} r := rsp{} code := 0 err := gout.POST(url).SetForm(&t).ShoudBindJSON(&r).Code(&code).Do() if err != nil { } x-www-form-urlencoded 使用SetWWWForm函数实现发送x-www-form-urlencoded类型数据 package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { code := 0 err := gout. POST(":8080/post"). // 打开debug模式 Debug(true). // 设置x-www-form-urlencoded数据 SetWWWForm( gout.H{ "int": 3, "float64": 3.14, "string": "test-www-Form", }, ). // 关心http code 返回值设置 Code(&code). Do() if err != nil { fmt.Printf("%s\n", err) return } if code != 200 { } } /* > POST /post HTTP/1.1 > Content-Type: application/x-www-form-urlencoded > float64=3.14&int=3&string=test-www-Form < HTTP/1.1 200 OK < Content-Length: 0 < Server: gurl-server */ protobuf SetProtoBuf支持，protobuf序列化后的[]byte，或者生成的protobuf结构体指针 package main import ( "github.com/guonaihong/gout" ) func main() { httpCode := 0 err := GET(":8080/echo"). SetProtoBuf( /* protobuf 生成的结构体，必须传指针类型*/ ). Code(&httpCode). Do() } callback callback主要用在，服务端会返回多种格式body的场景, 比如404返回的是html, 200返回json。 这时候要用Callback挂载多种处理函数，处理不同的数据结构 func main() { r, str404 := Result{}, "" code := 0 err := gout.GET(":8080").Callback(func(c *gout.Context) (err error) { switch c.Code { case 200: //http code为200时，服务端返回的是json 结构 c.BindJSON(&r) case 404: //http code为404时，服务端返回是html 字符串 c.BindBody(&str404) } code = c.Code return nil }).Do() if err != nil { fmt.Printf("err = %s\n", err) return } fmt.Printf("http code = %d, str404(%s) or json result(%v)\n", code, str404, r) } Set request timeout setimeout是request级别的超时方案。相比http.Client级别，更灵活。 package main import ( "fmt" "github.com/guonaihong/gout" "time" ) func main() { err := gout.GET(":8080"). SetTimeout(2 * time.Second). Do() if err != nil { fmt.Printf("err = %v\n", err) } } proxy SetProxy 设置代理服务地址 package main import ( "fmt" "github.com/guonaihong/gout" "log" ) func main() { c := &http.Client{} s := "" err := gout. New(c). GET("www.qq.com"). // 设置proxy服务地址 SetProxy("http://127.0.0.1:7000"). // 绑定返回数据到s里面 BindBody(&s). Do() if err != nil { log.Println(err) return } fmt.Println(s) } socks5 SetSOCKS5 设置socks5地址 package main import ( "fmt" "github.com/guonaihong/gout" "log" "net/http" ) func main() { c := &http.Client{} s := "" err := gout. New(c). GET("www.qq.com"). // 设置proxy服务地址 SetSOCKS5("127.0.0.1:7000"). // 绑定返回数据到s里面 BindBody(&s). Do() if err != nil { log.Println(err) return } fmt.Println(s) } cookie SetCookies设置cookie, 可以设置一个或者多个cookie package main import ( "fmt" "github.com/guonaihong/gout" "net/http" ) func main() { // === 发送多个cookie ==== err := gout. // :8080/cookie是http://127.0.0.1:8080/cookie的简写 GET(":8080/cookie"). //设置debug模式 Debug(true). SetCookies( //设置cookie1 &http.Cookie{ Name: "test1", Value: "test1", }, //设置cookie2 &http.Cookie{ Name: "test2", Value: "test2", }, ). Do() if err != nil { fmt.Println(err) return } // === 发送一个cookie === err = gout. // :8080/cookie/one是http://127.0.0.1:8080/cookie/one的简写 GET(":8080/cookie/one"). //设置debug模式 Debug(true). SetCookies( //设置cookie1 &http.Cookie{ Name: "test3", Value: "test3", }, ). Do() fmt.Println(err) } context WithContext设置context，可以取消http请求 Cancel a sending request package main import ( "context" "github.com/guonaihong/gout" "time" ) func main() { // 声明一个context ctx, cancel := context.WithCancel(context.Background()) //调用cancel可取消http请求 go func() { time.Sleep(time.Second) cancel() }() err := gout. GET("127.0.0.1:8080/cancel"). //设置GET请求以及需要访问的url WithContext(ctx). //设置context, 外层调用cancel函数就可取消这个http请求 Do() if err != nil { } } unix socket UnixSocket可以把http底层通信链路由tcp修改为unix domain socket 下面的例子，会通过domain socket发送http GET请求，http body的内容是hello world package main import ( "fmt" "github.com/guonaihong/gout" "net/http" ) func main() { c := http.Client{} g := gout. New(&c). UnixSocket("/tmp/test.socket") //设置unixsocket文件位置 err := g. GET("http://a/test"). //设置GET请求 SetBody("hello world"). //设置body内容 Do() fmt.Println(err) } http2 doc go 使用https访问http2的服务会自动启用http2协议，这里不需要任何特殊处理 https://http2.golang.org/(bradfitz建的http2测试网址,里面大约有十来个测试地址，下面的例子选了一个) package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { s := "" err := gout. GET("https://http2.golang.org/reqinfo"). //设置GET请求和请求url Debug(true). //打开debug模式，可以看到请求数据和响应数据 SetBody("hello, ###########"). //设置请求body的内容，如果你的请求内容是json格式，需要使用SetJSON函数 BindBody(&s). //解析响应body内容 Do() //结束函数 if err != nil { fmt.Printf("send fail:%s\n", err) } _ = s } debug mode Turn on debug mode 该模式主要方便调试用的，默认开启颜色高亮(如果要关闭颜色高亮，请往下看) func main() { err := gout.POST(":8080/colorjson"). Debug(true). //打开debug模式 SetJSON(gout.H{"str": "foo", "num": 100, "bool": false, "null": nil, "array": gout.A{"foo", "bar", "baz"}, "obj": gout.H{"a": 1, "b": 2}, }).Do() if err != nil { fmt.Printf("err = %v\n", err) } } Turn off color highlighting in debug mode 使用gout.NoColor()传入Debug函数关闭颜色高亮 func main() { err := gout.POST(":8080/colorjson"). Debug(gout.NoColor()). SetJSON(gout.H{"str": "foo", "num": 100, "bool": false, "null": nil, "array": gout.A{"foo", "bar", "baz"}, "obj": gout.H{"a": 1, "b": 2}, }).Do() if err != nil { fmt.Printf("err = %v\n", err) } } Custom debug mode debug 自定义模式，可传递函数。下面演示用环境变量开启debug模式(只有传递IOS_DEBUG环境变量才输出日志) package main import ( "fmt" "github.com/guonaihong/gout" "os" ) func IOSDebug() gout.DebugOpt { return gout.DebugFunc(func(o *gout.DebugOption) { if len(os.Getenv("IOS_DEBUG")) > 0 { o.Debug = true } }) } func main() { s := "" err := gout. GET("127.0.0.1:8080"). // Debug可以支持自定义方法 // 可以实现设置某个环境变量才输出debug信息 // 或者debug信息保存到文件里面，可以看下_example/15-debug-save-file.go Debug(IOSDebug()). SetBody("test hello"). BindBody(&s). Do() fmt.Printf("err = %v\n", err) } // env IOS_DEBUG=true go run customize.go trace info gout.Trace()可输出http各个阶段的耗时，比如dns lookup时间，tcp连接时间等等。可以很方便的做些性能调优。 package main import ( "fmt" "github.com/guonaihong/gout" ) func openDebugTrace() { err := gout.POST(":8080/colorjson"). Debug(gout.Trace()). SetJSON(gout.H{"str": "foo", "num": 100, "bool": false, "null": nil, "array": gout.A{"foo", "bar", "baz"}, "obj": gout.H{"a": 1, "b": 2}, }).Do() if err != nil { fmt.Printf("err = %v\n", err) } } output =================== Trace Info(S): =================== DnsDuration : 0s ConnDuration : 868.623µs TLSDuration : 0s RequestDuration : 376.712µs WaitResponeDuration : 717.008µs ResponseDuration : 76.158µs TotalDuration : 2.13921ms =================== Trace Info(E): =================== benchmark benchmarking a certain number of times 下面的例子，起了20并发。对:8080端口的服务，发送3000次请求进行压测，内容为json结构 package main import ( "fmt" "github.com/guonaihong/gout" ) const ( benchNumber = 30000 benchConcurrent = 20 ) func main() { err := gout. POST(":8080"). //压测本地8080端口 SetJSON(gout.H{"hello": "world"}). //设置请求body内容 Filter(). //打开过滤器 Bench(). //选择bench功能 Concurrent(benchConcurrent). //并发数 Number(benchNumber). //压测次数 Do() if err != nil { fmt.Printf("%v\n", err) } } benchmark-duration 下面的例子，起了20并发。对:8080端口的服务，压测持续时间为10s，内容为json结构 package main import ( "fmt" "github.com/guonaihong/gout" "time" ) const ( benchTime = 10 * time.Second benchConcurrent = 30 ) func main() { err := gout. POST(":8080"). //压测本机8080端口 SetJSON(gout.H{"hello": "world"}). //设置请求body内容 Filter(). //打开过滤器 Bench(). //选择bench功能 Concurrent(benchConcurrent). //并发数 Durations(benchTime). //压测时间 Do() if err != nil { fmt.Printf("%v\n", err) } } benchmark-rate 下面的例子，起了20并发。对:8080端口的服务，压测总次数为3000次，其中每秒发送1000次。内容为json结构 package main import ( "fmt" "github.com/guonaihong/gout" ) const ( benchNumber = 3000 benchConcurrent = 20 ) func main() { err := gout. POST(":8080"). //压测本机8080端口 SetJSON(gout.H{"hello": "world"}). //设置请求body内容 Filter(). //打开过滤器 Bench(). //选择bench功能 Rate(1000). //每秒发1000请求 Concurrent(benchConcurrent). //并发数 Number(benchNumber). //压测次数 Do() if err != nil { fmt.Printf("%v\n", err) } } Custom benchmark functions 自定义压测函数，构造每次不一样的http request数据 package main import ( "fmt" "github.com/google/uuid" "github.com/guonaihong/gout" "github.com/guonaihong/gout/filter" "sync/atomic" ) func main() { i := int32(0) err := filter.NewBench(). Concurrent(30). //开30个go程 Number(30000). //压测30000次 Loop(func(c *gout.Context) error { // 下面的代码，每次生成不一样的http body 用于压测 uid := uuid.New() //生成uuid id := atomic.AddInt32(&i, 1) //生成id, 可以理解为++i，线程安全版本 c.POST(":1234").SetJSON(gout.H{"sid": uid.String(), "appkey": fmt.Sprintf("ak:%d", id), "text": fmt.Sprintf("test text :%d", id)}) return nil }).Do() if err != nil { fmt.Printf("err = %v\n", err) } } retry-backoff retry 功能使用带抖动功能和指数回退的算法实现backoff package main import ( "fmt" "github.com/guonaihong/gout" "time" ) func main() { err := gout.HEAD("127.0.0.1:8080"). Debug(true). //打开debug模式 Filter(). //打开过滤器 Retry(). //打开重试模式 Attempt(5). //最多重试5次 WaitTime(500 * time.Millisecond). //基本等待时间 MaxWaitTime(3 * time.Second). //最长等待时间 Do() if err != nil { fmt.Printf("err = %v\n", err) } } retry conditions httpcode 指定重试条件，这里面的例子是服务端返回的状态码是209进行重试完整代码 package main import ( "fmt" "github.com/guonaihong/gout" "github.com/guonaihong/gout/filter" "time" ) func useRetryFuncCode() { s := "" err := gout.GET(":8080/code").Debug(true).BindBody(&s).F(). Retry().Attempt(3).WaitTime(time.Millisecond * 10).MaxWaitTime(time.Millisecond * 50). Func(func(c *gout.Context) error { if c.Error != nil || c.Code == 209 { return filter.ErrRetry } return nil }).Do() fmt.Printf("err = %v\n", err) } retry conditions backupurl 指定条件进行重试，这里的例子是默认url不能访问，使用backup url进行访问完整代码 package main import ( "fmt" "github.com/guonaihong/gout" "github.com/guonaihong/gout/core" "github.com/guonaihong/gout/filter" "time" ) func useRetryFunc() { // 获取一个没有服务绑定的端口 port := core.GetNoPortExists() s := "" err := gout.GET(":" + port).Debug(true).BindBody(&s).F(). Retry().Attempt(3).WaitTime(time.Millisecond * 10).MaxWaitTime(time.Millisecond * 50). Func(func(c *gout.Context) error { if c.Error != nil { c.SetHost(":1234") //必须是存在的端口 return filter.ErrRetry } return nil }).Do() fmt.Printf("err = %v\n", err) } import send raw http request package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { s := `POST /colorjson HTTP/1.1 Host: 127.0.0.1:8080 User-Agent: Go-http-client/1.1 Content-Length: 97 Content-Type: application/json Accept-Encoding: gzip {"array":["foo","bar","baz"],"bool":false,"null":null,"num":100,"obj":{"a":1,"b":2},"str":"foo"} ` err := gout.NewImport().RawText(s).Debug(true).SetHost(":1234").Do() if err != nil { fmt.Printf("err = %s\n", err) return } } export generate curl command package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { // 1.formdata err := gout.GET(":1234"). SetForm(gout.A{"text", "good", "mode", "A", "voice", gout.FormFile("./t8.go")}). Export().Curl().Do() // output: // curl -X GET -F "text=good" -F "mode=A" -F "voice=@./voice" "http://127.0.0.1:1234" // 2.json body err = gout.GET(":1234"). SetJSON(gout.H{"key1": "val1", "key2": "val2"}). Export().Curl().Do() // output: // curl -X GET -H "Content-Type:application/json" -d "{\"key1\":\"val1\",\"key2\":\"val2\"}" "http://127.0.0.1:1234" fmt.Printf("%v\n", err) } Incoming custom *http.Client 使用New接口即可使用自己的http.Client对象 package main import ( "fmt" "net/http" "github.com/guonaihong/gout" ) func main() { c := &http.Client{} //http.Client里面有fd连接池，如果对这块优化不是太了解，只使用一个实例就行 err := gout.New(c). // New接口可传入http.Client对象 GET("www.qq.com"). Debug(true). Do() if err != nil { fmt.Printf("err = %s\n", err) return } } Using chunked data format 使用Chunked接口, 设置为"Transfer-Encoding: chunked"的数据编码方式 package main import ( "fmt" "github.com/guonaihong/gout" ) func main() { err := gout.POST(":8080"). Chunked(). SetBody("11111111111"). Do() if err != nil { fmt.Printf("err :%v\n", err) } } // 使用nc 起一个tcp服务, 使用上面的代码发起数据观察下结果 // nc -l 8080 Global configuration Null values are also serialized query := gout.H{ "t": 1296, "callback": "searchresult", "q": "美食", "stype": 1, "pagesize": 100, "pagenum": 1, "imageType": 2, "imageColor": "", "brand": "", "imageSType": "", "fr": 1, "sortFlag": 1, "imageUType": "", "btype": "", "authid": "", "_": 1611822443760, } 调用代码如下： gout.GET(url).Debug(true).SetQuery(query).SetHeader(header).BindBody(&body).Do() 控制台请求信息如下： > GET xxxx?_=1611822443760&callback=searchresult&fr=1&imageType=2&pagenum=1&pagesize=100&q=%E7%BE%8E%E9%A3%9F&sortFlag=1&stype=1&t=1296 HTTP/1.1 默认会删除，authid等空值，使用gout.NotIgnoreEmpty()接口，空value不会删除 global set timeout 设置全局超时时间。可以简化一些代码。在使用全局配置默认你已经了解它会带来的一些弊端. package main import ( "fmt" "github.com/guonaihong/gout" "time" ) func main() { gout.SetTimeout(time.Second * 1) err := gout.GET("www.baidu.com").Do() if err != nil { fmt.Printf("err is:%v\n") } } Unique features forward gin data gout 设计之初就考虑到要和gin协同工作的可能性，下面展示如何方便地使用gout转发gin绑定的数据。 package main import ( "github.com/gin-gonic/gin" "github.com/guonaihong/gout" ) type testQuery struct { Size int `query:"size" form:"size"` // query tag是gout设置查询字符串需要的 Page int `query:"page" form:"page"` Ak string `query:"ak" form:"ak"` } //下一个服务节点 func nextSever() { r := gin.Default() r.GET("/query", func(c *gin.Context) { q := testQuery{} err := c.ShouldBindQuery(&q) if err != nil { return } c.JSON(200, q) }) r.Run(":1234") } func main() { go nextSever() r := gin.Default() // 演示把gin绑定到的查询字符串转发到nextServer节点 r.GET("/query", func(c *gin.Context) { q := testQuery{} // 绑定查询字符串 err := c.ShouldBindQuery(&q) if err != nil { return } // 开发转发, 复用gin所用结构体变量q code := 0 // http code err := gout. //发起GET请求 GET("127.0.0.1:1234/query"). //设置查询字符串 SetQuery(q). //关心http server返回的状态码 设置该函数 Code(&code). Do() if err != nil || code != 200 { /* todo Need to handle errors here */ } c.JSON(200, q) }) r.Run() } // http client // curl '127.0.0.1:8080/query?size=10&page=20&ak=test' FAQ gout benchmark性能如何 下面是与apache ab的性能对比_example/16d-benchmark-vs-ab.go
2021-05-17

资源下载

更多资源
Mario

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

时间: 2026-04-11 大小: 211.28KB 下载: 56次
Nacos

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

时间: 2026-08-21 大小: 189MB 下载: 7次
Rocky Linux

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

时间: 2026-08-21 大小: 1.42GB 下载: 6次
Sublime Text

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

时间: 2026-08-21 大小: 9.84MB 下载: 40次
热门标签
DeepSeek Jdk25 OpenAi HarmonyOS6 Nacos3 SpringBoot4 SpringCloud Docker Kubernetes Service Mesh Redis Gemini3 Rocky

欢迎您来访！

登录后，您将获得更多功能！
热门文章
联系我们

有任何问题或合作意向欢迎联系我们

Email: 99873273@qq.com

QQ: 99873273

用户登录
用户注册