Go语言实现网盘系统(未完)

该项目将基于go-zero和xorm

go-zero中文文档: https://legacy.go-zero.dev/cn/

Xorm中文文档: http://xorm.topgoer.com/

功能划分

整个项目可以分为3个模块: 用户模块、存储池模块和文件共享模块

数据库设计

用户是一个实体，建立对应的表user_basic，存储了用户信息，DDL如下:

create table users_basic
(
    id         int auto_increment
        primary key,
    identity   varchar(36) null,
    name       varchar(60) null,
    password   varchar(32) null,
    created_at datetime    null,
    updated_at datetime    null,
    deleted_at datetime    null,
    constraint id
        unique (id)
);

第一个就是id，是这张表的主键，identify字段表示用户的身份，name表示用户名，password表示密码，email表示邮箱，created_at表示创建时间，updated_at表示更新时间，deleted_at表示删除的时间

存储池对应了一张表，DDL如下:

create table repository_pool
(
    id       int auto_increment
        primary key,
    identity varchar(36)  null,
    hash     varchar(32)  null,
    name     varchar(255) null,
    ext      varchar(30)  null, # 文件扩展名
    size     double       null,
    path     varchar(255) null,
    constraint id
        unique (id)
);

用户存储库，和存储池的多对一的关系，DDL如下:

create table user_repository
(
    id                  int auto_increment
        primary key,
    identify            varchar(36)  null,
    user_identity       varchar(36)  null,
    parent_id           int          null,
    repository_identity varchar(36)  null,
    ext                 varchar(255) null,
    name                varchar(255) null,
    created_at          datetime     null,
    updated_at          datetime     null,
    deleted_at          datetime     null,
    constraint id
        unique (id)
);

共享文件有一张表，DDL如下:

create table share_basic
(
    id                  int auto_increment
        primary key,
    identity            varchar(36) null,
    user_identity       varchar(36) null,  # 分享者唯一标识
    repository_identity varchar(36) null,
    expired_time        int         null,  # 失效时间
    updated_at          datetime    null,
    created_at          datetime    null,
    deleted_at          datetime    null,
    constraint id
        unique (id)
);

在user_basic中添加数据，创建一些基本的用户

mysql> select * from users_basic;
+----+----------+------+----------+---------------------+---------------------+------------+
| id | identify | name | password | created_at          | updated_at          | deleted_at |
+----+----------+------+----------+---------------------+---------------------+------------+
|  1 | USER_1   | test | 123456   | 2022-09-12 11:47:54 | 2022-09-12 11:48:02 | NULL       |
+----+----------+------+----------+---------------------+---------------------+------------+

下面使用Xorm，安装方法: $ go get xorm.io/xorm

创建与一个models文件夹，编写与数据表对应的结构体和方法

package models

type UserBasic struct {
	Id       int
	Identity string
	Name     string
	Password string
	Email    string
}

func (table UserBasic) TableName() string {
	return "users_basic"
}

在项目中创建一个test文件夹，编写测试代码，尝试使用Xorm连接数据库:

package test

import (
	"bytes"
	"cloud-disk/models"
	"encoding/json"
	"fmt"
	_ "github.com/go-sql-driver/mysql"
	"log"
	"testing"
	"xorm.io/xorm"
)

var engine *xorm.Engine

func TestXormTest(t *testing.T) {
	var err error
	engine, err = xorm.NewEngine("mysql", "golang:123456@/cloud_disk?charset=utf8")
	if err != nil {
		log.Fatalln(err)
	}
	data := make([]*models.UserBasic, 0)
	err = engine.Find(&data)
	if err != nil {
		t.Fatal(err)
	}
	b, err := json.Marshal(data)
	if err != nil {
		log.Fatalln(err)
	}
	dst := new(bytes.Buffer)
	err = json.Indent(dst, b, "", " ")
	if err != nil {
		t.Fatal(err)
	}
	fmt.Println(dst.String())
}

运行代码，获取到了表中数据:

=== RUN   TestXormTest
[
 {
  "Id": 1,
  "Identify": "USER_1",
  "Name": "test",
  "Password": "123456",
  "Email": ""
 }
]
--- PASS: TestXormTest (0.00s)
PASS
ok  	cloud-disk/test	0.008s

项目初始化

安装go-zero和goctl:

$ go get -u github.com/zeromicro/go-zero
$ go install github.com/zeromicro/go-zero/tools/goctl@latest

在项目根目录执行$ goctl api new core，创建一个API服务，这时会创建出一个core文件夹，里面包含了一些文件:

core
├── core.api
├── core.go
├── etc
│   └── core-api.yaml
└── internal
    ├── config
    │   └── config.go
    ├── handler
    │   ├── corehandler.go
    │   └── routes.go
    ├── logic
    │   └── corelogic.go
    ├── svc
    │   └── servicecontext.go
    └── types
        └── types.go

进入core文件夹，执行命令如下，启动服务:

$ go run core.go -f etc/core-api.yaml
Starting server at 0.0.0.0:8888...

访问服务:

$ curl -i -X GET http://localhost:8888/from/you
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Traceparent: 00-835a1b4d021f755cd09ce2fdcd724afd-64ad02acaf7c22b5-00
Date: Mon, 12 Sep 2022 05:10:12 GMT
Content-Length: 4

基于自动生成的代码，还要编写具体的逻辑

进入internal/logic文件夹，改写如下函数:

func (l *CoreLogic) Core(req *types.Request) (resp *types.Response, err error) {
	// todo: add your logic here and delete this line

	return
}

添加如下代码:

func (l *CoreLogic) Core(req *types.Request) (resp *types.Response, err error) {
	resp = new(types.Response)
	resp.Message = "Hello Cloud Disk"
	return
}

再次启动服务并访问:

$ curl -i -X GET http://localhost:8888/from/you
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Traceparent: 00-511aeef2721af5adf8aa40ff2b7d9ce5-a2be678e70c0e2a3-00
Date: Mon, 12 Sep 2022 05:16:22 GMT
Content-Length: 30

{"message":"Hello Cloud Disk"}

服务给出了响应消息

在types.Response中有定义一个Message字段存放数据:

type Response struct {
	Message string `json:"message"`
}

将之前的models目录移动到core目录下，并创建init.go文件:

package models

import (
	"log"
	"xorm.io/xorm"
)

var Engine = Init()

func Init() *xorm.Engine {
	engine, err := xorm.NewEngine("mysql", "golang:123456@/cloud_disk?charset=utf8")
	if err != nil {
		log.Println("Xorm New Engine Error:", err)
		return nil
	}
	return engine
}

编写一段init函数，用于初始化Xorm数据库连接，将返回一个Engine，在logic中的Core函数中继续添加逻辑:

func (l *CoreLogic) Core(req *types.Request) (resp *types.Response, err error) {
	resp = new(types.Response)
	resp.Message = "Hello Cloud Disk"
	// 获取用户列表
	data := make([]*models.UserBasic, 0)
	err = models.Engine.Find(&data)
	if err != nil {
		log.Println("Get UserBasic Error", err)
		return
	}
	b, err := json.Marshal(data)
	if err != nil {
		log.Println("Marshal Error:", err)
		return
	}
	dst := new(bytes.Buffer)
	err = json.Indent(dst, b, "", " ")
	if err != nil {
		log.Println("Json Indent Error", err)
		return
	}
	fmt.Println(dst)

	resp = new(types.Response)
	resp.Message = dst.String()
	return
}

创建了一个data，用于存储查询到的数据，调用Find方法获取到数据表的所有数据，第一个参数为slice的指针或Map指针

现在再次启动服务并访问，可以看到程序取出了数据库中的数据:

$ curl -i -X GET http://localhost:8888/from/you
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Traceparent: 00-e8256a632201c5127e5bed8d44f66111-1d9f959482e3a918-00
Date: Mon, 12 Sep 2022 06:30:22 GMT
Content-Length: 140

{"message":"[\n {\n  \"Id\": 1,\n  \"Identify\": \"USER_1\",\n  \"Name\": \"test\",\n  \"Password\": \"123456\",\n  \"Email\": \"\"\n }\n]"}

