1、解决go的第三方库依赖或者通过go get github.com/hyper-carrot/go_lib/logging由于国家不允许进行翻墙，大部分情况无法下载，或者通过翻墙进行下载，但是还有一种比较笨的方法，自己进入github网址进行拉取第三方库。
2、首先进行配置环境查找GOPATH的地址。

3、找到目录如图所示：

go get命令会将项目下的所有子目录和源码文件存放到第一个工作区的src目录下、bin是exe运行程序或者golang编译可执行文件存放路径、pkg一般放入缓存的第三方库、或者golang编译包时，生成的.a文件存放路径。

注意：我们go get失败，可以通过 git clone https://github.com/hyper-carrot/go_lib/logging.git 进行拉取。再放到src目录下。如图所示：

package main

import (
	//标准库
	"fmt"
	//程序内部包
	"io/ioutil"
	"net/http"
	"net/url"	
	"log"
    //
	"strings"
	"encoding/json"
	//"os"
	// "crypto/tls"
	// "crypto/x509"
	// "flag"
	// "io/ioutil"
	// "net/http"
	//第三方库
    // "golang.org/x/net/http2"
	//随机数
	"math/rand"
	"time"	
	//文件上传
	"bytes"
	// "errors"
	// "github.com/valyala/fasthttp"
	// "io"
	// "mime/multipart"
	// "path"
	// "path/filepath"
	// "strings"
	//
	// "github.com/golang/glog"
	//
	// "bytes"
	"compress/gzip"
	"encoding/binary"
	"github.com/gitstliu/log4go"
    //go 常用库
	// "github.com/sail-services/sail-go/mod/data/log"
	// "github.com/sail-services/sail-go/mod/net/service"
	// sWeb "github.com/sail-services/sail-go/mod/net/web"
	//裸体图像检测
	// "github.com/koyachi/go-nude"
)
//http get 请求
func httpGet() {
	resp, err := http.Get("http://47.98.182.201:7001/v1/tenants/_1LWHJ9M/get-skill-groups")
	if err != nil {
		// handle error
	}

	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		// handle error
	}
	fmt.Println(string(body))
}
//http post 请求
func httpPost() {
	resp, err := http.Post("http://www.01happy.com/demo/accept.php",
		"application/x-www-form-urlencoded",
		strings.NewReader("name=cjb"))
	if err != nil {
		fmt.Println(err)
	}

	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		// handle error
	}

	fmt.Println(string(body))
}
//go post 表单提交
func httpPostForm() {
	resp, err := http.PostForm("http://www.01happy.com/demo/accept.php",
		url.Values{"key": {"Value"}, "id": {"123"}})

	if err != nil {
		// handle error
	}

	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		// handle error
	}

	fmt.Println(string(body))

}

//http do 请求
// func httpDo() {
// 	client := &http.Client{}

// 	req, err := http.NewRequest("POST", "http://www.01happy.com/demo/accept.php", strings.NewReader("name=cjb"))
// 	if err != nil {
// 		// handle error
// 	}
// 	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
// 	req.Header.Set("Cookie", "name=anny")
// 	resp, err := client.Do(req)
// 	defer resp.Body.Close()
// 	body, err := ioutil.ReadAll(resp.Body)
// 	if err != nil {
// 		// handle error
// 	}
// 	fmt.Println(string(body))
// }

// 提供接口服务
func sayhelloName(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Hello world!")
	fmt.Println("你好")
}
//json对象
type ConfigStruct struct {
    Host              string   `json:"host"`
    Port              int      `json:"port"`
    AnalyticsFile     string   `json:"analytics_file"`
    StaticFileVersion int      `json:"static_file_version"`
    StaticDir         string   `json:"static_dir"`
    TemplatesDir      string   `json:"templates_dir"`
    SerTcpSocketHost  string   `json:"serTcpSocketHost"`
    SerTcpSocketPort  int      `json:"serTcpSocketPort"`
    Fruits            []string `json:"fruits"`
}
//json 部分对象
type Other struct {
    SerTcpSocketHost string   `json:"serTcpSocketHost"`
    SerTcpSocketPort int      `json:"serTcpSocketPort"`
    Fruits           []string `json:"fruits"`
}

// go  https
func handle(w http.ResponseWriter, r *http.Request) {
    // 记录请求协议
    log.Printf("Got connection: %s", r.Proto)
    // 向客户发送一条消息
    w.Write([]byte("Hello"))
}

