package main

import (
    "fmt"
    "io"
    "net/http"
    "time"
)

func main() {
    // 简单的 GET 请求
    resp, err := http.Get("https://api.github.com")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Printf("Status: %s\n", resp.Status)
    fmt.Printf("Body: %s\n", body[:100])
}

package main

import (
    "fmt"
    "io"
    "net/http"
    "net/url"
    "time"
    "strings"
)

func main() {
    // 创建自定义客户端
    client := &http.Client{
        Timeout: 10 * time.Second,
        Transport: &http.Transport{
            MaxIdleConns:        10,
            IdleConnTimeout:     30 * time.Second,
            DisableCompression:  false,
        },
    }

    // 构建 POST 请求
    data := url.Values{}
    data.Set("username", "admin")
    data.Set("password", "secret")

    req, err := http.NewRequest(
        "POST",
        "https://httpbin.org/post",
        strings.NewReader(data.Encode()),
    )
    if err != nil {
        panic(err)
    }

    // 设置请求头
    req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
    req.Header.Set("User-Agent", "MyGoClient/1.0")

    // 发送请求
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    // 处理响应
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

// 定义结构体
type User struct {
    Name  string `json:"name"`
    Email string `json:"email"`
}

type Post struct {
    ID     int    `json:"id"`
    Title  string `json:"title"`
    Body   string `json:"body"`
    UserID int    `json:"userId"`
}

func main() {
    // 发送 JSON 数据
    user := User{
        Name:  "John Doe",
        Email: "john@example.com",
    }

    jsonData, _ := json.Marshal(user)

    req, err := http.NewRequest(
        "POST",
        "https://jsonplaceholder.typicode.com/users",
        bytes.NewBuffer(jsonData),
    )
    if err != nil {
        panic(err)
    }

    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    // 解析 JSON 响应
    var result User
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        panic(err)
    }

    fmt.Printf("Created user: %+v\n", result)
}

package main

import (
    "fmt"
    "io"
    "mime/multipart"
    "net/http"
    "net/url"
    "os"
    "path/filepath"
    "strings"
)

func main() {
    // GET with query parameters
    params := url.Values{}
    params.Add("page", "1")
    params.Add("limit", "10")

    resp, _ := http.Get("https://httpbin.org/get?" + params.Encode())
    defer resp.Body.Close()
    fmt.Println("GET request completed")

    // POST with form data
    formData := url.Values{
        "key1": {"value1"},
        "key2": {"value2"},
    }

    resp, _ = http.PostForm("https://httpbin.org/post", formData)
    defer resp.Body.Close()
    fmt.Println("POST form request completed")

    // 文件上传
    uploadFile("test.txt", "https://httpbin.org/post")
}

func uploadFile(filename string, targetURL string) error {
    file, err := os.Open(filename)
    if err != nil {
        return err
    }
    defer file.Close()

    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)
    part, err := writer.CreateFormFile("file", filepath.Base(filename))
    if err != nil {
        return err
    }

    io.Copy(part, file)
    writer.Close()

    req, err := http.NewRequest("POST", targetURL, body)
    if err != nil {
        return err
    }

    req.Header.Set("Content-Type", writer.FormDataContentType())

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    fmt.Println("File upload completed")
    return nil
}

package main

import (
    "context"
    "fmt"
    "net/http"
    "sync"
    "time"
)

func main() {
    urls := []string{
        "https://httpbin.org/delay/1",
        "https://httpbin.org/delay/2",
        "https://httpbin.org/delay/3",
    }

    var wg sync.WaitGroup
    results := make(chan string, len(urls))

    for _, url := range urls {
        wg.Add(1)
        go func(url string) {
            defer wg.Done()
            if result, err := fetchWithTimeout(url, 5*time.Second); err != nil {
                results <- fmt.Sprintf("Error fetching %s: %v", url, err)
            } else {
                results <- fmt.Sprintf("Success: %s - %s", url, result)
            }
        }(url)
    }

    go func() {
        wg.Wait()
        close(results)
    }()

    for result := range results {
        fmt.Println(result)
    }
}

func fetchWithTimeout(url string, timeout time.Duration) (string, error) {
    ctx, cancel := context.WithTimeout(context.Background(), timeout)
    defer cancel()

    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        return "", err
    }

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()

    return resp.Status, nil
}

package main

import (
    "fmt"
    "io"
    "net/http"
    "time"
)

// 重试中间件
func withRetry(maxRetries int, client *http.Client) *http.Client {
    client.Transport = &retryTransport{
        maxRetries: maxRetries,
        transport:  http.DefaultTransport,
    }
    return client
}

type retryTransport struct {
    maxRetries int
    transport  http.RoundTripper
}

