go语言开发

GORM一对一关系的查询

Fri, 26 Apr 2024 13:44:29 +0800

// User 有一张 CreditCard，UserID 是外键
type User struct {
  gorm.Model
  CreditCard CreditCard
}

type CreditCard struct {
  gorm.Model
  Number string
  UserID uint
}

通过Preload方法可以获取CreditCard 的相关数据

// 检索用户列表并预加载信用卡
func GetAll(db *gorm.DB) ([]User, error) {
    var users []User
    err := db.Model(&User{}).Preload("CreditCard").Find(&users).Error
    return users, err
}

指定外键名称

type User struct {
  gorm.Model
  CreditCard CreditCard `gorm:"foreignKey:UserName"` // 使用 UserName 作为外键
}

type CreditCard struct {
  gorm.Model
  Number   string
  UserName string
}

GORM使用 SQL 表达式更新

Fri, 26 Apr 2024 13:34:01 +0800

通过表达式可以更灵活的更新数据

// product's ID is `3`
db.Model(&product).Update("price", gorm.Expr("price * ? + ?", 2, 100))
// UPDATE "products" SET "price" = price * 2 + 100, "updated_at" = '2013-11-17 21:34:10' WHERE "id" = 3;

db.Model(&product).Updates(map[string]interface{}{"price": gorm.Expr("price * ? + ?", 2, 100)})
// UPDATE "products" SET "price" = price * 2 + 100, "updated_at" = '2013-11-17 21:34:10' WHERE "id" = 3;

db.Model(&product).UpdateColumn("quantity", gorm.Expr("quantity - ?", 1))
// UPDATE "products" SET "quantity" = quantity - 1 WHERE "id" = 3;

db.Model(&product).Where("quantity > 1").UpdateColumn("quantity", gorm.Expr("quantity - ?", 1))
// UPDATE "products" SET "quantity" = quantity - 1 WHERE "id" = 3 AND quantity > 1;

[GIN-debug] [WARNING] You trusted all proxies, this is NOT safe. We recommend you to set a value.

Thu, 25 Apr 2024 10:32:51 +0800

根据warning也就是给gin设置一个信任ip : 127.0.0.1

	router := gin.Default()
	router.SetTrustedProxies([]string{"127.0.0.1"})

chromedp.Nodes方法详情

Wed, 28 Feb 2024 16:37:40 +0800

主要功能获取网页的内容保存一个个节点数组，

使用方法：

chromedp.Nodes(`参数`,&nodes),

参数可以class id 如 .tableFull > tbody > tr

也可以name input[name="xx"] input[tag="xx"]

获取的最终数据如下

for _,v:=range nodes{

       if len(v.Children) >0{
      fmt.Println("------------------------")
              fmt.Println(v.Children[0].NodeValue) //这里打印的是最终节点里的内容，如果里面有子节点就会空
   }
   

}

如果内容空 v.Children 小于等于0 说明不是内容或则还有子节点

git 基本操作

Tue, 27 Feb 2024 08:19:31 +0800

- 创建一个目录也就是本地仓库
- git init    #告诉git这是本地仓库归你管
- ssh-keygen -t rsa -C注册github用的邮箱      #生成SSH KEY
- 将生成的SSH KEY保存在github的设置中
- git add 文件名   #将要上传的文件放到缓存空间
- git add .  #将当前目录下的所有文件放到缓存空间
- git commit -m "备注信息"  #将缓存空间的所有文件放到仓库
- git remote add origin 链接地址     #连接远程仓库
- git push -u origin master   #将仓库里的文件上传到GitHub指定仓库的分支，定义仓库别名为origin，分支名为master
- git pull origin master #将别名为origin仓库下的master分支的文件下载到当前目录
- git clone 项目链接 #克隆项目到本地

chromedp使用入门

Sat, 24 Feb 2024 10:40:56 +0800

案例演示： https://github.com/chromedp/examples 这个项目

一些常见的方法：