//go http2 请求
// const url = "https://localhost:8000"
// var httpVersion = flag.Int("version", 2, "HTTP version")


//go 获取随机数据


func GetRandomStr(len int) string{
	originStr := "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890abcdefghijklmnopqrstuvwxyz"
	str := ""
	bStr := []byte(originStr)
	rand.Seed(time.Now().Unix())
	for i:=0;i<len;i++{
		str += string(bStr[rand.Intn(61)])
	}
	return str
}

// go 文件上传
// func PostRawData(url string,data []byte) ([]byte,error){
// 	request := fasthttp.AcquireRequest()
// 	request.SetRequestURI(url)
// 	request.Header.SetMethod("POST")
// 	request.SetBody(data)
// 	response := fasthttp.AcquireResponse()
// 	err := requestFellowRedirect(request,response)
// 	if err != nil{
// 		return nil,err
// 	}
// 	return response.Body(),err
// }

// func PostFields(url string,fields map[string]string) ([]byte,error){
// 	//新建一个缓冲，用于存放文件内容
// 	bodyBufer := &bytes.Buffer{}
// 	//创建一个multipart文件写入器，方便按照http规定格式写入内容
// 	bodyWriter := multipart.NewWriter(bodyBufer)
// 	err := writeFieldsData(bodyWriter,fields)
// 	if err != nil{
// 		bodyWriter.Close()
// 		return nil,err
// 	}
// 	//关闭bodyWriter停止写入数据
// 	bodyWriter.Close()
// 	contentType := bodyWriter.FormDataContentType()
// 	//构建request，发送请求
// 	req := fasthttp.AcquireRequest()
// 	req.Header.SetContentType(contentType)
// 	//直接将构建好的数据放入post的body中
// 	req.SetBody(bodyBufer.Bytes())
// 	req.Header.SetMethod("POST")
// 	req.SetRequestURI(url)
// 	resp := fasthttp.AcquireResponse()
// 	err = requestFellowRedirect(req,resp)
// 	if err != nil{
// 		return nil,err
// 	}
// 	return resp.Body(),nil
// }
// //支持多文件上传
// func PostFiles(url string,files map[string]string) ([]byte,error){
// 	//新建一个缓冲，用于存放文件内容
// 	bodyBufer := &bytes.Buffer{}
// 	//创建一个multipart文件写入器，方便按照http规定格式写入内容
// 	bodyWriter := multipart.NewWriter(bodyBufer)

// 	err := writeFilesData(bodyWriter,files)
// 	if err != nil{
// 		bodyWriter.Close()
// 		return nil,err
// 	}
// 	//关闭bodyWriter停止写入数据
// 	bodyWriter.Close()
// 	contentType := bodyWriter.FormDataContentType()
// 	//构建request，发送请求
// 	request := fasthttp.AcquireRequest()
// 	request.Header.SetContentType(contentType)
// 	//直接将构建好的数据放入post的body中
// 	request.SetBody(bodyBufer.Bytes())
// 	request.Header.SetMethod("POST")
// 	request.SetRequestURI(url)
// 	response := fasthttp.AcquireResponse()
// 	err = requestFellowRedirect(request,response)
// 	if err != nil{
// 		return nil,err
// 	}
// 	return response.Body(),nil
// }

// //支持多文件上传
// func PostFilesAndFields(url string,files map[string]string,fields map[string]string) ([]byte,error){
// 	//新建一个缓冲，用于存放文件内容
// 	bodyBufer := &bytes.Buffer{}
// 	//创建一个multipart文件写入器，方便按照http规定格式写入内容
// 	bodyWriter := multipart.NewWriter(bodyBufer)

// 	err := writeFilesData(bodyWriter,files)
// 	if err != nil{
// 		bodyWriter.Close()
// 		return nil,err
// 	}
// 	err = writeFieldsData(bodyWriter,fields)
// 	if err != nil{
// 		bodyWriter.Close()
// 		return nil,err
// 	}
// 	//关闭bodyWriter停止写入数据
// 	bodyWriter.Close()
// 	contentType := bodyWriter.FormDataContentType()
// 	//构建request，发送请求
// 	request := fasthttp.AcquireRequest()
// 	request.Header.SetContentType(contentType)
// 	//直接将构建好的数据放入post的body中
// 	request.SetBody(bodyBufer.Bytes())
// 	request.Header.SetMethod("POST")
// 	request.SetRequestURI(url)
// 	response := fasthttp.AcquireResponse()
// 	err = requestFellowRedirect(request,response)
// 	if err != nil{
// 		return nil,err
// 	}
// 	return response.Body(),nil
// }

