// 1. 定义元素接口 (Element)

// Shape 接口代表“元素”，它定义了一个 Accept 方法，
// 用于接收访问者。
type Shape interface {
Accept(v Visitor)
}

// 2. 定义具体元素 (Concrete Element)

// Circle 圆形
type Circle struct {
Radius float64
}

// Accept 实现 Shape 接口
// 关键点：利用 Go 的类型系统，将自己(c)传给访问者的 VisitCircle 方法
// 这就是“双重分派”的第一步
func (c *Circle) Accept(v Visitor) {
v.VisitCircle(c)
}

// Rectangle 矩形
type Rectangle struct {
Width, Height float64
}

// Accept 实现 Shape 接口
func (r *Rectangle) Accept(v Visitor) {
v.VisitRectangle(r)
}

// 3. 定义访问者接口 (Visitor)

// Visitor 接口定义了对每种具体元素的操作方法
type Visitor interface {
VisitCircle(c *Circle)
VisitRectangle(r *Rectangle)
}

// 4. 定义具体访问者 (Concrete Visitor)

// --- 访问者 1: 面积计算器 ---

type AreaCalculator struct {
area float64
}

func (a *AreaCalculator) VisitCircle(c *Circle) {
fmt.Println("AreaCalculator: Calculating area for Circle")
a.area += math.Pi * c.Radius * c.Radius
}

func (a *AreaCalculator) VisitRectangle(r *Rectangle) {
fmt.Println("AreaCalculator: Calculating area for Rectangle")
a.area += r.Width * r.Height
}

// --- 访问者 2: JSON 导出器 ---

type JsonExporter struct{}

func (j *JsonExporter) VisitCircle(c *Circle) {
fmt.Printf("JSON: { \"type\": \"circle\", \"radius\": %.2f }\n", c.Radius)
}

func (j *JsonExporter) VisitRectangle(r *Rectangle) {
fmt.Printf("JSON: { \"type\": \"rectangle\", \"width\": %.2f, \"height\": %.2f }\n", r.Width, r.Height)
}

func main() {
// 创建一组形状（对象结构）
shapes := []Shape{
&Circle{Radius: 5},
&Rectangle{Width: 4, Height: 6},
&Circle{Radius: 2},
}

// 场景 1: 使用“面积计算”访问者
fmt.Println("--- Calculating Area ---")
areaCalc := &AreaCalculator{}
for _, s := range shapes {
s.Accept(areaCalc)
}
fmt.Printf("Total Area: %.2f\n", areaCalc.area)

fmt.Println("\n--- Exporting JSON ---")
// 场景 2: 使用“JSON 导出”访问者
jsonExp := &JsonExporter{}
for _, s := range shapes {
s.Accept(jsonExp)
}
}

// @title           项目名称 (如: 支付系统 API)
// @version         1.0
// @description     这里写项目的详细描述...
// @host            localhost:8080
// @BasePath        /api/v1
func main() { //... }

// @Key          Value...

// @Param  name  query  string  false  "用户名"

// @Param  request  body  model.CreateUserRequest  true  "注册信息"

package main

// LoginReq 登录请求参数
type LoginReq struct {
    Username string `json:"username" example:"admin"` // example 字段会在文档中显示默认值
    Password string `json:"password" example:"123456"`
}

// User 用户响应结构
type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

// GetUserList 获取用户列表 (Query 参数示例)
// @Summary      获取用户列表
// @Tags         User
// @Param        page      query    int     false  "页码"
// @Param        keyword   query    string  false  "搜索关键字"
// @Success      200       {array}  User
// @Router       /users [get]
func GetUserList(c *gin.Context) { /* ... */ }

// Login 用户登录 (Body 参数示例)
// @Summary      用户登录
// @Tags         Auth
// @Accept       json
// @Produce      json
// @Param        request   body     LoginReq  true  "登录信息"
// @Success      200       {object} User
// @Router       /login [post]
func Login(c *gin.Context) { /* ... */ }

import (
    // ... 其他包
    // 1. 引入 swag 依赖
    swaggerFiles "github.com/swaggo/files"
    ginSwagger "github.com/swaggo/gin-swagger"

    // 2. 必须引入生成的 docs 包
    _ "your/module/docs"
)

func main() {
    r := gin.Default()
    // ... 路由注册 ...
    
    // 3. 注册 Swagger 路由
    r.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler))
    r.Run(":8080")
}