chromedp.NewContext() 初始化chromedp的上下文，后续这个页面都使用这个上下文进行操作
 chromedp.Run() 运行一个chrome的一系列操作
 chromedp.Navigate() 将浏览器导航到某个页面
 chromedp.WaitVisible() 等候某个元素可见，再继续执行。
 chromedp.Click() 模拟鼠标点击某个元素
 chromedp.Value() 获取某个元素的value值
 chromedp.ActionFunc() 再当前页面执行某些自定义函数
 chromedp.Text() 读取某个元素的text值
 chromedp.Evaluate() 执行某个js，相当于控制台输入js
 network.SetExtraHTTPHeaders() 截取请求，额外增加header头
 chromedp.SendKeys() 模拟键盘操作，输入字符
 chromedp.Nodes() 根据xpath获取某些元素，并存储进入数组
 chromedp.NewRemoteAllocator
 chromedp.OuterHTML() 获取元素的outer html
 chromedp.Screenshot() 根据某个元素截图
 page.CaptureScreenshot() 截取整个页面的元素
 chromedp.Submit() 提交某个表单
 chromedp.WaitNotPresent() 等候某个元素不存在，比如“正在搜索。。。”
 chromedp.Tasks{} 一系列Action组成的任务

简单案例

package main
 
import (
 "context"
 "fmt"
 "log"
 
 "github.com/chromedp/cdproto/cdp"
 "github.com/chromedp/chromedp"
)
 
func main() {
 
 ctx, cancel := chromedp.NewContext(
  context.Background(),
  chromedp.WithLogf(log.Printf),
 )
 defer cancel()
 
 var nodes []*cdp.Node
 err := chromedp.Run(ctx,
  chromedp.Navigate("https://www.cnblogs.com/"),
  chromedp.WaitVisible(`#footer`, chromedp.ByID),
  chromedp.Nodes(`.//a[@class="titlelnk"]`, &nodes),
 )
 if err != nil {
  log.Fatal(err)
 }
 
 fmt.Println("get nodes:", len(nodes))
 // print titles
 for _, node := range nodes {
  fmt.Println(node.Children[0].NodeValue, ":", node.AttributeValue("href"))
 }
}

常用API

chromedp.Navigate("https://xxxx") // 跳转的url
chromedp.WaitVisible(`#username`, chromedp.ByID), //  使用chromedp.ByID选择器。所以就是等待id=username的标签元素加载完。
chromedp.SendKeys(`#username`, "username", chromedp.ByID), // 使用chromedp.ByID选择器。向id=username的标签输入username。
chromedp.SetValue 设置值，和sendkey不同的是，如果原有的输入框中有内容，sendkey不会清空原来的值，setva
chromedp.Value(`#input1`, val1, chromedp.ByID), // 获取id=input1的值，并把值传给val1
chromedp.Click("btn-submit",chromedp.Bysearch), // 触发点击事件，
chromedp.Screenshot(`#row`, &buf, chromedp.ByID), // 截图id=row的标签，把值传入buf 需要事先定义var buf []byte 
chromedp.ActionFunc(func(context.Context, cdp.Executor) error { // 将图片写入文件
 return ioutil.WriteFile("test.png", buf, 0644)
}),

常用选择器

chromedp.BySearch // 如果不写，默认会使用这个选择器，类似devtools ctrl+f 搜索
chromedp.ByID // 只id来选择元素
chromedp.ByQuery // 根据document.querySelector的规则选择元素，返回单个节点
chromedp.ByQueryAll // 根据document.querySelectorAll返回所有匹配的节点
chromedp.ByNodeIP // 检索特定节点(必须先有分配的节点IP)，这个暂时没用过也没看到过例子，如果有例子可以发给我看下

gin验证参数

Thu, 04 Jan 2024 13:57:21 +0800

// 不能为空，并且不能没有这个字段
required： 必填字段，如：binding:"required"  

// 针对字符串的长度
min 最小长度，如：binding:"min=5"
max 最大长度，如：binding:"max=10"
len 长度，如：binding:"len=6"