// func Get(url string) ([]byte,error){
// 	client := fasthttp.Client{}
// 	_,resp,err := client.Get(nil,url)
// 	return resp,err
// }

// //支持重定向文件下载
// func DownLoadFileByGet(url,savePath string) (string,error){
// 	//fasthttp.Do不支持自动重定向，此处自己实现
// 	req := fasthttp.AcquireRequest()
// 	req.SetRequestURI(url)
// 	resp := fasthttp.AcquireResponse()
// 	err := requestFellowRedirect(req,resp)
// 	if err != nil{
// 		return "",err
// 	}
// 	return saveFile(savePath,resp)
// }
// //用于需要上传form表单下载文件的情况
// func DownloadFileByPostFields(url,savePath string,fields map[string]string) (string,error){
// 	//新建一个缓冲，用于存放文件内容
// 	bodyBufer := &bytes.Buffer{}
// 	//创建一个multipart文件写入器，方便按照http规定格式写入内容
// 	bodyWriter := multipart.NewWriter(bodyBufer)
// 	err := writeFieldsData(bodyWriter,fields)
// 	if err != nil{
// 		bodyWriter.Close()
// 		return "",err
// 	}
// 	//关闭bodyWriter停止写入数据
// 	bodyWriter.Close()
// 	contentType := bodyWriter.FormDataContentType()
// 	//构建request，发送请求
// 	req := fasthttp.AcquireRequest()
// 	req.Header.SetContentType(contentType)
// 	//直接将构建好的数据放入post的body中
// 	req.SetBody(bodyBufer.Bytes())
// 	req.Header.SetMethod("POST")
// 	req.SetRequestURI(url)
// 	resp := fasthttp.AcquireResponse()
// 	err = requestFellowRedirect(req,resp)
// 	if err != nil{
// 		return "",err
// 	}
// 	return saveFile(savePath,resp)
// }
// //用于需要上传json串等数据下载文件的情况
// func DownloadFileByPostRawData(url,savePath string,rawData []byte)(string,error){
// 	req := fasthttp.AcquireRequest()
// 	req.SetRequestURI(url)
// 	req.Header.SetMethod("POST")
// 	req.SetBody(rawData)
// 	resp := fasthttp.AcquireResponse()
// 	err := requestFellowRedirect(req,resp)
// 	if err != nil{
// 		return "",err
// 	}
// 	return saveFile(savePath,resp)
// }

// func writeFieldsData(bodyWriter *multipart.Writer,fields map[string]string) error{
// 	for k,v := range fields{
// 		fieldWriter,err := bodyWriter.CreateFormField(k)
// 		if err != nil{
// 			return err
// 		}
// 		fieldWriter.Write([]byte(v))
// 	}
// 	return nil
// }

// func writeFilesData(bodyWriter *multipart.Writer,files map[string]string) error{
// 	for key,val := range files{
// 		//从bodyWriter生成fileWriter,并将文件内容写入fileWriter,多个文件可进行多次
// 		fileWriter,err := bodyWriter.CreateFormFile(key,path.Base(val))
// 		if err != nil{
// 			return err
// 		}
// 		file,err := os.Open(val)
// 		if err != nil{
// 			return err
// 		}
// 		//不要忘记关闭打开的文件
// 		_,err = io.Copy(fileWriter,file)
// 		if err != nil{
// 			return err
// 		}
// 		file.Close()
// 	}
// 	return nil
// }
//发出请求，如果返回重定向则继续请求重定向地址，直到返回非重定向结果
// func requestFellowRedirect(req *fasthttp.Request,resp *fasthttp.Response)error{
// 	for{
// 		err := fasthttp.Do(req,resp)
// 		if err != nil{
// 			return err
// 		}
// 		statusCode := resp.StatusCode()
// 		if statusCode != fasthttp.StatusMovedPermanently &&
// 			statusCode !=  fasthttp.StatusFound &&
// 			statusCode !=  fasthttp.StatusSeeOther &&
// 			statusCode !=  fasthttp.StatusTemporaryRedirect &&
// 			statusCode !=  fasthttp.StatusPermanentRedirect {
// 			break
// 		}
// 		location := ""
// 		//获取重定向链接地址
// 		resp.Header.VisitAll(func (key,val []byte){
// 			if (string(key) == "Location"){
// 				location = string(val)
// 			}
// 		})