package downloader

import "fmt"

type Steps interface {
fetch(uri string) ([]byte, error)
finish()
}

type Downloader[T Steps] struct {
impl T
}

// Download 是模板方法，定义了下载资源的流程
func (d *Downloader[T]) Download(uri string) {
fmt.Println("Preparing to download...")
data, err := d.impl.fetch(uri)
if err != nil {
fmt.Printf("Download failed: %v\n", err)
return
}
d.save(data)
d.impl.finish()
}

func (d *Downloader[T]) save(data []byte) {
fmt.Printf("Saving data (size: %d bytes) to a file.\n", len(data))
}

type HttpDownloader struct{}

func (h HttpDownloader) fetch(uri string) ([]byte, error) {
fmt.Printf("Downloading from HTTP URI: %s\n", uri)
return []byte("http data"), nil
}

func (h HttpDownloader) finish() {
fmt.Println("HTTP download finished.")
}

package main

import "downloader"

func main() {
httpDownloader := downloader.Downloader[downloader.HttpDownloader]{}
httpDownloader.Download("http://example.com/file.zip")
}

package compression

// Strategy 接口定义了压缩算法
// 首先定义一个策略接口，它包含所有策略都必须实现的 `compress` 方法。
type Strategy interface {
compress(data []byte) ([]byte, error)
}

// 为 `zip` 和 `gzip` 创建具体的策略实现。
// zipStrategy 实现了 zip 压缩
type zipStrategy struct{}

func (z *zipStrategy) compress(data []byte) ([]byte, error) {
// 模拟 zip 压缩
fmt.Println("Compressing data using ZIP")
return append([]byte("zip_"), data...), nil
}

// gzipStrategy 实现了 gzip 压缩
type gzipStrategy struct{}

func (g *gzipStrategy) compress(data []byte) ([]byte, error) {
// 模拟 gzip 压缩
fmt.Println("Compressing data using GZIP")
return append([]byte("gzip_"), data...), nil
}

// 创建上下文（Context）
// 上下文持有对策略接口的引用，并提供一个方法来执行策略。它还允许在运行时更换策略。

// Compressor 是上下文，它使用一个策略来压缩数据
type Compressor struct {
S *Strategy
}

// SetStrategy 允许在运行时更换策略
func (c *Compressor) SetStrategy(strategy Strategy) {
c.S = &strategy
}

// CompressData 执行压缩
func (c *Compressor) CompressData(data []byte) ([]byte, error) {
return c.S.compress(data)
}

package main

import (
"fmt"
"log"
"compression"
)

func main() {
data := []byte("This is some data to be compressed.")

// 初始使用 zip 策略
zip := &compression.zipStrategy{}
compressor := &compression.Compressor{
S: zip,
}                       

compressedData, err := compressor.CompressData(data)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Compressed data: %s", compressedData)

// 在运行时切换到 gzip 策略
gzip := &compression.gzipStrategy{}
compressor.SetStrategy(gzip)

compressedData, err = compressor.CompressData(data)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Compressed data: %s", compressedData)
}

package vending

import "fmt"

// 状态接口：定义状态的行为
type state interface {
requestItem() error
insertMoney() error
dispenseItem() int
addItem(n int) int
}

// 上下文：持有当前状态引用
type context struct {
s *state
    count int
}

func NewContext(itemCount int) *context {
var s state
if itemCount > 0 {
s = &hasItemState{}
} else {
s = &noItemState{}
}
    c := &context{s: s, count: itemCount}
    initAllStates(c)
return c
}

var (
hasItem       *hasItemState
noItem        *noItemState 
itemRequested *itemRequestedState
hasMoney      *hasMoneyState
)

// initAllStates 初始化所有状态
func initAllStates(c *context) {
hasItem       = &hasItemState{c: c}
noItem        = &noItemState{c: c}
itemRequested = &itemRequestedState{c: c}
hasMoney      = &hasMoneyState{c: c}
}

