1

go version go1.20 windows/amd64

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

package main

import (
    "crypto/rand"
    "encoding/base64"
    "fmt"
    "net/smtp"
    "time"

    "gorm.io/driver/postgres"
    "gorm.io/gorm"
)

// 定义User模型
type User struct {
    ID             uint      `gorm:"primaryKey"`
    Username       string    `gorm:"unique"`
    Email          string    `gorm:"unique"`
    Password       string
    SubscriptionID uint
    Subscription   Subscription
    IsActive       bool
    CreatedAt      time.Time
}

// 定义Subscription模型
type Subscription struct {
    ID        uint   `gorm:"primaryKey"`
    Name      string
    CreatedAt time.Time
}

// 定义Resource模型
type Resource struct {
    ID           uint   `gorm:"primaryKey"`
    Name         string
    ResourceType string
    CreatedAt    time.Time
}

// 定义UserResource模型
type UserResource struct {
    ID        uint `gorm:"primaryKey"`
    UserID    uint
    ResourceID uint
    CreatedAt time.Time
}

// 定义Activation模型
type Activation struct {
    ID             uint   `gorm:"primaryKey"`
    UserID         uint
    ActivationCode string `gorm:"size:9"`
    CreatedAt      time.Time
}

// 生成9位激活码
func generateActivationCode() (string, error) {
    b := make([]byte, 6) // 6 bytes * 4/3 = 8 characters
    _, err := rand.Read(b)
    if err != nil {
        return "", err
    }
    return base64.StdEncoding.EncodeToString(b)[:9], nil
}

// 发送激活邮件
func sendActivationEmail(user *User, code string) error {
    from := "your-email@example.com"
    pass := "your-email-password"
    to := user.Email
    activationLink := fmt.Sprintf("http://your-domain.com/activate?code=%s", code)

    msg := fmt.Sprintf("To: %s\r\n"+
        "Subject: Please activate your account\r\n"+
        "\r\n"+
        "Click the following link to activate your account:\r\n"+
        "%s\r\n", to, activationLink)

    return smtp.SendMail("smtp.example.com:587",
        smtp.PlainAuth("", from, pass, "smtp.example.com"),
        from, []string{to}, []byte(msg))
}

func main() {
    dsn := "host=localhost user=gorm dbname=gorm password=gorm sslmode=disable"
    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        panic("failed to connect database")
    }

    // 自动迁移表结构
    db.AutoMigrate(&User{}, &Subscription{}, &Resource{}, &UserResource{}, &Activation{})

    // 用户注册示例
    activationCode, err := generateActivationCode()
    if err != nil {
        panic("failed to generate activation code")
    }

    user := User{
        Username:       "test_user",
        Email:          "test_user@example.com",
        Password:       "password", // 在实际应用中应加密存储密码
        SubscriptionID: 1,           // 假设已经有一个 Subscription
    }
    db.Create(&user)

    activation := Activation{
        UserID:         user.ID,
        ActivationCode: activationCode,
    }
    db.Create(&activation)

    // 发送激活邮件
    if err := sendActivationEmail(&user, activationCode); err != nil {
        panic("failed to send activation email")
    }

    fmt.Println("User registered, awaiting activation...")
}

// 激活用户
func activateUser(w http.ResponseWriter, r *http.Request) {
    activationCode := r.URL.Query().Get("code")
    if activationCode == "" {
        http.Error(w, "Missing activation code", http.StatusBadRequest)
        return
    }

    dsn := "host=localhost user=gorm dbname=gorm password=gorm sslmode=disable"
    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        http.Error(w, "Database connection error", http.StatusInternalServerError)
        return
    }

    var activation Activation
    if err := db.Where("activation_code = ?", activationCode).First(&activation).Error; err != nil {
        http.Error(w, "Invalid activation code", http.StatusBadRequest)
        return
    }

    var user User
    db.First(&user, activation.UserID)

    // 更新用户激活状态
    user.IsActive = true
    db.Save(&user)

    // 删除激活记录
    db.Delete(&activation)

    w.Write([]byte("Account activated successfully!"))
}

func main() {
    http.HandleFunc("/activate", activateUser)
    http.ListenAndServe(":8080", nil)
}

1
2
3
4
5
6
7
8
9

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username VARCHAR(255) UNIQUE NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    password VARCHAR(255) NOT NULL,
    subscription_id INT REFERENCES subscriptions(id),
    is_active BOOLEAN DEFAULT FALSE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

1
2
3
4
5

