Go语言中defer关键字的核心机制与高级用法解析

package main

import "fmt"

func exampleFunc() {
    fmt.Println("Entering exampleFunc")
    defer fmt.Println("Exiting exampleFunc (deferred)") // defer在此处声明
    fmt.Println("Inside exampleFunc logic")
}

func main() {
    fmt.Println("Start main")
    exampleFunc()
    fmt.Println("End main")
}

Start main
Entering exampleFunc
Inside exampleFunc logic
Exiting exampleFunc (deferred)
End main

package main

import "fmt"

type Db struct{}

func (db Db) Begin() {
    fmt.Println("Transaction Begun")
}

func (db Db) Commit() {
    fmt.Println("Transaction Committed")
}

// 假设我们希望dbStuff()返回时才提交事务
func dbStuff() {
    db := Db{}
    db.Trans() // 调用Trans方法
    fmt.Println("Doing stuff in dbStuff...")
}

func (db Db) Trans() {
    db.Begin()
    defer db.Commit() // 这里的defer会延迟到db.Trans()返回时执行
    fmt.Println("Doing stuff in db.Trans()...")
}

func main() {
    fmt.Println("Start main")
    dbStuff()
    fmt.Println("End main")
}

Start main
Transaction Begun
Doing stuff in db.Trans()...
Transaction Committed
Doing stuff in dbStuff...
End main

package main

import "fmt"

func main() {
    fmt.Println("Start main")
    defer greet()() // 这里的greet()会被立即调用
    fmt.Println("Some code here...")
    fmt.Println("End main")
}

func greet() func() {
    fmt.Println("Hello from greet()!") // greet()函数内部的逻辑会立即执行
    return func() { fmt.Println("Bye from deferred closure!") } // 返回一个匿名函数（闭包）
}

Start main
Hello from greet()!
Some code here...
End main
Bye from deferred closure!

package main

import (
    "errors"
    "fmt"
)

type Database struct{}

func (db *Database) Begin() *Transaction {
    fmt.Println("Transaction Begun")
    return &Transaction{committed: false, rolledBack: false}
}

type Transaction struct {
    committed  bool
    rolledBack bool
}

func (tx *Transaction) Commit() error {
    if tx.rolledBack {
        return errors.New("transaction already rolled back")
    }
    fmt.Println("Transaction Committed")
    tx.committed = true
    return nil
}

func (tx *Transaction) Rollback() error {
    if tx.committed {
        return errors.New("transaction already committed")
    }
    fmt.Println("Transaction Rolled back")
    tx.rolledBack = true
    return nil
}

// dbStuff负责整个事务的生命周期
func dbStuff(db *Database, shouldFail bool) (err error) {
    fmt.Println("Entering dbStuff")
    tx := db.Begin() // 开启事务

    // 使用defer确保事务在dbStuff函数退出时被处理
    defer func() {
        if r := recover(); r != nil { // 处理panic情况
            fmt.Println("Recovered from panic:", r)
            tx.Rollback()
            panic(r) // 重新抛出panic
        } else if err != nil { // 如果函数返回错误，则回滚
            tx.Rollback()
        } else { // 否则提交
            tx.Commit()
        }
    }()

    fmt.Println("Doing database operations...")
    if shouldFail {
        err = errors.New("simulated error during operations")
        return err // 模拟错误返回
    }

    // 实际业务逻辑...
    fmt.Println("Exiting dbStuff logic normally")
    return nil // 正常返回
}

func main() {
    db := &Database{}

    fmt.Println("\n--- Scenario 1: Successful operation ---")
    err := dbStuff(db, false)
    if err != nil {
        fmt.Println("dbStuff finished with error:", err)
    } else {
        fmt.Println("dbStuff finished successfully.")
    }

    fmt.Println("\n--- Scenario 2: Failed operation ---")
    err = dbStuff(db, true)
    if err != nil {
        fmt.Println("dbStuff finished with error:", err)
    } else {
        fmt.Println("dbStuff finished successfully.")
    }

    fmt.Println("\nAfter all dbStuff calls")
}

--- Scenario 1: Successful operation ---
Entering dbStuff
Transaction Begun
Doing database operations...
Exiting dbStuff logic normally
Transaction Committed
dbStuff finished successfully.

--- Scenario 2: Failed operation ---
Entering dbStuff
Transaction Begun
Doing database operations...
Transaction Rolled back
dbStuff finished with error: simulated error during operations

After all dbStuff calls