1
var name string = "wsh"
2

3
var (
4
  name string
5
  isReady bool
6
  age int
7
)

1
playerName := "AlphaPlayer"

1
const sercet string = "wsh"

1
func main() {
2
    var v [1]int
3
    v[0] = 1
4
    fmt.Println(v)
5
    v1 := [2]string{"1","2"}
6
}

1
v[low:high]

1
numbers := [5]int{10, 20, 30, 40, 50}
2
numslice = numbers[2:4]

1
s := make([]int, 5, 10)
2
arg1 _ 类型
3
arg2 _ 长度
4
arg3 _ 容量

1
// 使用 make 初始化
2
s := make([]int, 5)

1
sum := 0
2
for i := 0; i < 5 ; i++ {
3
  sum += i
4
}
5
fmt.Println(sum)

1
i := 0
2
if i < 5 {
3
  i+=1
4
}
5
fmt.Println(i)

1
func main() {
2
  defer fmt.println("1")
3
  defer fmt.Println("world")
4
  fmt.Println("hello")
5
}

1
var data interface{}
2
data = 100

1
value, ok := data.(int)

1
type Animal interface {
2
    Speak() string
3
}
4

5
type Dog struct{}
6
func (d Dog) Speak() string { return "ww" }
7
type Cat struct{}
8
func (c Cat) Speak() string { return "mm" }
9
func MakeSound(animal Animal) {
10
    fmt.Println(animal.Speak())
11
}

1
go task(1)
2
// 主进程

1
// 声明
2
var wg sync.WaitGroup
3
// 在每一个协程中添加 wg.Add(1) defer wg.Done() ,主进程写 wg.Wait()

1
// 初始化一个 channel 传递 t 类型数据
2
t_data := make(chan t)
3
// 传输数据
4
t_data <- "data"
5
//接受数据
6
value := <-ch

1
t_data := make(chan t,10)

1
func worker(quit chan bool) {
2
    for {
3
        select {
4
        case <-quit:
5
            fmt.Println("接收到退出命令")
6
            return // 结束函数
7
        default:
8
            fmt.Println("......")
9
            time.Sleep(1 * time.Second)
10
        }
11
    }
12
}

1
select {
2
case msg := <-ch:
3
    fmt.Println("收到消息:", msg)
4
default:
5
    // 如果 ch 里没数据，select 不会卡住，而是立刻跳到这里
6
    fmt.Println("没接受到数据，执行其他操作")
7
}

1
Lock()
2
Unlock()
3
TryLock()

1
import "sync"
2

3
type SafeBank struct {
4
    Money int
5
    mu     sync.Mutex
6
}
7

8
func (s *SafeBank) cq(n int){
9
    s.mu.Lock()
10
    defer s.mu.Unlock()
11
    s.Money += n
12
}

1
// 格式化代码
2
go fmt ./...
3

4
// 静态检查
5
go vet ./...
6

7
// 编译检查
8
go build
9

10
go run m.go

1
import "projectName/folderName"
2

3
folderName.FuncName

1
import "github.com/gin-gonic/gin"

1
import "gorm.io/gorm"
2
import "gorm.io/driver/postgres"
3

4
type User struct {
5
  gorm.model
6
  Username string `json:"user"`
7
  Password string `json:"password"`
8
}

1
// 1. 签发 token
2
import "github.com/golang-jwt/jwt/v5"
3

4
type Claims struct {
5
    UserID int `json:"user_id"`
6
    Role   string `json:"role"`
7
    jwt.RegisteredClaims
8
}
9

10
userClaims := Claims{
11
    UserID: 111,
12
    Role: "user",
13
    RegisteredClaims: jwt.RegisteredClaims{
14
        ExpiresAt: jwt.NewNumericDate(time.Now().Add(24*time.Hour)),
15
        IssuedAt:  jwt.NewNumericDate(time.Now()),
16
    }
17
}
18

19
token := jwt.NewWithClaims(jwt.SigningMethodHS256,userClaims)
20
signedToken, err := token.SignedString([]byte("jwt-key"))

1
// 2. 验证 token
2

