个人中心
gpt4 book ai didi

Go实现短url项目的方法示例

转载 作者：qq735679552 更新时间：2022-09-29 22:32:09 26 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Go实现短url项目的方法示例由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

首先说一下这种业务的应用场景： 1.把一个长url转换为一个短url网址 2.主要用于微博，二维码，等有字数限制的场景 。

主要实现的功能分析： 1.把长url的地址转换为短url地址 2.通过短url获取对应的原始长url地址 3.相同长url地址是否需要同样的短url地址 。

这里实现的是一个api服务 。

Go实现短url项目的方法示例

数据库设计 。

数据库的设计其实也没有非常复杂，如图所示:

Go实现短url项目的方法示例

这里有个设置需要主要就是关于数据库表中id的设计，需要设置为自增的 。

并且这里有个问题需要提前知道，我们的思路是根据id的值会转换为62进制关于进制转换的代码为:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 将十进制转换为62进制  0-9a-zA-Z 六十二进制
func transTo62(id int64)string{
   // 1 -- > 1
   // 10-- > a
   // 61-- > Z
   charset := "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
   var shortUrl []byte
   for{
     var result byte
     number := id % 62
     result = charset[number]
     var tmp []byte
     tmp = append(tmp,result)
     shortUrl = append(tmp,shortUrl...)
     id = id / 62
     if id == 0{
       break
     }
   }
   fmt.Println(string(shortUrl))
   return string(shortUrl)
}

所以这里需要设置一下数据库id的起始值，可以设置的大一点，这样转换为62进制之后不至于太短 。

代码逻辑 。

项目完整的代码git地址：https://github.com/pythonsite/go_simple_code/tree/master/short_url 当然这里的代码还有待后面继续做优化，但是这里通过golang内置的net/http 库实现了一个简单的api功能 。

代码的目录结构 。

?
1
2
3
4
5
6
7
8
|____logic
| |____logic.go
|____model
| |____data.go
|____api
| |____api.go
|____client
| |____client.go

logic目录为主要的处理逻辑 model是定义了request和response结构体 api目录为程序的入口程序 client 为测试请求，进行地址的转换 。

model 代码为:

?
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
package model
 
 
type Long2ShortRequest struct {
   OriginUrl string `json:"origin_url"`
}
 
type ResponseHeader struct {
   Code int `json:"code"`
   Message string `json:"message"`
}
 
type Long2ShortResponse struct {
   ResponseHeader
   ShortUrl string `json:"short_url"`
}
 
type Short2LongRequest struct {
   ShortUrl string `json:"short_url"`
}
 
type Short2LongResponse struct {
   ResponseHeader
   OriginUrl string `json:"origin_url"`
}

logic的代码为:

?
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
package logic
 
import(
   "go_dev/11/short_url/model"
   "github.com/jmoiron/sqlx"
   "fmt"
   "crypto/md5"
   "database/sql"
)
 
var (
   Db *sqlx.DB
)
 
type ShortUrl struct {
   Id int64 `db:"id"`
   ShortUrl string `db:"short_url"`
   OriginUrl string `db:"origin_url"`
   HashCode string `db:"hash_code"`
}
 
func InitDb(dsn string)(err error) {
   // 数据库初始化
   Db, err = sqlx.Open("mysql",dsn)
   if err != nil{
     fmt.Println("connect to mysql failed:",err)
     return
   }
   return
}
 
func Long2Short(req *model.Long2ShortRequest) (response *model.Long2ShortResponse, err error) {
   response = &model.Long2ShortResponse{}
   urlMd5 := fmt.Sprintf("%x",md5.Sum([]byte(req.OriginUrl)))
   var short ShortUrl
   err = Db.Get(&short,"select id,short_url,origin_url,hash_code from short_url where hash_code=?",urlMd5)
   if err == sql.ErrNoRows{
     err = nil
     // 数据库中没有记录，重新生成一个新的短url
     shortUrl,errRet := generateShortUrl(req,urlMd5)
     if errRet != nil{
       err = errRet
       return
     }
     response.ShortUrl = shortUrl
     return
   }
   if err != nil{
     return
   }
   response.ShortUrl = short.ShortUrl
   return
}
 
func generateShortUrl(req *model.Long2ShortRequest,hashcode string)(shortUrl string,err error){
   result,err := Db.Exec("insert INTO short_url(origin_url,hash_code)VALUES (?,?)",req.OriginUrl,hashcode)
   if err != nil{
     return
   }
   // 0-9a-zA-Z 六十二进制
   insertId,_:= result.LastInsertId()
   shortUrl = transTo62(insertId)
   _,err = Db.Exec("update short_url set short_url=? where id=?",shortUrl,insertId)
   if err != nil{
     fmt.Println(err)
     return
   }
   return
}
 
