go mod tidy

.gitignore

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

base.go

@@ -12,32 +12,31 @@ func buildBodyRequest(wf *Workflow) *http.Request {
 	var err error
 	contentType := ""
 
-	if wf.Body.IOBody == nil {
-		req, err = http.NewRequest(wf.Method, wf.GetStringURL(), nil)
+	if wf.Body.GetIOBody() == nil {
+		req, err = http.NewRequest(wf.Method, wf.GetRawURL(), nil)
 	} else {
 		var bodybuf *bytes.Buffer
-		switch wf.Body.IOBody.(type) {
+		switch wf.Body.GetIOBody().(type) {
 		case []byte:
-			bodybuf = bytes.NewBuffer(wf.Body.IOBody.([]byte))
+			bodybuf = bytes.NewBuffer(wf.Body.GetIOBody().([]byte))
+		case string:
+			bodybuf = bytes.NewBuffer([]byte(wf.Body.GetIOBody().(string)))
 		case *bytes.Buffer:
-			bodybuf = bytes.NewBuffer(wf.Body.IOBody.(*bytes.Buffer).Bytes())
+			bodybuf = bytes.NewBuffer(wf.Body.GetIOBody().(*bytes.Buffer).Bytes())
 		default:
-			panic(errors.New("the type is not exist, type is" + reflect.TypeOf(wf.Body.IOBody).String()))
+			panic(errors.New("the type is not exist, type is " + reflect.TypeOf(wf.Body.GetIOBody()).String()))
 		}
-		req, err = http.NewRequest(wf.Method, wf.GetStringURL(), bodybuf)
+		req, err = http.NewRequest(wf.Method, wf.GetRawURL(), bodybuf)
 	}
 
 	if err != nil {
 		panic(err)
 	}
 
-	if wf.Body.ContentType != "" {
-		if wf.Body.ContentType == TypeContentEmpty {
+	if wf.Body.ContentType() != "" {
+		contentType = wf.Body.ContentType()
+	} else {
 		contentType = ""
-		} else {
-			contentType = wf.Body.ContentType
-		}
-	} else {
 		if contentType == "" {
 			if wf.Method == "POST" || wf.Method == "PUT" || wf.Method == "PATCH" {
 				contentType = TypeURLENCODED

go.mod

@@ -0,0 +1,9 @@
+module requests
+
+go 1.12
+
+require (
+	474420502.top/eson/gjson v1.1.3
+	github.com/tidwall/match v1.0.1 // indirect
+	golang.org/x/net v0.0.0-20190628185345-da137c7871d7
+)

go.sum

@@ -0,0 +1,9 @@
+474420502.top/eson/gjson v1.1.3 h1:SDeD1/SWm1YknuokcPww8ZmsOOguQqFAYLWnQTMMX98=
+474420502.top/eson/gjson v1.1.3/go.mod h1:95mdr7XPHsGvsGZj/FeQ+iT7mggI6LKc3JT/ZnveebI=
+github.com/tidwall/match v1.0.1 h1:PnKP62LPNxHKTwvHHZZzdOAOCtsJTjo6dZLCwpKm5xc=
+github.com/tidwall/match v1.0.1/go.mod h1:LujAq0jyVjBy028G1WhWfIzbpQfMO8bBZ6Tyb0+pL9E=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/net v0.0.0-20190628185345-da137c7871d7 h1:rTIdg5QFRR7XCaK4LCjBiPbx8j4DQRpdYMnGn/bJUEU=
+golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=

multipart.go

@@ -15,16 +15,19 @@ func writeFormUploadFile(mwriter *multipart.Writer, ufile *UploadFile) {
 		log.Panic(err)
 	}
 	io.Copy(part, ufile.FileReaderCloser)
+
+	err = ufile.FileReaderCloser.Close()
+	if err != nil {
+		panic(err)
+	}
 }
 
-func createMultipart(postParams *Body, params []interface{}) {
+func createMultipart(postParams IBody, params []interface{}) {
 	plen := len(params)
 
 	body := &bytes.Buffer{}
 	mwriter := multipart.NewWriter(body)
 
-	defer mwriter.Close()
-
 	for _, iparam := range params[0 : plen-1] {
 		switch param := iparam.(type) {
 		case *UploadFile:
@@ -85,6 +88,11 @@ func createMultipart(postParams *Body, params []interface{}) {
 		}
 	}
 
-	postParams.ContentType = mwriter.FormDataContentType()
-	postParams.IOBody = body
+	postParams.AddContentType(mwriter.FormDataContentType())
+	postParams.SetIOBody(body)
+
+	err := mwriter.Close()
+	if err != nil {
+		panic(err)
+	}
 }

response.go

@@ -9,52 +9,48 @@ import (
 	"net/http"
 )
 
-// Response 响应内容包含http.Response
+// Response 响应内容包含http.Response 已读
 type Response struct {
-	DContent  string
-	GResponse *http.Response
+	readContent  string
+	readResponse *http.Response
 }
 
 // FromHTTPResponse 生成Response 从标准http.Response
 func FromHTTPResponse(resp *http.Response) (*Response, error) {
-
+	var err error
 	// 复制response 返回内容 并且测试是否有解压的需求
 	srcbuf, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		panic(err)
+		return nil, err
 	}
 	resp.Body.Close()
 
-	cbuf := bytes.NewBuffer([]byte{})
-	_, err = io.Copy(cbuf, bytes.NewReader(srcbuf))
-
-	if err != nil {
-		panic(err)
-	}
-
-	resp.Body = ioutil.NopCloser(cbuf)
-
-	content := string(srcbuf)
+	content := ""
 	srcReader := bytes.NewReader(srcbuf)
 
-	if r, err := gzip.NewReader(srcReader); err == nil {
-		buf, err := ioutil.ReadAll(r)
+	var reader io.ReadCloser
+	if reader, err = gzip.NewReader(srcReader); err == nil {
+		defer reader.Close()
+		buf, err := ioutil.ReadAll(reader)
 		if err != nil {
-			panic(err)
+			return nil, err
 		}
 		content = string(buf)
-	} else if r, err := zlib.NewReader(srcReader); err == nil {
-		buf, err := ioutil.ReadAll(r)
+	} else if reader, err = zlib.NewReader(srcReader); err == nil {
+		defer reader.Close()
+		buf, err := ioutil.ReadAll(reader)
 		if err != nil {
-			panic(err)
+			return nil, err
 		}
 		content = string(buf)
+	} else {
+		content = string(srcbuf)
 	}
 
-	return &Response{DContent: content, GResponse: resp}, nil
+	return &Response{readContent: content, readResponse: resp}, nil
 }
 
 // Content 返回解压后的内容
 func (gresp *Response) Content() string {
-	return gresp.DContent
+	return gresp.readContent
 }

session.go

@@ -8,6 +8,7 @@ import (
 	"net/url"
 	"reflect"
 	"runtime"
+	"strings"
 	"time"
 
 	"golang.org/x/net/publicsuffix"
@@ -16,9 +17,69 @@ import (
 // Body 相关参数结构
 type Body struct {
 	// Query       map[string][]string
-	IOBody interface{}
+	ioBody interface{}
+	// prefix ContentType 前缀
+	prefix string
 	// Files       []UploadFile
-	ContentType string
+	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
+}
+
+// GetIOBody 获取ioBody值
+func (body *Body) GetIOBody() 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 {
+	// GetIOBody  获取iobody data
+	GetIOBody() interface{}
+	// SetIOBody  设置iobody data
+	SetIOBody(iobody interface{})
+	// ContentType      返回包括 Prefix 所有的ContentType
+	ContentType() string
+	// AppendContent
+	AddContentType(ct string)
+	// SetPrefix 设置 Prefix;  唯一前缀
+	SetPrefix(ct string)
 }
 
 // BasicAuth 帐号认真结构
@@ -31,12 +92,15 @@ type BasicAuth struct {
 
 // Session 的基本方法
 type Session struct {
-	client    *http.Client
-	transport *http.Transport
-	cookiejar http.CookieJar
-	body      *Body
 	auth *BasicAuth
 
+	body IBody
+
+	client    *http.Client
+	cookiejar http.CookieJar
+
+	transport *http.Transport
+
 	Header http.Header
 	Query  url.Values
 }
@@ -44,20 +108,37 @@ type Session struct {
 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
-	// TypeContentEmpty 没有Form的类型 Content
-	TypeContentEmpty = "ContentEmpty"
+
+	// 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"
 )
@@ -67,32 +148,37 @@ type TypeConfig int
 
 const (
 	_ TypeConfig = iota
-	// ConfigRequestTimeout request 包括 dial request redirect 总时间超时
-	ConfigRequestTimeout // 支持time.Duration 和 int(秒为单位)
+	// CRequestTimeout request 包括 dial request redirect 总时间超时
+	CRequestTimeout // 支持time.Duration 和 int(秒为单位)
 
-	// ConfigDialTimeout 一个Connect过程的Timeout
-	ConfigDialTimeout // 支持time.Duration 和 int(秒为单位)
+	// CDialTimeout 一个Connect过程的Timeout
+	CDialTimeout // 支持time.Duration 和 int(秒为单位)
 
-	// ConfigProxy 代理链接
-	ConfigProxy // http, https, socks5
+	// CKeepAlives 默认不KeepAlives, 容易被一直KeepAlives 没关闭链接
+	CKeepAlives
 
-	// ConfigInsecure InsecureSkipVerify
-	ConfigInsecure // true, false
+	// CProxy 代理链接
+	CProxy // http, https, socks5
 
-	// ConfigBasicAuth 帐号认证
-	ConfigBasicAuth // user pwd
+	// CInsecure InsecureSkipVerify
+	CInsecure // true, false
 
-	// ConfigTLS 帐号认证
-	ConfigTLS // user pwd
+	// CBasicAuth 帐号认证
+	CBasicAuth // user pwd
 
-	// ConfigCookiejar 持久化 CookieJar
-	ConfigCookiejar // true or false ; default = true
+	// 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}
+	transport := &http.Transport{DisableCompression: true, DisableKeepAlives: true}
+
+	EnsureTransporterFinalized(transport)
 
 	client.Transport = transport
 	cjar, err := cookiejar.New(&cookiejar.Options{PublicSuffixList: publicsuffix.List})
@@ -101,14 +187,14 @@ func NewSession() *Session {
 	}
 
 	client.Jar = cjar
-	return &Session{client: client, body: &Body{}, transport: transport, auth: nil, cookiejar: client.Jar, Header: make(http.Header)}
+	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 ConfigRequestTimeout:
+	case CRequestTimeout:
 		switch v := values.(type) {
 		case time.Duration:
 			ses.client.Timeout = v
@@ -123,9 +209,11 @@ func (ses *Session) SetConfig(typeConfig TypeConfig, values interface{}) {
 		default:
 			panic(errors.New("error type " + reflect.TypeOf(v).String()))
 		}
-	case ConfigDialTimeout:
+	case CDialTimeout:
 		// 没时间实现这些小细节
-	case ConfigCookiejar:
+	case CKeepAlives:
+		ses.transport.DisableKeepAlives = !values.(bool)
+	case CCookiejar:
 		v := values.(bool)
 		if v {
 			if ses.client.Jar == nil {
@@ -134,7 +222,7 @@ func (ses *Session) SetConfig(typeConfig TypeConfig, values interface{}) {
 		} else {
 			ses.client.Jar = nil
 		}
-	case ConfigProxy:
+	case CProxy:
 		switch v := values.(type) {
 		case string:
 			purl, err := (url.Parse(v))
@@ -144,12 +232,14 @@ func (ses *Session) SetConfig(typeConfig TypeConfig, values interface{}) {
 			ses.transport.Proxy = http.ProxyURL(purl)
 		case *url.URL:
 			ses.transport.Proxy = http.ProxyURL(v)
+		case nil:
+			ses.transport.Proxy = nil
 		}
-	case ConfigInsecure:
-		ses.transport.TLSClientConfig = &tls.Config{InsecureSkipVerify: !values.(bool)}
-	case ConfigTLS:
+	case CInsecure:
+		ses.transport.TLSClientConfig = &tls.Config{InsecureSkipVerify: values.(bool)}
+	case CTLS:
 		ses.transport.TLSClientConfig = values.(*tls.Config)
-	case ConfigBasicAuth:
+	case CBasicAuth:
 		if ses.auth == nil {
 			ses.auth = &BasicAuth{}
 		}
@@ -198,9 +288,8 @@ 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 {
-
+// GetCookies 返回 Cookies
+func (ses *Session) GetCookies(u *url.URL) []*http.Cookie {
 	return ses.cookiejar.Cookies(u)
 }
 
@@ -225,6 +314,13 @@ func (ses *Session) ClearCookies() {
 	ses.client.Jar = ses.cookiejar
 }
 
+// Head 请求
+func (ses *Session) Head(url string) *Workflow {
+	wf := NewWorkflow(ses, url)
+	wf.Method = "HEAD"
+	return wf
+}
+
 // Get 请求
 func (ses *Session) Get(url string) *Workflow {
 	wf := NewWorkflow(ses, url)
@@ -253,20 +349,6 @@ func (ses *Session) Patch(url string) *Workflow {
 	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)
@@ -274,16 +356,22 @@ func (ses *Session) Options(url string) *Workflow {
 	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()
+// Delete 请求
+func (ses *Session) Delete(url string) *Workflow {
+	wf := NewWorkflow(ses, url)
+	wf.Method = "DELETE"
+	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

@@ -76,14 +76,14 @@ 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").AutoSetBody(tt.args.params...).Execute()
 
 			if err != nil {
 				t.Errorf("Metchod error = %v", err)
 				return
 			}
 
-			if tt.want.MatchString(got.DContent) == false {
+			if tt.want.MatchString(got.readContent) == false {
 				t.Errorf("Metchod = %v, want %v", got, tt.want)
 			}
 
@@ -118,7 +118,7 @@ func TestSession_Setparams(t *testing.T) {
 		},
 		{
 			name:   "test xml",
-			fields: fields{client: &http.Client{}, params: &Body{}},
+			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>"`),
 		},
@@ -127,13 +127,13 @@ 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").AutoSetBody(tt.args.params...).Execute()
 			if (err != nil) != tt.wantErr {
 				t.Errorf("Metchod error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
 
-			if tt.want.MatchString(got.DContent) == false {
+			if tt.want.MatchString(got.readContent) == false {
 				t.Errorf("Metchod = %v, want %v", got, tt.want)
 			}
 		})
@@ -169,14 +169,14 @@ 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").AutoSetBody(tt.args.params, TypeFormData).Execute()
 
 			if err != nil {
 				t.Errorf("Metchod error = %v", err)
 				return
 			}
 
-			if tt.want.MatchString(got.DContent) == false {
+			if tt.want.MatchString(got.readContent) == false {
 				t.Errorf("Metchod = %v, want %v", got, tt.want)
 			}
 
@@ -213,14 +213,14 @@ 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").AutoSetBody(tt.args.params, TypeFormData).Execute()
 
 			if err != nil {
 				t.Errorf("Metchod error = %v", err)
 				return
 			}
 
-			if tt.want.MatchString(got.DContent) == false {
+			if tt.want.MatchString(got.readContent) == false {
 				t.Errorf("Metchod = %v, want %v", got, tt.want)
 			}
 
@@ -257,14 +257,14 @@ 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").AutoSetBody(tt.args.params, TypeFormData).Execute()
 
 			if err != nil {
 				t.Errorf("Metchod error = %v", err)
 				return
 			}
 
-			if tt.want.MatchString(got.DContent) == false {
+			if tt.want.MatchString(got.readContent) == false {
 				t.Errorf("Metchod = %v, want %v", got, tt.want)
 			}
 
@@ -285,19 +285,19 @@ func TestSession_SetConfig(t *testing.T) {
 	}{
 		{
 			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,
 		},
 	}
@@ -319,7 +319,7 @@ func TestSession_SetConfig(t *testing.T) {
 func TestSession_SetConfigInsecure(t *testing.T) {
 
 	ses := NewSession()
-	ses.SetConfig(ConfigInsecure, false)
+	ses.SetConfig(CInsecure, true)
 
 	for _, badSSL := range []string{
 		"https://self-signed.badssl.com/",
@@ -330,8 +330,8 @@ func TestSession_SetConfigInsecure(t *testing.T) {
 		if err != nil {
 			t.Error("Unable to make request", err)
 		}
-		if resp.GResponse.StatusCode != 200 {
-			t.Error("Request did not return OK, is ", resp.GResponse.StatusCode)
+		if resp.readResponse.StatusCode != 200 {
+			t.Error("Request did not return OK, is ", resp.readResponse.StatusCode)
 		}
 	}
 
@@ -341,14 +341,13 @@ 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)
+		if !regexp.MustCompile(`"a": "1"`).MatchString(resp.readContent) {
+			t.Error(resp.readContent)
 		}
 	})
 }
@@ -365,8 +364,8 @@ func TestSession_Header(t *testing.T) {
 			t.Error("cookies set error", err)
 		}
 
-		if len(resp.DContent) <= 5000 {
-			t.Error(resp.DContent, len(resp.DContent))
+		if len(resp.readContent) <= 5000 {
+			t.Error(resp.readContent, len(resp.readContent))
 		}
 
 		ses = NewSession()
@@ -375,8 +374,8 @@ func TestSession_Header(t *testing.T) {
 			t.Error("cookies set error", err)
 		}
 
-		if len(resp.DContent) <= 5000 {
-			t.Error(resp.DContent, len(resp.DContent))
+		if len(resp.readContent) <= 5000 {
+			t.Error(resp.readContent, len(resp.readContent))
 		}
 	})
 }

upload_file.go

@@ -17,13 +17,11 @@ type UploadFile struct {
 // UploadFileFromPath 从本地文件获取上传文件
 func UploadFileFromPath(fileName string) (*UploadFile, error) {
 	fd, err := os.Open(fileName)
-
 	if err != nil {
 		return nil, err
 	}
 
 	return &UploadFile{FileReaderCloser: fd, FileName: fileName}, nil
-
 }
 
 // UploadFileFromGlob 根据Glob从本地文件获取上传文件

workflow.go

@@ -1,31 +1,30 @@
 package requests
 
 import (
-	"log"
 	"net/http"
 	"net/url"
 	"regexp"
 	"strings"
 )
 
-// Workflow 工作流
+// Workflow 工作流 设计点: 这个并不影响Session的属性变化 如 NewWorkflow(ses, url).AddHeader() 对ses没影响
 type Workflow struct {
 	session   *Session
 	ParsedURL *url.URL
 	Method    string
-	Body      *Body
+	Body      IBody
 	Header    http.Header
 	Cookies   map[string]*http.Cookie
 }
 
 // NewWorkflow new and init workflow
-func NewWorkflow(ses *Session, u string) *Workflow {
+func NewWorkflow(ses *Session, urlstr string) *Workflow {
 	wf := &Workflow{}
 	wf.SwitchSession(ses)
 
-	wf.SetURL(u)
+	wf.SetRawURL(urlstr)
 
-	wf.Body = &Body{}
+	wf.Body = NewBody()
 	wf.Header = make(http.Header)
 	wf.Cookies = make(map[string]*http.Cookie)
 	return wf
@@ -38,13 +37,20 @@ func (wf *Workflow) SwitchSession(ses *Session) {
 
 // AddHeader 添加头信息  Get方法从Header参数上获取
 func (wf *Workflow) AddHeader(key, value string) *Workflow {
-	wf.Header.Add(key, value)
+	wf.Header[key] = append(wf.Header[key], value)
 	return wf
 }
 
-// SetHeader 设置头信息 这样构造 []string{value} Get方法从Header参数上获取
-func (wf *Workflow) SetHeader(key, value string) *Workflow {
-	wf.Header.Set(key, value)
+// SetHeader 设置完全替换原有Header
+func (wf *Workflow) SetHeader(header http.Header) *Workflow {
+	wf.Header = make(http.Header)
+	for k, HValues := range header {
+		var newHValues []string
+		for _, value := range HValues {
+			newHValues = append(newHValues, value)
+		}
+		wf.Header[k] = newHValues
+	}
 	return wf
 }
 
@@ -70,6 +76,14 @@ func (wf *Workflow) AddCookie(c *http.Cookie) *Workflow {
 	return wf
 }
 
+// AddCookies 添加[]*http.Cookie
+func (wf *Workflow) AddCookies(cookies []*http.Cookie) *Workflow {
+	for _, c := range cookies {
+		wf.AddCookie(c)
+	}
+	return wf
+}
+
 // AddKVCookie 添加 以 key value 的 Cookie
 func (wf *Workflow) AddKVCookie(name, value string) *Workflow {
 	wf.Cookies[name] = &http.Cookie{Name: name, Value: value}
@@ -95,14 +109,25 @@ func (wf *Workflow) DelCookie(name interface{}) *Workflow {
 	return nil
 }
 
-// GetStringURL 获取url的string形式
-func (wf *Workflow) GetStringURL() string {
+// 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
 }
 
-// SetURL 设置 url
-func (wf *Workflow) SetURL(srcURL string) *Workflow {
+// SetRawURL 设置 url
+func (wf *Workflow) SetRawURL(srcURL string) *Workflow {
 	purl, err := url.ParseRequestURI(srcURL)
 	if err != nil {
 		panic(err)
@@ -174,25 +199,34 @@ func (wf *Workflow) SetURLRawPath(path string) *Workflow {
 	return wf
 }
 
-// SetBodyParams 参数设置
-func (wf *Workflow) SetBodyParams(params ...interface{}) *Workflow {
-	if params != nil {
+// SetBody 参数设置
+func (wf *Workflow) SetBody(body IBody) *Workflow {
+	wf.Body = body
+	return wf
+}
 
+// GetBody 参数设置
+func (wf *Workflow) GetBody(body IBody) IBody {
+	return wf.Body
+}
+
+// AutoSetBody 参数设置
+func (wf *Workflow) AutoSetBody(params ...interface{}) *Workflow {
+
+	if params != nil {
 		plen := len(params)
 		defaultContentType := TypeURLENCODED
 
 		if plen >= 2 {
 			t := params[plen-1]
 			defaultContentType = t.(string)
-			wf.Body.ContentType = defaultContentType
-		} else {
-			wf.Body.ContentType = defaultContentType
 		}
 
+		wf.Body.SetPrefix(defaultContentType)
+
 		if defaultContentType == TypeFormData {
 			createMultipart(wf.Body, params)
 		} else {
-
 			var values url.Values
 			switch param := params[0].(type) {
 			case map[string]string:
@@ -200,19 +234,18 @@ func (wf *Workflow) SetBodyParams(params ...interface{}) *Workflow {
 				for k, v := range param {
 					values.Set(k, v)
 				}
-				wf.Body.IOBody = []byte(values.Encode())
+				wf.Body.SetIOBody([]byte(values.Encode()))
 			case map[string][]string:
 				values = param
-				wf.Body.IOBody = []byte(values.Encode())
+				wf.Body.SetIOBody([]byte(values.Encode()))
 			case string:
-				wf.Body.IOBody = []byte(param)
+				wf.Body.SetIOBody([]byte(param))
 			case []byte:
-				wf.Body.IOBody = param
+				wf.Body.SetIOBody(param)
 			}
 
 		}
 	}
-
 	return wf
 }
 
@@ -273,11 +306,11 @@ func (wf *Workflow) Execute() (*Response, error) {
 	if wf.session.auth != nil {
 		req.SetBasicAuth(wf.session.auth.User, wf.session.auth.Password)
 	}
-	log.Println(req.Header)
 
 	resp, err := wf.session.client.Do(req)
 	if err != nil {
 		return nil, err
 	}
+
 	return FromHTTPResponse(resp)
 }

workflow_test.go

@@ -0,0 +1,60 @@
+package requests
+
+import (
+	"regexp"
+	"testing"
+
+	"474420502.top/eson/gjson"
+)
+
+func TestWorkflow(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.readContent) {
+			t.Error(resp.readContent)
+		}
+
+		wf := ses.Get("http://httpbin.org/cookies/set")
+		resp, err = wf.AddKVCookie("b", "2").Execute()
+		if err != nil {
+			t.Error("cookies set error", err)
+		}
+
+		result := gjson.Get(resp.readContent, "cookies.a")
+		if result.Exists() {
+			t.Error(resp.readContent)
+		}
+
+		result = gjson.Get(resp.readContent, "cookies.b")
+		if result.Int() != 2 {
+			t.Error(resp.readContent)
+		}
+
+		resp, err = wf.AddKVCookie("a", "3").Execute()
+		results := gjson.GetMany(resp.readContent, "cookies.a", "cookies.b")
+		if results[0].Int() != 3 {
+			t.Error(resp.readContent)
+		}
+
+		if results[1].Int() != 2 {
+			t.Error(resp.readContent)
+		}
+
+		resp, err = wf.AddHeader("XX", "123").SetRawURL("http://httpbin.org/headers").Execute()
+		if err != nil {
+			t.Error("cookies set error", err)
+		}
+
+		// headers 只能是String 表示
+		result = gjson.Get(resp.readContent, "headers.Xx")
+		if result.String() != "123" {
+			t.Error(resp.readContent)
+		}
+	})
+}