客户需求：网站禁止国内访问

本范例采用golang实现了一个最简单web server，缓存使用的memcached，数据库使用的sqlite3。

 

实现原理是：浏览器访问网站，服务器获取客户端的ip地址，先在缓存里查找；缓存里没有，就去数据库查找；数据库里没有，就去公开服务器获取。例如访问 http://ip-api.com/json/45.65.32.46，返回的countryCode是FR。获取成功就保存到数据库。下次如果还是这个ip就不用去访问别人的网站了，自己本地也能获得一份比较完整的ip归属地表。

memcached服务端在这里下载：https://www.runoob.com/Memcached/window-install-memcached.html

运行前先获取库：

go get github.com/bradfitz/gomemcache/memcache
go get github.com/mattn/go-sqlite3

看完整代码：

package main

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"strings"

	"github.com/bradfitz/gomemcache/memcache"
	_ "github.com/mattn/go-sqlite3"
)

var (
	//Memcached缓存
	//直接运行下载的文件即可https://www.runoob.com/Memcached/window-install-memcached.html
	server = "127.0.0.1:11211"
)

var mc *memcache.Client

//读缓存,缓存没有，就去数据库读。
func memGet(key string) string {
	it, err := mc.Get(key)
	if err != nil {
		fmt.Println(err.Error())

	} else {
		if string(it.Key) == key {
			//fmt.Println("value is ", string(it.Value))
			return string(it.Value)
		} else {
			fmt.Println("Get failed")
			return ""
		}
	}

	sqlstr := fmt.Sprintf("SELECT * FROM ip_info where ip='%s'", key)
	fmt.Println(sqlstr)
	rows, err := db.Query(sqlstr)
	if err != nil {
		fmt.Println(err.Error())
	} else {
		var ip, countryCode string
		for rows.Next() {
			err = rows.Scan(&ip, &countryCode)
			if err != nil {
				fmt.Println(err.Error())
			}
			fmt.Println(countryCode)
			if countryCode != "" {
				memSet(ip, countryCode)
				return countryCode
			}
		}
		rows.Close()
	}

	return ""
}

//写缓存
func memSet(key, value string) {
	mc.Set(&memcache.Item{Key: key, Value: []byte(value)})
	stmt, err := db.Prepare("INSERT INTO ip_info(ip, countryCode) values(?,?)")
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	_, err = stmt.Exec(key, value)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
}

//初始化数据
var db *sql.DB
var gerr error

func init_data() {
	db, gerr = sql.Open("sqlite3", "./sqlite3.db")
	if gerr != nil {
		fmt.Println(gerr.Error())
		return
	}
	//创建表
	sql_table := `
    CREATE TABLE IF NOT EXISTS ip_info(
        ip VARCHAR(20) NULL PRIMARY KEY,
        countryCode VARCHAR(5) NULL
    );
    `

	db.Exec(sql_table)

	mc = memcache.New(server)
	if mc == nil {
		fmt.Println("memcache New failed")
	}
}

//通过HTTP请求获取请求端ip
func get_remote_ip(r *http.Request) string {
	remote_ip := r.Header.Get("x-forwarded-for") //通过反向代理访问的
	if remote_ip == "" {
		//直接访问的
		RemoteAddr := r.RemoteAddr
		if strings.Contains(r.RemoteAddr, ":") {
			RemoteAddr_Port := strings.Split(r.RemoteAddr, ":")
			remote_ip = RemoteAddr_Port[0]
		} else {
			remote_ip = RemoteAddr
		}
	}
	return remote_ip
}

func httpget(url string) string {
	resp, err := http.Get(url)
	if err != nil {
		fmt.Println(err)
		return ""
	}
	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	//fmt.Println(resp.StatusCode)
	if resp.StatusCode == 200 {
		//fmt.Println("ok")
	}
	return string(body)
}

type LocationRsp struct {
	CountryCode string `json:"countryCode"`
}

//ip地址转归属地
func ip2location(ip string) string {
	m := memGet(ip) //应用层只操作缓存，缓存里操作数据库
	if m != "" {
		return m
	}

	rsp := httpget("http://ip-api.com/json/" + ip)
	//fmt.Println(rsp)

	var location LocationRsp
	err := json.Unmarshal([]byte(rsp), &location)
	if err != nil {
		return ""
	} else {
		fmt.Println(location.CountryCode)
		if location.CountryCode != "" {
			memSet(ip, location.CountryCode)
			return location.CountryCode
		}
	}
	return ""
}

//处理http请求
func indexHandler(w http.ResponseWriter, r *http.Request) {
	remote_ip := get_remote_ip(r)
	location := ip2location(remote_ip)
	fmt.Fprintf(w, "您的访问请求来自:"+location)
}

//程序主入口
func main() {
	init_data()
	http.HandleFunc("/", indexHandler)
	http.ListenAndServe(":8000", nil)
}