实现密码登录

修改core.api文件，与登录功能相对应:

type LoginRequest {
	Name string `json: "name"`
	Password string `json: "password"`
}

type LoginReply {
	Token string `json:"token"`
}

service core-api {
	@handler User
	get /user/login(LoginRequest) returns (LoginReply)
}

LoginRequest封装了请求体结构，LoginRely对应响应体

定义好API文件后可以一键生成代码:

$ goctl api go -api core.api -dir . -style go_zero

会发现handler目录和logic目录下多了两个go文件

handler/user_handler.go:

package handler

import (
	"net/http"

	"cloud-disk/core/internal/logic"
	"cloud-disk/core/internal/svc"
	"cloud-disk/core/internal/types"
	"github.com/zeromicro/go-zero/rest/httpx"
)

func UserHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		var req types.LoginRequest
		if err := httpx.Parse(r, &req); err != nil {
			httpx.Error(w, err)
			return
		}

		l := logic.NewUserLogic(r.Context(), svcCtx)
		resp, err := l.User(&req)
		if err != nil {
			httpx.Error(w, err)
		} else {
			httpx.OkJson(w, resp)
		}
	}
}

logic/user_logic.go:

package logic

import (
	"context"

	"cloud-disk/core/internal/svc"
	"cloud-disk/core/internal/types"

	"github.com/zeromicro/go-zero/core/logx"
)

type UserLogic struct {
	logx.Logger
	ctx    context.Context
	svcCtx *svc.ServiceContext
}

func NewUserLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserLogic {
	return &UserLogic{
		Logger: logx.WithContext(ctx),
		ctx:    ctx,
		svcCtx: svcCtx,
	}
}

func (l *UserLogic) User(req *types.LoginRequest) (resp *types.LoginReply, err error) {
	// todo: add your logic here and delete this line

	return
}

编写user_logic.go文件，添加具体逻辑:

func (l *UserLogic) User(req *types.LoginRequest) (resp *types.LoginReply, err error) {
	// 从数据库中查询当前用户
	user := new(models.UserBasic)
	get, err := models.Engine.Where("name = ? AND password = ?",
		req.Name, helper.Md5(req.Password)).Get(user)
	if err != nil {
		return nil, err
	}
	if !get {
		return nil, errors.New("wrong username or password")
	}

	// 生成token
	token, err := helper.GenerateToken(user.Id, user.Identify, user.Name)
	if err != nil {
		return nil, err
	}
	resp = new(types.LoginReply)
	resp.Token = token

	return
}

创建user对应的结构体，使用Xorm进行数据查询，密码取md5值，调用Get方法将数据保存到user，之后调用了一个GenerateToken，通过用户的Id、Identify和Name生成Token值，将token赋值到响应中

创建helper包，在helper包中定义一个GenerateToken方法，生成Token值:

package helper

import (
	"cloud-disk/core/define"
	"crypto/md5"
	"fmt"
	"github.com/golang-jwt/jwt/v4"
)

func Md5(s string) string {
	return fmt.Sprintf("%x", md5.Sum([]byte(s)))
}

func GenerateToken(id int, identify, name string) (string, error) {
	uc := define.UserClaim{
		Id:       id,
		Identify: identify,
		Name:     name,
	}
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, uc)
	tokenString, err := token.SignedString([]byte(define.JwtKey))
	if err != nil {
		return "", err
	}
	return tokenString, nil
}

在GenerateToken方法中将三个参数赋值到一个UserClaim结构体中，定义如下:

type UserClaim struct {
	Id       int
	Identify string
	Name     string
	jwt.StandardClaims
}

使用jwt.NewWithClaims基于指定的加密算法和用户信息生成一个token，之后进行类型转换并返回

运行测试:

$ go run core.go -f etc/core-api.yaml
Starting server at 0.0.0.0:8888...

使用Postman进行测试:

服务端成功返回了token值

那么密码登录就实现了

用户详情信息

实现的功能是查询用户详细信息

继续修改api文件:

service core-api {
	// 用户登录
	@handler UserLogin
	get /user/login(LoginRequest) returns (LoginReply)

	// 用户详情
	@handler UserDetail
	get /user/detail(UserDetailRequest) returns (UserDetailReply)
}

type LoginRequest {
	Name     string `json:"name"`
	Password string `json:"password"`
}

type LoginReply {
	Token string `json:"token"`
}

type UserDetailRequest {
	Identity string `json:"identity"`
}

type UserDetailReply {
	Name  string `json:"name"`
	Email string `json:"email"`
}

将原来的User修改为UserLogin，添加UserDetail

使用命令，重新生成:

$ goctl api go -api core.api -dir . -style go_zero
etc/core-api.yaml exists, ignored generation
internal/config/config.go exists, ignored generation
core.go exists, ignored generation
internal/svc/service_context.go exists, ignored generation
Done.

将原来的User相关的代码迁移到UserLogin中，此处省略

下面编写UserLogin相关的逻辑，即编写login中user_detail_login的相关函数:

func (l *UserDetailLogic) UserDetail(req *types.UserDetailRequest) (resp *types.UserDetailReply, err error) {
	resp = &types.UserDetailReply{}
	ub := new(models.UserBasic)
	get, err := models.Engine.Where("identity=?", req.Identity).Get(ub)
	if err != nil {
		return nil, err
	}

	if !get {
		return nil, errors.New("user not found")
	}
	resp.Name = ub.Name
	resp.Email = ub.Email

	return
}

现在可以用identity进行用户信息的查询:

查询结果如上

发送验证码

验证码会发送到邮箱，而go程序想要发送邮件，可以安装一个库:

$ go get github.com/jordan-wright/email

编写发送邮件的测试函数:

package test

import (
	"cloud-disk/core/define"
	"crypto/tls"
	"github.com/jordan-wright/email"
	"net/smtp"
	"testing"
)

func TestSendMail(t *testing.T) {
	e := email.NewEmail()
	e.From = "Get <n3ptune@163.com>"
	e.To = []string{"1017042497@qq.com"}
	e.Subject = "test"
	e.HTML = []byte("<h1>您的验证码为: 123456</h1>")
	err := e.SendWithTLS(define.MailServer, smtp.PlainAuth("",
		define.MailUsername, define.MailPassword, define.MailHost),
		&tls.Config{InsecureSkipVerify: true, ServerName: define.MailHost},
	)
	if err != nil {
		t.Fatal(err)
	}
}

调用SendWithTLS即可发送邮件，参数要传入一系列关于认证的信息，这里使用的是163邮箱，定义在了define包下:

var (
	MailPassword = "邮箱授权码"
	MailServer   = "smtp.163.com:465"
	MailHost     = "smtp.163.com"
	MailUsername = "n3ptune@163.com"
)

运行这段代码就可以发送邮件

修改API文件，添加一个handler:

service core-api {
	.....
	@handler MailCodeSend
	post /mail/code/send(MailCodeSendRequest) returns (MailCodeSendReply)
}

添加请求体及其响应:

type MailCodeSendRequest {
	Email string `json:"email"`
}

type MailCodeSendReply {
	Code string `json:"code"`
}

再次使用goctl一键生成代码

在helper包中封装一个函数，用于发送邮件验证码:

func SendCode(mail, code string) error {
	e := email.NewEmail()
	e.From = "Get <n3ptune@163.com>"
	e.To = []string{mail}
	e.Subject = "test"
	e.HTML = []byte("<h1>您的验证码为: " + code + "</h1>")
	err := e.SendWithTLS(define.MailServer, smtp.PlainAuth("",
		define.MailUsername, define.MailPassword, define.MailHost),
		&tls.Config{InsecureSkipVerify: true, ServerName: define.MailHost},
	)
	if err != nil {
		return err
	}
	return nil
}

放到logic文件夹下:

func (l *MailCodeSendLogic) MailCodeSend(req *types.MailCodeSendRequest) (resp *types.MailCodeSendReply, err error) {
	err = helper.SendCode(req.Email, "123456")
	if err != nil {
		return nil, err
	}
	return
}