// 针对数字的大小
eq 等于，如：binding:"eq=3"
ne 不等于，如：binding:"ne=12"
gt 大于，如：binding:"gt=10"
gte 大于等于，如：binding:"gte=10"
lt 小于，如：binding:"lt=10"
lte 小于等于，如：binding:"lte=10"

// 针对同级字段的
eqfield 等于其他字段的值，如：PassWord string `binding:"eqfield=Password"`
nefield 不等于其他字段的值


- 忽略字段，如：binding:"-"

演示代码

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/go-playground/validator/v10"
	"reflect"
)

type UserInfo struct {
	Username string `json:"username" binding:"required" msg:"用户名不能为空"`
	Password string `json:"password" binding:"min=3,max=6" msg:"密码长度不能小于3大于6"`
	Email    string `json:"email" binding:"email" msg:"邮箱地址格式不正确"`
}

func GetValidMsg(err error, obj any) string {
	// 使用的时候，需要传obj的指针
	getObj := reflect.TypeOf(obj)
	// 将err接口断言为具体类型
	if errs, ok := err.(validator.ValidationErrors); ok {
		// 断言成功
		for _, e := range errs {
			// 循环每一个错误信息
			// 根据报错字段名，获取结构体的具体字段
			if f, exits := getObj.Elem().FieldByName(e.Field()); exits {
				msg := f.Tag.Get("msg")
				return msg
			}
		}
	}

	return err.Error()
}

func main() {
	router := gin.Default()

	router.POST("/users", func(c *gin.Context) {
		var userInfo UserInfo
		err := c.ShouldBindJSON(&userInfo)
		if err != nil {
			fmt.Println(err)
			c.JSON(200, gin.H{"msg": GetValidMsg(err, &userInfo)})
			return
		}
		c.JSON(200, userInfo)
	})

	router.Run(":8000")
}

go语言数据类型

Sat, 30 Dec 2023 09:58:41 +0800

一：值类型

变量直接存储值，内存通过栈中分配，系统自动回收，不需要初始化

1：基本数据类型 int string bool

var a int var b string

2: 数组

var s [2]int

3：结构体

s:= struct {
 Id int
 Name string
}{}

二：引用类型

变量存储的是一个内存地址内存在堆上分配，通过GC回收，使用需要初始化，可以通过make初始化

1:切片

c:= make([]string,0)

2：管道

ch:= make(chan string,5)

3：Map

m:= make(map[string]string)

4: 指针

var n = 100
var p *int  = &n

GRPC使用入门

Fri, 29 Dec 2023 14:59:25 +0800

1：官网

https://grpc.io/

2：go 开发文档

https://grpc.io/docs/languages/go/quickstart/

3：proto文件规范介绍

https://protobuf.dev/programming-guides/proto3/

4：下载编译器

下载地址：https://github.com/protocolbuffers/protobuf/releases/

下载完成后配置电脑环境变量在path里添加bin位置

测试命令

protoc --version 如果正常运行代表配置成功

5：配置proto文件

syntax = "proto3";

service HelloService{
  //定义若干个服务的方法，定义服务接口
  //rpc 服务名字 服务器参数 返回参数
  rpc hello(LoginRequest) returns(Result){};
}