func (c *context) RequestItem() error  { return c.s.requestItem(c) }
func (c *context) InsertMoney() error  { return c.s.insertMoney(c) }
func (c *context) DispenseItem() error { 
    if c.s.dispenseItem() == 0 {
        return fmt.Errorf("can't dispense")
    }
    return nil
}
func (c *context) AddItem(n int) error     { 
    if c.s.addItem(n) == 0 {
        return fmt.Errorf("can't add item")
    }
    return nil
} 

// 状态切换
func (c *context) setState(s *state) { c.s = s }

//展示数量（非必须）
func (c *context) ShowCount() int { return c.count }



// NoItem：无货
type noItemState struct{c *context}

func (st *noItemState) requestItem() error  { return fmt.Errorf("no item") }
func (st *noItemState) insertMoney() error  { return fmt.Errorf("no item") }
func (st *noItemState) dispenseItem() int { return 0 }
func (st *noItemState) addItem(n int) int {
st.c.count += n
c.setState(hasItem)
return st.c.count
}

// HasItem：有货
type hasItemState struct{c *context}

func (st *hasItemState) requestItem() error {
c.setState(itemRequested)
return nil
}
func (st *hasItemState) insertMoney() error  { return fmt.Errorf("request first") }
func (st *hasItemState) dispenseItem() int { return 0 }
func (st *hasItemState) addItem(n int) int      { st.c.count+=n; return st.c.count } // 自环

// ItemRequested：已请求
type itemRequestedState struct{c *context}

func (st *itemRequestedState) requestItem() error  { return fmt.Errorf("already requested") }
func (st *itemRequestedState) insertMoney() error {
c.setState(hasMoney)
return nil
}
func (st *itemRequestedState) dispenseItem() int { return fmt.Errorf("insert first") }
func (st *itemRequestedState) addItem(n int) int      { st.c.count+=n; return st.c.count } // 自环

// HasMoney：已投币
type hasMoneyState struct{c *context}

func (st *hasMoneyState) requestItem() error { return fmt.Errorf("already requested") }
func (st *hasMoneyState) insertMoney() error { return fmt.Errorf("already has money") }
func (st *hasMoneyState) dispenseItem() int {
st.c.count--
if st.c.count > 0 {
c.setState(hasItem)
} else {
c.setState(noItem)
}
return st.c.count
}
func (st *hasMoneyState) addItem(n int) int  { 
    return 0
} 

package main

import (
"fmt"
"log"

"vending"
)

func main() {
c := vending.NewContext(10) // 初始状态：hasItem
    fmt.Println("count:", c.ShowCount())
err := c.RequestItem() // 状态切换：hasItem -> itemRequested
if err != nil {
log.Fatal(err)
}
err = c.InsertMoney() // 状态切换：itemRequested -> hasMoney
if err != nil {
log.Fatal(err)
}
err = c.DispenseItem() // 状态切换：hasMoney -> hasItem
if err != nil {
log.Fatal(err)
}
    fmt.Println("count:", c.ShowCount())
    err = c.AddItem(5) // hasItem -> hasItem
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("count:", c.ShowCount())
}

package main

import (
  "net/http"
  "os"
  "time"
  "github.com/gin-gonic/gin"
  "github.com/golang-jwt/jwt/v5"
)

// definition of user struct, in gorm model

func main() {
  r := gin.Default()
  secret := []byte("1111111") // secret是自己设置的字符串，但实际不应明文写在代码里，实际可写在环境变量里，用secret := []byte(os.Getenv("JWT_SECRET"))读取；或者写在某配置文件里，用类似于secret := []byte(os.ReadFile(filepath.Join(".", "jwt.secret")))的方式从配置文件读取

  // 注册路由组，所有 JWT 相关接口都在 /api 下
  api := r.Group("/api")

  // 1. 登录接口：验证用户名密码后签发 JWT
  api.POST("/login", func(c *gin.Context) {
    var req struct{ Username, Password string }
    if err := c.BindJSON(&req); err != nil { 
        c.Status(http.StatusBadRequest)
        return 
    }
    // 验证用户名密码（这里简单对比，实际应使用gorm从数据库查询）
    if req.Username != "user" || req.Password != "1" {
      c.Status(http.StatusUnauthorized)
      return
    }
    // 创建一个待签名的 token，签名算法指定为 HS256
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.RegisteredClaims{
      Subject:   req.Username, // 用户名/uid作为 subject
      ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour)), // 这里设置过期时间1小时后，可以设置为其他值
      IssuedAt:  jwt.NewNumericDate(time.Now()),
      NotBefore: jwt.NewNumericDate(time.Now()),
    })
    // 用密钥签名 token
    s, err := token.SignedString(secret);
    if err != nil { 
        c.JSON(http.StatusInternalServerError, gin.H{"error": "Error creating token"})
        return 
    }
    c.JSON(http.StatusOK, gin.H{"token": s})
  })