使用Postman进行测试:

响应回复200，说明邮件发送成功，可以到邮箱进行验证

用户注册

向用户的邮箱发送验证码，用户通过验证码来注册

添加一条handler:

@handler MailCodeSendRegister
post /mail/code/send/register(MailCodeSendRequest) returns (MailCodeSendReply)

使用goctl重新生成代码

下面要利用redis，装对应的包:

$ go get github.com/go-redis/redis/v8

在redis中添加一对键值用于测试:

127.0.0.1:6379> set name "test"
OK

写一段测试代码:

package test

import (
	"context"
	"github.com/go-redis/redis/v8"
	"testing"
	"time"
)

var ctx = context.Background()
var rdb = redis.NewClient(&redis.Options{
	Addr:     "localhost:6379",
	Password: "",
	DB:       0,
})

func TestSetValue(t *testing.T) {
	err := rdb.Set(ctx, "key", "value", time.Second*10).Err()
	if err != nil {
		t.Error(err)
	}
}

func TestGetValue(t *testing.T) {
	val, err := rdb.Get(ctx, "key").Result()
	if err != nil {
		t.Error(err)
	}
	t.Log(val)
}

这段代码用于测试redis，TestSetValue的作用是设置redis键值，TestGetValue的作用是获取值

在models包中添加一段初始化redis的代码:

var RDB = InitRedis()

func InitRedis() *redis.Client {
	return redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
}

这段代码可供其他包来调用，如下在logic目录下调用这段代码，设置一对有效的键值:

func (l *MailCodeSendRegisterLogic) MailCodeSendRegister(req *types.MailCodeSendRequest) (resp *types.MailCodeSendReply, err error) {
	code := helper.RandCode()
	// 发送验证码
	err = helper.SendCode(req.Email, code)
	models.RDB.Set(l.ctx, req.Email, code, time.Second*time.Duration(define.CodeExpire))
	return
}

CodeExpire是验证码过期时间，被定义在了define包中

RandCode用于生成一个随机验证码:

func RandCode() string {
	s := "1234567890"
	var code string
	rand.Seed(time.Now().UnixNano()) // 设置随机数种子
	for i := 0; i < define.CodeLength; i++ {
		code += string(s[rand.Intn(len(s))]) // 取随机数作为下标
	}
	return code
}

测试:

这时指定邮箱就会收到验证码，这个验证码同时也会被存入redis，可用来与用户输入进行校验

同时对于已经注册的邮箱会不予注册，要检查数据库是否已经存在该邮箱:

cnt, err := models.Engine.Where("email=?", req.Email).Count(new(models.UserBasic))
if err != nil {
	return nil, err
}
// 邮箱已经被注册
if cnt > 0 {
    err = errors.New("email exists")
    return
}

通过Where和Count方法，如果返回的个数大于0，说明已经存在了

上述实现的是发送验证码邮件，下面开始实现注册的逻辑

在API文件中添加一条handler:

@handler UserRegister
post /post/register(UserRegisterRequest) returns (UserRegisterReply)

在API文件中添加用户注册的请求体和响应体:

type UserRegisterRequest {
	Name     string `json:"name"`
	Password string `json:"password"`
	Email    string `json:"email"`
	Code     string `json:"code"`
}

type UserRegisterReply {
}

重新生成代码后，编写logic

func (l *UserRegisterLogic) UserRegister(req *types.UserRegisterRequest) (resp *types.UserRegisterReply, err error) {
	code, err := models.RDB.Get(l.ctx, req.Email).Result()
	if err != nil {
		return nil, errors.New("email verification code not exists")
	}
	if code != req.Code {
		err = errors.New("verification code incorrect")
		return
	}
	// 判断用户名是否存在
	cnt, err := models.Engine.Where("name=?", req.Name).Count(new(models.UserBasic))
	if err != nil {
		return nil, err
	}
	if cnt > 0 {
		err = errors.New("user exists")
		return nil, err
	}
	user := &models.UserBasic{
		Identity: helper.UUID(),
		Name:     req.Name,
		Password: helper.Md5(req.Password),
		Email:    req.Email,
	}
	n, err := models.Engine.Insert(user)
	if err != nil {
		return nil, err
	}
	log.Println("insert user row:", n)

	return
}

