func (p *param) loadFromBytes(body []byte, serializer Serializer) (*reflect.Value, error) {
	var err error
	obj, callback := createObj(p.Type)
	if len(body) > 0 {
		entityObj := obj.Addr().Interface()
		err = serializer.Unmarshal(body, entityObj)
		obj = callback(reflect.ValueOf(entityObj))
	} else {
		obj = callback(obj)
	}
	return &obj, err
}
loadFromBytes Load object from bytes
package webapi
import (
	"errors"
	"fmt"
	"net/http"
	"net/url"
	"reflect"
	"strconv"
	"strings"
)
type (
	function struct {
		Args        []*param        
		ContextArgs []reflect.Type  
		Context     reflect.Type    
		Function    reflect.Value   
	}
	param struct {
		reflect.Type
		isBody  bool
		isQuery bool
	}
)
var types = struct {
	Error      reflect.Type
	Controller reflect.Type
}{
	reflect.TypeOf((*error)(nil)).Elem(),
	reflect.TypeOf((*Controller)(nil)).Elem(),
}
func (method *function) run(ctx *Context, arguments ...string) (objs []interface{}) {
	args := make([]reflect.Value, 0)
	if method.Context != nil {
		obj, callback := createObj(method.Context)
		if setController(obj, reflect.ValueOf(interface{}(ctx).(Controller))) {
			var err error
			arguments, err = initController(obj, method, arguments...)
			if err != nil {
				if ctx.statuscode == 0 {
					ctx.Reply(http.StatusBadRequest, err.Error())
				}
				return
			}
		} else {
			ctx.Reply(http.StatusNotFound)
			return
		}
		args = append(args, callback(obj))
	}
	paramArgs, err := ctx.analyseParams(method.Args, arguments...)
	if err != nil {
		if ctx.statuscode == 0 {
			ctx.Reply(http.StatusBadRequest, err.Error())
		}
		return
	}
	result := method.Function.Call(append(args, paramArgs...))
	objs = make([]interface{}, len(result))
	for index, res := range result {
		objs[index] = res.Interface()
	}
	return
}
func (method *function) MakeHandler() func(ctx *Context, args ...string) {
	return func(ctx *Context, args ...string) {
		var reply = method.run(ctx, args...)
		if ctx.statuscode == 0 && len(reply) > 0 {
			response, isResp := reply[0].(Replyable)
			if !isResp {
				response = &Reply{
					Status: http.StatusOK,
					Body:   reply[0],
				}
			}
			statusCode := response.StatusCode()
			if statusCode == 0 {
				statusCode = http.StatusOK
				if response.Data() == nil {
					statusCode = http.StatusNoContent
				}
			}
			ctx.Reply(statusCode, response.Data())
		}
	}
}
func (p *param) Load(obj interface{}, serializer Serializer) (*reflect.Value, error) {
	if b, isBytes := obj.([]byte); isBytes {
		return p.loadFromBytes(b, serializer)
	} else if values, isValues := obj.(url.Values); isValues {
		return p.loadFromValues(values)
	}
	return nil, errors.New("cannot accept input type " + reflect.TypeOf(obj).Name())
}
func (p *param) New() reflect.Value {
	val, function := createObj(p.Type)
	return function(val)
}