go语言抖音demo

已于 2023-02-24 13:24:18 修改
阅读量1.2k 收藏 12
点赞数 1
文章标签： ffmpeg 开发语言 go
于 2023-02-24 13:21:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59253379/article/details/129198792
版权

一、项目介绍

采用gin+gorm框架实现了抖音各个功能接口的项目。

项目服务地址：本机wsl子系统，采用端口映射的方式得以让外面的客户端通过宿主机访问到wsl上的服务。

github地址： github仓库地址

二、项目实现

2.1 技术选型与相关开发文档

GORM

数据库ORM框架，目前最好用最稳定的框架，

gorm官方文档

gorm

GIN

经典的http框架，响应和接收前端请求。

gin中文文档

gin

REDIS

redis内存数据库，用来做缓存。计数、存储等。

redis中文网

redigo

MYSQL

常用的db数据库，用来存储关系型数据。

mysql官方文档

YAML

配置文件，书写配置属性。

yaml基础语法

yaml.v3

JWT

Json web token用来用户验证，用户权限等操作。

jwt官方文档

jwt-go

FFMPEG

用来截取视频的第一帧，生成对应的图片。

ffmpeg官方文档

ffmpeg-go

DOCKER

用来承载镜像的mysql和redis

docker官网

2.2 架构设计

架构设计我觉得分为两部分，一部分是整体项目的设计，另一部分是数据库的设计。

整体架构：

本项目借鉴mvc三层架构的思想，整体扩散到局部，每个层各司其职，有些承接上下文，利于维护和更新。

项目架构如图所示：

在这里插入图片描述

cache

cache层是关于缓存设计的实现，缓存采用的是redis，主要缓存了一些热数据及经常更新更改的数据。在普通的业务请求上添加一层缓存，能显著提高请求的响应速度。

  • common

  • common层就是一些业务常用的相同的结构体和方法。

  • config

  • config层就是一些基本的配置选项，mysql、redis、静态文件路径等。这里使用conf.yaml文件来统一管理。

dao

dao层就是对db数据库的增删查改操作了，它无关业务代码，只面向底层数据。

handle

handle层就是面向前端请求提供的对外接口了，它负责整理好数据，将数据规范化返回给前端。

middleware

middleware就是字面意思了，中间件层，用来检验用户token、来判断前端注册账号密码是否符合规范。

public

public层就是用来存放静态资源的，把前端传上来的视频以及切割好的图片存于此层，用作路径映射，将资源呈现给前端。

service

service层就是用来实现主要的业务逻辑，核心代码所在。将处理完后的数据传给顶层的handle

utls

utls层就是工具层，这个层主要是提供一些字符串变换、解析，及外部工具的使用的方法。

数据库架构：

数据库采用的是关系型数据库mysql,数据模型中存在着一对一，一对多，多对多的关系。

数据对象关系如下图：

在这里插入图片描述

从上如就可以看出，数据库总共有设计了六张表，其中两张关系表，四张实体表。user->video，video->user在喜欢这个关系中是多对多关系，而user<->user在关注关系中是多对多，usesr->comment、user->message、video->comment则都是一对多关系。

2.3 项目代码介绍

dao

在这里插入图片描述

首先从dao层的代码说起，dao层主要是用来设计对db数据库的访问并把数据封装对象的过程。代码设计全部采用的是单例模式，我的是gorm框架来对数据库进行访问，直接反射到对应的结构体中。在使用gorm的过程中，通过使用外键，使用gorm框架的的has one、has many 、many to many 、belongs to、通过设置标签进行联合查询，有些特殊需求是通过自写sql来解决的。下面通过看几个例子

关联查询：

// QueryLikeByUserid DeleteLike 查找映射 并且返回lists
func (LikeDao) QueryLikeByUserid(userid int64) ([]Video, error) {
   user := &User{}
   err := db.Preload("VideoLieLists").Where("user_id = ?", userid).Preload("VideoLieLists.Author").Find(user).Error
   if err != nil {
      return nil, err
   }
   return user.VideoLieLists, nil
}

手写sql:

// QueryMessageLists 消息记录
func (MessageDao) QueryMessageLists(userid, ToUserId int64, preMsgTime int64) ([]Message, error) {
   var MessageLists []Message
   MessageLists = make([]Message, 0, 10)
   err := db.Raw("SELECT * FROM `message` WHERE message.create_time>? and ((to_user_id = ? and message.from_user_id  = ?) or (to_user_id = ? and message.from_user_id = ?)) ORDER BY  create_time", preMsgTime, userid, ToUserId, ToUserId, userid).Scan(&MessageLists).Error
   if err != nil {
      return nil, err
   }
   return MessageLists, nil
}

总的来说dao层就是对数据的增删改查，由于时间原因没有设置事务操作，后续会添加。

Service

Service层就是用来实现基本的服务逻辑，为handle层提供服务，通过调用dao层来调用数据实现对应的逻辑。用户登陆的例子来说，拿到从handle层传来的参数，首先判断用户是否存在，**然后对password进行md5加密，**去对比数据库中的密码（数据库中的密码都是md5形式存储，不对db管理者开放），对比完成后，若成功匹配，则登陆成功，返回给handle相应的token信息和用户id。以上就是Service的基本流程，拿到参数，走逻辑，然后返回结果。

func UserLogin(username string, password string) (*UserRegisInfo, error) {
   var err error
   var token string
   var user *dao.User
   //进行md5加密
   password = utls.Md5Encryption(password)
   user, err = dao.GetUserInstance().QueryUserByName(username)
   //判断用户是否存在
   if user.ID == 0 {
      err = errors.New("user not exists")
      return nil, err
   }
   if err != nil {
      return nil, err
   }
   //验证密码是否正确
   if password != user.Password {
      err = errors.New("password is wrong")
      return nil, err
   }
   //生成token
   token, err = utls.GenerateToken(username, user.ID)
   //成功返回
   return &UserRegisInfo{Token: token, UserID: user.ID}, nil
}
handle

handle是与前端请求打交道的模块，拿到前端请求的参数，对其进行初步处理，然后调用service层的方法实现对应的功能。拿登陆这个例子来说，首先拿到前端传来的query参数，然后调用service的登陆方法，进而进行错误处理，将返回的数据进行包装返回给前端。可以这么理解就是一个只负责接收数据和传回数据的模块。

func Login(c *gin.Context) {
   username := c.Query("username")
   password := c.Query("password")

   info, err := service.UserLogin(username, password)
   if err != nil {
      log.Println(err.Error())
      c.JSON(http.StatusOK, UserRegisterResponse{
         Response: common.Response{StatusCode: 1, StatusMsg: err.Error()},
      })
      return
   } else {
      c.JSON(http.StatusOK, UserRegisterResponse{
         Response: common.Response{StatusCode: 0},
         Token:    info.Token,
         UserId:   info.UserID,
      })
      return
   }
}
middleware

中间件层，前端进入后端的一道门槛。首先我设计了注册时检验账号和密码的规范性的中间件，利用正则表达式，检测账号密码的合理性。其次为了保证用户的使用流畅度 ，我找了一个中间件限制了post请求大小，也就是上传文件的请求大小。

package middleware

import (
   "douyin/common"
   "github.com/gin-gonic/gin"
   "net/http"
   "regexp"
)

func Check() gin.HandlerFunc {

   return func(c *gin.Context) {
      username := c.Query("username")
      password := c.Query("username")
      //传给handle层
      //5～16字节，允许字母、数字、下划线，以字母开头
      matchString := "^[a-zA-Z][a-zA-Z0-9_]{4,15}$"
      usernameMatch, _ := regexp.MatchString(matchString, username)
      passwordMatch, _ := regexp.MatchString(matchString, password)

      if usernameMatch && passwordMatch != true {
         c.JSON(http.StatusOK, common.Response{
            StatusCode: 1, StatusMsg: "Account or password is illegal",
         })
         c.Abort()
         return
      }
      c.Set("username", username)
      c.Set("password", password)
      //挂起
      c.Next()
   }
}

当前端注册请求过来时，会先经过中间件结构，中间件中会判断账号密码的合理性，若不合理，直接调用gin框架的abort（）进行终止，终止掉后面所有的该请求下的函数。

其次我设计了用户权限，对token的检查，检查其是否有效，是否正确。

package middleware

import (
   "douyin/cache"
   "douyin/common"
   "douyin/dao"
   "douyin/handle"
   "douyin/utls"
   "fmt"
   "github.com/gin-gonic/gin"
   "net/http"
)