CREATE TABLE subscriptions (
    id SERIAL PRIMARY KEY,
    name VARCHAR(50) NOT NULL,   -- 'free' 或者 'vip'
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

1
2
3
4
5
6

CREATE TABLE resources (
    id SERIAL PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    resource_type VARCHAR(50) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

1
2
3
4
5
6

CREATE TABLE user_resources (
    id SERIAL PRIMARY KEY,
    user_id INT REFERENCES users(id),
    resource_id INT REFERENCES resources(id),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

1
2
3
4
5
6

CREATE TABLE activations (
    id SERIAL PRIMARY KEY,
    user_id INT REFERENCES users(id),
    activation_code VARCHAR(9) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

package main

import (
	"context"
	"fmt"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"
)

type H struct{}

func (H) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	time.Sleep(5 * time.Second)
	fmt.Fprintf(w, "Hello, World!") // 向客户端发送响应
}

func initServer() *http.Server {
	s := &http.Server{
		Addr:    ":8080",
		Handler: H{},
	}
	return s
}

type Backend struct {
	Ctx context.Context
	Srv *http.Server

	CancelFunc func()
}

var onlyOneSignalHandler = make(chan struct{})
var shutdownSignals = []os.Signal{os.Interrupt, syscall.SIGTERM}
var shutdownHandler chan os.Signal

// SetupSignalContext is same as SetupSignalHandler, but a context.Context is returned.
// Only one of SetupSignalContext and SetupSignalHandler should be called, and only can
// be called once.
func (b *Backend) SetupSignalContext() context.Context {
	close(onlyOneSignalHandler) // panics when called twice

	shutdownHandler = make(chan os.Signal, 2)

	signal.Notify(shutdownHandler, shutdownSignals...)

	go func() {
		<-shutdownHandler
		b.Clean()
		<-shutdownHandler
		os.Exit(1) // second signal. Exit directly.
	}()

	return b.Ctx
}

// SetupSignalHandler registered for SIGTERM and SIGINT. A stop channel is returned
// which is closed on one of these signals. If a second signal is caught, the program
// is terminated with exit code 1.
// Only one of SetupSignalContext and SetupSignalHandler should be called, and only can
// be called once.
func (b *Backend) SetupSignalHandler() <-chan struct{} {
	return b.SetupSignalContext().Done()
}

func (b *Backend) RunAndServe(stopCh <-chan struct{}) {
	b.Srv.ListenAndServe()
	<-stopCh
	if err := b.Srv.Shutdown(b.Ctx); err != nil {
		log.Fatal("Server Shutdown:", err)
	}
	log.Printf("initServer exiting")
}

func (b *Backend) Clean() {
	fmt.Println("do some clean")
	time.Sleep(time.Second * 10)
	b.CancelFunc()
	fmt.Println("clean over")
	b.Ctx.Done()
}

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	simpleBackend := Backend{
		Ctx:        ctx,
		Srv:        initServer(),
		CancelFunc: cancel,
	}
	simpleBackend.RunAndServe(simpleBackend.SetupSignalHandler())
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

func RunWithTimeout(fun func() error, timeout time.Duration) error {
	finished := make(chan struct{})
	var err error
	go func() {
		err = fun()
		finished <- struct{}{}
	}()

	select {
	case <-finished:
		return err
	case <-time.After(timeout):
		return fmt.Errorf("timeout")
	}
}

1
2
3
4
5

type Human struct {
	Name string
} 

var people = Human{Name:"zhangsan"}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

package main

import (
	"fmt"
	"math/rand"
	"runtime"
	"sync"
	"sync/atomic"
	"time"
)

func main() {
	var state = make(map[int]int)
	var mutex = &sync.Mutex{}
	var ops int64 = 0
	for r := 0; r < 100; r++ {
		// 运行100个go协程来重复读取state
		go func() {
			total := 0
			for {
				key := rand.Intn(5)
				mutex.Lock()
				total += state[key]
				mutex.Unlock()
				atomic.AddInt64(&ops, 1)
				runtime.Gosched() // 为了确保这个Go协程不会在调度中饿死，我们在每次操作后明确的使用runtime.Gosched()进行释放。是自动处理的。
			}
		}()
	}
	for w := 0; w < 10; w++ { // 模拟写入操作
		go func() {
			for {
				key := rand.Intn(5)
				val := rand.Intn(100)
				mutex.Lock()
				state[key] = val
				mutex.Unlock()
				atomic.AddInt64(&ops, 1)
				runtime.Gosched()
			}
		}()
	}
	time.Sleep(time.Second)
	opsFinal := atomic.LoadInt64(&ops)
	fmt.Println("ops:", opsFinal)
	mutex.Lock() //对 state 使用一个最终的锁，显示它是如何结束的。
	fmt.Println("state:", state)
	mutex.Unlock()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

func doSomething() {
    m.Lock()
    item := ...
    http.Get()  // 各种耗时的 IO 操作
    m.Unlock()
}

// 改为
func doSomething() {
    m.Lock()
    item := ...
    m.Unlock()

    http.Get()
}

1
2
3
4
5
6
7

type Animal struct {
	Name string
}

type Old struct {
	Age int
}