ParseURL -> ParsedURL name; add method Set Get ParsedURL

v0.0.9

.gitignore

@@ -1 +1,2 @@
 *.pyc
+*.vscode

base.go

@@ -7,33 +7,43 @@ import (
 	"reflect"
 )
 
-func buildBodyRequest(ver, rawurl string, params *Params) *http.Request {
+func buildBodyRequest(wf *Workflow) *http.Request {
 	var req *http.Request
 	var err error
+	contentType := ""
 
-	if params.IOBody == nil {
+	if wf.Body.IOBody() == nil {
-		req, err = http.NewRequest(ver, rawurl, nil)
+		req, err = http.NewRequest(wf.Method, wf.GetRawURL(), nil)
 	} else {
-		var body *bytes.Buffer
+		var bodybuf *bytes.Buffer
-		switch params.IOBody.(type) {
+		switch wf.Body.IOBody().(type) {
 		case []byte:
-			body = bytes.NewBuffer(params.IOBody.([]byte))
+			bodybuf = bytes.NewBuffer(wf.Body.IOBody().([]byte))
 		case *bytes.Buffer:
-			body = bytes.NewBuffer(params.IOBody.(*bytes.Buffer).Bytes())
+			bodybuf = bytes.NewBuffer(wf.Body.IOBody().(*bytes.Buffer).Bytes())
 		default:
-			panic(errors.New("the type is not exist, type is" + reflect.TypeOf(params.IOBody).String()))
+			panic(errors.New("the type is not exist, type is" + reflect.TypeOf(wf.Body.IOBody).String()))
 		}
-		req, err = http.NewRequest(ver, rawurl, body)
+		req, err = http.NewRequest(wf.Method, wf.GetRawURL(), bodybuf)
 	}
 
 	if err != nil {
 		panic(err)
 	}
 
-	if params.ContentType == "" {
+	if wf.Body.ContentType() != "" {
-		req.Header.Set("Content-Type", TypeURLENCODED)
+		contentType = wf.Body.ContentType()
 	} else {
-		req.Header.Set("Content-Type", params.ContentType)
+		contentType = ""
+		if contentType == "" {
+			if wf.Method == "POST" || wf.Method == "PUT" || wf.Method == "PATCH" {
+				contentType = TypeURLENCODED
+			}
+		}
+	}
+
+	if contentType != "" {
+		req.Header.Set(HeaderKeyContentType, contentType)
 	}
 
 	return req

multipart.go

@@ -17,7 +17,7 @@ func writeFormUploadFile(mwriter *multipart.Writer, ufile *UploadFile) {
 	io.Copy(part, ufile.FileReaderCloser)
 }
 
-func createMultipart(postParams *Params, params []interface{}) {
+func createMultipart(postParams IBody, params []interface{}) {
 	plen := len(params)
 
 	body := &bytes.Buffer{}
@@ -85,6 +85,6 @@ func createMultipart(postParams *Params, params []interface{}) {
 		}
 	}
 
-	postParams.ContentType = mwriter.FormDataContentType()
+	postParams.AddContentType(mwriter.FormDataContentType())
-	postParams.IOBody = body
+	postParams.SetIOBody(body)
 }

requests_method.go

@@ -1,199 +0,0 @@
-package requests
-
-import (
-	"crypto/tls"
-	"errors"
-	"net/http"
-	"net/url"
-	"reflect"
-	"time"
-)
-
-// Params 相关参数结构
-type Params struct {
-	// Query       map[string][]string
-	IOBody interface{}
-	// Files       []UploadFile
-	ContentType string
-}
-
-// BasicAuth 帐号认真结构
-type BasicAuth struct {
-	// User 帐号
-	User string
-	// Password 密码
-	Password string
-}
-
-// Session 的基本方法
-type Session struct {
-	client    *http.Client
-	transport *http.Transport
-	cookies   http.CookieJar
-	params    *Params
-	auth      *BasicAuth
-}
-
-// TypeContent post类型参数
-type TypeContent int
-
-const (
-	_ TypeContent = iota
-	// TypeJSON 类型
-	TypeJSON = "application/json"
-	// TypeXML 类型
-	TypeXML = "text/xml"
-	// TypeURLENCODED 类型
-	TypeURLENCODED = "application/x-www-form-urlencoded"
-	// TypeFormData 类型
-	TypeFormData = "multipart/form-data"
-)
-
-// TypeConfig 配置类型
-type TypeConfig int
-
-const (
-	_ TypeConfig = iota
-	// ConfigRequestTimeout request 包括 dial request redirect 总时间超时
-	ConfigRequestTimeout // 支持time.Duration 和 int(秒为单位)
-
-	// ConfigDialTimeout 一个Connect过程的Timeout
-	ConfigDialTimeout // 支持time.Duration 和 int(秒为单位)
-
-	// ConfigProxy 代理链接
-	ConfigProxy // http, https, socks5
-
-	// ConfigInsecure InsecureSkipVerify
-	ConfigInsecure // true, false
-
-	// ConfigBasicAuth 帐号认证
-	ConfigBasicAuth // user pwd
-
-	// ConfigTLS 帐号认证
-	ConfigTLS // user pwd
-)
-
-// NewSession 创建Session
-func NewSession() *Session {
-	client := &http.Client{}
-	transport := &http.Transport{}
-	client.Transport = transport
-
-	return &Session{client: client, params: &Params{}, transport: transport, auth: nil}
-}
-
-// SetConfig 设置配置
-func (ses *Session) SetConfig(typeConfig TypeConfig, values interface{}) {
-
-	switch typeConfig {
-	case ConfigRequestTimeout:
-		switch v := values.(type) {
-		case time.Duration:
-			ses.client.Timeout = v
-		case int:
-			ses.client.Timeout = time.Duration(v * int(time.Second))
-		case int64:
-			ses.client.Timeout = time.Duration(v * int64(time.Second))
-		case float32:
-			ses.client.Timeout = time.Duration(v * float32(time.Second))
-		case float64:
-			ses.client.Timeout = time.Duration(v * float64(time.Second))
-		default:
-			panic(errors.New("error type " + reflect.TypeOf(v).String()))
-		}
-	case ConfigDialTimeout:
-
-	case ConfigProxy:
-		switch v := values.(type) {
-		case string:
-			purl, err := (url.Parse(v))
-			if err != nil {
-				panic(err)
-			}
-			ses.transport.Proxy = http.ProxyURL(purl)
-		case *url.URL:
-			ses.transport.Proxy = http.ProxyURL(v)
-		}
-	case ConfigInsecure:
-		ses.transport.TLSClientConfig = &tls.Config{InsecureSkipVerify: !values.(bool)}
-	case ConfigTLS:
-		ses.transport.TLSClientConfig = values.(*tls.Config)
-	case ConfigBasicAuth:
-		if ses.auth == nil {
-			ses.auth = &BasicAuth{}
-		}
-
-		switch v := values.(type) {
-		case *BasicAuth:
-			ses.auth.User = v.User
-			ses.auth.User = v.Password
-		case BasicAuth:
-			ses.auth.User = v.User
-			ses.auth.User = v.Password
-		case []string:
-			ses.auth.User = v[0]
-			ses.auth.User = v[1]
-		case nil:
-			ses.auth = nil
-		}
-	default:
-		panic(errors.New("unknown typeConfig " + reflect.TypeOf(typeConfig).String()))
-	}
-	return
-}
-
-// Get 请求
-func (ses *Session) Get(url string) *Workflow {
-	wf := NewWorkflow(ses)
-	wf.Method = "GET"
-	wf.SetURL(url)
-	return wf
-}
-
-// Post 请求
-func (ses *Session) Post(url string) *Workflow {
-	wf := NewWorkflow(ses)
-	wf.Method = "POST"
-	wf.SetURL(url)
-	return wf
-}
-
-// Put 请求
-func (ses *Session) Put(url string) *Workflow {
-	wf := NewWorkflow(ses)
-	wf.Method = "PUT"
-	wf.SetURL(url)
-	return wf
-}
-
-// Patch 请求
-func (ses *Session) Patch(url string) *Workflow {
-	wf := NewWorkflow(ses)
-	wf.Method = "PATCH"
-	wf.SetURL(url)
-	return wf
-}
-
-// Delete 请求
-func (ses *Session) Delete(url string) *Workflow {
-	wf := NewWorkflow(ses)
-	wf.Method = "DELETE"
-	wf.SetURL(url)
-	return wf
-}
-
-// Head 请求
-func (ses *Session) Head(url string) *Workflow {
-	wf := NewWorkflow(ses)
-	wf.Method = "HEAD"
-	wf.SetURL(url)
-	return wf
-}
-
-// Options 请求
-func (ses *Session) Options(url string) *Workflow {
-	wf := NewWorkflow(ses)
-	wf.Method = "OPTIONS"
-	wf.SetURL(url)
-	return wf
-}

session.go

@@ -0,0 +1,374 @@
+package requests
+
+import (
+	"crypto/tls"
+	"errors"
+	"net/http"
+	"net/http/cookiejar"
+	"net/url"
+	"reflect"
+	"runtime"
+	"strings"
+	"time"
+
+	"golang.org/x/net/publicsuffix"
+)
+
+// Body 相关参数结构
+type Body struct {
+	// Query       map[string][]string
+	ioBody interface{}
+	// prefix ContentType 前缀
+	prefix string
+	// Files       []UploadFile
+	contentTypes map[string]int
+}
+
+// NewBody new body pointer
+func NewBody() *Body {
+	b := &Body{}
+	b.contentTypes = make(map[string]int)
+	return b
+}
+
+// SetIOBody 设置IOBody的值
+func (body *Body) SetIOBody(iobody interface{}) {
+	body.ioBody = iobody
+}
+
+// IOBody 获取ioBody值
+func (body *Body) IOBody() interface{} {
+	return body.ioBody
+}
+
+// ContentType 获取ContentType
+func (body *Body) ContentType() string {
+	content := body.prefix
+	for kvalue := range body.contentTypes {
+		content += kvalue + ";"
+	}
+	return strings.TrimRight(content, ";")
+}
+
+// SetPrefix SetPrefix 和 AddContentType的顺序会影响到ContentType()的返回结果
+func (body *Body) SetPrefix(ct string) {
+	body.prefix = strings.TrimRight(ct, ";") + ";"
+}
+
+// AddContentType 添加 Add Type类型
+func (body *Body) AddContentType(ct string) {
+	for _, v := range strings.Split(ct, ";") {
+		v = strings.Trim(v, " ")
+		if v != "" {
+			if body.prefix != v {
+				body.contentTypes[v] = 1
+			}
+		}
+	}
+
+}
+
+// IBody 相关参数结构
+type IBody interface {
+
+	// Query       map[string][]string
+	IOBody() interface{}
+	// SetIOBody
+	SetIOBody(iobody interface{})
+	// Files       []UploadFile
+	ContentType() string
+	// AppendContent
+	AddContentType(ct string)
+	// AddPrefix 添加 Prefix
+	SetPrefix(ct string)
+}
+
+// BasicAuth 帐号认真结构
+type BasicAuth struct {
+	// User 帐号
+	User string
+	// Password 密码
+	Password string
+}
+
+// Session 的基本方法
+type Session struct {
+	auth *BasicAuth
+
+	body IBody
+
+	client    *http.Client
+	cookiejar http.CookieJar
+
+	transport *http.Transport
+
+	Header http.Header
+	Query  url.Values
+}
+
+const (
+	// TypeJSON 类型
+	TypeJSON = "application/json"
+
+	// TypeXML 类型
+	TypeXML = "text/xml"
+
+	// TypePlain 类型
+	TypePlain = "text/plain"
+
+	// TypeHTML 类型
+	TypeHTML = "text/html"
+
+	// TypeURLENCODED 类型
+	TypeURLENCODED = "application/x-www-form-urlencoded"
+
+	// TypeForm PostForm类型
+	TypeForm = TypeURLENCODED
+
+	// TypeStream application/octet-stream 只能提交一个二进制流, 很少用
+	TypeStream = "application/octet-stream"
+
+	// TypeFormData 类型
+	TypeFormData = "multipart/form-data"
+
+	// TypeMixed Mixed类型
+	TypeMixed = "multipart/mixed"
+
+	// HeaderKeyHost Host
+	HeaderKeyHost = "Host"
+
+	// HeaderKeyUA User-Agent
+	HeaderKeyUA = "User-Agent"
+
+	// HeaderKeyContentType Content-Type
+	HeaderKeyContentType = "Content-Type"
+)
+
+// TypeConfig 配置类型
+type TypeConfig int
+
+const (
+	_ TypeConfig = iota
+	// CRequestTimeout request 包括 dial request redirect 总时间超时
+	CRequestTimeout // 支持time.Duration 和 int(秒为单位)
+
+	// CDialTimeout 一个Connect过程的Timeout
+	CDialTimeout // 支持time.Duration 和 int(秒为单位)
+
+	// CProxy 代理链接
+	CProxy // http, https, socks5
+
+	// CInsecure InsecureSkipVerify
+	CInsecure // true, false
+
+	// CBasicAuth 帐号认证
+	CBasicAuth // user pwd
+
+	// CTLS 帐号认证
+	CTLS // user pwd
+
+	// CCookiejar 持久化 CookieJar
+	CCookiejar // true or false ; default = true
+)
+
+// NewSession 创建Session
+func NewSession() *Session {
+	client := &http.Client{}
+	transport := &http.Transport{DisableCompression: true}
+
+	client.Transport = transport
+	cjar, err := cookiejar.New(&cookiejar.Options{PublicSuffixList: publicsuffix.List})
+	if err != nil {
+		panic(err)
+	}
+
+	client.Jar = cjar
+	return &Session{client: client, body: NewBody(), transport: transport, auth: nil, cookiejar: client.Jar, Header: make(http.Header)}
+}
+
+// SetConfig 设置配置
+func (ses *Session) SetConfig(typeConfig TypeConfig, values interface{}) {
+
+	switch typeConfig {
+	case CRequestTimeout:
+		switch v := values.(type) {
+		case time.Duration:
+			ses.client.Timeout = v
+		case int:
+			ses.client.Timeout = time.Duration(v * int(time.Second))
+		case int64:
+			ses.client.Timeout = time.Duration(v * int64(time.Second))
+		case float32:
+			ses.client.Timeout = time.Duration(v * float32(time.Second))
+		case float64:
+			ses.client.Timeout = time.Duration(v * float64(time.Second))
+		default:
+			panic(errors.New("error type " + reflect.TypeOf(v).String()))
+		}
+	case CDialTimeout:
+		// 没时间实现这些小细节
+	case CCookiejar:
+		v := values.(bool)
+		if v {
+			if ses.client.Jar == nil {
+				ses.client.Jar = ses.cookiejar
+			}
+		} else {
+			ses.client.Jar = nil
+		}
+	case CProxy:
+		switch v := values.(type) {
+		case string:
+			purl, err := (url.Parse(v))
+			if err != nil {
+				panic(err)
+			}
+			ses.transport.Proxy = http.ProxyURL(purl)
+		case *url.URL:
+			ses.transport.Proxy = http.ProxyURL(v)
+		case nil:
+			ses.transport.Proxy = nil
+		}
+	case CInsecure:
+		ses.transport.TLSClientConfig = &tls.Config{InsecureSkipVerify: !values.(bool)}
+	case CTLS:
+		ses.transport.TLSClientConfig = values.(*tls.Config)
+	case CBasicAuth:
+		if ses.auth == nil {
+			ses.auth = &BasicAuth{}
+		}
+
+		switch v := values.(type) {
+		case *BasicAuth:
+			ses.auth.User = v.User
+			ses.auth.User = v.Password
+		case BasicAuth:
+			ses.auth.User = v.User
+			ses.auth.User = v.Password
+		case []string:
+			ses.auth.User = v[0]
+			ses.auth.User = v[1]
+		case nil:
+			ses.auth = nil
+		}
+	default:
+		panic(errors.New("unknown typeConfig " + reflect.TypeOf(typeConfig).String()))
+	}
+	return
+}
+
+// SetQuery 设置url query的持久参数的值
+func (ses *Session) SetQuery(values url.Values) {
+	ses.Query = values
+}
+
+// GetQuery 获取get query的值
+func (ses *Session) GetQuery() url.Values {
+	return ses.Query
+}
+
+// SetHeader 设置set Header的值
+func (ses *Session) SetHeader(header http.Header) {
+	ses.Header = header
+}
+
+// GetHeader 获取get Header的值
+func (ses *Session) GetHeader() http.Header {
+	return ses.Header
+}
+
+// SetCookies 设置Cookies 或者添加Cookies Del
+func (ses *Session) SetCookies(u *url.URL, cookies []*http.Cookie) {
+	ses.cookiejar.SetCookies(u, cookies)
+}
+
+// Cookies 返回 Cookies
+func (ses *Session) Cookies(u *url.URL) []*http.Cookie {
+	return ses.cookiejar.Cookies(u)
+}
+
+// DelCookies 删除 Cookies
+func (ses *Session) DelCookies(u *url.URL, name string) {
+	cookies := ses.cookiejar.Cookies(u)
+	for _, c := range cookies {
+		if c.Name == name {
+			c.MaxAge = -1
+		}
+	}
+	ses.SetCookies(u, cookies)
+}
+
+// ClearCookies 清楚所有cookiejar上的cookies
+func (ses *Session) ClearCookies() {
+	cjar, err := cookiejar.New(&cookiejar.Options{PublicSuffixList: publicsuffix.List})
+	if err != nil {
+		panic(err)
+	}
+	ses.cookiejar = cjar
+	ses.client.Jar = ses.cookiejar
+}
+
+// Get 请求
+func (ses *Session) Get(url string) *Workflow {
+	wf := NewWorkflow(ses, url)
+	wf.Method = "GET"
+	return wf
+}
+
+// Post 请求
+func (ses *Session) Post(url string) *Workflow {
+	wf := NewWorkflow(ses, url)
+	wf.Method = "POST"
+	return wf
+}
+
+// Put 请求
+func (ses *Session) Put(url string) *Workflow {
+	wf := NewWorkflow(ses, url)
+	wf.Method = "PUT"
+	return wf
+}
+
+// Patch 请求
+func (ses *Session) Patch(url string) *Workflow {
+	wf := NewWorkflow(ses, url)
+	wf.Method = "PATCH"
+	return wf
+}
+
+// Delete 请求
+func (ses *Session) Delete(url string) *Workflow {
+	wf := NewWorkflow(ses, url)
+	wf.Method = "DELETE"
+	return wf
+}
+
+// Head 请求
+func (ses *Session) Head(url string) *Workflow {
+	wf := NewWorkflow(ses, url)
+	wf.Method = "HEAD"
+	return wf
+}
+
+// Options 请求
+func (ses *Session) Options(url string) *Workflow {
+	wf := NewWorkflow(ses, url)
+	wf.Method = "OPTIONS"
+	return wf
+}
+
+// CloseIdleConnections  closes the idle connections that a session client may make use of
+// 从levigross/grequests 借鉴
+func (ses *Session) CloseIdleConnections() {
+	ses.client.Transport.(*http.Transport).CloseIdleConnections()
+}
+
+// EnsureTransporterFinalized will ensure that when the HTTP client is GCed
+// the runtime will close the idle connections (so that they won't leak)
+// this function was adopted from Hashicorp's go-cleanhttp package
+// 暂时不用, 标记到以后是否起作用
+func EnsureTransporterFinalized(httpTransport *http.Transport) {
+	runtime.SetFinalizer(&httpTransport, func(transportInt **http.Transport) {
+		(*transportInt).CloseIdleConnections()
+	})
+}

session_test.go

@@ -30,7 +30,6 @@ func TestSession_Get(t *testing.T) {
 		fields fields
 		args   args
 	}{
-		// TODO: Add test cases.
 		{
 			name:   "Get test",
 			fields: fields{client: &http.Client{}},
@@ -77,7 +76,7 @@ func TestSession_Post(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			ses := NewSession()
-			got, err := ses.Post("http://httpbin.org/post").SetBodyParams(tt.args.params...).Execute()
+			got, err := ses.Post("http://httpbin.org/post").SetBody(tt.args.params...).Execute()
 
 			if err != nil {
 				t.Errorf("Metchod error = %v", err)
@@ -95,7 +94,7 @@ func TestSession_Post(t *testing.T) {
 func TestSession_Setparams(t *testing.T) {
 	type fields struct {
 		client *http.Client
-		params *Params
+		params *Body
 	}
 	type args struct {
 		params []interface{}
@@ -107,7 +106,6 @@ func TestSession_Setparams(t *testing.T) {
 		want    *regexp.Regexp
 		wantErr bool
 	}{
-		// TODO: Add test cases.
 		{
 			name: "test Setparams",
 			args: args{params: []interface{}{map[string]string{"a": "1", "b": "2"}}},
@@ -120,7 +118,7 @@ func TestSession_Setparams(t *testing.T) {
 		},
 		{
 			name:   "test xml",
-			fields: fields{client: &http.Client{}, params: &Params{}},
+			fields: fields{client: &http.Client{}, params: NewBody()},
 			args:   args{params: []interface{}{`<request><parameters><password>test</password></parameters></request>`, TypeXML}},
 			want:   regexp.MustCompile(`"data": "<request><parameters><password>test</password></parameters></request>"`),
 		},
@@ -129,7 +127,7 @@ func TestSession_Setparams(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			ses := NewSession()
 
-			got, err := ses.Post("http://httpbin.org/post").SetBodyParams(tt.args.params...).Execute()
+			got, err := ses.Post("http://httpbin.org/post").SetBody(tt.args.params...).Execute()
 			if (err != nil) != tt.wantErr {
 				t.Errorf("Metchod error = %v, wantErr %v", err, tt.wantErr)
 				return
@@ -171,7 +169,7 @@ func TestSession_PostUploadFile(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			ses := NewSession()
-			got, err := ses.Post("http://httpbin.org/post").SetBodyParams(tt.args.params, TypeFormData).Execute()
+			got, err := ses.Post("http://httpbin.org/post").SetBody(tt.args.params, TypeFormData).Execute()
 
 			if err != nil {
 				t.Errorf("Metchod error = %v", err)
@@ -215,7 +213,7 @@ func TestSession_Put(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			ses := NewSession()
-			got, err := ses.Put("http://httpbin.org/put").SetBodyParams(tt.args.params, TypeFormData).Execute()
+			got, err := ses.Put("http://httpbin.org/put").SetBody(tt.args.params, TypeFormData).Execute()
 
 			if err != nil {
 				t.Errorf("Metchod error = %v", err)
@@ -259,7 +257,7 @@ func TestSession_Patch(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			ses := NewSession()
-			got, err := ses.Patch("http://httpbin.org/patch").SetBodyParams(tt.args.params, TypeFormData).Execute()
+			got, err := ses.Patch("http://httpbin.org/patch").SetBody(tt.args.params, TypeFormData).Execute()
 
 			if err != nil {
 				t.Errorf("Metchod error = %v", err)
@@ -285,22 +283,21 @@ func TestSession_SetConfig(t *testing.T) {
 		args    args
 		wantErr bool
 	}{
-		// TODO: Add test cases.
 		{
 			name:    "test timeout",
-			args:    args{typeConfig: ConfigRequestTimeout, values: 0.01},
+			args:    args{typeConfig: CRequestTimeout, values: 0.01},
 			wantErr: true,
 		},
 
 		{
 			name:    "test not timeout",
-			args:    args{typeConfig: ConfigRequestTimeout, values: 5},
+			args:    args{typeConfig: CRequestTimeout, values: 5},
 			wantErr: false,
 		},
 
 		{
 			name:    "test proxy",
-			args:    args{typeConfig: ConfigProxy, values: "http://474420502.top:7070"},
+			args:    args{typeConfig: CProxy, values: "http://474420502.top:7070"},
 			wantErr: false,
 		},
 	}
@@ -322,7 +319,7 @@ func TestSession_SetConfig(t *testing.T) {
 func TestSession_SetConfigInsecure(t *testing.T) {
 
 	ses := NewSession()
-	ses.SetConfig(ConfigInsecure, false)
+	ses.SetConfig(CInsecure, false)
 
 	for _, badSSL := range []string{
 		"https://self-signed.badssl.com/",
@@ -339,3 +336,47 @@ func TestSession_SetConfigInsecure(t *testing.T) {
 	}
 
 }
+
+func TestSession_Cookies(t *testing.T) {
+	ses := NewSession()
+
+	t.Run("set cookie", func(t *testing.T) {
+
+		resp, err := ses.Get("http://httpbin.org/cookies/set").AddKVCookie("a", "1").Execute()
+		if err != nil {
+			t.Error("cookies set error", err)
+		}
+
+		if !regexp.MustCompile(`"a": "1"`).MatchString(resp.DContent) {
+			t.Error(resp.DContent)
+		}
+	})
+}
+
+func TestSession_Header(t *testing.T) {
+	chromeua := "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36"
+	ses := NewSession()
+
+	t.Run("ua header test", func(t *testing.T) {
+
+		ses.Header.Add(HeaderKeyUA, chromeua)
+		resp, err := ses.Get("https://www.baidu.com").Execute()
+		if err != nil {
+			t.Error("cookies set error", err)
+		}
+
+		if len(resp.DContent) <= 5000 {
+			t.Error(resp.DContent, len(resp.DContent))
+		}
+
+		ses = NewSession()
+		resp, err = ses.Get("https://www.baidu.com").AddHeader(HeaderKeyUA, chromeua).Execute()
+		if err != nil {
+			t.Error("cookies set error", err)
+		}
+
+		if len(resp.DContent) <= 5000 {
+			t.Error(resp.DContent, len(resp.DContent))
+		}
+	})
+}

workflow.go

@@ -1,8 +1,10 @@
 package requests
 
 import (
+	"net/http"
 	"net/url"
 	"regexp"
+	"strings"
 )
 
 // Workflow 工作流
@@ -10,14 +12,21 @@ type Workflow struct {
 	session   *Session
 	ParsedURL *url.URL
 	Method    string
-	Body      *Params
+	Body      IBody
+	Header    http.Header
+	Cookies   map[string]*http.Cookie
 }
 
 // NewWorkflow new and init workflow
-func NewWorkflow(ses *Session) *Workflow {
+func NewWorkflow(ses *Session, u string) *Workflow {
 	wf := &Workflow{}
 	wf.SwitchSession(ses)
-	wf.Body = &Params{}
+
+	wf.SetRawURL(u)
+
+	wf.Body = NewBody()
+	wf.Header = make(http.Header)
+	wf.Cookies = make(map[string]*http.Cookie)
 	return wf
 }
 
@@ -26,13 +35,84 @@ func (wf *Workflow) SwitchSession(ses *Session) {
 	wf.session = ses
 }
 
-// GetStringURL 获取url的string形式
+// AddHeader 添加头信息  Get方法从Header参数上获取
-func (wf *Workflow) GetStringURL() string {
+func (wf *Workflow) AddHeader(key, value string) *Workflow {
-	return wf.ParsedURL.String()
+	wf.Header.Add(key, value)
+	return wf
 }
 
-// SetURL 设置 url
+// SetHeader 设置头信息 这样构造 []string{value} Get方法从Header参数上获取
-func (wf *Workflow) SetURL(srcURL string) *Workflow {
+func (wf *Workflow) SetHeader(key, value string) *Workflow {
+	wf.Header.Set(key, value)
+	return wf
+}
+
+// GetHeader 获取Workflow Header
+func (wf *Workflow) GetHeader() http.Header {
+	return wf.Header
+}
+
+// GetCombineHeader 获取后的Header信息
+func (wf *Workflow) GetCombineHeader() http.Header {
+	return mergeMapList(wf.session.Header, wf.Header)
+}
+
+// DelHeader 添加头信息 Get方法从Header参数上获取
+func (wf *Workflow) DelHeader(key string) *Workflow {
+	wf.Header.Del(key)
+	return wf
+}
+
+// AddCookie 添加Cookie
+func (wf *Workflow) AddCookie(c *http.Cookie) *Workflow {
+	wf.Cookies[c.Name] = c
+	return wf
+}
+
+// AddKVCookie 添加 以 key value 的 Cookie
+func (wf *Workflow) AddKVCookie(name, value string) *Workflow {
+	wf.Cookies[name] = &http.Cookie{Name: name, Value: value}
+	return wf
+}
+
+// DelCookie 删除Cookie
+func (wf *Workflow) DelCookie(name interface{}) *Workflow {
+	switch n := name.(type) {
+	case string:
+		if _, ok := wf.Cookies[n]; ok {
+			delete(wf.Cookies, n)
+			return wf
+		}
+	case *http.Cookie:
+		if _, ok := wf.Cookies[n.Name]; ok {
+			delete(wf.Cookies, n.Name)
+			return wf
+		}
+	default:
+		panic("name type is not support")
+	}
+	return nil
+}
+
+// GetParsedURL 获取url的string形式
+func (wf *Workflow) GetParsedURL() *url.URL {
+	return wf.ParsedURL
+}
+
+// SetParsedURL 获取url的string形式
+func (wf *Workflow) SetParsedURL(u *url.URL) *Workflow {
+	wf.ParsedURL = u
+	return wf
+}
+
+// GetRawURL 获取url的string形式
+func (wf *Workflow) GetRawURL() string {
+	u := strings.Split(wf.ParsedURL.String(), "?")[0] + "?" + wf.GetCombineQuery().Encode()
+	return u
+}
+
+// SetRawURL 设置 url
+func (wf *Workflow) SetRawURL(srcURL string) *Workflow {
 	purl, err := url.ParseRequestURI(srcURL)
 	if err != nil {
 		panic(err)
@@ -41,20 +121,26 @@ func (wf *Workflow) SetURL(srcURL string) *Workflow {
 	return wf
 }
 
-// GetURLQuery 获取Query参数
+// GetQuery 获取Query参数
-func (wf *Workflow) GetURLQuery() url.Values {
+func (wf *Workflow) GetQuery() url.Values {
-	if wf.ParsedURL != nil {
+	return wf.ParsedURL.Query()
-		return wf.ParsedURL.Query()
+}
-	}
 
+// GetCombineQuery 获取Query参数
+func (wf *Workflow) GetCombineQuery() url.Values {
+	if wf.ParsedURL != nil {
+		vs := wf.ParsedURL.Query()
+		return mergeMapList(wf.session.GetQuery(), vs)
+	}
 	return nil
 }
 
-// SetURLQuery 设置Query参数
+// SetQuery 设置Query参数
-func (wf *Workflow) SetURLQuery(query url.Values) *Workflow {
+func (wf *Workflow) SetQuery(query url.Values) *Workflow {
 	if query == nil {
 		return wf
 	}
+	query = (url.Values)(mergeMapList(wf.session.Query, query))
 	wf.ParsedURL.RawQuery = query.Encode()
 	return wf
 }
@@ -92,56 +178,110 @@ func (wf *Workflow) SetURLPath(path []string) *Workflow {
 	return wf
 }
 
-// SetURLRawPath 设置Path参数
+// SetURLRawPath 设置Pa晚上参数
 func (wf *Workflow) SetURLRawPath(path string) *Workflow {
 	wf.ParsedURL.Path = path
 	return wf
 }
 
-// SetBodyParams 参数设置
+// SetBody 参数设置
-func (wf *Workflow) SetBodyParams(params ...interface{}) *Workflow {
+func (wf *Workflow) SetBody(params ...interface{}) *Workflow {
-	if params == nil {
-		return wf
-	}
 
-	plen := len(params)
+	if params != nil {
-	defaultContentType := TypeURLENCODED
+		plen := len(params)
+		defaultContentType := TypeURLENCODED
 
-	if plen >= 2 {
+		if plen >= 2 {
-		t := params[plen-1]
+			t := params[plen-1]
-		defaultContentType = t.(string)
+			defaultContentType = t.(string)
-		wf.Body.ContentType = defaultContentType
+			wf.Body.SetPrefix(defaultContentType)
-	} else {
+		} else {
-		wf.Body.ContentType = defaultContentType
+			wf.Body.SetPrefix(defaultContentType)
-	}
+		}
 
-	if defaultContentType == TypeFormData {
+		if defaultContentType == TypeFormData {
-		// TODO: form-data
+			createMultipart(wf.Body, params)
-		createMultipart(wf.Body, params)
+		} else {
-	} else {
+			var values url.Values
-		var values url.Values
+			switch param := params[0].(type) {
-		switch param := params[0].(type) {
+			case map[string]string:
-		case map[string]string:
+				values := make(url.Values)
-			values := make(url.Values)
+				for k, v := range param {
-			for k, v := range param {
+					values.Set(k, v)
-				values.Set(k, v)
+				}
+				wf.Body.SetIOBody([]byte(values.Encode()))
+			case map[string][]string:
+				values = param
+				wf.Body.SetIOBody([]byte(values.Encode()))
+			case string:
+				wf.Body.SetIOBody([]byte(param))
+			case []byte:
+				wf.Body.SetIOBody(param)
 			}
-			wf.Body.IOBody = []byte(values.Encode())
+
-		case map[string][]string:
-			values = param
-			wf.Body.IOBody = []byte(values.Encode())
-		case string:
-			wf.Body.IOBody = []byte(param)
-		case []byte:
-			wf.Body.IOBody = param
 		}
 	}
 	return wf
 }
 
+func mergeMapList(headers ...map[string][]string) map[string][]string {
+
+	set := make(map[string]map[string]int)
+	merged := make(map[string][]string)
+
+	for _, header := range headers {
+		for key, values := range header {
+			for _, v := range values {
+				if vs, ok := set[key]; ok {
+					vs[v] = 1
+				} else {
+					set[key] = make(map[string]int)
+					set[key][v] = 1
+				}
+			}
+		}
+	}
+
+	for key, mvalue := range set {
+		for v := range mvalue {
+			// merged.Add(key, v)
+			if mergeValue, ok := merged[key]; ok {
+				merged[key] = append(mergeValue, v)
+			} else {
+				merged[key] = []string{v}
+			}
+		}
+	}
+
+	return merged
+}
+
+// setHeaderRequest 设置request的头
+func setHeaderRequest(req *http.Request, wf *Workflow) {
+	req.Header = mergeMapList(req.Header, wf.session.Header, wf.Header)
+}
+
+// setHeaderRequest 设置request的临时Cookie, 永久需要在session上设置cookie
+func setTempCookieRequest(req *http.Request, wf *Workflow) {
+	if wf.Cookies != nil {
+		for _, c := range wf.Cookies {
+			req.AddCookie(c)
+		}
+	}
+}
+
 // Execute 执行
 func (wf *Workflow) Execute() (*Response, error) {
-	req := buildBodyRequest(wf.Method, wf.GetStringURL(), wf.Body)
+
+	req := buildBodyRequest(wf)
+
+	setHeaderRequest(req, wf)
+	setTempCookieRequest(req, wf)
+
+	if wf.session.auth != nil {
+		req.SetBasicAuth(wf.session.auth.User, wf.session.auth.Password)
+	}
+
 	resp, err := wf.session.client.Do(req)
 	if err != nil {
 		return nil, err