// 将十进制转换为62进制  0-9a-zA-Z 六十二进制
func transTo62(id int64)string{
   // 1 -- > 1
   // 10-- > a
   // 61-- > Z
   charset := "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
   var shortUrl []byte
   for{
     var result byte
     number := id % 62
     result = charset[number]
     var tmp []byte
     tmp = append(tmp,result)
     shortUrl = append(tmp,shortUrl...)
     id = id / 62
     if id == 0{
       break
     }
   }
   fmt.Println(string(shortUrl))
   return string(shortUrl)
}
 
 
func Short2Long(req *model.Short2LongRequest) (response *model.Short2LongResponse, err error) {
   response = &model.Short2LongResponse{}
   var short ShortUrl
   err = Db.Get(&short,"select id,short_url,origin_url,hash_code from short_url where short_url=?",req.ShortUrl)
   if err == sql.ErrNoRows{
     response.Code = 404
     return
   }
   if err != nil{
     response.Code = 500
     return
   }
   response.OriginUrl = short.OriginUrl
   return
}

api的代码为:

?
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
package main
 
import (
   "io/ioutil"
   "net/http"
   "fmt"
   "encoding/json"
   "go_dev/11/short_url/logic"
   "go_dev/11/short_url/model"
   _ "github.com/go-sql-driver/mysql"
)
 
const (
   ErrSuccess = 0
   ErrInvalidParameter = 1001
   ErrServerBusy = 1002
)
 
func getMessage(code int) (msg string){
   switch code {
   case ErrSuccess:
     msg = "success"
   case ErrInvalidParameter:
     msg = "invalid parameter"
   case ErrServerBusy:
     msg = "server busy"
   default:
     msg = "unknown error"
   }
 
   return
}
 
// 用于将返回序列化数据，失败的返回
func responseError(w http.ResponseWriter, code int) {
   var response model.ResponseHeader
   response.Code = code
   response.Message = getMessage(code)
 
   data, err := json.Marshal(response)
   if err != nil {
     w.Write([]byte("{\"code\":500, \"message\": \"server busy\"}"))
     return
   }
 
   w.Write(data)
}
 
// 用于将返回序列化数据，成功的返回
func responseSuccess(w http.ResponseWriter, data interface{}) {
 
 
   dataByte, err := json.Marshal(data)
   if err != nil {
     w.Write([]byte("{\"code\":500, \"message\": \"server busy\"}"))
     return
   }
 
   w.Write(dataByte)
}
 
// 长地址到短地址
func Long2Short(w http.ResponseWriter, r *http.Request) {
   // 这里需要说明的是发来的数据是通过post发过来一个json格式的数据
   data, err := ioutil.ReadAll(r.Body)
   if err != nil {
     fmt.Println("read all failded, ", err)
     responseError(w, 1001)
     return
   }
 
   var req model.Long2ShortRequest
   // 将反序列化的数据保存在结构体中
   err = json.Unmarshal(data, &req)
   if err != nil {
     fmt.Println("Unmarshal failded, ", err)
     responseError(w, 1002)
     return
   }
 
   resp, err := logic.Long2Short(&req)
   if err != nil {
     fmt.Println("Long2Short failded, ", err)
     responseError(w, 1003)
     return
   }
 
   responseSuccess(w, resp)
}
 
// 短地址到长地址
func Short2Long(w http.ResponseWriter, r *http.Request) {
   // 这里需要说明的是发来的数据是通过post发过来一个json格式的数据
   data, err := ioutil.ReadAll(r.Body)
   if err != nil {
     fmt.Println("read all failded, ", err)
     responseError(w, 1001)
     return
   }
 
   var req model.Short2LongRequest
   // 将反序列化的数据保存在结构体中
   err = json.Unmarshal(data, &req)
   if err != nil {
     fmt.Println("Unmarshal failded, ", err)
     responseError(w, 1002)
     return
   }
 
   resp, err := logic.Short2Long(&req)
   if err != nil {
     fmt.Println("Long2Short failded, ", err)
     responseError(w, 1003)
     return
   }
   responseSuccess(w, resp)
}
 
func main(){
   err := logic.InitDb("root:123456@tcp(192.168.50.145:3306)/short_url?parseTime=true")
   if err != nil{
     fmt.Printf("init db failed,err:%v\n",err)
     return
   }
   http.HandleFunc("/trans/long2short", Long2Short)
   http.HandleFunc("/trans/short2long", Short2Long)
   http.ListenAndServe(":18888", nil)
}

小结 。

这次通过这个小代码对go也有了一个初步的认识和使用，同时也通过net/http 包实现了api的功能，也对其基本使用有了大致了解 。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我.

原文链接：http://www.cnblogs.com/zhaof/p/8576946.html 。

最后此篇关于Go实现短url项目的方法示例的文章就讲到这里了,如果你想了解更多关于Go实现短url项目的方法示例的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

26 4 0
文章推荐： GoLang 中的随机数的示例代码
文章推荐： 使用Go语言实现配置文件热加载功能
文章推荐： Mac上Go环境和VS Code的正确安装与配置方法
文章推荐： Golang中文字符串截取函数实现原理
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com