首先说一下这种业务的应用场景：
1.把一个长url转换为一个短url网址
2.主要用于微博，二维码，等有字数限制的场景
主要实现的功能分析：
1.把长url的地址转换为短url地址
2.通过短url获取对应的原始长url地址
3.相同长url地址是否需要同样的短url地址
这里实现的是一个api服务
数据库设计
数据库的设计其实也没有非常复杂，如图所示：
这里有个设置需要主要就是关于数据库表中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 modeltype 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 logicimport( "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 mainimport ( "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