func UserAuth() gin.HandlerFunc {

   return func(c *gin.Context) {
      //得到token字段
      //1.get请求
      token := c.Query("token")
      if token == "" {
         //2.post请求
         token = c.PostForm("token")
      }

      // 两种情况下来，判断是否有token
      if token == "" {
         c.JSON(http.StatusOK, handle.UserResponse{
            Response: common.Response{StatusCode: 1, StatusMsg: "token 不存在"},
         })
         c.Abort()
      }
      //解析
      t, claim, err := utls.ParseToken(token)
      //判断是否有效
      if !t.Valid || err != nil {
         c.JSON(http.StatusOK, handle.UserResponse{
            Response: common.Response{StatusCode: 1, StatusMsg: "token有效期过了或者" + err.Error()},
         })
         c.Abort()
         return
      }
      //1.首先到redis中查找，没有的话去mysql中查找
      //2.mysql中没有说明token失败
      var isExists = true

      err = cache.UserIsExists(claim.UserId)
      if err != nil {
         fmt.Println(err)
         //在redis中不存在
         isExists = false
      }
      if !isExists {
         //进行db查找
         var user *dao.User
         user, err = dao.GetUserInstance().QueryUserByID(claim.UserId)
         if err != nil {
            c.JSON(http.StatusOK, handle.UserResponse{
               Response: common.Response{StatusCode: 1, StatusMsg: "token find failed"},
            })
            c.Abort()
            return
         }
         if user.ID == 0 {
            c.JSON(http.StatusOK, handle.UserResponse{
               Response: common.Response{StatusCode: 1, StatusMsg: "id is not exists"},
            })
            c.Abort()
            return
         }
      }
      //传给handle层
      c.Set("userid", claim.UserId)
      //挂起
      c.Next()
   }
}

其中token是jwt生成的。在utls包中封装了token的生成与解析的方法，在生成token的时候在，中在token字段中加入了userid，通过检测userid是否存在token是否存在。这其中还用到了redis缓存，这在cache中再继续介绍。

cache

1.在实现业务逻辑的时候，发现对于登陆用户，请求视频流接口的时候，对于该用户对视频的状态和对视频作者的状态确定起来十分棘手，因为想追求性能，又要做到不业务不能出错，首先想到的是查询出所有like表和follow中的映射关系，进行循环查找，后面一想，当用户多了起来，时间复杂度直接on2，太影响性能了。最终决定用redis进行缓存。利用redis中的set集合，用行为加userid作为主键，将关注的userid或喜欢的videoid分别放入对应的集合，在进行状态判断的时候首先从redis中查找该videoid或者userid是否在“喜欢集合”或者“关注集合中”，若不存在就进行db查找。（其实还是有待改进）下面是实现缓存的一些接口，对外提供了添加、删除、和判断的功能，以供使用。

func getUserRelationKey(userid int64) string {
   return fmt.Sprintf("%s_%d", "UserRelationKey", userid)
}

func getUserVideoRelation(userid int64) string {
   return fmt.Sprintf("%s_%d", "UserVideoRelationKey", userid)
}

// SetUserRelation 建立用户和用户的关系集合
func SetUserRelation(userid, touserId int64) error {
   conn := RedisPool.Get()
   defer func(conn redis.Conn) {
      err := conn.Close()
      if err != nil {
      }
   }(conn)

   key := getUserRelationKey(userid)
   //往集合中加关注的人
   _, err := conn.Do("SADD", key, touserId)
   if err != nil {
      return err
   }
   return nil
}

// SetUserVideoRelation 建立用户和视频的关系集合
func SetUserVideoRelation(userid, videoId int64) error {
   conn := RedisPool.Get()
   defer func(conn redis.Conn) {
      err := conn.Close()
      if err != nil {
      }
   }(conn)
   key := getUserVideoRelation(userid)
   //往集合中加关注的人
   _, err := conn.Do("SADD", key, videoId)
   if err != nil {
      return err
   }
   return nil
}

// IsUserRelation 判断是否在集合中
func IsUserRelation(userid, touserId int64) bool {
   conn := RedisPool.Get()
   defer func(conn redis.Conn) {
      err := conn.Close()
      if err != nil {
      }
   }(conn)
   key := getUserRelationKey(userid)
   res, err := conn.Do("SISMEMBER", key, touserId)
   if err != nil {
      log.Println(err.Error())
      return false
   }
   if res == 0 {
      return false
   }
   return true
}