// 2. 验证受保护接口
    // 中间件：检查请求头 Authorization 是否包含有效的 JWT
  auth := func(c *gin.Context) {
    h := c.GetHeader("Authorization")
    tokenStr := strings.TrimPrefix(h, "Bearer ")
    if len(tokenStr) == 0 || tokenStr == h { 
        c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Invalid token format"})
        return 
    }
    claims := &jwt.RegisteredClaims{}
    tok, err := jwt.ParseWithClaims(tokenStr, claims, func(t *jwt.Token) (any, error) {
      return secret, nil
    })
    if err != nil || !tok.Valid { 
        c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Invalid or expired token"})
        return 
    }
    // 把用户名设置到上下文，后续处理函数可以从上下文中获取
    c.Set("Subject", claims.Subject) 
    c.Next()
  }
  api.GET("/me", auth, func(c *gin.Context) { 
    // 从上下文获取用户名
    username, ok := c.Get("Subject")
    if !ok {
      c.JSON(http.StatusInternalServerError, gin.H{"error": "User claims not found in context"})
  return
    }
    // 这里是根据用户名/uid调用gorm相关查询用户信息的逻辑
    //...
    c.JSON(http.StatusOK, gin.H{"username": username}) //以json格式返回200状态码以及用户信息，可以根据实际情况添加其他用户信息
  })
  r.Run() //默认8080。也可以指定端口，如 r.Run(":3000")
}

type Observer interface {
    Update(event string, data any)
}

type Subject interface {
    Register(o Observer)
    Unregister(o Observer)
    Notify(event string, data any)
}

type Topic struct {
    observers []Observer
}

func (t *Topic) Register(o Observer) {
    t.observers = append(t.observers, o)
}

func (t *Topic) Unregister(o Observer) {
    i := -1
    for idx, ob := range t.observers {
        if ob == o {
            i = idx
            break
        }
    }
    if i >= 0 {
        t.observers = append(t.observers[:i], t.observers[i+1:]...)
    }
}

func (t *Topic) Notify(event string, data any) {
    for _, o := range t.observers {
        o.Update(event, data)
    }
}

type PrintObserver struct {
    name string
}

func (p *PrintObserver) Update(event string, data any) {
    fmt.Printf("[%s] %s: %v\n", p.name, event, data)
}

func main() {
    t := &Topic{}
    a := &PrintObserver{name: "A"}
    b := &PrintObserver{name: "B"}

    t.Register(a)
    t.Register(b)

    t.Notify("price_changed", 42)
    t.Unregister(a)
    t.Notify("price_changed", 43)
}

type Memento interface{ mementoMarker() }

type memento struct{
    content string
    cursor  int
}

func (m *memento) mementoMarker(){}

type Editor struct{
    content string
    cursor  int
}

func (e *Editor) SetContent(s string){ e.content = s }
func (e *Editor) SetCursor(pos int){ e.cursor = pos }
func (e *Editor) Save() Memento { return &memento{content: e.content, cursor: e.cursor} }
func (e *Editor) Restore(mem Memento){ mm := mem.(*memento); e.content, e.cursor = mm.content, mm.cursor }

type History struct{ stack []Memento }

func (h *History) Push(m Memento){ h.stack = append(h.stack, m) }
func (h *History) Pop() {
    if len(h.stack) == 0 { return }
    i := len(h.stack)-1
    m := h.stack[i]
    h.stack = h.stack[:i]
}
func (h *History) Top() Memento{
    if len(h.stack) == 0 { return nil }
    return h.stack[len(h.stack)-1]
}