// 		if location == ""{
// 			return errors.New("redirect response without location")
// 		}
// 		resp.Reset()
// 		req.SetRequestURI(location)
// 	}
// 	return nil
// }
//根据http请求的response保存文件
// func saveFile(savePath string,resp *fasthttp.Response)(string,error){
// 	//先返回文件下载地址
// 	fileName := ""
// 	//从header头的Content-disposition获得文件名
// 	resp.Header.VisitAll(func (key,val []byte){
// 		if (string(key) == "Content-Disposition"){
// 			infoStr := string(val)
// 			stringArr := strings.Split(infoStr,";")
// 			for _,str := range stringArr{
// 				if  strings.Index(str,"filename") == 1{
// 					strArr := strings.Split(str,"=")
// 					fileName = strings.Trim(strArr[1],""")
// 					break
// 				}
// 			}
// 		}
// 	})
// 	if fileName == ""{
// 		strArr := strings.Split(string(resp.Header.ContentType()),"/")
// 		fileName = GetRandomStr(30)+"."+strArr[1]
// 	}
// 	//有时候上传图片的名称中包含路径名
// 	fileName =filepath.Base(fileName)
// 	if savePath == ""{
// 		savePath = os.TempDir()
// 	}
// 	fullFile := savePath+"/"+fileName
// 	file,err := os.Create(fullFile)
// 	defer file.Close()
// 	if err != nil{
// 		return "",err
// 	}
// 	_,err = file.Write(resp.Body())
// 	if err != nil{
// 		return "",nil
// 	}
// 	return fullFile,nil
// }



// func  Test(){
//    var s []string

//    fmt.ErrorF("failed to write data .")
//    //空字符串检查
//    if s==""{}
//    //非空slice检查
//    if len(s)>0{} 
//    //bool值
//    if b {}
//    if !b {}
//    //btye slice string 值相互比较
//    var s1 []byte
//    var s2 []byte
//    bytes.Equal(s1,s2) == 0
//    bytes.Equal(s1,s2) != 0
//    //检查是否包含字符串
//    strings.ContainesRune()
// }


// 1. PanicHandler
// 通用Panic处理器

// 2. InterfacesToStrings
// 将Interface数组转换为String数组

// 3. GetFilesWithFolder
// 获得文件夹下所有文件

// 4. ObjectToJson
// 将对象转换为JSON

// 5. ObjectsToJson
// 将对象数组转换为JSON数组

// 6. DecodeGzipBytes
// 解码GZIP

// 7. EncodeGzipBytes
// 编码GZIP

// 8. JsonToObject
// 将JSON转换为对象

// 9. StringToBytes
// 将String 转换为byte数组

// 10. Int64ToBytes
// 将int64转为byte数组

// 11. IntToBool
// 将int转换为bool

// 12. IsGzipEncode
// 判断HTTP请求是否GZIP


type TimeSpan struct {
	startNS int64
	endNS   int64
}

type NodeToRecord interface {
	ToRecord() string
}

func PanicHandler() {
	if r := recover(); r != nil {
		log4go.Error("Run time Error %v", r)
		panic(r)
	}
}

func InterfacesToStrings(src []interface{}) []string {
	result := []string{}
	for _, value := range src {
		result = append(result, value.(string))
	}
	return result
}

func (this *TimeSpan) Start() {
	this.startNS = time.Now().UnixNano()
}

func (this *TimeSpan) End() {
	this.endNS = time.Now().UnixNano()
}

func (this *TimeSpan) GetTimeSpanMS() float64 {

	return float64(this.endNS-this.startNS) / 1000000
}

func GetFilesWithFolder(folderName string) ([]string, error) {

	result := make([]string, 0, 1000)

	infos, readDirError := ioutil.ReadDir(folderName)

	if readDirError != nil {
		return nil, readDirError
	}

	for _, info := range infos {

		if !info.IsDir() {
			result = append(result, folderName+"/"+info.Name())
		}
	}

	return result, nil
}

func ObjectToJson(value interface{}) (string, error) {
	meta, err := json.Marshal(value)
	return string(meta), err
}

func ObjectsToJson(values []interface{}) ([]interface{}, error) {
	result := [](interface{}){}

	for _, currValue := range values {
		meta, err := ObjectToJson(currValue)

		if err != nil {
			return nil, err
		} else {
			result = append(result, meta)
		}
	}

	return result, nil
}

func DecodeGzipBytes(meta []byte) ([]byte, error) {
	b := bytes.Buffer{}
	b.Write(meta)
	r, _ := gzip.NewReader(&b)
	defer r.Close()
	datas, readErr := ioutil.ReadAll(r)

	if readErr != nil {
		return nil, readErr
	}

	return datas, nil
}