// IsUserVideoRelation 判断是否在集合里面
func IsUserVideoRelation(userid, videoId int64) bool {
   conn := RedisPool.Get()
   defer func(conn redis.Conn) {
      err := conn.Close()
      if err != nil {
      }
   }(conn)

   key := getUserVideoRelation(userid)

   res, err := conn.Do("SISMEMBER", key, videoId)
   if err != nil {
      log.Println(err.Error())
      return false
   }
   if res == 0 {
      return false
   }
   return true
}
func DeleteUserRelation(userid, touserId int64) error {
   conn := RedisPool.Get()
   defer func(conn redis.Conn) {
      err := conn.Close()
      if err != nil {
      }
   }(conn)

   key := getUserRelationKey(userid)
   //往集合中加关注的人
   _, err := conn.Do("SREM", key, touserId)
   if err != nil {
      return err
   }
   return nil
}

// DeleteUserVideoRelation 删除关系
func DeleteUserVideoRelation(userid, videoId int64) error {
   conn := RedisPool.Get()
   defer func(conn redis.Conn) {
      err := conn.Close()
      if err != nil {
      }
   }(conn)
   key := getUserVideoRelation(userid)
   //往集合中加关注的人
   _, err := conn.Do("SREM", key, videoId)
   if err != nil {
      return err
   }
   return nil
}

2.继续写到后面看到这三个接口：

optional int64 total_favorited = 9; //获赞数量

optional int64 work_count = 10; //作品数量

optional int64 favorite_count = 11; //点赞数量

在数据库中若加入了这三个字段，就需要频繁的进行更新；若不加入这三个字段利用sql语句提供的count进行计数，你会发现，count操作比较耗费性能，当数量一多那更是“动弹不得”。所以对于计数操作，我也进行了redis缓存，看了字节内部的使用redis那门课学了点。就对外提供了对上述三个字段的incr、decr、和get的接口。

// SetUserCount 设置user计数
func SetUserCount(userid int64) error {
   conn := RedisPool.Get()

   defer func(conn redis.Conn) {
      err := conn.Close()
      if err != nil {
      }
   }(conn)

   key := getUserCountKey(userid)
   _, err := conn.Do("hmset", redis.Args{key}.AddFlat(map[string]int64{
      "followCount":   0,
      "followerCount": 0,
      "workCount":     0,
      "favoriteCount": 0,
      "totalFavorite": 0,
   })...)
   if err != nil {
      return err
   }
   return nil
}

func GetUserFollowCount(userID int64) (int64, error) {
   res, err := get(userID, "followCount")
   return res, err
}
func GetUserFollowerCount(userID int64) (int64, error) {
   res, err := get(userID, "followerCount")
   return res, err
}
func GetUserWorkCount(userID int64) (int64, error) {
   res, err := get(userID, "workCount")
   return res, err
}
func GetUserFavoriteCount(userID int64) (int64, error) {
   res, err := get(userID, "favoriteCount")
   return res, err
}
func GetUserTotalFavoriteCount(userID int64) (int64, error) {
   res, err := get(userID, "totalFavorite")
   return res, err
}

func DecrByUserFollowCount(userID int64) error {
   err := change(userID, "followCount", -1)
   return err
}
func IncrByUserFollowCount(userID int64) error {
   err := change(userID, "followCount", 1)
   return err
}

func DecrByUserFollowerCount(userID int64) error {
   err := change(userID, "followerCount", -1)
   return err
}
func IncrByUserFollowerCount(userID int64) error {
   err := change(userID, "followerCount", 1)
   return err
}
func DecrByUserWorkCount(userID int64) error {
   err := change(userID, "workCount", -1)
   return err
}
func IncrByUserWorkCount(userID int64) error {
   err := change(userID, "workCount", 1)
   return err
}

func DecrByUserTotalFavorite(userID int64) error {
   err := change(userID, "totalFavorite", -1)
   return err
}
func IncrByUserTotalFavorite(userID int64) error {
   err := change(userID, "totalFavorite", 1)
   return err
}

func DecrByUserFavoriteCount(userID int64) error {
   err := change(userID, "favoriteCount", -1)
   return err
}
func IncrByUserFavoriteCount(userID int64) error {
   err := change(userID, "favoriteCount", 1)
   return err
}