func main(){
    e := &Editor{}
    h := &History{}

    e.SetContent("a"); e.SetCursor(1); h.Push(e.Save())
    e.SetContent("ab"); e.SetCursor(2); h.Push(e.Save())
    e.SetContent("abc"); e.SetCursor(3)

    h.Pop()
    m := h.Top()
    e.Restore(m)
    fmt.Println(e.content, e.cursor)
}

package main

import (
    "fmt"
)

type Mediator interface {
    Register(c Colleague)
    Send(from string, to string, msg string)
    Broadcast(from string, msg string)
}

type Colleague interface {
    Name() string
    Receive(from string, msg string)
    Send(to string, msg string)
    Broadcast(msg string)
}

type ChatRoom struct {
    members map[string]Colleague
}

func NewChatRoom() *ChatRoom {
    return &ChatRoom{members: make(map[string]Colleague)}
}

func (r *ChatRoom) Register(c Colleague) {
    r.members[c.Name()] = c
}

func (r *ChatRoom) Send(from string, to string, msg string) {
    if m, ok := r.members[to]; ok {
        m.Receive(from, msg)
    }
}

func (r *ChatRoom) Broadcast(from string, msg string) {
    for name, m := range r.members {
        if name == from {
            continue
        }
        m.Receive(from, msg)
    }
}

type User struct {
    name string
    room *ChatRoom
}

func NewUser(name string, room *ChatRoom) *User {
    return &User{name: name, room: room}
}

func (u *User) Name() string { return u.name }

func (u *User) Receive(from string, msg string) {
    fmt.Printf("[%s] <- %s: %s\n", u.name, from, msg)
}

func (u *User) Send(to string, msg string) {
    u.room.Send(u.name, to, msg)
}

func (u *User) Broadcast(msg string) {
    u.room.Broadcast(u.name, msg)
}

func main() {
    room := NewChatRoom()

    alice := NewUser("alice", room)
    bob := NewUser("bob", room)
    eve := NewUser("eve", room)

    room.Register(alice)
    room.Register(bob)
    room.Register(eve)

    alice.Send("bob", "Hi Bob")
    bob.Send("alice", "Hi Alice")
    eve.Broadcast("Hello everyone")
}

// Iterator 是泛型迭代器接口
type Iterator[E any] interface {
IsEnd() bool
GetCur() E
}

// Collection 是泛型聚合接口
type Collection[E any] interface {
CreateIterator() Iterator[E]
}
// TreeNode
type TreeNode[T any] struct {
Val   T
Left  *TreeNode[T]
Right *TreeNode[T]
}

// BinaryTree 是我们的具体聚合类
type BinaryTree[T any] struct {
Root *TreeNode[T]
}

// InOrderIterator 是具体迭代器类
type InOrderIterator[T any] struct {
stack []*TreeNode[T]
}

// CreateIterator 是 BinaryTree 实现 Collection 接口的方法
func (bt *BinaryTree[T]) CreateIterator() Iterator[*TreeNode[T]] {
it := &InOrderIterator[T]{stack: make([]*TreeNode[T], 0)}
// 初始化时，将根节点及其所有左子节点压入栈
it.pushLeft(bt.Root)
return it
}

// pushLeft 辅助函数，将一个节点及其所有左子节点压入栈
func (it *InOrderIterator[T]) pushLeft(node *TreeNode[T]) {
for node != nil {
it.stack = append(it.stack, node)
node = node.Left
}
}

func (it *InOrderIterator[T]) IsEnd() bool {
return len(it.stack) <= 0
}

// GetCur 返回当前迭代器指向的节点，且将迭代器指向下一个节点
func (it *InOrderIterator[T]) GetCur() *TreeNode[T] {
    if(it.IsEnd()){
        return nil
    }
// 从栈顶弹出一个节点
n := len(it.stack) - 1
node := it.stack[n]
it.stack = it.stack[:n]

// 如果该节点有右子树，则将右子节点及其所有左子节点压栈
if node.Right != nil {
it.pushLeft(node.Right)
}
return node
}