3
func KeyFuncFactory(secret []byte) jwt.Keyfunc {
4
    return func(token *jwt.Token) (inerface{}, error) {
5
        if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
6
            return nil, log.Fatalf("unexpected signing method:%v",token.Header["alg"])
7
        }
8
        return secret ,nil
9
    }
10
}
11

12
func InspectionToken(token string,secretKey string) (*Claims,error) {
13
    claims := &Claims{}
14
    _, err := jwt.ParseWithClaims(token,claims,KeyFuncFactory(secretKey))
15
    if err != nil {
16
      return nil,err
17
    }
18

19
    return claims,nil
20
}

1
//redis 初始化
2

3
import (
4
  "context"
5
  "log"
6
  "os"
7

8
  "github.com/redis/go-redis/v9"
9
)
10

11
var RDB *redis.Client
12
var Ctx = context.Background()
13

14
func InitRedis() {
15
    addr := os.Getenv("REDIS_ADDR")
16
    password := os.Getenv("REDIS_PASSWORD")
17
    RDB = redis.NewClient(&redis.Options{
18
        Addr: addr,
19
        Password: password,
20
        DB: 0,
21
        // redis 16 个哈希表
22
    })
23
    if err := RDB.Ping(Ctx).Err(); err != nil {
24
        log.Fatalf("redis 连接失败，请重试：%v",err)
25
    }
26
}

1
// 使用 redis 做排行榜查询，避免频繁查询 postgresql 造成的压力
2
// 使用了 有序集合，内部维护了一个跳表，时间复杂度 O(log2(N))
3

4
var teams []model.Team
5

6
if err := DB.Find(&teams).Error; err != nil {
7
    log.Fatalf("获取排行榜数据失败：%v",err)
8
}
9

10
redisMembers := make([]redis.Z, 0, len(teams))
11

12
for _, team := range teams {
13
    redisMembers = append(redisMembers, redis.Z{
14
        Score:  float64(team.Score),
15
        Member: team.TeamName,
16
    })
17
}
18

19
if len(redisMembers) > 0 {
20
    if err := RDB.ZAdd(Ctx, "scoreboard", redisMembers...).Err(); err != nil {
21
        log.Printf("批量更新排行榜分数失败：%v", err)
22
    }
23
}
24
log.Printf("排行榜数据获取完成，共加载 %d 个团队数据",len(teams))
25

26

27
// 1. 优先从 redis 获取排行榜数据
28
results, err := config.RDB.ZRevRangeWithScores(config.Ctx, "scoreboard", 0, -1).Result()
29
results_count := len(results)
30
if err == nil && results_count > 0 {
31
    data := make([]model.Rank, results_count)
32
    for i, j := range results {
33
        data[i] = model.Rank{
34
            Rank:     i + 1,
35
            TeamName: j.Member.(string),
36
            Score:    j.Score,
37
        }
38
    }
39
    c.JSON(http.StatusOK, gin.H{
40
        "message": "获取排行榜数据成功",
41
        "data":    data,
42
    })
43
    return
44
}
45

46
// 2. 如果 redis 数据为空或查询失败，从数据库查询
47
var teams []model.Team
48
if err := config.DB.Order("score desc").Find(&teams).Error; err != nil {
49
    c.JSON(http.StatusInternalServerError, gin.H{
50
        "message": "获取排行榜数据失败",
51
    })
52
    return
53
}
54

55
c.JSON(http.StatusOK, gin.H{
56
    "message": "获取排行榜数据成功",
57
    "data":    teams,
58
})

1
// 初始化 mq
2
package async_tasks
3

4
import (
5
  "backend/util/zaphelper"
6
  "os"
7

8
  "github.com/hibiken/asynq"
9

10
)
11

12
var AsynqClient *asynq.Client
13
var server *asynq.Server
14
var inspector *asynq.Inspector
15

16
// 任务类型常量
17
const (
18
  TypeStartContainer = "container:start"
19
  TypeStopContainer  = "container:stop"
20
  TypeSyncScore      = "rank:sync"
21
)
22

23