func change(userid int64, field string, incr int64) error {

   key := getUserCountKey(userid)
   conn := RedisPool.Get()

   //释放资源
   defer func(conn redis.Conn) {
      err := conn.Close()
      if err != nil {
      }
   }(conn)

   isExists, _ := conn.Do("exists", key)
   //判断键值是否存在
   if isExists == 0 {
      return errors.New("is not exists")
   }

   before, err := redis.Int64(conn.Do("hget", key, field))
   if err != nil {
      return err
   }
   if before+incr < 0 {
      //此时已经小于0了
      fmt.Println(errors.New("already <0"))
      log.Println(errors.New("already <0"))
      return nil
   }
   _, err = conn.Do("HIncrBy", key, field, incr)
   if err != nil {
      return err
   }
   return nil
}

func get(userid int64, field string) (int64, error) {
   key := getUserCountKey(userid)

   conn := RedisPool.Get()
   //释放资源
   defer func(conn redis.Conn) {
      err := conn.Close()
      if err != nil {
      }
   }(conn)

   isExists, _ := conn.Do("exists", key)

   //判断键值是否存在
   if isExists == 0 {
      return 0, errors.New("is not exists")
   }

   res, err := redis.Int64(conn.Do("hget", key, field))

   if err != nil {
      return 0, err
   }
   return res, nil
}

3.缓存中我是用的是redis的连接池的技术。

func RedisPoolInit() error {
   RedisPool = &redis.Pool{
      MaxIdle:     config.C.Redis.Maxidle,   //最大空闲数
      MaxActive:   config.C.Redis.Maxactive, //最大连接数，0不设上
      Wait:        true,
      IdleTimeout: time.Duration(1) * time.Second, //空闲等待时间
      Dial: func() (redis.Conn, error) {
         c, err := redis.Dial("tcp", config.C.Redis.Ipaddress+":"+config.C.Redis.Port) //redis IP地址
         if err != nil {
            fmt.Println(err)
            return nil, err
         }
         //密码认证
         if _, err = c.Do("AUTH", config.C.Redis.Authpassword); err != nil {
            err := c.Close()
            if err != nil {
               return nil, err
            }
            return nil, err
         }
         redis.DialDatabase(0)
         return c, err
      },
   }
   return nil
}
config

对于config层，首先手写配置文件项.yaml，然后利用代码生成工具生成了对应的结构体。然后对其读取和解析。

# mysql
mysql:
  username: root
  password: 123456
  ipaddress: 127.0.0.1
  port: 3309
  dbname: douyin

# redis
redis:
  ipaddress: 127.0.0.1
  port: 6379  
  authpassword: 123456    #redis验证密码
  maxidle: 5              #连接池最大空闲数
  maxactive: 0            #连接池最大连接数 0 表示不设上

# resource(静态图片和视频的资源)
resouece:
  ipaddress: 172.25.169.130 #宿主机的ip地址
  port: 12345               #宿主机的端口
  
type Config struct {
   Mysql    Mysql    `yaml:"mysql"`
   Redis    Redis    `yaml:"redis"`
   Resouece Resouece `yaml:"resouece"`
}

type Mysql struct {
   Username  string `yaml:"username"`
   Password  string `yaml:"password"`
   Ipaddress string `yaml:"ipaddress"`
   Port      string `yaml:"port"`
   Dbname    string `yaml:"dbname"`
}

type Redis struct {
   Ipaddress    string `yaml:"ipaddress"`
   Port         string `yaml:"port"`
   Authpassword string `yaml:"authpassword"`
   Maxidle      int    `yaml:"maxidle"`
   Maxactive    int    `yaml:"maxactive"`
}

type Resouece struct {
   Ipaddress string `yaml:"ipaddress"`
   Port      string `yaml:"port"`
}

var C Config

func ConfInit() error {
   yamlFile, err := os.ReadFile("./config/config.yaml")
   if err != nil {
      fmt.Println(err.Error())
      return err
   }
   // 将读取的yaml文件解析为响应的 struct
   err = yaml.Unmarshal(yamlFile, &C)
   if err != nil {
      fmt.Println(err.Error())
      return err
   }
   return nil
}
utils