func (t *retryTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    for i := 0; i <= t.maxRetries; i++ {
        resp, err := t.transport.RoundTrip(req)
        if err == nil && resp.StatusCode < 500 {
            return resp, nil
        }

        if i < t.maxRetries {
            time.Sleep(time.Duration(i*i) * 100 * time.Millisecond)
        }
    }
    return nil, fmt.Errorf("max retries exceeded")
}

func main() {
    // 使用重试机制的客户端
    client := &http.Client{
        Timeout: 30 * time.Second,
    }
    client = withRetry(3, client)

    // 设置代理
    // proxyURL, _ := url.Parse("http://proxy:8080")
    // client.Transport = &http.Transport{Proxy: http.ProxyURL(proxyURL)}

    resp, err := client.Get("https://httpbin.org/status/500")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    defer resp.Body.Close()

    fmt.Printf("Final status: %s\n", resp.Status)
}

package main

import (
    "fmt"
    "net/http"
    "net/http/cookiejar"
)

func main() {
    // 创建 Cookie Jar
    jar, _ := cookiejar.New(nil)

    client := &http.Client{
        Jar: jar,
    }

    // 第一次请求会设置 Cookie
    resp, _ := client.Get("https://httpbin.org/cookies/set?name=value")
    defer resp.Body.Close()

    // 后续请求会自动携带 Cookie
    resp, _ = client.Get("https://httpbin.org/cookies")
    defer resp.Body.Close()

    fmt.Println("Cookies handled automatically")
}

package main

import (
    "net/http"
    "time"
)

func createOptimizedClient() *http.Client {
    return &http.Client{
        Timeout: time.Second * 30,
        Transport: &http.Transport{
            MaxIdleConns:        100,              // 最大空闲连接数
            MaxConnsPerHost:     10,               // 每个主机最大连接数
            MaxIdleConnsPerHost: 10,               // 每个主机最大空闲连接数
            IdleConnTimeout:     90 * time.Second, // 空闲连接超时时间
            TLSHandshakeTimeout: 10 * time.Second, // TLS握手超时
            ExpectContinueTimeout: 1 * time.Second,
        },
    }
}

// 获取当前时间（本地时区）
now := time.Now()
fmt.Println(now) // 2023-10-01 15:30:45.123456 +08:00

// 获取当前 UTC 时间
utcNow := time.Now().UTC()
fmt.Println(utcNow) // 2023-10-01 07:30:45.123456 +0000 UTC

now := time.Now()

year := now.Year()          // 2023
month := now.Month()        // October 或 10
day := now.Day()            // 1
hour := now.Hour()          // 15
minute := now.Minute()      // 30
second := now.Second()      // 45
nanosecond := now.Nanosecond() // 123456
weekday := now.Weekday()    // Sunday

now := time.Now()

// 格式化为字符串
fmt.Println(now.Format("2006-01-02 15:04:05"))      // 2023-10-01 15:30:45
fmt.Println(now.Format("2006/01/02"))               // 2023/10/01
fmt.Println(now.Format("15:04:05"))                 // 15:30:45
fmt.Println(now.Format(time.RFC3339))               // 2023-10-01T15:30:45+08:00
fmt.Println(now.Format(time.RFC1123))               // Sun, 01 Oct 2023 15:30:45 CST

now := time.Now()

// 秒级时间戳
timestamp := now.Unix()          // 1696159845

// 毫秒级时间戳
milliTimestamp := now.UnixMilli() // 1696159845123

// 微秒级时间戳
microTimestamp := now.UnixMicro() // 1696159845123456

// 纳秒级时间戳
nanoTimestamp := now.UnixNano()   // 1696159845123456789

// 获取今天开始时间（00:00:00）
today := time.Now().Truncate(24 * time.Hour)
fmt.Println(today) // 2023-10-01 00:00:00 +0800 CST

// 获取本月第一天
year, month, _ := time.Now().Date()
firstDayOfMonth := time.Date(year, month, 1, 0, 0, 0, 0, time.Now().Location())

// 计算时间差
start := time.Now()
// ... 执行一些操作
duration := time.Since(start)
fmt.Printf("耗时: %v\n", duration)

package main

import (
    "fmt"
    "time"
)

func main() {
    // 获取当前时间
    now := time.Now()

    // 显示各种格式
    fmt.Printf("当前时间: %v\n", now)
    fmt.Printf("格式化: %s\n", now.Format("2006-01-02 15:04:05"))
    fmt.Printf("时间戳(秒): %d\n", now.Unix())
    fmt.Printf("时间戳(毫秒): %d\n", now.UnixMilli())

    // 获取各部分
    fmt.Printf("日期: %d年%d月%d日\n", now.Year(), now.Month(), now.Day())
    fmt.Printf("时间: %02d:%02d:%02d\n", now.Hour(), now.Minute(), now.Second())
}