func main() {
// 构造一棵二叉树
//      4
//     / \
//    2   5
//   / \
//  1   3
root := &TreeNode[int]{
Val: 4,
Left: &TreeNode[int]{
Val: 2,
Left:  &TreeNode[int]{Val: 1},
Right: &TreeNode[int]{Val: 3},
},
Right: &TreeNode[int]{Val: 5},
}

// 泛型客户端通过接口使用
c := &BinaryTree[int]{Root: root}
it := c.CreateIterator() // Iterator[*TreeNode[int]]

for !it.IsEnd() {
fmt.Printf("%d ", it.GetCur().Val)
}
// 输出: 1 2 3 4 5
}

// Command 接口定义了一个执行操作的方法
type Command interface {
    Execute(receiver *Receiver)
}
// Receiver 是请求的接收者，它知道如何执行与请求相关的操作
type Receiver struct {
    //...
}

func (r *Receiver) Action() {
    // 执行具体的操作
}

// Command1 是一个具体的命令类，它实现了 Command 接口
type Command1 struct {
    //...
}

func (c *Command1) Execute(r *Receiver) {
    r.Action()
}

// Invoker 是请求的发送者，它持有一个 Command 对象  
type Invoker struct {
    command *Command
}

func (i *Invoker) SetCommand(command *Command) {
    i.command = command
}

// ExecuteCommand 是 Invoker 用来间接执行命令的方法
func (i *Invoker) ExecuteCommand(r *Receiver) {
    i.command.Execute(r)
}

receiver := &Receiver{}
command := &Command1{}
invoker := &Invoker{}
invoker.SetCommand(command)
invoker.ExecuteCommand(receiver)

func handle(request *Request) {
    if conditionA(request) {
        // 处理 A
    } else if conditionB(request) {
        // 处理 B
    } else if conditionC(request) {
        // 处理 C
    } else {
        // 默认处理
    }
}

// 处理者接口
type Handler interface {
    Execute(p *client)
    SetNext(next *Handler)
}

// 具体的处理者实现
type Handler1 struct {
    next *Handler
}

// 具体的处理者实现
type Handler2 struct {
    next *Handler
}

func (h *Handler1) Execute(p *client) {
    //...Handle 1处理逻辑，然后调用下一个处理者
    if h.next != nil {
        h.next.Execute(p)
    }
}

func (h *Handler1) SetNext(next *Handler) {
    h.next = next
}

func (h *Handler2) Execute(p *client) {
    //...Handle 2处理逻辑，然后调用下一个处理者
    if h.next != nil {
        h.next.Execute(p)
    }
}

func (h *Handler2) SetNext(next *Handler) {
    h.next = next
}

h1 := &Handler1{}
h2 := &Handler2{}
h1.SetNext(h2)
c := &client{}
h1.Execute(c)

// Server 是代理和真实服务器的通用接口
type Server interface {
HandleRequest(url, method string) (int, string)
}

// Application 是我们的后端真实服务
type Application struct{}

func (a *Application) HandleRequest(url, method string) (int, string) {
if url == "/app/status" && method == "GET" {
return 200, "Ok"
}
if url == "/create/user" && method == "POST" {
return 201, "User Created"
}
return 404, "Not Found"
}

import "fmt"

// Nginx 是一个代理，它控制对 Application 的访问
type Nginx struct {
application      *Application
maxAllowedReq    int
rateLimiter      map[string]int
}

func NewNginxServer() *Nginx {
return &Nginx{
application:      &Application{},
maxAllowedReq:    2,
rateLimiter:      make(map[string]int),
}
}

// checkRateLimit 检查并更新请求速率
func (n *Nginx) checkRateLimit(url string) bool {
n.rateLimiter[url]++
if n.rateLimiter[url] > n.maxAllowedReq {
return false // 超出速率限制
}
return true
}

// HandleRequest 代理的核心方法
func (n *Nginx) HandleRequest(url, method string) (int, string) {
// 在转发请求前，执行额外的逻辑（访问控制）
if !n.checkRateLimit(url) {
return 429, "Too Many Requests"
}

// 将请求转发给真实服务
return n.application.HandleRequest(url, method)
}