首先从redis中以email为键查询验证码，判断用户发送的验证码是否正确，如果验证码正确则检查该用户名是否已经在数据库中已经存在，如果不存在则注册用户，其中生成一个UUID作为Identity，密码要进行MD5加密，将用户信息插入数据库中，将借助第三方库生成UUID:

func UUID() string {
	return uuid.NewV4().String()
}

测试时首先向mail/code/send/register发送一条POST请求，请求邮箱验证

随后查看邮箱得到验证码，再发送一次POST请求，用于注册

注册成功的话，会返回200

检查数据库，可以看到数据插入成功，就代表用户注册成功了

配置文件

将代码中所需的配置信息放到yaml文件中，在etc下的yaml文件中添加内容

Mysql:
  DataSource: golang:123456@/cloud_disk?charset=utf8
Redis:
 Addr: localhost:6379

上面加上了mysql和redis的相关信息

在config.go中添加一个config结构体:

type Config struct {
	rest.RestConf
	Mysql struct {
		DataSource string
	}
	Redis struct {
		Addr string
	}
}

在service_context.go中初始化两个数据库的连接:

type ServiceContext struct {
	Config config.Config
	Engine *xorm.Engine
	RDB    *redis.Client
}

func NewServiceContext(c config.Config) *ServiceContext {
	return &ServiceContext{
		Config: c,
		Engine: models.Init(c.Mysql.DataSource),
		RDB:    models.InitRedis(c),
	}
}

重写Init函数:

func Init(dataSource string) *xorm.Engine {
	engine, err := xorm.NewEngine("mysql", "golang:123456@/cloud_disk?charset=utf8")
	if err != nil {
		log.Println("Xorm New Engine Error:", err)
		return nil
	}
	return engine
}

func InitRedis(c config.Config) *redis.Client {
	return redis.NewClient(&redis.Options{
		Addr:     c.Redis.Addr,
		Password: "",
		DB:       0,
	})
}

原来的变量赋值就不需要了，其他代码也要稍作改动

上传文件到COS

注册一个腾讯云COS，创建一个存储桶:

Go SDK文档: https://cloud.tencent.com/document/product/436/31215

下载SDK:

$ go get -u github.com/tencentyun/cos-go-sdk-v5

编写一段测试代码:

package test

import (
	"cloud-disk/core/define"
	"context"
	"fmt"
	"github.com/tencentyun/cos-go-sdk-v5"
	"net/http"
	"net/url"
	"testing"
)

func TestFileUploadByFilepath(t *testing.T) {
	u, _ := url.Parse("https://microdisk-1307366489.cos.ap-shanghai.myqcloud.com")
	b := &cos.BaseURL{BucketURL: u}
	client := cos.NewClient(b, &http.Client{
		Transport: &cos.AuthorizationTransport{
			SecretID:  define.TencentSecretID,  // 腾讯云SecretID
			SecretKey: define.TencentSecretKey, // 腾讯云SecretKey
		},
	})

	key := "mircodisk/apple.jpg"

	_, _, err := client.Object.Upload(
		context.Background(), key, "../file/apple.jpg", nil,
	)
	if err != nil {
		panic(err)
	}
}

根据SDK文档给出的代码稍作修改，实现文件的上传，在Upload函数中传入目标路径和要上传的文件的路径，即可将文件上传

还有一种PUT上传方式，要传入的是一个io.Reader:

func TestFileUploadByReader(t *testing.T) {
	u, _ := url.Parse("https://microdisk-1307366489.cos.ap-shanghai.myqcloud.com")
	b := &cos.BaseURL{BucketURL: u}
	client := cos.NewClient(b, &http.Client{
		Transport: &cos.AuthorizationTransport{
			SecretID:  define.TencentSecretID,
			SecretKey: define.TencentSecretKey,
		},
	})

	key := "mircodisk/test.jpg"

	f, err := os.ReadFile("../file/apple.jpg")
	if err != nil {
		return
	}

	_, err = client.Object.Put(
		context.Background(), key, bytes.NewReader(f), nil,
	)
	if err != nil {
		panic(err)
	}
}