24
func InitMessageQuene() {
25
    addr := os.Getenv("REDIS_ADDR")
26
    if addr == "" {
27
        addr = "localhost:6379"
28
    }
29
    password := os.Getenv("REDIS_PASSWORD")
30
    if password == "" {
31
      password = "wsh_laribely"
32
    }
33

34
    redisOption := asynq.RedisClientOpt{
35
        Addr: addr,
36
        Password: password,
37
        DB: 1,
38
    }
39
    asynqConfig := asynq.Config{
40
        Concurrency: 30,
41
        Queues: map[string]int {
42
            "critical": 6,
43
            "commom": 3,
44
            "low": 1,
45
        },
46
        StrictPriority: true,
47
        Logger: zaphelper.NewZapLogger(zaphelper.Logger),
48
    }
49
    AsynqClient = asynq.NewClient(redisOption)
50
    inspector = asynq.NewInspector(redisOption)
51

52
    // 启动一个协程监听队列是否有任务
53
    go func() {
54
        server = asynq.NewServer(
55
          redisOption,
56
            asynqConfig,
57
        )
58
        mux := asynq.NewServeMux()
59
    mux.HandleFunc(TypeStartContainer, HandleStartContainerTask)
60
    mux.HandleFunc(TypeStopContainer, HandleStopContainerTask)
61
    mux.HandleFunc(TypeSyncScore, HandleSyncScoreTask)
62

63
        if err := server.Run(mux); err != nil {
64
            zaphelper.Sugar.Errorf("消息队列启动失败: %v", err)
65
        }
66
    }()
67
}

1
// mq 的应用

1
func HashPassword(password string) string {
2
  bytes, err := bcrypt.GenerateFromPassword([]byte(password), 14)
3
  if err != nil {
4
    log.Printf("Error hashing password: %v", err)
5
    panic(err)
6
  }
7
  return string(bytes)
8
}

1
func HashPassword(password string) (string,error) {
2
  bytes, err := bcrypt.GenerateFromPassword([]byte(password), 14)
3
  if err != nil {
4
    log.Printf("Error hashing password: %v", err)
5
    return "", err
6
  }
7
  return string(bytes),nil
8
}

1
func RegisterUser(req model.RegisterRequest) (*model.User, error) {
2
    // 检查用户名是否存在
3
    var existUser model.User
4
    if err := database.DB.Where("username = ?", req.Username).First(&existUser).Error; err == nil {
5
        return nil, errors.New("用户名已存在")
6
    }
7

8
    // 检查邮箱是否存在
9
    if err := database.DB.Where("email = ?", req.Email).First(&existUser).Error; err == nil {
10
        return nil, errors.New("邮箱已被注册")
11
    }
12

13
    // 加密密码
14
    hashedPassword := HashPassword(req.Password)
15

16
    // 创建用户
17
    user := model.User{
18
        Username: req.Username,
19
        Email:    req.Email,
20
        Password: hashedPassword,
21
    }
22

23
    // 保存到数据库
24
    if err := database.DB.Create(&user).Error; err != nil {
25
        return nil, errors.New("用户创建失败")
26
    }
27

28
    return &user, nil
29
}

1
func HashPassword(password string) string {
2
  bytes, err := bcrypt.GenerateFromPassword([]byte(password), 14)
3
  if err != nil {
4
    log.Printf("Error hashing password: %v", err)
5
    panic(err)
6
  }
7
  return string(bytes)
8
}
9
func CheckPasswordHash(password, hash string) bool {
10
  err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
11
  return err == nil
12
}

1
func LoginHandler(c *gin.Context) {
2
    var loginRequest model.LoginRequest
3

4
    if err := c.ShouldBindJSON(&loginRequest); err != nil {
5
        c.JSON(400, gin.H{"error": "请求参数错误: " + err.Error()})
6
        return
7
    }
8

9
    user, err := util.LoginUser(loginRequest)
10
    if err != nil {
11
        c.JSON(401, gin.H{"error": err.Error()})
12
        return
13
    }
14

15
    c.JSON(200, gin.H{
16
        "message": "登录成功",
17
        "user":    user,
18
    })
19
}

1
type User struct {
2
  gorm.Model
3
  Username string `gorm:"uniqueIndex;not null"`
4
  Email    string `gorm:"uniqueIndex;not null;email"`
5
  Password string `gorm:"not null;size:255" json:"-"`
6
}