入坑第五式 - 短域名 - 《Golang 入坑之旅》

短域名

短域名

为啥叫匕首？是因为本节我们来构建一个短域名工具。短域名，顾名思义就是会将一个很长的域名压缩成一个非常短的域名。短域名主要是容易分发，但说实话真不容易记。但这个缺点却无关紧要，因为让你背下一个长域名也是不可能的事情。

因此短域名就好比一个短匕首，短小精悍易于携带。一个典型的短域名工具，大致来说会有这么几个组件:

长短翻译组件
查询组件
持久化组件
其它组件
先声明一下，这些组件名称不是标准名称，而是我自创的。长短翻译组件，是将一个长域名(譬如:https://xxxxxx/xxxxx?zzzzzz 这样的域名翻译成短域名(https://xxx/xxxxx )。在翻译过程当中，需要做两件事：一、确定当前的长域名是否存在相对应的短域名，如果不吝惜存储，其实这部可以忽略。二、保证不会生成重复的短域名，这一点必须保证。

而查询组件，就是用来确定当前的长域名是否存在相对应的短域名。上面说过如果不吝惜存储，那么这步可以省略。此话怎么理解呢？对于一个短域名工具来说，有一个数据指标很重要：跳转速度！用户可以容忍工具生成域名的时候慢一些，但不能容忍这个短域名跳转的时候慢。所以毋庸置疑，所有的域名配对数据必须保存在内存当中，还必须使用一种高效的数据结构来保存这些配对结构。对于搜索的算法复杂度最好做到O(1)(常数时间)。

那么此时此刻问题就来了，内存相对于磁盘来说是一种稀缺资源，应该如何尽可能的有效利用内存呢？一个思路是去重。另外一个思路是LRU方案。查询组件就是用来去重的，我们的短域名工具可以在翻译之前，先查询一下当前域名是否处理过。如果处理过，直接返回相对应的短域名，如果没有处理过，再继续翻译。而LRU方案，可以自己实现也可以通过第三方工具来实现。我的方案是借助于Redis来实现，虽然增加了架构复杂度和降低了一些处理性能，但保证了LRU的准确性和稳定性，利大于弊。

持久化组件，则是用来容灾的。因为所有数据都在内存当中，所以必须要有持久化方案，否则一旦出现数据丢失，用户体验就会直线下降。

其它组件，就包括数据统计，流量管控，自定义域名格式等等辅助组件了。所以这个短域名工具大致的架构图如下:

好，让我们撸起袖子开始写吧。

首先是数据加载模块。也就是从持久化数据里面加载数据，为了简便，我们用文件来替代Redis。

// SO 保存短URL和原始URL对应关系
type SO struct {
    Surl string `json:"surl"`
    Ourl string `json:"ourl"`
}
func datainit() (map[string]*SO, map[string]*SO, error) {
    dir := os.Getenv("FLAK_CONF_DIR")
    if dir == "" {
        golog.Error("PLEASE SETTING FLAK_CONF_DIR! ")
        return nil, nil, errors.New("PLEASE SETTING FLAK_CONF_DIR")
    }
    urlFile := dir + PERSISTENCE
    u := make([]SO)
    data, err := ioutil.ReadFile(urlFile)
    if err != nil {
        golog.Error(err.Error())
        return nil, nil, err
    }
    err = json.Unmarshal(data, &u)
    if err != nil {
        golog.Error(err.Error())
        return nil, nil, err
    }
    urlMap := make(map[string]*SO)
    destMap := make(map[string]*SO)
    for _, su := range u.S {
        urlMap[su.Surl] = &su
        destMap[su.Ourl] = &su
    }
    return urlMap, destMap, nil
}

FLAK_CONF_DIR 是持久化文件所在目录

通过os.Getenv("FLAK_CONF_DIR")就可以读取到当前的环境变量，但需要注意如果变量为空，则返回的dir则有可能为空。所以需要判断一下。然后就可以通过ioutil.ReadFile(urlFile)来读取文件里面的数据，目前我们的数据不多，一个文件就能存下了。当数据量大的时候，就不能使用文件做持久化了，上一个DB就是很自然的事情了。

前面几式中，我们也没有提过如何使用Golang来处理Json数据，正好这里就补上。如果要将一个文本里的数据转成Json结构，那就先通过ioutil.ReadFile来读取文本里的数据，而后通过json.Unmarshal来反序列化成Json结构。例如上面的:

err = json.Unmarshal(data, &u)

通过上面的datainit函数，我们就加载了持久化之后的数据。

现在让我们开始编写翻译组件吧

func createSUrl(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    surl := vars["url"]
    if d[surl] != nil {
        Sandstorm.HTTPSuccess(w, DHOST+"/"+d[surl].Surl)
        return
    }
    le := 10
    length := os.Getenv("FLAK_URL_LENGTH")
    if length == "" {
        golog.Error("PLEASE SETTING FLAK_URL_LENGTH! GIVE IT DEFAULT VALUE")
    }
    le, err := strconv.Atoi(length)
    if err != nil {
        golog.Error("FLAK_URL_LENGTH WRONG!", length)
        le = 10
    }
    shortUlr := string(Krand(le, KC_RAND_KIND_ALL))
    so := &SO{
        Surl: shortUlr,
        Ourl: surl,
    }
    u[shortUlr] = so
    d[surl] = so
    Sandstorm.HTTPSuccess(w, DHOST+"/"+shortUlr)
}

surl是source url的缩写，表示的是准备翻译的长域名。d[surl]用来判断当前这个长域名是否被处理过，d此时此刻就是destMap。这一步充当了查询组件的角色，还是要说明一下，当前没有使用Redis，如果使用了Redis，这一步应该是在Redis中查询surl是否存在。

如果d[surl]!=nil说明surl被处理过，就直接返回相对应的短域名。如果等于nil，则继续处理。

我们用Krand函数来生成随机字符串,

// 随机字符串
func Krand(size int, kind int) []byte {
    ikind, kinds, result := kind, [][]int{[]int{10, 48}, []int{26, 97}, []int{26, 65}}, make([]byte, size)
    is_all := kind > 2 || kind < 0
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < size; i++ {
        if is_all { // random ikind
            ikind = rand.Intn(3)
        }
        scope, base := kinds[ikind][0], kinds[ikind][1]
        result[i] = uint8(base + rand.Intn(scope))
    }
    return result
}

在Krand函数里面，使用当前时间戳做随机种子，这样尽可能的保证唯一性。但还没有考虑分布式的环境，如果在分布式环境中，应该再添加每台机器的机器ID，这样就能保证唯一性。

通过Krand就生成了一个混合大小写和数字的10位字符串，也就生成了一个短域名。当用户发起一个短域名访问请求时，我们就可以反向查询短域名所对应的长域名:

func getOUrl(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    surl := vars["url"]
    golog.Debug("NEW FORWARD", surl)
    if u[surl] == nil {
        Sandstorm.HTTPError(w, "", http.StatusNotFound)
        return
    }
    newURL := HOST + "/" + u[surl].Ourl
    golog.Debug("NEWURL:", newURL)
    Sandstorm.DisDebug()
    re := make(map[string]string)
    re["Location"] = newURL
    Sandstorm.HTTPReDirect(w, r, re)
}

然后返回一个302状态码，在Localtion放入相对应的长域名。这样用户端的浏览器(假设是浏览器发起的访问)就可以跳转到相对应的长域名了。

基本工作就这些了，还有一些收尾的动作。比如持久化，再开头的时候，我们只加载了数据，这里需要定时将内存数据写入到文本当中

// SaveData 定时备份数据
func SaveData() {
    c := time.Tick(time.Duration(1) * time.Minute)
    for _ = range c {
        persistence()
    }
}
// persistence 将缓存中的数据持久化到文件中
func persistence() {
    url := new(URL)
    sarray := make([]SO, len(u))
    i := 0
    for k := range u {
        sarray[i] = *u[k]
        i++
    }
    url.S = sarray
    data, err := json.Marshal(url)
    if err != nil {
        golog.Error(err.Error())
        return
    }
    dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
    if err != nil {
        golog.Error(err.Error())
        return
    }
    urlFile := dir + PERSISTENCE
    err = ioutil.WriteFile(urlFile, data, 0644)
    if err != nil {
        golog.Error(err.Error())
        return
    }
}

按照加载的逆向顺序来做就OK了。

此时各个零件都写完了，我们来写个main函数把零件都串起来:

package main
import (
    "log"
    "net/http"
    "os"
    "github.com/andy-zhangtao/golog"
    "github.com/gorilla/mux"
)
var (
    // u 以短url为key保存对应关系
    u = make(map[string]*SO)
    // d 以目的url为key保存对应关系
    d = make(map[string]*SO)
)
func main() {
    var err error
    if len(os.Args) != 2 {
        golog.Error("FLAK NEED A PORT!!")
        os.Exit(-1)
    }
    golog.Debug("FLAK START ON ", os.Args[1])
    u, d, err = datainit()
    if err != nil {
        golog.Error("INIT FAILED ", err.Error())
        os.Exit(-1)
    }
    go SaveData()
    r := mux.NewRouter()
    r.HandleFunc("/{url}", getOUrl).Methods(http.MethodGet)
    r.HandleFunc(CREATE+"{url}", createSUrl).Methods(http.MethodGet)
    log.Println(http.ListenAndServe(":"+os.Args[1], r))
}

在main当中，我们暴露了两个API:/create/{url}和/{url}，分别是用来创建短域名和使用短域名的。上面所有代码可以在https://github.com/andy-zhangtao/Flak 中看到源码。

通过上面的编码，一个最简单的短域名工具就完成了。