接下来实现文件上传的逻辑

在API文件中添加Handler:

@handler FileUpload
post /file/upload(FileUploadRequest) returns (FileUploadReply)

在API文件中添加请求体:

type FileUploadRequest {
	Hash string `json:"hash,optional"`
	Name string `json:"name,optional"`
	Ext  string `json:"ext,optional"`
	Size int64  `json:"size,optional"`
	Path string `json:"path,optional"`
}

type FileUploadReply {
	Identity string `json:"identity"`
}

然后重新生成代码

在helper包中添加一段函数:

func CosUpload(r *http.Request) (string, error) {
	u, _ := url.Parse(define.CosBucket)
	b := &cos.BaseURL{BucketURL: u}
	client := cos.NewClient(b, &http.Client{
		Transport: &cos.AuthorizationTransport{
			SecretID:  define.TencentSecretID,
			SecretKey: define.TencentSecretKey,
		},
	})

	file, fileHeader, err := r.FormFile("file")
	key := "mircodisk/" + UUID() + path.Ext(fileHeader.Filename)

	_, err = client.Object.Put(
		context.Background(), key, file, nil,
	)
	if err != nil {
		panic(err)
	}
	return define.CosBucket + "/" + key, nil
}

该函数的作用是上传文件到COS，并返回地址，其中的FormFile的方法获取到文件的信息

在models中抽象respository_pool，作用于xorm:

type RepositoryPool struct {
	Id        int
	Identity  string
	Hash      string
	Name      string
	Ext       string
	Size      int64
	Path      string
	CreatedAt time.Time `xorm:"created"`
	UpdatedAt time.Time `xorm:"updated"`
	DeletedAt time.Time `xorm:"deleted"`
}

func (table RepositoryPool) TableName() string {
	return "repository_pool"
}

编写handler下的与FileUpload相关的代码:

func FileUploadHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		var req types.FileUploadRequest
		if err := httpx.Parse(r, &req); err != nil {
			httpx.Error(w, err)
			return
		}

		file, fileHeader, err := r.FormFile("file")
		if err != nil {
			return
		}
		b := make([]byte, fileHeader.Size)
		_, err = file.Read(b)
		if err != nil {
			return
		}
		hash := fmt.Sprintf("%x", md5.Sum(b))
		rp := new(models.RepositoryPool)
		has, err := svcCtx.Engine.Where("hash=?", hash).Get(rp)
		if err != nil {
			return
		}

		if has {
			httpx.OkJson(w, &types.FileUploadReply{Identity: rp.Identity})
			return
		}

		cosPath, err := helper.CosUpload(r)
		if err != nil {
			return
		}

		req.Name = fileHeader.Filename
		req.Ext = path.Ext(fileHeader.Filename)
		req.Size = fileHeader.Size
		req.Hash = hash
		req.Path = cosPath

		l := logic.NewFileUploadLogic(r.Context(), svcCtx)
		resp, err := l.FileUpload(&req)
		if err != nil {
			httpx.Error(w, err)
		} else {
			httpx.OkJson(w, resp)
		}
	}
}

文件上传后，对文件取哈希值，若数据库中已经存在哈希值，则视为文件重复

在logic中编写如下代码:

func (l *FileUploadLogic) FileUpload(req *types.FileUploadRequest) (resp *types.FileUploadReply, err error) {
	rp := &models.RepositoryPool{
		Identity:  helper.UUID(),
		Hash:      req.Hash,
		Name:      req.Name,
		Ext:       req.Ext,
		Size:      req.Size,
		Path:      req.Path,
		CreatedAt: time.Time{},
		UpdatedAt: time.Time{},
		DeletedAt: time.Time{},
	}

	_, err = l.svcCtx.Engine.Insert(rp)
	if err != nil {
		return nil, err
	}
	resp = new(types.FileUploadReply)
	resp.Identity = rp.Identity

	return
}

这段代码在文件上传时，将数据插入数据库