最近接触了一下微信公众号开发，刚好很久很久之前申请过一个公众号，看了下API文档，用go实现了一个简单的获取 access_token的功能。 下面的代码可以从微信服务器获取access_tokens，并保存在内存中，然后其他程序可以通过http请求获取到内存中的 access_token，超时的时候，还会自动重新从微信服务器获取新的access_tokens。 只需要配置 config.json文件即可,config.json和main.go文件处于同一目录层级，config.json格式文件配置如下:

{

“appid”:”XXX”,

“secret”:”XXX”,

“token”:”XXX”,

“port”:”7001”

}

其中 appid,secret以及token需要在微信公众平台获取相关信息。

port 则是你使用的监听接口，即其他人通过这个接口获取access_tokens。 获取的方式是通过浏览器访问你的 url地址+/token 后缀。

运行时，输入 go run main.go config.json 即可

代码： main.go

package main

import (

“bytes”

“encoding/json”

“io/ioutil”

“log”

“net/http”

“os”

“time”

)

const wx_params_timestamp string = “timestamp”

const wx_params_signature string = “signature”

const wx_params_nonce string = “nonce”

const wx_params_echostr string = “echostr”

const wx_access_token_key string = “access_token”

const wx_access_token_time_key string = “expires_in”

const wx_access_token_error_code string = “errcode”

const wx_access_token_error_msg string = “errmsg”

//

var wx_gzh_token_str string

var wx_gzh_appid string

var wx_gzh_secret string

var global_access_token string

var global_access_token_time_out int64

type SConsConfig struct {

Appid string `json:”appid”`

Secret string `json:”secret”`

Token string `json:”token”`

Port string `json:”port”`

}

func NewJsonStruct() *SConsConfig {

return &SConsConfig{}

}

func (jst *SConsConfig) LoadConfig(fileName string, v interface{}) {

data, err := ioutil.ReadFile(fileName)

if err != nil {

return

}

err = json.Unmarshal(data, v)

if err != nil {

return

}

}

func ParseSconsConfig(fileName string) (v SConsConfig, err error) {

JsonParse := NewJsonStruct()

v = SConsConfig{}

JsonParse.LoadConfig(fileName, &v)

return v, nil

}

type wx_access_token_center_handler struct{}

func (h *wx_access_token_center_handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {

log.Println(“somebody require token”)

current_time := time.Now().Unix()

if current_time > global_access_token_time_out {

log.Println(“token timetou ,require from wx………..”)

GetAccessToken(wx_gzh_appid, wx_gzh_secret)

} else {

log.Println(“token is valid,require from local”)

}

w.Write([]byte(global_access_token))

}

func ParseTokens(str string) {

decoder := json.NewDecoder(bytes.NewBufferString(str))

decoder.UseNumber()

var result map[string]interface{}

if err := decoder.Decode(&result); err != nil {

log.Println(“json parse failed,str=”, str, “\nerr=”, err)

os.Exit(1)

}

log.Println(“parse”, str, “json”)

if _, ok := result[wx_access_token_error_code]; ok {

log.Println(“error token,code=”, result[wx_access_token_error_code])

log.Println(“errmsg=”, result[wx_access_token_error_msg])

}

access_token := result[wx_access_token_key]

access_token_value, ok := access_token.(string)

if !ok {

log.Println(“parse access_token failed,access_token=”, access_token)

}

log.Println(“access_token_value:”, access_token_value)

time_num := result[wx_access_token_time_key]

time_num_value, err := time_num.(json.Number).Int64()

if err != nil {

log.Println(“parase time_num failed,time_num=”, time_num)

}

log.Println(“time:”, time_num_value)

current_time := time.Now().Unix()

global_access_token = access_token_value

global_access_token_time_out = current_time + time_num_value

formatTimeStr := time.Unix(global_access_token_time_out, 0).Format(“2006-01-02 15:04:05”)

log.Println(“success parse json,token will be timeout at “, global_access_token_time_out, “,”, formatTimeStr)

}

func GetAccessToken(appid string, secret string) {

params := “/cgi-bin/token?grant_type=client_credential&appid=” + appid + “&secret=” + secret

urls := []string{“api.weixin.qq.com”, “api2.weixin.qq.com”, “sh.api.weixin.qq.com”, “sz.api.weixin.qq.com”, “hk.api.weixin.qq.com”}

success := false

for _, v := range urls {

url := “https://“ + v + params

resp, err := http.Get(url)

if nil != err {

log.Println(“get wx access token from “+url+” error,err=”, err)

} else {

success = true

log.Println(“get wx access token from “ + url + “ success”)

defer resp.Body.Close()

body, err := ioutil.ReadAll(resp.Body)

if nil != err {

log.Println(“get wx access token error,read resp body error,err=”, err)

return

}

tokenstr := string(body)

log.Println(“access_token:”, tokenstr)

ParseTokens(tokenstr)

break

}

}

if !success {

log.Println(“get wx access error from all api”)

os.Exit(1)

}

}

func InitGlobal() {

wx_gzh_appid = “”

wx_gzh_secret = “”

wx_gzh_token_str = “”

global_access_token = “”

global_access_token_time_out = 0

}

func HttpTokenServer(tokenPort string) {

http.Handle(“/token”, &wx_access_token_center_handler{})

port := “0.0.0.0:” + tokenPort

log.Println(“start listen token port:”, tokenPort)

http.ListenAndServe(port, nil)

}

func main() {

log.Println(“start gzh token center”)

log.Println(“param format: config.json”)

arg_num := len(os.Args)

if arg_num < 2 {

log.Println(“please input the port”)

os.Exit(1)

}

InitGlobal()

configFile := os.Args[1]

config, err := ParseSconsConfig(configFile)

if nil != err {

log.Println(“parse config error,err=”, err)

os.Exit(1)

}

wx_gzh_appid = config.Appid

wx_gzh_secret = config.Secret

wx_gzh_token_str = config.Token

HttpTokenServer(config.Port)

}