盲目的学了一段时间了，刚开始从Box2d开始学习，明白了很多，Box2d是物理模型的基础，是我们在游戏中模拟现实的很重要的一个开源工具。后来在朋友的建议下学习了cocos，也是小程序开发的利器，而golang是一款高效的httprouter服务器，如果考虑安全肯定是没有tcp的安全。用起来太容易了，可以快速的游戏服务。
1.数据库连接：
数据库用的是gorm，连接数据库一个需要
_ "github.com/go-sql-driver/mysql"
"github.com/jinzhu/gorm"
mysql的驱动和gorm库支持。代码如下：
package mysqldb_test
import (
"fmt"
"log"
mymodals "main/modals"
"time"
_ "github.com/go-sql-driver/mysql"
"github.com/jinzhu/gorm"
"github.com/userlll1986/main/config"
)
var Db *gorm.DB
var err error
// User 结构体声明
// type User struct {
// UserId int64 `gorm:"primaryKey;autoIncrement"`
// UserName string `gorm:"not null;type:varchar(32)"`
// UserPwd string `gorm:"not null;type:varchar(128)"`
// UserPhone string `gorm:"unique;type:varchar(32)"`
// }
// 数据库配置
func InitDb(config *config.Config) {
url := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local",
config.Data.Username,
config.Data.Password,
config.Data.Ip,
config.Data.Part,
config.Data.DataBase,
)
// 这个地方要注意，不要写称 := 写成 = 才对
Db, err = gorm.Open(config.Data.Category, url)
// 设置表前缀
gorm.DefaultTableNameHandler = func(db *gorm.DB, defaultTableName string) string {
//fmt.Println("db.DefaultTableNameHandler", config.Data.Prefix, defaultTableName)
return config.Data.Prefix + defaultTableName
}
if err != nil {
log.Fatalf("连接数据库【%s:%s/%s】失败, 失败的原因：【%s】", config.Data.Ip, config.Data.Part, config.Data.DataBase, err)
}
// db配置输出SQL语句
Db.LogMode(config.Data.Sql)
// 使用表名不适用复数
Db.SingularTable(true)
// 连接池配置
Db.DB().SetMaxOpenConns(20)
Db.DB().SetMaxIdleConns(10)
Db.DB().SetConnMaxLifetime(10 * time.Second)
// 判断是否需要用来映射结构体到到数据库
// fmt.Println(config.Data.Init.Status)
if config.Data.Init.Status {
// 自动迁移数据库表结构
// err := Db.AutoMigrate(&User{})
// if err != nil {
// fmt.Println("数据库表迁移失败!", err)
// } else {
// fmt.Println("数据库表迁移成功!")
// }
// 插入单条数据
// var user = User{UserName: "wjj", UserPwd: "123", UserPhone: "111"}
// Db.Create(&user)
// var users = []User{
// {UserName: "th", UserPwd: "123", UserPhone: "222"},
// {UserName: "lhf", UserPwd: "123", UserPhone: "333"},
// {UserName: "zcy", UserPwd: "123", UserPhone: "444"},
// }
// for _, user := range users {
// Db.Create(&user)
// }
// 查询全部记录
var users []mymodals.User
Db.Find(&users)
Db.Where("user_name = ?", "wjj").Find(&users)
// Db.First(&users)
// // 打印结果
// fmt.Println(users)
// 查询总数
// var users []User
// var totalSize int64
// Db.Find(&users).Count(&totalSize)
// fmt.Println("记录总数:", totalSize)
// 查询user_id为1的记录
// var stu User
// Db.Where("user_id = ?", 1).Find(&stu)
// // 修改stu姓名为wjj1
// stu.UserName = "wjj1"
// // 修改(按照主键修改)
// Db.Save(&stu)
// var stu User
// Db.Model(&stu).Where("user_id = ?", 1).Update("user_name", "wjj2")
// var fields = map[string]interface{}{"user_name": "WJJ", "user_pwd": "999"}
// fmt.Println(fields)
// Db.Model(&stu).Where("user_id = ?", 1).Updates(fields)
// // 删除
// var user = User{UserId: 1}
// Db.Delete(&user)
// 按照条件删除
// Db.Where("user_id = ?", 10).Delete(&User{})
}
log.Printf("连接数据库【%s:%s/%s】成功", config.Data.Ip, config.Data.Part, config.Data.DataBase)
}
代码中注释的部分没有删除，有数据库自迁移和增删改查的基本操作在里面。
2.先分享一下主程序，这样看起来比较容易理解。
port := os.Getenv("PORT")
if port == "" {
port = "8080"
log.Printf("Defaulting to port %s", port)
}
// 读取配置文件
myconfig := config.NewConfig()
myconfig.ReadConfig()
// 初始化数据库连接
mysqldb_test.InitDb(myconfig)
// Starts a new Gin instance with no middle-ware
r := gin.New()
// 使用 Recovery 中间件
r.Use(gin.Recovery())
// 使用 Logger 中间件
r.Use(gin.Logger())
// 使用 CORSMiddleware 中间件
r.Use(corsMiddleware())
// 使用限流中间件
r.Use(limiter.Middleware)
//使用数据库中间件
// 将db作为中间件传递给路由处理函数
r.Use(func(c *gin.Context) {
c.Set("db", mysqldb_test.Db)
c.Next()
})
// 在路由处理函数中可以通过c.MustGet("db").(*gorm.DB)获取到db对象，然后进行数据库操作
// 创建Redis客户端
redisClient := redis.NewClient(&redis.Options{
Addr: "127.0.0.1:54372", // Redis服务器地址
Password: "123456", // Redis密码
DB: 0, // Redis数据库编号
})
// 使用Redis中间件
r.Use(func(c *gin.Context) {
// 在Gin的上下文中设置Redis客户端
c.Set("redis", redisClient)
// 继续处理后续的请求
c.Next()
})
// 定义路由和处理函数
r.GET("/get/:key", func(c *gin.Context) {
// 从上下文中获取Redis客户端
redisClient := c.MustGet("redis").(*redis.Client)
// 从URL参数中获取键名
key := c.Param("key")
// 使用Redis客户端进行GET操作
val, err := redisClient.Get(c, key).Result()
if err == redis.Nil {
c.JSON(200, gin.H{
"result": fmt.Sprintf("Key '%s' not found", key),
})
} else if err != nil {
c.JSON(500, gin.H{
"error": err.Error(),
})
} else {
c.JSON(200, gin.H{
"result": val,
})
}
})
// 添加ES中间件,暂不使用
//r.Use(ElasticSearchMiddleware())
// 定义路由
// r.GET("/", func(c *gin.Context) {
// // 从上下文中获取ES客户端
// esClient := c.MustGet("esClient").(*elastic.Client)
// // 使用ES客户端进行查询
// // 这里只是一个示例，具体的ES查询操作可以根据实际需求进行修改
// _, _, err := esClient.Ping().Do(c.Request.Context())
// if err != nil {
// c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to ping Elasticsearch"})
// return
// }
// c.JSON(http.StatusOK, gin.H{"message": "Hello from Gin with Elasticsearch middleware!"})
// })
// 创建RabbitMQ连接
conn, err := amqp.Dial("amqp://lafba13j4134:llhafaif99973@localhost:5672/")
if err != nil {
fmt.Println("连接RabbitMQ失败:", err)
return
}
defer conn.Close()
// 添加RabbitMQ中间件
r.Use(RabbitMQMiddleware(conn, "my_queue"))这里有数据库中间件（第一部分讲的），日志中间件，限流中间件，rabbitmq中间件等。
下面会每一部分加上代码，这些中间件很容易使用，加一些代码就能直接使用，很方便。
3，下面是跨域请求中间件：
func corsMiddleware() gin.HandlerFunc {
return func(c *gin.Context) {
// 允许所有的跨域请求
c.Header("Access-Control-Allow-Origin", "*")
c.Header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
c.Header("Access-Control-Allow-Headers", "Content-Type, Authorization")
c.Header("Access-Control-Max-Age", "86400") // 预检请求缓存时间，单位为秒
// 处理预检请求
if c.Request.Method == "OPTIONS" {
c.AbortWithStatus(200)
return
}
// 继续处理其他请求
c.Next()
}
}4，限流中间件
var (
limiter = NewLimiter(10, 1*time.Minute) // 设置限流器，允许每分钟最多请求10次
)
// NewLimiter 创建限流器
func NewLimiter(limit int, duration time.Duration) *Limiter {
return &Limiter{
limit: limit,
duration: duration,
timestamps: make(map[string][]int64),
}
}
// Limiter 限流器
type Limiter struct {
limit int // 限制的请求数量
duration time.Duration // 时间窗口
timestamps map[string][]int64 // 请求的时间戳
}
// Middleware 限流中间件
func (l *Limiter) Middleware(c *gin.Context) {
ip := c.ClientIP() // 获取客户端IP地址
// 检查请求时间戳切片是否存在
if _, ok := l.timestamps[ip]; !ok {
l.timestamps[ip] = make([]int64, 0)
}
now := time.Now().Unix() // 当前时间戳
// 移除过期的请求时间戳
for i := 0; i < len(l.timestamps[ip]); i++ {
if l.timestamps[ip][i] < now-int64(l.duration.Seconds()) {
l.timestamps[ip] = append(l.timestamps[ip][:i], l.timestamps[ip][i+1:]...)
i--
}
}
// 检查请求数量是否超过限制
if len(l.timestamps[ip]) >= l.limit {
c.JSON(429, gin.H{
"message": "Too Many Requests",
})
c.Abort()
return
}
// 添加当前请求时间戳到切片
l.timestamps[ip] = append(l.timestamps[ip], now)
// 继续处理请求
c.Next()
}5，redis中间件
// 创建Redis客户端
redisClient := redis.NewClient(&redis.Options{
Addr: "127.0.0.1:54372", // Redis服务器地址
Password: "123456", // Redis密码
DB: 0, // Redis数据库编号
})
// 使用Redis中间件
r.Use(func(c *gin.Context) {
// 在Gin的上下文中设置Redis客户端
c.Set("redis", redisClient)
// 继续处理后续的请求
c.Next()
})中间件等使用很简单，直接c.MustGet("redis").(*redis.Client)直接取出来就能使用，c是gin.Context类型，是请求传的参数。
6，go和cocos通讯
在gin端：
func login(c *gin.Context) {
var req mymodals.AccountServiceRequest
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
if req.Type == "AccountService" && req.Tag == "account_login" {
if resp, err := myaccount.CallFunc("Account_login", c, req.Type, req.Tag, req.Body); err != nil {
fmt.Println("Error:", err)
var resp mymodals.AccountServiceResponse
resp.Result = "error"
resp.Body.Length = 1
resp.Body.Detail = err.Error()
c.JSON(http.StatusBadRequest, resp)
} else {
fmt.Println("Result of bar: ", resp[0].Interface())
c.JSON(http.StatusOK, resp[0].Interface())
}
} else if req.Type == "AccountService" {
if resp, err := myaccount.CallFunc(req.Tag, c, req.Type, req.Tag, req.Body); err != nil {
fmt.Println("Error:", err)
var resp mymodals.AccountServiceResponse
resp.Result = "error"
resp.Body.Length = 1
resp.Body.Detail = err.Error()
c.JSON(http.StatusBadRequest, resp)
} else {
fmt.Println("Result of bar:", resp[0].Interface())
c.JSON(http.StatusOK, resp[0].Interface())
}
}
}CallFunc用的是反射机制，通过传过来的参数调用函数。反射调用的具体函数如下，这里面调用了数据库中间价，做了token验证。
func Account_login(c *gin.Context, Type string, Tag string, Body map[string]interface{}) mymodals.AccountServiceResponse {
// 这里进行实际的登录验证逻辑
log.Printf("Account_login: %v,%v,%v", Type, Tag, Body)
// 例如：检查用户名和密码是否匹配，验证码是否正确等
var users []mymodals.User
var db = c.MustGet("db").(*gorm.DB)
db.Where("user_name = ?", Body["username"].(string)).Find(&users)
var resp mymodals.AccountServiceResponse
resp.Type = "AccountService"
resp.Tag = "account_login"
//增加token验证
token, err := authjwt.GenerateToken(Body["username"].(string))
if err != nil {
// ctx.JSON(http.StatusInternalServerError, gin.H{
// "code": 500, // Token生成错误
// "message": "请重新登录",
// })
var resp mymodals.AccountServiceResponse
resp.Result = "error"
resp.Body.Length = 1
resp.Body.Detail = err.Error()
// c.JSON(http.StatusBadRequest, resp)
return resp
}
if len(users) > 0 {
// 验证密码是否正确
hashedPassword := hashPassword(Body["password"].(string))
log.Printf("hashedPassword: %s", hashedPassword)
if users[0].UserPwd == Body["password"].(string) {
// 登录成功, 记录登录日志
// c.JSON(http.StatusOK, gin.H{"result": "ok"})
resp.Result = "ok"
resp.Body.Length = 1
resp.Body.Token = token
// return
} else {
resp.Result = "error"
resp.Body.Length = 1
resp.Body.Detail = "用户名或密码错误"
}
} else {
resp.Result = "error"
resp.Body.Length = 1
resp.Body.Detail = "用户名或密码错误"
}
log.Printf("登录响应: %v", resp)
return resp
// 将响应数据发送给客户端
// c.JSON(http.StatusOK, resp)
}7.cocos端协议的发送和接收
import { _decorator, Component, Node,Button,EventMouse,EditBox,Label } from 'cc';
import { setGlobalData, getGlobalData } from './global';
const { ccclass, property } = _decorator;
@ccclass('login')
export class login extends Component {
@property(Button)
private btnLogin: Button | null = null; //
@property(Button)
private btnLogout: Button | null = null; //
@property(EditBox)
private editBoxUsername: EditBox | null = null; // 用户名输入框
@property(EditBox)
private editBoxPassword: EditBox | null = null; // 密码输入框
@property(Label)
private errorMessage: Label | null = null; // 用于显示错误信息的 Label
start() {
if (this.btnLogin) {
// // 监听鼠标进入 Mask 事件
this.btnLogin.node.on("click", this.onMouseClickMask, this);
}
if (this.errorMessage) {
this.errorMessage.node.active = false;
}
if (this.btnLogout) {
this.btnLogout.node.on("click", this.onMouseClickLogout, this);
}
}
private onMouseClickLogout(event: EventMouse) {
console.log('鼠标点击了 Logout 按钮');
// 在这里添加你点击后想要执行的逻辑
// 关闭当前游戏窗口
cc.director.loadScene("EmptyScene");
}
update(deltaTime: number) {
}
private onMouseClickMask(event: EventMouse) {
console.log('鼠标点击了 Mask 区域');
// 在这里添加你点击后想要执行的逻辑
const username = this.editBoxUsername ? this.editBoxUsername.string : "";
const password = this.editBoxPassword ? this.editBoxPassword.string : "";
const ip = "127.0.0.1"; // 获取客户端的 IP 地址，这里假设为固定的 IP
const captcha = "12345"; // 从输入框获取验证码
const proving = "北京市"; // 从输入框获取省份
const machineCode = "machine123"; // 获取机器码
const clientType = "ios"; // 客户端类型
const data = JSON.stringify({
type: "AccountService",
tag: "account_login",
body: {
username: username,
password: password,
ip: ip,
captcha: captcha,
proving: proving,
machineCode: machineCode,
client_type: clientType
}
});
fetch('http://localhost:8080/v2/login', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: data,
})
.then(response => response.json())
.then(data => this.handleLoginResponse(data))
.catch((error) => console.error('Error:', error));
}
handleLoginResponse(response: any): void {
if (response.result === "ok") {
console.log("登录成功",response,response.body.token);
// 在这里可以进行登录成功的处理逻辑
setGlobalData(response.body.token); // 获取登录成功后的 Token
// 例如：跳转到游戏主界面
cc.director.loadScene("hall");
} else {
console.log("登录失败:", response.body.detail);
// 在这里可以进行登录失败的处理逻辑
// 例如：显示错误提示
if (this.errorMessage) {
this.errorMessage.string = response.body.detail;
this.errorMessage.node.active = true;
// 设置 3 秒后自动隐藏错误信息
setTimeout(() => {
this.errorMessage.node.active = false;
}, 3000);
}
// cc.find('Canvas/ErrorMessage').getComponent(cc.Label).string = response.body.detail;
}
}
}
![Vue3 + TypeScript，关于item[key]的报错处理方法](https://i-blog.csdnimg.cn/direct/27de1eb52d7d48ccab56a9f035156e49.png)