func main() {
nginx := NewNginxServer()

// 第一次请求 /app/status
code, body := nginx.HandleRequest("/app/status", "GET")
fmt.Printf("Url: /app/status, Code: %d, Body: %s\n", code, body)

// 第二次请求 /app/status
code, body = nginx.HandleRequest("/app/status", "GET")
fmt.Printf("Url: /app/status, Code: %d, Body: %s\n", code, body)

// 第三次请求 /app/status，将被限流
code, body = nginx.HandleRequest("/app/status", "GET")
fmt.Printf("Url: /app/status, Code: %d, Body: %s\n", code, body)
}

// 传统方式：每个对象都包含所有数据
type Tree struct {
X, Y      int
Name      string
Color     string
Texture   []byte // 假设这份数据很大
}

// 1. 享元对象：存储共享的【内部状态】
type treeType struct {
Name    string
Color   string
Texture []byte // 这份数据被共享
}

// 2. 享元工厂：确保相同类型的享元只创建一次
type treeTypeFactory struct {
types map[string]*treeType
}

func (f *treeTypeFactory) GetTreeType(name, color string, texture []byte) *treeType {
key := name + "_" + color
if t, ok := f.types[key]; ok {
return t // 已存在，直接返回
}
// 不存在，创建新的并存起来
newType := &treeType{name, color, texture}
f.types[key] = newType
return newType
}

// 3. 上下文对象：存储【外部状态】和对享元的引用
type Tree struct {
X, Y int
Type *treeType // 指向共享的享元对象
}

type Forest struct {
trees   []*Tree
factory *treeTypeFactory
}

func (f *Forest) SetFactory() {
f.factory = &treeTypeFactory{
types: make(map[string]*treeType),
}
}

func (f *Forest) PlantTree(x, y int, name, color string, texture []byte) {
// 从工厂获取共享的 treeType
treeType := f.factory.GetTreeType(name, color, texture)
// 创建 Tree，只存储外部状态和引用
tree := &Tree{X: x, Y: y, Type: treeType}
f.trees = append(f.trees, tree)
}

func (f *Forest) GetTrees() []*Tree {
return f.trees
}

// 子系统：CPU
type CPU struct{}

func (c *CPU) Start()    { fmt.Println("CPU: start") }
func (c *CPU) Shutdown() { fmt.Println("CPU: shutdown") }

// 子系统：内存
type Memory struct{}

func (m *Memory) LoadOS() { fmt.Println("Memory: load OS into memory") }
func (m *Memory) Clear()  { fmt.Println("Memory: clear") }

// 子系统：磁盘
type Disk struct{}

func (d *Disk) ReadBootSector() { fmt.Println("Disk: read boot sector") }

// 外观：计算机
type ComputerFacade struct {
cpu  *CPU
mem  *Memory
disk *Disk
}

func NewComputerFacade() *ComputerFacade {
return &ComputerFacade{
cpu:  &CPU{},
mem:  &Memory{},
disk: &Disk{},
}
}

// 对外暴露的简化接口：开机流程
func (c *ComputerFacade) PowerOn() {
fmt.Println("== PowerOn ==")
c.disk.ReadBootSector()
c.cpu.Start()
c.mem.LoadOS()
fmt.Println("System is up.")
}

// 对外暴露的简化接口：关机流程
func (c *ComputerFacade) PowerOff() {
fmt.Println("== PowerOff ==")
c.cpu.Shutdown()
c.mem.Clear()
fmt.Println("System is down.")
}

func main() {
pc := NewComputerFacade()
pc.PowerOn()
pc.PowerOff()
}

type Coffee interface {
GetCoffee() string
}

type Latte struct {
}

func (l *Latte) GetCoffee() string {
return "Latte"
}

type CoffeeDecorator struct {
    CoffeeOrdered *Coffee
    AddCondiment string
}

func (d *CoffeeDecorator) GetCoffee() string {
return d.CoffeeOrdered.GetCoffee() + " with " + d.AddCondiment
}

func main() {
latte := &Latte{}
latteWithMilk := &CoffeeDecorator{CoffeeOrdered: latte, AddCondiment: "Milk"}
latteWithMilkAndSugar := &CoffeeDecorator{CoffeeOrdered: latteWithMilk, AddCondiment: "Sugar"}
fmt.Println(latteWithMilkAndSugar.GetCoffee())
}