func EncodeGzipBytes(meta []byte) []byte {
	b := bytes.Buffer{}
	w := gzip.NewWriter(&b)
	defer w.Close()

	w.Write(meta)
	w.Flush()

	return b.Bytes()
}

func JsonToObject(meta string, result interface{}) error {
	return json.Unmarshal(StringToBytes(meta), result)
}

func StringToBytes(value string) []byte {
	return []byte(value)
}

func MetaToJsonContent(value string) string {
	return fmt.Sprintf("{%s}", value)
}

func Int64ToBytes(value int64) []byte {

	result := []byte{}

	buffer := bytes.NewBuffer(result)
	binary.Write(buffer, binary.BigEndian, &value)

	return buffer.Bytes()
}

func IntToBool(value int) bool {
	if value == 1 {
		return true
	} else {
		return false
	}
}

func IsGzipEncode(header http.Header) bool {

	log4go.Debug("header : %v", header)

	value := header["Content-Encoding"]

	return value != nil && strings.EqualFold(value[0], "gzip")
}

//go 语言常用库
// var (
// 	web = &sWeb.Web{
// 		Project: &sWeb.Project{
// 			Name:    "HelloWorld",
// 			Version: "0.1",
// 			Url:     "helloworld.com",
// 		},
// 		Base: &sWeb.Base{
// 			Port:            8888,                               // 端口
// 			SecretKey:       `CWVM(A&yX/dScm503YdD5.,>(~c>X?`, // AES统一秘钥 (Cookie, CSRF)
// 			DefaultLang:     "en-US",                            // 默认语言
// 			I18nLangs:       []string{"en-US", "zh-CN"},         // 语言ID
// 			I18nNames:       []string{"Engligh", "中文"},          // 语言列表
// 			PathRootDev:     "../",                              // 开发模式的相对路径
// 			PathRootRelease: "./",                               // 发布模式的相对路径
// 			PathLangs:       "langs",                            // 语言文件路径
// 			PathTemplate:    "html",                             // 模板文件路径
// 		},
// 		Pro: &sWeb.Pro{
// 			PathStatics: [][]string{ // URL绑定静态目录
// 				{"s", "public"},               // 静态文件目录 (JS, CSS...)
// 				{"hongbao", "public/hongbao"}, // 推广活动页面 (用HTML写的推广主题)
// 			},
// 			StaticFiles: [][]string{ // URL绑定静态文件
// 				{"/favicon.ico", "public/img/logo_icon.ico"}, // favicon
// 			},
// 		},
// 	}
// )

// func getIndex(con *service.Context) {
// 	web.Tpl("index", 100, false, con) // 1.模板文件 2.模板标记(用于主题分类, 例100~199是前台, 200~299是后台, 300~399是专题页面...) 3.是否为PJAX(让网站体验更好) 4.上下文变量
// }

// func get404(con *service.Context) {
// 	web.Tpl("404", 200, false, con)
// }


