func (s *Server) Start() error {
	if s.config.Listener == nil {
		ln, err := net.Listen("tcp", s.config.Address)
		if err != nil {
			return err
		}
		if s.config.TLSCertFile != "" && s.config.TLSKeyFile != "" {
			config := &tls.Config{}
			if !s.config.DisableHTTP2 {
				config.NextProtos = append(config.NextProtos, "h2")
			}
			config.Certificates = make([]tls.Certificate, 1)
			config.Certificates[0], err = tls.LoadX509KeyPair(s.config.TLSCertFile, s.config.TLSKeyFile)
			if err != nil {
				return err
			}
			s.config.Listener = tls.NewListener(tcpKeepAliveListener{ln.(*net.TCPListener)}, config)
		} else {
			s.config.Listener = tcpKeepAliveListener{ln.(*net.TCPListener)}
		}
	}
	return s.Serve(s.config.Listener)
}
Start implements `engine.Server#Start` function.
package standard
import (
	"crypto/tls"
	"net"
	"net/http"
	"sync"
	"time"
	"github.com/insionng/vodka"
	"github.com/insionng/vodka/engine"
	"github.com/insionng/vodka/log"
	glog "github.com/insionng/vodka/libraries/gommon/log"
)
type (
	Server struct {
		*http.Server
		config  engine.Config
		handler engine.Handler
		logger  log.Logger
		pool    *pool
	}
	pool struct {
		request         sync.Pool
		response        sync.Pool
		responseAdapter sync.Pool
		header          sync.Pool
		url             sync.Pool
	}
)
func New(addr string) *Server {
	c := engine.Config{Address: addr}
	return WithConfig(c)
}
func WithTLS(addr, certFile, keyFile string) *Server {
	c := engine.Config{
		Address:     addr,
		TLSCertFile: certFile,
		TLSKeyFile:  keyFile,
	}
	return WithConfig(c)
}
func WithConfig(c engine.Config) (s *Server) {
	s = &Server{
		Server: new(http.Server),
		config: c,
		pool: &pool{
			request: sync.Pool{
				New: func() interface{} {
					return &Request{logger: s.logger}
				},
			},
			response: sync.Pool{
				New: func() interface{} {
					return &Response{logger: s.logger}
				},
			},
			responseAdapter: sync.Pool{
				New: func() interface{} {
					return &responseAdapter{}
				},
			},
			header: sync.Pool{
				New: func() interface{} {
					return &Header{}
				},
			},
			url: sync.Pool{
				New: func() interface{} {
					return &URL{}
				},
			},
		},
		handler: engine.HandlerFunc(func(req engine.Request, res engine.Response) {
			panic("vodka: handler not set, use `Server#SetHandler()` to set it.")
		}),
		logger: glog.New("vodka"),
	}
	s.ReadTimeout = c.ReadTimeout
	s.WriteTimeout = c.WriteTimeout
	s.Addr = c.Address
	s.Handler = s
	return
}
func (s *Server) SetHandler(h engine.Handler) {
	s.handler = h
}
func (s *Server) SetLogger(l log.Logger) {
	s.logger = l
}