Go标准库之Requests的介绍与基本使用

go get -u github.com/levigross/grequests

import "github.com/levigross/grequests"

func get() {
	resp, err := grequests.get("http://127.0.0.1:8080/book/", nil)
	if err != nil {
		log.fatalln("unable to make request: ", err)
	}

	if !resp.ok {
		log.fatalln("请求超时!")
	}

	// 解析响应的json数据
	var data []map[string]interface{}
	if err := resp.json(&data); err != nil {
		log.fatalln("unable to parse json response: ", err)
	}
	fmt.println(data)
}

func post() {
	postdata := map[string]string{
		"id":   "1",
		"name": "go入门到进阶",
	}
	geq := &grequests.requestoptions{
		json: postdata,
	}
	resp, err := grequests.post("http://127.0.0.1:8080/book/create", geq)
	if err != nil {
		log.fatalln("unable to make request: ", err)
	}
	fmt.println(resp.string())
}

func uploadfile() {
	// 允许您通过指定磁盘上的位置来创建fileupload结构片
	// 打开要上传的文件
	file, err := os.open("./go.mod")
	if err != nil {
		log.fatalln("unable to open file: ", err)
	}
	defer file.close()

	// 创建fileupload结构片
	ro := &grequests.requestoptions{
		files: []grequests.fileupload{{
			filename:     "1.txt", // 上传后的文件名称
			fieldname:    "file",  // 上传文件对应字段
			filecontents: file, // 使用文件内容作为filecontents
		}},
	}
	// 发送post请求
	resp, err := grequests.post("http://127.0.0.1:8080/book/upload/", ro)
	if err != nil {
		log.fatalln("unable to make request: ", err)
	}
	fmt.println(resp.string())
}

func proxy() {
	// 代理服务器
	const proxyserver = "http-pro.xxx.com:9010"

	// 代理隧道验证信息
	const proxyuser = "xxxxxxxxx"
	const proxypass = "xxxxxxxxx"

	// 初始化代理url
	proxyurl, _ := url.parse("http://" + proxyuser + ":" + proxypass + "@" + proxyserver)

	// 创建请求选项
	ro := &grequests.requestoptions{
		proxies: map[string]*url.url{
			"http": proxyurl,
		},
		headers: map[string]string{
			"user-agent": "mozilla/5.0 (windows nt 10.0; win64; x64) applewebkit/537.36 (khtml, like gecko) chrome/105.0.0.0 safari/537.36",
		},
	}

	// 发起get请求
	resp, err := grequests.get("http://www.example.com", ro)
	if err != nil {
		fmt.println("error:", err)
		return
	}

	// 打印响应状态码
	fmt.println("status code:", resp.statuscode)

	// 打印响应体
	fmt.println("response:", resp.string())
}

session := grequests.session{
		requestoptions: &grequests.requestoptions{
			headers: map[string]string{
				"authority":  "mp3.haoge500.com",
				"referer":    "https://www.zz123.com/",
				"user-agent": "mozilla/5.0 (windows nt 10.0; win64; x64) applewebkit/537.36 (khtml, like gecko) chrome/107.0.0.0 safari/537.36",
			},
		},
	}

package main

import (
	"encoding/json"
	"github.com/gin-gonic/gin"
	"net/http"
	"os"
)

type book struct {
	id   string `json:"id"`
	name string `json:"name"`
}

type bookhandler struct {
}

func (b *bookhandler) registerroutes(server *gin.engine) {
	bg := server.group("/book")
	bg.post("/upload", b.upload)
	bg.post("/create", b.create)
	bg.get("/", b.getallbooks) // 查询书籍
}

func (b *bookhandler) upload(ctx *gin.context) {
	// 从请求中获取文件
	file, err := ctx.formfile("file")
	if err != nil {
		ctx.json(http.statusbadrequest, gin.h{"error": "无法获取上传的文件"})
		return
	}

	// 将文件保存到服务器
	// 注意：这里需要确保保存文件的目录存在，并且服务器有写入权限
	savepath := "./uploads/" + file.filename
	if err := ctx.saveuploadedfile(file, savepath); err != nil {
		ctx.json(http.statusinternalservererror, gin.h{"error": "文件保存失败"})
		return
	}

	ctx.json(http.statusok, gin.h{"message": "文件上传成功"})
}

func (b *bookhandler) create(ctx *gin.context) {
	var req book
	if err := ctx.bind(&req); err != nil {
		return
	}

	// 将新的书籍数据保存到data.json文件中
	if err := addbooktofile(&req); err != nil {
		ctx.json(http.statusinternalservererror, gin.h{"error": "failed to save book data"})
		return
	}

	ctx.json(http.statusok, gin.h{"message": "book added successfully"})
}
func (b *bookhandler) getallbooks(c *gin.context) {
	// 从data.json文件中读取书籍数据
	books, err := getbooksfromfile()
	if err != nil {
		c.json(http.statusinternalservererror, gin.h{"error": "failed to read book data"})
		return
	}

	// 获取url查询参数中的id
	id := c.query("id")

	// 如果提供了id，查找具有匹配id的书籍列表
	if id != "" {
		// 查找具有匹配id的书籍
		var foundbooks []book
		for _, book := range books {
			if book.id == id {
				foundbooks = append(foundbooks, book)
			}
		}
		// 如果找到了匹配的书籍，返回这些书籍
		if len(foundbooks) > 0 {
			c.json(http.statusok, foundbooks)
			return
		}
		// 如果没有找到匹配的书籍，返回404
		c.json(http.statusnotfound, gin.h{"error": "books not found"})
		return
	}

	// 如果没有提供id，返回所有书籍
	c.json(http.statusok, books)
}
func addbooktofile(book *book) error {
	// 读取现有的data.json文件内容
	var books []book
	data, err := os.readfile("data.json")
	if err != nil && !os.isnotexist(err) {
		return err
	}

	// 如果文件存在，解析现有的书籍数据
	if err == nil {
		if err := json.unmarshal(data, &books); err != nil {
			return err
		}
	}

	// 将新的书籍添加到数组中
	books = append(books, *book)

	// 将更新后的书籍数组序列化为json
	newdata, err := json.marshalindent(books, "", "    ")
	if err != nil {
		return err
	}

	// 将序列化的json数据写入data.json文件
	if err := os.writefile("data.json", newdata, 0644); err != nil {
		return err
	}

	return nil
}
func getbooksfromfile() ([]book, error) {
	// 读取data.json文件内容
	data, err := os.readfile("data.json")
	if err != nil {
		return nil, err
	}

	// 解析json数据到书籍数组中
	var books []book
	if err := json.unmarshal(data, &books); err != nil {
		return nil, err
	}

	return books, nil
}

func initwebserver(bookhandler *bookhandler) *gin.engine {
	server := gin.default()
	bookhandler.registerroutes(server)
	return server
}

func main() {
	// 确保上传目录存在
	os.mkdirall("./uploads", 0755)

	bookhandler := &bookhandler{}
	server := initwebserver(bookhandler)
	server.run(":8080") // 在8080端口启动服务器
}