//自定义消息内容
message LoginRequest{   string query = 1;   int32 page_number = 2;  // Which page number do we want?   int32 results_per_page = 3;  // Number of results to return per page. }

阿里云OSS直传签名Go版

Thu, 04 May 2023 09:38:05 +0800

1:进入RAM控制台，创建一个RAM用户访问方式一般选择OPenApi就可以了

登陆名称自己随意填写不重复就可以，确定后添加成功

生成的密钥信息可以保存到本地。

2：为RAM用户添加系统策略

添加AliyunSTSAssumeRoleAccess权限这个步骤主要创建了一个用于获取临时访问凭证的角色，获得角色ARN

3：创建角色

如图：选择角色-> 创建角色

类型选择阿里云账户

添加角色名创建完成

这里的角色名称和ARN保存一下后续代码中要用到

4：创建策略

这里主要通过自定义策略实现，选择左边权限管理-》权限策略-》创建策略

切换到脚本编辑模式填写脚本内容

主要是设置Rescource配置对资源的访问权限

Action：允许的操作

{ "Version": "1", "Statement": [ { "Effect": "Allow", "Action": [ "oss:PutObject" ], "Resource": [ "acs:oss:*:*:oss的bucket名字/目录", "acs:oss:*:*:oss的bucket名字/目录/*" ] } ]}

如果不限制目录可以这样写

"Resource": [ "acs:oss:*:*:oss的bucket名字", "acs:oss:*:*:oss的bucket名字/*" ]

脚本编辑完成后取个名字保存备用

4：为角色添加策略

把上面的脚本权限添加给校色，回到角色列表找到对应的用户选择添加权限

通过名字查找上面添加的策略，然后保存就完成了整个权限的添加。

万事俱备接下来是关于Go语言相关的事情。

6：Go代码上传案例

package main  
  
import (  
	"fmt"  
	"os"
	"time"
	"strconv"
	"net/http" 
	"io"  
	"io/ioutil"  
	"encoding/base64"
	"encoding/pem"
	"encoding/json"
	"crypto"
	"crypto/md5"
	"crypto/rsa"
	"crypto/x509"
	"crypto/hmac"
	"crypto/sha1"
	"errors"
	"hash"
)

// 请填写您的AccessKeyId。
var accessKeyId string = "<yourAccessKeyId>"
// 请填写您的AccessKeySecret。
var accessKeySecret string = "<yourAccessKeySecret>"
// host的格式为 bucketname.endpoint ，请替换为您的真实信息。
var host string = "http://bucket-name.oss-cn-hangzhou.aliyuncs.com" 
// callbackUrl为 上传回调服务器的URL，请将下面的IP和Port配置为您自己的真实信息。
var callbackUrl string = "http://88.88.88.88:8888";
// 用户上传文件时指定的前缀。
var upload_dir string = "user-dir-prefix/"
var expire_time int64 = 30

const (  
    base64Table = "123QRSTUabcdVWXYZHijKLAWDCABDstEFGuvwxyzGHIJklmnopqr234560178912"  
)  

var coder = base64.NewEncoding(base64Table) 
func base64Encode(src []byte) []byte {  
    return []byte(coder.EncodeToString(src))  
}  

func get_gmt_iso8601(expire_end int64) string {
    var tokenExpire = time.Unix(expire_end, 0).UTC().Format("2006-01-02T15:04:05Z")
    return tokenExpire 
}

type ConfigStruct struct{
    Expiration string `json:"expiration"`
    Conditions [][]string `json:"conditions"`
} 

type PolicyToken struct{
    AccessKeyId string `json:"accessid"`
    Host string `json:"host"`
    Expire int64 `json:"expire"`
    Signature string `json:"signature"`
    Policy string `json:"policy"`
    Directory string `json:"dir"`
    Callback string `json:"callback"`
}

type CallbackParam struct{
    CallbackUrl string `json:"callbackUrl"`
    CallbackBody string `json:"callbackBody"`
    CallbackBodyType string `json:"callbackBodyType"`
}

func get_policy_token() string {
    now := time.Now().Unix()
    expire_end := now + expire_time 
    var tokenExpire = get_gmt_iso8601(expire_end)

    //create post policy json
    var config ConfigStruct
    config.Expiration = tokenExpire  
    var condition []string
    condition = append(condition, "starts-with")
    condition = append(condition, "$key")
    condition = append(condition, upload_dir)
    config.Conditions = append(config.Conditions, condition)

    //calucate signature
    result,err:=json.Marshal(config)
    debyte := base64.StdEncoding.EncodeToString(result)
    h := hmac.New(func() hash.Hash { return sha1.New() }, []byte(accessKeySecret))
    io.WriteString(h, debyte)
    signedStr := base64.StdEncoding.EncodeToString(h.Sum(nil))

    var callbackParam CallbackParam
    callbackParam.CallbackUrl = callbackUrl
    callbackParam.CallbackBody = "filename=${object}&size=${size}&mimeType=${mimeType}&height=${imageInfo.height}&width=${imageInfo.width}"
    callbackParam.CallbackBodyType = "application/x-www-form-urlencoded"
    callback_str,err:=json.Marshal(callbackParam)
    if err != nil {
        fmt.Println("callback json err:", err)
    }
    callbackBase64 := base64.StdEncoding.EncodeToString(callback_str)

    var policyToken PolicyToken
    policyToken.AccessKeyId = accessKeyId
    policyToken.Host = host
    policyToken.Expire = expire_end
    policyToken.Signature = string(signedStr)
    policyToken.Directory = upload_dir
    policyToken.Policy = string(debyte)
    policyToken.Callback = string(callbackBase64)
    response,err:=json.Marshal(policyToken)
    if err != nil {
        fmt.Println("json err:", err)
    }
    return string(response)
}

func main() {
        strIPPort := ":8080";
        if (len(os.Args)==3) {
                strIPPort = fmt.Sprintf("%s:%s", os.Args[1], os.Args[2])
        } else if (len(os.Args)!=1) {
                fmt.Println("Usage   : go run callbackserver.go                ")
                fmt.Println("Usage   : go run callbackserver.go ip port        ")
                fmt.Println("Example : go run callbackserver.go 11.22.33.44 80 ")
                fmt.Println("Example : go run callbackserver.go 0.0.0.0 8080 ")
                fmt.Println("")
                os.Exit(0)
        }
        fmt.Printf("\ncallbackserver is running on %s \n", strIPPort);
        http.HandleFunc("/", handlerRequest)   
        err := http.ListenAndServe(strIPPort, nil)  
        if (err != nil) {
                strError := fmt.Sprintf("http.ListenAndServe failed : %s \n", err.Error())
                panic(strError)
        }
}

func handlerRequest(w http.ResponseWriter, r *http.Request) {   
        if (r.Method == "GET") {
                response := get_policy_token()
                w.Header().Set("Access-Control-Allow-Methods", "POST")
                w.Header().Set("Access-Control-Allow-Origin", "*")
                io.WriteString(w, response)
		}
		
        if (r.Method == "POST") {
                fmt.Println("\nHandle Post Request ... ")

                // Get PublicKey bytes
                bytePublicKey, err := getPublicKey(r)
                if (err != nil) {
                        responseFailed(w)
                        return
                }

                // Get Authorization bytes : decode from Base64String
                byteAuthorization, err := getAuthorization(r)
                if (err != nil) {
                        responseFailed(w)
                        return
                }

                // Get MD5 bytes from Newly Constructed Authrization String. 
                byteMD5, err := getMD5FromNewAuthString(r)
                if (err != nil) {
                        responseFailed(w)
                        return
                }

                // verifySignature and response to client 
                if (verifySignature(bytePublicKey, byteMD5, byteAuthorization)) {
                        // do something you want accoding to callback_body ...

                        responseSuccess(w)  // response OK : 200  
                } else {
                        responseFailed(w)   // response FAILED : 400 
                }
        }
}  

// getPublicKey : Get PublicKey bytes from Request.URL
func getPublicKey(r *http.Request) ([]byte, error) {
        var bytePublicKey []byte
        // get PublicKey URL
        publicKeyURLBase64 := r.Header.Get("x-oss-pub-key-url")
        if (publicKeyURLBase64 == "") {
                fmt.Println("GetPublicKey from Request header failed :  No x-oss-pub-key-url field. ")
                return bytePublicKey, errors.New("no x-oss-pub-key-url field in Request header ")
        }
        publicKeyURL, _ := base64.StdEncoding.DecodeString(publicKeyURLBase64)
        // fmt.Printf("publicKeyURL={%s}\n", publicKeyURL)
        // get PublicKey Content from URL
        responsePublicKeyURL, err := http.Get(string(publicKeyURL))
        if (err != nil) {
                fmt.Printf("Get PublicKey Content from URL failed : %s \n", err.Error())
                return bytePublicKey, err
        }               
        bytePublicKey, err = ioutil.ReadAll(responsePublicKeyURL.Body)
        if (err != nil) {
                fmt.Printf("Read PublicKey Content from URL failed : %s \n", err.Error())
                return bytePublicKey, err
        }
        defer responsePublicKeyURL.Body.Close() 
        // fmt.Printf("publicKey={%s}\n", bytePublicKey)
        return bytePublicKey, nil
}

// getAuthorization : decode from Base64String
func getAuthorization(r *http.Request) ([]byte, error) {
        var byteAuthorization []byte
        // Get Authorization bytes : decode from Base64String
        strAuthorizationBase64 := r.Header.Get("authorization")
        if (strAuthorizationBase64 == "") {
                fmt.Println("Failed to get authorization field from request header. ")
                return byteAuthorization, errors.New("no authorization field in Request header")
        }
        byteAuthorization, _ = base64.StdEncoding.DecodeString(strAuthorizationBase64)
        return byteAuthorization, nil
}

// getMD5FromNewAuthString : Get MD5 bytes from Newly Constructed Authrization String. 
func getMD5FromNewAuthString(r *http.Request) ([]byte, error) {
        var byteMD5 []byte
        // Construct the New Auth String from URI+Query+Body
        bodyContent, err := ioutil.ReadAll(r.Body)
        r.Body.Close()
        if (err != nil) {
                fmt.Printf("Read Request Body failed : %s \n", err.Error())
                return byteMD5, err
        }
        strCallbackBody := string(bodyContent)
        // fmt.Printf("r.URL.RawPath={%s}, r.URL.Query()={%s}, strCallbackBody={%s}\n", r.URL.RawPath, r.URL.Query(), strCallbackBody)
        strURLPathDecode, errUnescape := unescapePath(r.URL.Path, encodePathSegment)  //url.PathUnescape(r.URL.Path) for Golang v1.8.2+
        if (errUnescape != nil) {
                fmt.Printf("url.PathUnescape failed : URL.Path=%s, error=%s \n", r.URL.Path, err.Error())
                return byteMD5, errUnescape
        }

        // Generate New Auth String prepare for MD5
        strAuth := ""
        if (r.URL.RawQuery == "") {
                strAuth = fmt.Sprintf("%s\n%s", strURLPathDecode, strCallbackBody)
        } else {
                strAuth = fmt.Sprintf("%s?%s\n%s", strURLPathDecode, r.URL.RawQuery, strCallbackBody)
        }
        // fmt.Printf("NewlyConstructedAuthString={%s}\n", strAuth)

        // Generate MD5 from the New Auth String 
        md5Ctx := md5.New()
        md5Ctx.Write([]byte(strAuth))
        byteMD5 = md5Ctx.Sum(nil)

        return byteMD5, nil
}

/*  VerifySignature
*   VerifySignature需要三个重要的数据信息来进行签名验证： 1>获取公钥PublicKey;  2>生成新的MD5鉴权串;  3>解码Request携带的鉴权串; 
*   1>获取公钥PublicKey : 从RequestHeader的"x-oss-pub-key-url"字段中获取 URL, 读取URL链接的包含的公钥内容， 进行解码解析， 将其作为rsa.VerifyPKCS1v15的入参。 
*   2>生成新的MD5鉴权串 : 把Request中的url中的path部分进行urldecode， 加上url的query部分， 再加上body， 组合之后进行MD5编码， 得到MD5鉴权字节串。 
*   3>解码Request携带的鉴权串 ： 获取RequestHeader的"authorization"字段， 对其进行Base64解码，作为签名验证的鉴权对比串。 
*   rsa.VerifyPKCS1v15进行签名验证，返回验证结果。
* */
func verifySignature(bytePublicKey []byte, byteMd5 []byte, authorization []byte) bool {
        pubBlock, _ := pem.Decode(bytePublicKey)
        if (pubBlock == nil) {
                fmt.Printf("Failed to parse PEM block containing the public key")
                return false
        }
        pubInterface, err := x509.ParsePKIXPublicKey(pubBlock.Bytes)
        if (pubInterface == nil) || (err != nil) {
                fmt.Printf("x509.ParsePKIXPublicKey(publicKey) failed : %s \n", err.Error())
                return false
        }
        pub := pubInterface.(*rsa.PublicKey)
        
        errorVerifyPKCS1v15 := rsa.VerifyPKCS1v15(pub, crypto.MD5, byteMd5, authorization)
        if (errorVerifyPKCS1v15 != nil) {
                fmt.Printf("\nSignature Verification is Failed : %s \n", errorVerifyPKCS1v15.Error())
                //printByteArray(byteMd5, "AuthMd5(fromNewAuthString)")
                //printByteArray(bytePublicKey, "PublicKeyBase64")
                //printByteArray(authorization, "AuthorizationFromRequest")
                return false
        }

        fmt.Printf("\nSignature Verification is Successful. \n")
        return true
}

// responseSuccess : Response 200 to client
func responseSuccess(w http.ResponseWriter) {
        strResponseBody := "{\"Status\":\"OK\"}"
        w.Header().Set("Content-Type", "application/json")
        w.Header().Set("Content-Length", strconv.Itoa(len(strResponseBody)))
        w.WriteHeader(http.StatusOK)
        w.Write([]byte(strResponseBody))
        fmt.Printf("\nPost Response : 200 OK . \n")
}

// responseFailed : Response 400 to client
func responseFailed(w http.ResponseWriter) {
        w.WriteHeader(http.StatusBadRequest)
        fmt.Printf("\nPost Response : 400 BAD . \n")
}

func printByteArray(byteArrary []byte , arrName string) {
        fmt.Printf("++++++++ printByteArray :  ArrayName=%s, ArrayLength=%d \n", arrName, len(byteArrary))
        for i:=0; i<len(byteArrary); i++ {
                fmt.Printf("%02x", byteArrary[i]);
        }
        fmt.Printf("\n-------- printByteArray :  End . \n")  
}

type EscapeError string
func (e EscapeError) Error() string {
        return "invalid URL escape " + strconv.Quote(string(e))
}

type InvalidHostError string
func (e InvalidHostError) Error() string {
  	return "invalid character " + strconv.Quote(string(e)) + " in host name"
}
type encoding int
const (
        encodePath encoding = 1 + iota
        encodePathSegment
        encodeHost
        encodeZone
        encodeUserPassword
        encodeQueryComponent
        encodeFragment
)

// unescapePath : unescapes a string; the mode specifies, which section of the URL string is being unescaped.
func unescapePath(s string, mode encoding) (string, error) {
        // Count %, check that they're well-formed.
        mode = encodePathSegment
  	n := 0
  	hasPlus := false
  	for i := 0; i < len(s); {
  		switch s[i] {
  		case '%':
  			n++
  			if i+2 >= len(s) || !ishex(s[i+1]) || !ishex(s[i+2]) {
  				s = s[i:]
  				if len(s) > 3 {
  					s = s[:3]
  				}
  				return "", EscapeError(s)
  			}
  			// Per https://tools.ietf.org/html/rfc3986#page-21
  			// in the host component %-encoding can only be used
  			// for non-ASCII bytes.
  			// But https://tools.ietf.org/html/rfc6874#section-2
  			// introduces %25 being allowed to escape a percent sign
  			// in IPv6 scoped-address literals. Yay.
  			if mode == encodeHost && unhex(s[i+1]) < 8 && s[i:i+3] != "%25" {
  				return "", EscapeError(s[i : i+3])
  			}
  			if mode == encodeZone {
  				// RFC 6874 says basically "anything goes" for zone identifiers
  				// and that even non-ASCII can be redundantly escaped,
  				// but it seems prudent to restrict %-escaped bytes here to those
  				// that are valid host name bytes in their unescaped form.
  				// That is, you can use escaping in the zone identifier but not
  				// to introduce bytes you couldn't just write directly.
  				// But Windows puts spaces here! Yay.
  				v := unhex(s[i+1])<<4 | unhex(s[i+2])
  				if s[i:i+3] != "%25" && v != ' ' && shouldEscape(v, encodeHost) {
  					return "", EscapeError(s[i : i+3])
  				}
  			}
  			i += 3
  		case '+':
  			hasPlus = mode == encodeQueryComponent
  			i++
  		default:
  			if (mode == encodeHost || mode == encodeZone) && s[i] < 0x80 && shouldEscape(s[i], mode) {
  				return "", InvalidHostError(s[i : i+1])
  			}
  			i++
  		}
  	}
  
  	if n == 0 && !hasPlus {
  		return s, nil
  	}
  
  	t := make([]byte, len(s)-2*n)
  	j := 0
  	for i := 0; i < len(s); {
  		switch s[i] {
  		case '%':
  			t[j] = unhex(s[i+1])<<4 | unhex(s[i+2])
  			j++
  			i += 3
  		case '+':
  			if mode == encodeQueryComponent {
  				t[j] = ' '
  			} else {
  				t[j] = '+'
  			}
  			j++
  			i++
  		default:
  			t[j] = s[i]
  			j++
  			i++
  		}
  	}
  	return string(t), nil
}

// Please be informed that for now shouldEscape does not check all
// reserved characters correctly. See golang.org/issue/5684.
func shouldEscape(c byte, mode encoding) bool {
  	// §2.3 Unreserved characters (alphanum)
  	if 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || '0' <= c && c <= '9' {
  		return false
  	}
  
  	if mode == encodeHost || mode == encodeZone {
  		// §3.2.2 Host allows
  		//	sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
  		// as part of reg-name.
  		// We add : because we include :port as part of host.
  		// We add [ ] because we include [ipv6]:port as part of host.
  		// We add < > because they're the only characters left that
  		// we could possibly allow, and Parse will reject them if we
  		// escape them (because hosts can't use %-encoding for
  		// ASCII bytes).
  		switch c {
  		case '!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '=', ':', '[', ']', '<', '>', '"':
  			return false
  		}
  	}
  
  	switch c {
  	case '-', '_', '.', '~': // §2.3 Unreserved characters (mark)
  		return false
  
  	case '$', '&', '+', ',', '/', ':', ';', '=', '?', '@': // §2.2 Reserved characters (reserved)
  		// Different sections of the URL allow a few of
  		// the reserved characters to appear unescaped.
  		switch mode {
  		case encodePath: // §3.3
  			// The RFC allows : @ & = + $ but saves / ; , for assigning
  			// meaning to individual path segments. This package
  			// only manipulates the path as a whole, so we allow those
  			// last three as well. That leaves only ? to escape.
  			return c == '?'
  
  		case encodePathSegment: // §3.3
  			// The RFC allows : @ & = + $ but saves / ; , for assigning
  			// meaning to individual path segments.
  			return c == '/' || c == ';' || c == ',' || c == '?'
  
  		case encodeUserPassword: // §3.2.1
  			// The RFC allows ';', ':', '&', '=', '+', '$', and ',' in
  			// userinfo, so we must escape only '@', '/', and '?'.
  			// The parsing of userinfo treats ':' as special so we must escape
  			// that too.
  			return c == '@' || c == '/' || c == '?' || c == ':'
  
  		case encodeQueryComponent: // §3.4
  			// The RFC reserves (so we must escape) everything.
  			return true
  
  		case encodeFragment: // §4.1
  			// The RFC text is silent but the grammar allows
  			// everything, so escape nothing.
  			return false
  		}
  	}

  	// Everything else must be escaped.
  	return true
}

func ishex(c byte) bool {
  	switch {
  	case '0' <= c && c <= '9':
  		return true
  	case 'a' <= c && c <= 'f':
  		return true
  	case 'A' <= c && c <= 'F':
  		return true
  	}
  	return false
}

func unhex(c byte) byte {
  	switch {
  	case '0' <= c && c <= '9':
  		return c - '0'
  	case 'a' <= c && c <= 'f':
  		return c - 'a' + 10
  	case 'A' <= c && c <= 'F':
  		return c - 'A' + 10
  	}
  	return 0
}