func main() {
	//httpGet()
	//httpPost()
	//httpPostForm()
	//httpDo()

    //https 请求
	// 在 8000 端口启动服务器
    // 确切地说，如何运行HTTP/1.1服务器。
    srv := &http.Server{Addr:":8000", Handler: http.HandlerFunc(handle)}
    // 用TLS启动服务器，因为我们运行的是http/2，它必须是与TLS一起运行。
    // 确切地说，如何使用TLS连接运行HTTP/1.1服务器。
    log.Printf("Serving on https://0.0.0.0:8000")
	log.Fatal(srv.ListenAndServeTLS("server.crt", "server.key"))
	

	//http 请求
	http.HandleFunc("/", sayhelloName)
	err := http.ListenAndServe(":3000", nil)
	if err != nil {
		log.Fatal("ListenAndServe: ", err)
	}

    // go  string 转json
	jsonStr := `{"host": "http://localhost:9090","port": 9090,"analytics_file": "","static_file_version": 1,"static_dir": "E:/Project/goTest/src/","templates_dir": "E:/Project/goTest/src/templates/","serTcpSocketHost": ":12340","serTcpSocketPort": 12340,"fruits": ["apple", "peach"]}`
    //json str 转map
    var dat map[string]interface{}
    if err := json.Unmarshal([]byte(jsonStr), &dat); err == nil {
        fmt.Println("==============json str 转map=======================")
        fmt.Println(dat)
        fmt.Println(dat["host"])
    }
 
    //json str 转struct
    // var config ConfigStruct
    // if err := json.Unmarshal([]byte(jsonStr), &config); err == nil {
    //     fmt.Println("================json str 转struct==")
    //     fmt.Println(config)
    //     fmt.Println(config.Host)
    // }
 
    //json str 转struct(部份字段)
    //var part Other
    // if err := json.Unmarshal([]byte(jsonStr), &part); err == nil {
    //     fmt.Println("================json str 转struct==")
    //     fmt.Println(part)
    //     fmt.Println(part.SerTcpSocketPort)
    // }
 
    //struct 到json str
    // if b, err := json.Marshal(config); err == nil {
    //     fmt.Println("================struct 到json str==")
    //     fmt.Println(string(b))
    // }
 
    //map 到json str
    // fmt.Println("================map 到json str=====================")
    // enc := json.NewEncoder(os.Stdout)
    // enc.Encode(dat)
 
    //array 到 json str
    // arr := []string{"hello", "apple", "python", "golang", "base", "peach", "pear"}
    // lang, err := json.Marshal(arr)
    // if err == nil {
    //     fmt.Println("================array 到 json str==")
    //     fmt.Println(string(lang))
    // }
 
    //json 到 []string
    // var wo []string
    // if err := json.Unmarshal(lang, &wo); err == nil {
    //     fmt.Println("================json 到 []string==")
    //     fmt.Println(wo)
	// }
	
	//go http2.0 
	// flag.Parse()
	// client := &http.Client{}
	// // Create a pool with the server certificate since it is not signed
	// // by a known CA
	// caCert, err := ioutil.ReadFile("server.crt")
    //     if err != nil {
 	// 	log.Fatalf("Reading server certificate: %s", err)
	// }
	// caCertPool := x509.NewCertPool()
	// caCertPool.AppendCertsFromPEM(caCert)
	// // Create TLS configuration with the certificate of the server
	// tlsConfig := &tls.Config{
	// 	RootCAs: caCertPool,
	// }

	// Use the proper transport in the client
	// switch *httpVersion {
 	// case 1:
	// 	client.Transport = &http.Transport{
	// 		TLSClientConfig: tlsConfig,
	// 	}
	// case 2:
	// 	client.Transport = &http2.Transport{
	// 		TLSClientConfig: tlsConfig,
	// 	}
	// }
	// // Perform the request
	// resp, err := client.Get(url)

	// if err != nil {
 	// 	log.Fatalf("Failed get: %s", err)
	// }
	// defer resp.Body.Close()
	// body, err := ioutil.ReadAll(resp.Body)
	// if err != nil {
 	// 	log.Fatalf("Failed reading response body: %s", err)
	// }
	// fmt.Printf(
	// 	"Got response %d: %s %sn",
	// 	resp.StatusCode, resp.Proto, string(body))
		

		// 编码转换 com/data/convert
		// 加密解密 com/data/crypt
		// 时间处理 com/data/datetime
		// 数学计算 com/data/number
		// 随机数 com/data/random
		// 切片数据处理 com/data/slice
		// 字符串数据处理 com/data/strings
		// ID生成和处理 com/data/uuid
		// 文件系统 com/sys/fs
		// 日期处理 mod/data/calendar
		// Json处理 mod/data/json
		// 日志Log mod/data/log
		// 网络数据抓取 mod/net/fetcher
		// 网络服务框架 mod/net/service (无反射, 性能好, 功能全, 模块化)
		// 网络服务框架的可选模块 mod/net/service/mod
		// Web服务端 mod/net/web (开箱即用 100行代码即可包含日志记录, 国际化, 安全加密, 模板功能, 静态文件绑定与路径绑定, 开发模式与发布模式)
		//web.Log = log.New(os.Stdout, log.LEVEL_DATA, log.DATA_BASIC) // 1.Log输出流(打印到文件还是终端) 2.Log数据显示等级 3.数据详细等级(日期时间代码文件名和行号等)
		// web.Init()
		// web.Ser.Rou.Get("/", getIndex)
		// web.Ser.Rou.NotFound(get404)
		// web.Run()

		//裸体图像检测
		// imagePath := "images/test2.jpg"
		// isNude, err := nude.IsNude(imagePath)
		// if err != nil {
		// 	log.Fatal(err)
		// }
		// fmt.Printf("isNude = %vn", isNude)
}

推荐：学习go网址：
Go 命令教程
Golang