对于工具包就是一些工具的使用了，有jwt、MD5等。重点go中是如何使用ffmpeg的，传video路径，传入图片生成路径，以及你想截取的帧序。

func GenerateSnapshot(videoPath, snapshotPath string, frameNum int) (err error) {
   buf := bytes.NewBuffer(nil)
   err = ffmpeg.Input(videoPath).
      Filter("select", ffmpeg.Args{fmt.Sprintf("gte(n,%d)", frameNum)}).
      Output("pipe:", ffmpeg.KwArgs{"vframes": 1, "format": "image2", "vcodec": "mjpeg"}).
      WithOutput(buf, os.Stdout).
      Run()
   if err != nil {
      return err
   }

   img, err := imaging.Decode(buf)
   if err != nil {
      return err
   }

   err = imaging.Save(img, snapshotPath+".png")
   if err != nil {
      return err
   }
   return nil
}

三、测试结果

功能测试：

user_info：
TestUserRegister
tests := []struct {
   name string
   args
}{
   {
      "测试1",
      args{
         "____________",
         "123456mksjxnjancanjskandndjasnjdkasn",
      },
   },
   {
      "测试2",
      args{
         "小王",
         "123456",
      },
   },
   {
      "测试3",
      args{
         "",
         "123456",
      },
   },
}
TestUserLogin
tests := []struct {
   name string
   args
}{
   {
      "测试1",
      args{
         "小王",
         "123456",
      },
   },
   {
      "测试2",
      args{
         "_____",
         "123456",
      },
   },
   {
      "测试3",
      args{
         "hhhy",
         "123456",
      },
   },
video_info:
TestPublishedVideoLists
type args struct {
   userid int64
}
tests := []struct {
   name string
   args
}{
   {
      "测试1",
      args{
         1,
      },
   },
   {
      "测试2",
      args{
         100000,
      },
   },
   {
      "测试3",
      args{
         -10,
      },
   },
}
message_info：
TestGetMessageLists
type args struct {
   userid   int64
   toUserId int64
   preTime  int64
}
tests := []struct {
   name string
   args
}{
   {
      name: "测试1",
      args: args{
         userid: 10,
         toUserId: 11,
         preTime: 213123213,
      },
   },
   {
      name: "测试2",
      args: args{
         userid: 10,
         toUserId: -11,
         preTime: 00213123213,
      },
   },
}
TestSendMessage
type args struct {
   userid   int64
   toUserId int64
   content  string
   action   string
}
tests := []struct {
   name string
   args
}{
   {
      name: "测试1",
      args: args{
         userid:   10,
         toUserId: 11,
         content:  "你好啊",
         action:   "1",
      },
   },
   {
      name: "测试2",
      args: args{
         userid:   11,
         toUserId: 10,
         content:  "你也好啊",
         action:   "1",
      },
   },
}
like_info：
TestGetLikeLists
tests := []struct {
   name   string
   userid int64
}{
   {
      name:   "test1",
      userid: 10,
   },
   {
      name:   "test2",
      userid: 11,
   },
}
TestThumbUpOrCancel
tests := []struct {
   name    string
   userid  int64
   videoId int64
   action  string
}{
   {
      name:    "test1",
      userid:  10,
      videoId: 1,
      action:  "1",
   },
   {

      name:    "test2",
      userid:  11,
      videoId: 2,
      action:  "1",
   },
   {
      name:    "test3",
      userid:  10,
      videoId: 2,
      action:  "1",
   },
}
follow_info：
TestFollowerLists
tests := []struct {
   name   string
   userid int64
}{
   {
      name:   "test1",
      userid: 10,
   },
   {
      name:   "test2",
      userid: 11,
   },
}
TestFollowLists
tests := []struct {
   name   string
   userid int64
}{
   {
      name:   "test1",
      userid: 10,
   },
   {
      name:   "test2",
      userid: 16,
   },
}
comment_info：
TestCommentOrDelete
tests := []struct {
   name        string
   videoId     int64
   userId      int64
   action      string
   commentText string
   commentId   int64
}{
   {
      name:        "test1",
      videoId:     1,
      userId:      10,
      action:      "1",
      commentText: "test_comment1",
      commentId:   13,
   },
   {
      name:        "test2",
      videoId:     2,
      userId:      10,
      action:      "1",
      commentText: "test_comment2",
      commentId:   11,
   },
   {
      name:        "test3",
      videoId:     3,
      userId:      12,
      action:      "1",
      commentText: "test_comment3",
      commentId:   12,
   },
}
TestGetCommentLists
tests := []struct {
   name    string
   videoId int64
}{
   {
      name:    "test1",
      videoId: 1,
   },
   {
      name:    "test2",
      videoId: 2,
   },
   {
      name:    "test3",
      videoId: 3,
   },
}

性能测试：

利用ppprof工具进行性能分析，主要是在io.write的时候浪费了较多的性能，就是在回传静态文件的时候浪费了性能。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

四、项目总结与反思

1.仍然存在的问题：

  • 数据库没有进行事务操作，可能会导致数据的不安全，在极高并发的时候还需要考虑读写锁。
  • redis没有设计好合适的过期值和分布式锁。
  • 测试不够完善，后续进行完善。

2.已经识别出来的优化项目

  • 所有的有关计数的count的操作都可以用redis缓存来解决，项目中关注数和粉丝数还未实现。
  • 可以考虑用go语言的泛型来处理一些冗余的代码，这等待后续学习go的泛型。
  • 项目中还存在一部分拷贝，考虑优化成指针等。

3.架构演进的可能性

  • 可以尝试进行分布式开发。
  • 可以引进短信验证的功能，增强安全性。

五、其他补充资料

通过端口映射的方法使得外部的客户端能访问到wsl：

https://juejin.cn/post/7198169454186070071

奔跑的小白、
关注
  • 1
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
go语言小小demo一枚
07-01
go语言小小demo一枚 go语言小小demo一枚 go语言小小demo一枚 go语言小小demo一枚
Go语言入门DEMO
weixin_43889339的博客
03-17 1726
目录先干为敬，主要来自菜鸟教程 import "fmt" type PeopleInfo struct { name string age int } type Father interface { Hear(word string) Speak() string ChangeName(name string) } // (p PeopleInfo)称为接收器，一个函数只有一个接收器 // 推荐此类写法为struct 扩展成员方法 // 支持指针类型（适合大对象）、非指针类型（适合
Go Web 开发 Demo【用户登录、注册、验证】
梦想是动物管理员
05-01 1313
Go 语言Web开发基础，GIN 实现用户注册、登录、验证
Golang 各种Demo
09-04
包含Golang 语法的各种Demo，可以帮助Go语言初学者，快速入门上手。非常实用的学习案例，直接go run运行就可以了。
Go语言demo
11-13
Go语言demo
抖音小程序 go 语言版 SDK.zip
02-25
如题，抖音小程序源码，易于运行部署，用于学习交流
抖音 iOS Object-C版，抖音demo适配了iphone、ipad
最新发布
05-12
抖音 iOS Object-C版，抖音demo适配了iphone、ipad 同时兼容iOS8.0至iOS12.0系统。当前抖音demo使用Object-C语言编写 结构 本项目共分为三个部分。第一部分为抖音个人主页实现，包含NSOperationQueue多队列解析webp...
php对接抖音api demo
01-04
本文将详述如何使用PHP对接抖音API，并提供一个简单的PHP对接抖音API的DEMO示例，以帮助开发者理解并实践这个过程。 首先，我们要了解抖音API的基本概念。抖音API（Douyin API）是抖音官方提供的接口，允许开发者...
go-learning:go语言学习demo
04-19
go基础"21世纪的c语言",go语言起源于2007年，并于2009年正式对外发布，Go 语言的主要目标是将静态语言的安全性和高效性与动态语言的易开发性进行有机结合，达到完美平衡，从而使编程变得更加有乐趣，而不是在艰难...
Go语言学习笔记（一）——基础语法与demo开发解析
rippersudo的博客
05-12 979
主要内容：1、go语言基础语法；2、示例代码解析
[go-web开发小试验] 1-第一个demo程序
一名普通码农的菜地
11-19 727
前言 目前的go似乎值得一试。 参考 参考了网上的go web开发入门 之类的文章。 步骤 在idea上面开一个新项目，然后，嗯。。。我用的是go1.11，有module模块了，然后添加一个文件，内容如下： package src import ( "fmt" "log" "net/http" "strings" ) func sayhelloName(w http.ResponseW...
抖音分享页面(2020版本) 数据抓取 Golang版
lypgcs的博客
10-18 1624
本文以分享技术为主，禁止将本文内容使用任何形式的商业形式或违法活动，后果自负。 --- # 原理介绍 通过代码模拟浏览器打开抖音的分享页面，从而获取到用户的信息，而不需要理解各种抖音请求的算法，最低门槛开始数据获取之路。 简单看一下下面的图，显示出来的信息都可以获取到，比如关注数，粉丝数，点赞数，作品数，喜欢数。 # 分享从哪里来？ 在右下角菜单"我"-->右上角菜单"三条杠"-->我的二维码, 如果是其他用户也可以在用户信息界面的右上角菜单找到. ...
抖音用什么编程语言_什么是抖音蓝V，抖音开通蓝V有什么用，如何开通抖音蓝V？...
weixin_29322855的博客
12-18 648
一、什么是抖音蓝V？从本文的标题就能看出来，今天我们要说的事主要是抖音企业蓝V认证的事。大家都知道最近抖音是火的一塌糊涂，抖音日活跃用户数量接近3亿，月活跃用户数量5亿，并继续保持高速增长。大部分企业都开始通过抖音做营销，开始用个人号做营销还不错，但随着抖音企业号的推出，个人营销号被严重打击。于是很多企业开始注册抖音企业账号，为了获取更多抖音的营销功能，大部分注册抖音企业号的用户都开始想办法认证抖...
gin + kitex + gorm 抖音项目实现1: user微服务
weixin_44306211的博客
02-18 506
抖音项目实现1: user微服务。
抖音项目实现2: api层的实现 | 青训营笔记
weixin_44306211的博客
02-23 522
测试user微服务，api层的实现
go语言小游戏--星际大战
qq_63730529的博客
11-08 546
在游戏中总共设计了两种人物，分别是我方飞机和敌方外星人飞船。至此，游戏的基本功能都已介绍完毕，在此基础上还可以添加游戏状态等其他功能go语言小白，如果有更好的建议欢迎评论区留言~~参考：https://blog.csdn.net/darjun/article/details/128213350。
直播间弹幕采集
bboysteed的博客
06-06 1308
直播间信息抓取，wss协议分析
go语言抖音直播真实地址提取
Clown95
09-28 2756
package live import ( "GetRelLiveUrl/utils" "encoding/json" "fmt" "net/http" "regexp" "strings" ) type Dy struct { Data struct { Room struct { StreamURL struct { RtmpPullURL string `json:"rtmp_pull_url"` HlsPullURL string `
GO语言入门 - Demo项目尝试
精致技术
11-28 1777
1. 配置GOROOT 2. File - New Project - Go Modules: Location选择本地工程目录(不要选择全局设置的GOPATH路径，否则执行go get等命令或IDE相关操作时会提示：$GOPATH/go.mod exists but should not) 选择新建Go Modules类型的工程，目的是可以使用GO依赖管理工具go Modules配置goproxy代理，从国内代理仓库下载工程依赖的一些第三方组件库文件。 GOROOT选择Go安装根目录...
抖音小程序 demo
09-07
抖音小程序 demo 是一款基于抖音平台的小程序示例，可以让开发者在抖音平台上开发自己的小程序应用。 抖音小程序 demo 提供了丰富的功能和接口，开发者可以使用抖音小程序开发工具进行开发，使用抖音小程序 API 进行接口调用，实现各种功能的开发，如发布视频、播放视频、评论点赞等。 抖音小程序 demo 的界面设计和交互方式与抖音平台保持一致，用户可以通过滑动浏览视频、关注用户、搜索视频等。开发者可以根据自己的需求进行个性化定制，如更换界面主题、添加自定义功能等。 对于开发者来说，抖音小程序 demo 提供了丰富的开发文档和示例代码，方便开发者学习和参考。开发者还可以通过抖音小程序开发者社区与其他开发者交流经验，分享开发心得，一起探讨问题。 对于用户来说，抖音小程序 demo 可以提供更多的内容和功能，丰富用户的使用体验。用户可以通过抖音小程序 demo 发现更多有趣的视频和创作者，与其他用户互动和交流。 总结来说，抖音小程序 demo 是抖音平台上的一个小程序示例，为开发者提供了丰富的开发功能和接口。同时，也为用户提供了更多有趣的内容和功能，提升用户的使用体验。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值